sidekick-shared 0.26.1 → 0.26.3

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to sidekick-shared will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.26.3] - 2026-09-09
+
+### Added
+
+- `diagnoseProviderFailure()` and its pure types are available from the root and browser entry points. Results contain bounded diagnosis/recovery identifiers, evidence provenance, and optional HTTP/retry-after data without raw errors or credentials.
+- `fetchProviderServiceStatus()` is available from the root and Node entry points, with pure result types also exported through browser. Stateless official-feed checks support cancellation and a ten-second deadline, preserve component/incident associations and independent timestamps, and distinguish observed, unavailable, and omitted incident evidence.
+- `HealthReport.serviceStatus` and `DoctorOptions.fetchServiceStatuses` add explicit service evidence while retaining legacy status output and injection. `toLegacyProviderStatus()` supports compatibility projections.
+
+### Changed
+
+- Doctor reports unavailable and partial public evidence explicitly. Existing `ErrorCategory`, quota guidance, and legacy status functions/types remain compatible; consumers needing availability semantics should adopt the new API.
+
+## [0.26.2] - 2026-09-06
+
+### Added
+
+- `DoctorOptions.provider` selects the session provider to diagnose; `HealthReport.sessionProvider` records it.
+- Optional watcher `onBatchComplete` callback for persisting state after all events in a read have been delivered.
+- `SessionSearchOptions.projectPath` and `signal` for provider-aware workspace filtering and cancellation; legacy `projectSlug` remains supported.
+
+### Fixed
+
+- JSONL watcher and provider reader checkpoints end at complete lines, retaining partial UTF-8 characters across reads and restarts. Codex restores parser context when seeking.
+- Watcher failures retain polling fallback; OpenCode watchers share the canonical data-directory resolver.
+- Session search enumerates through providers, includes database-only sessions, and deduplicates paths.
+- Doctor checks the selected session provider, treats unrelated integrations as informational, and reads account status without changing account selection.
+
 ## [0.26.1] - 2026-09-05
 
 ### Fixed

package/README.md

@@ -9,6 +9,7 @@ Types, parsers, providers, readers, formatters, aggregation, search, reporting,
 
 ## Recent additions
 
+- **0.26.2: reliable monitoring and search** — complete-line JSONL cursors preserve Unicode and Codex parser context; watcher `onBatchComplete` signals a delivered batch. `searchSessions()` adds workspace-path filtering and cancellation, and Doctor accepts an explicit session provider.
 - **One token vocabulary and cost provenance (0.26.0)** — `summarizeTokens()` gives every surface the same `total` (input + output + cache writes + cache reads) and `context` (input + cache) figures; `AggregatedTokens.costUsd` carries `costProvenance` so reports can say whether a cost was provider-reported or estimated; `parseClaudeStatuslinePayload()` / `quotaFromStatuslinePayload()` turn Claude Code's status-line JSON into an official `statusline` quota source; `readQuotaSnapshot()` reports `ageMs` / `freshness` and keeps the sample's origin as `capturedSource`; `resolveQuota()` shares quota resolution across CLI, MCP, and dashboard startup, with default local-sample preferences and an API-first option used by one-shot Codex queries; `readSessionFileStats()` / `computeSessionFileStats()` give every provider one `readSessionStats()` over the shared aggregator, with `availability`, `costProvenance`, and `toolFailures` on `SessionFileStats`; `collectUsageEvents()` reads priced usage events from session logs with a per-session cache, `computeBillingBlocks()` groups them into five-hour billing blocks, and `bucketUsage()` turns them into day, week, month, or session rows; `applySessionSummary()` and `importSessionHistory()` let any host fold finished sessions into `historical-data.json` the way the extension does; observed sessions are read once per discovery, re-read only when their fingerprint changes, and classified from events by `classifySessionActivity()`; `readSessionReportInputs()` derives report metrics and transcript from one read; `writeStateFile()` / `readStateFile()` (also on the `statusline` subpath) maintain the public, versioned `state.json` for external tools, validated by `sidekickStateFileSchema`; `getScheduledPeakHoursState()` and `evaluateQuotaThresholds()` are shared by the CLI and extension dashboards.
 - **Host-safe APIs (0.25.0)** — `listSessionPreviewsAsync()` / `readSessionPreviewAsync()` read previews with bounded concurrency and cooperative yielding; `ObservedSessionCollector.subscribe()` and `SessionMonitor.subscribe()` replace host polling loops with debounced change batches; `createSessionProviders({ onDiagnostic })` constructs every usable provider with structured diagnostics instead of throwing; `findSessionById()` resolves one session without scanning; `exportResolvedModelCatalog()` / `importResolvedModelCatalog()` and `registerModelAlias()` transfer context/pricing resolutions across realms; `onAccountsChanged()` reports login/logout/switch events; provider constructors perform no environment I/O, and quota pollers stay dormant without an account.
 - **Native session-file helpers** — `encodeClaudeWorkspacePath()` / `getClaudeSessionDirectory()` locate Claude Code's `~/.claude/projects/` directories with the real on-disk encoding, `findCodexRolloutFile()` resolves a Codex session id to its rollout path, `readCodexHistory()` tail-reads `~/.codex/history.jsonl`, `listSessionPreviews()` / `readSessionPreview()` build a cheap stat-first recent-sessions index across providers, and `parseMcpToolName()` splits `mcp__<server>__<tool>` identifiers (browser-safe).
@@ -104,7 +105,7 @@ returns the platform default that both overrides bypass.
 | **Credentials**                 | Claude Max OAuth credential reading from `~/.claude/.credentials.json`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | **Quota**                       | Claude Max subscription quota fetching (5-hour and 7-day windows), Codex rate-limit extraction from event streams (plus Codex reset credits via `fetchCodexResetCreditsFromApi()`, attached to quota state by `fetchCodexQuotaFromApi()`), and authoritative z.ai Coding Plan quota fetching via `resolveZaiQuota()` / `fetchZaiQuotaFromApi()` (reads z.ai's `api/monitor/usage/quota/limit` endpoint with cached-snapshot fallback). The observed-traffic z.ai estimator was removed from the package root exports in 0.23.0 and every remaining export of it is `@deprecated` — `resolveZaiQuota()` is the single supported z.ai quota API                                                                                                                                                                                                                                                                                                                                    |
 | **Provider Status**             | API health checking via status.claude.com and status.openai.com (indicator, components, incidents)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| **Doctor**                      | Typed cross-provider health diagnostics — `runDoctor()` checks project identity, sessions, accounts, providers, and dependencies into a `HealthReport`; `formatHealthReport()` renders it and `getSessionDiagnostics()` exposes the per-provider session probe                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| **Doctor**                      | Typed cross-provider health diagnostics — `runDoctor()` checks project identity, sessions, accounts, providers, and dependencies into a `HealthReport`; `formatHealthReport()` renders it and `getSessionDiagnostics()` retains the legacy Claude Code path probe; `runDoctor({ provider })` diagnoses the selected session provider                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | **Schemas**                     | Zod schemas for runtime validation of data crossing process/IPC boundaries — JSONL session events (`sessionEventSchema`, `messageUsageSchema`, `sessionMessageSchema`), assistant turns, observed-session V1 records, quota, account status, account management, quota history, and the public `state.json` contract (`sidekickStateFileSchema`) — plus `extractSessionEvents()` to unwrap `progress`-wrapped events. Account and quota APIs guarantee results valid against the same-release schemas. Also published fs-free via the [`sidekick-shared/schemas`](#supported-import-paths) subpath                                                                                                                                                                                                                                                                                                                                                                               |
 | **Extractors**                  | Pure functions for single-event processing: `extractTokenUsage()`, `extractToolCall()` (top-level `tool_use`), `extractToolCalls()` (assistant content blocks), plus Node-only session asset extraction (`gatherAssetsForCwd()`, `readClaudeAssets()`, `readCodexAssets()`) for URLs, file paths, commands, and plans                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | **Model Info & Pricing**        | Model family parsing (Anthropic / OpenAI / Google, including legacy `claude-3-opus-…` and `claude-3-5-sonnet-…` IDs), context-window lookup (including Fable 5 / Opus 4.8 / Opus 4.7 / Sonnet 4.7 1M and GPT-5.x variants), pricing tables with optional LiteLLM hydration, normalized non-double-counting cost (`calculateNormalizedUsageCost()`, fed by `normalizeProviderUsage()` / `extractNormalizedUsage()`), legacy cost helpers retained but deprecated (`calculateCost()`, `calculateCostWithProvenance()`), `mergeCostSources()`, display helpers (`shortModelName()`, `getModelDisplayInfo()`, `compareModelIds()`, `sortModelIds()`, `formatCost()`), and cross-realm catalog transfer — `exportResolvedModelCatalog()` / `importResolvedModelCatalog()` move resolved context windows and pricing (with provenance, prefix inheritance explicit) between Node and browser realms, and `registerModelAlias()` resolves short or host-specific names to canonical ids |
@@ -448,20 +449,83 @@ const tasks = await readTasks(project, { status: 'pending' });
 console.log(`Found ${tasks.length} tasks`);
 ```
 
-### Check provider status
+### Diagnose terminal provider failures
+
+`diagnoseProviderFailure()` is a pure, synchronous helper exported from `sidekick-shared` and `sidekick-shared/browser`. The caller decides whether an SDK event is terminal: a Codex `ErrorItem`, including a reconnect notice, must not become terminal merely because its message can be classified.
 
 ```typescript
-import { fetchProviderStatus } from 'sidekick-shared';
+import { diagnoseProviderFailure } from 'sidekick-shared/browser';
 
-const status = await fetchProviderStatus();
-if (status.indicator !== 'none') {
-  console.log(`Claude API: ${status.description}`);
-  for (const c of status.affectedComponents) {
-    console.log(`  ${c.name}: ${c.status}`);
-  }
+function diagnoseTerminalError(error: unknown) {
+  return diagnoseProviderFailure({
+    provider: 'codex', // AccountProviderId: 'claude-code' | 'codex'
+    credentialKind: 'oauth', // 'oauth' | 'api-key' | 'unknown'
+    error,
+    authentication: {
+      credentialKind: 'oauth',
+      state: 'authenticated',
+      source: 'local-check',
+      checkedAt: '2026-09-09T12:00:00.000Z',
+    },
+  });
+}
+```
+
+Authentication evidence is optional. Its states are `authenticated`, `missing`, `signed-out`, `expired`, `rejected`, and `unknown`; sources are `local-check` and `provider-response`. The caller owns the observation's freshness and relevance. File presence alone does not establish authenticated request success.
+
+The result contains `provider`, caller-supplied `credentialKind`, `diagnosis`, `recovery`, and `evidence`. Evidence records a bounded rule and its source (`structured-error`, `http-status`, `message`, or `authentication-check`); authentication-check evidence includes `checkedAt`. Valid supplied authentication evidence is preserved separately. Optional `httpStatus` and `retryAfter` retain request information; retry-after is `{ kind: 'delay', delayMs }` or `{ kind: 'date', at }`, without a clock-dependent conversion.
+
+| Diagnosis                                                      | Recovery identifier                                                                      |
+| -------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `missing_credentials`                                          | `sign_in`, `update_credentials`, or `check_authentication`, according to credential kind |
+| `oauth_reauthentication_required`                              | `sign_in`                                                                                |
+| `api_credentials_rejected`                                     | `update_credentials`                                                                     |
+| `authentication_rejected` (credential kind unknown)            | `check_authentication`                                                                   |
+| `invalid_provider_session`                                     | `start_new_session`                                                                      |
+| `service_unavailable`, `timeout`, `rate_limited`, `overloaded` | `retry_later`                                                                            |
+| `connection_failed`                                            | `check_connection`                                                                       |
+| `execution_policy_denied`                                      | `review_execution_policy`                                                                |
+| `runtime_unavailable`                                          | `repair_runtime`                                                                         |
+| `context_overflow`                                             | `reduce_context`                                                                         |
+| `unknown`                                                      | `inspect_error`                                                                          |
+
+Recognized structured request codes take precedence over HTTP status, followed by narrow message patterns. A bare 401 establishes credential rejection, with recovery chosen from the credential kind; a bare 403 does not distinguish authentication from execution policy and remains unknown. Explicit credential rejection from the request overrides a successful local OAuth check. OAuth observations never validate API keys. Thread/conversation failures, 5xx responses, DNS failures, and connection resets do not establish rejected account credentials. The reported `Reconnecting... 2/5 (unexpected status 503 Service Unavailable: upstream connect error or disconnect/reset before headers. reset reason: connection termination)` is classified as `service_unavailable`, with message provenance and HTTP 503, if the caller supplies it as a terminal error.
+
+The projection contains no raw errors, stacks, credentials, or request URLs. Product wording belongs to consumers. The helper performs no I/O, credential reads, SDK calls, stream control, retries, or UI actions. Existing transcript/tool `ErrorCategory` and quota-specific guidance contracts remain unchanged.
+
+### Check public provider service status
+
+```typescript
+import { fetchProviderServiceStatus } from 'sidekick-shared/node';
+import type { ProviderServiceStatus } from 'sidekick-shared/browser';
+
+const controller = new AbortController();
+const status: ProviderServiceStatus = await fetchProviderServiceStatus('codex', {
+  signal: controller.signal,
+});
+
+if (status.availability === 'unavailable') {
+  console.log('Public status unavailable', status.reason, status.checkedAt);
+} else {
+  console.log(status.severity, status.checkedAt, status.providerUpdatedAt);
+  // null means the feed omitted incident evidence; [] explicitly reports none unresolved.
+  console.log(status.incidents === null ? 'Incident information unavailable' : status.incidents);
 }
 ```
 
+The fetcher is exported from root and Node, with pure result types also exported from browser. It requests the official [Claude summary](https://status.claude.com/api/v2/summary.json) or [OpenAI summary](https://status.openai.com/api/v2/summary.json) without credentials. Every call has a ten-second deadline covering headers and body consumption, supports caller cancellation, and performs one request with no retries or cache.
+
+- `observed` results contain provider, source URL, check timestamp, reported severity/description, provider page update timestamp, all reported components, and unresolved incidents. Supported severity values are `none`, `minor`, `major`, `critical`, and `maintenance`.
+- Components retain IDs, names, and reported states. Incidents retain IDs, titles, status, impact, HTTP(S) links, provider update timestamps, and component IDs. Unknown associations are `null`; unmatched IDs are preserved. Resolved and postmortem incidents are excluded.
+- Omitted incident data is represented as `incidents: null`, preserving a partial observation without claiming zero incidents. Missing provider timestamps and links remain `null`; the check timestamp never substitutes for a provider update.
+- `unavailable` results contain no severity. Reasons are `http_error`, `network_error`, `timeout`, `cancelled`, or `invalid_response`, with optional HTTP status and no raw error text. Malformed supplied fields are rejected rather than defaulted to operational.
+
+Request failure, authentication, CLI readiness, and public service status are separate observations. Public incidents supplement a diagnosis but do not prove a failed request's cause. An operational public page does not prove that the user's connection works. Preserve component associations to avoid attributing unrelated vendor incidents to Claude Code or Codex; unknown component mappings and custom provider endpoints remain uncorrelated. The result's `provider` identifies the selected public feed, not a verified request-backend mapping.
+
+Consumers own caching, stale-evidence presentation, polling, and request coalescing. Neither API initiates sign-in, modifies credentials, switches providers, requests a model response, or replays a turn.
+
+`fetchProviderStatus()`, `fetchOpenAIStatus()`, and `ProviderStatusState` remain compatible. Their historical fallback combines `indicator: 'none'` with `Status unavailable`; migrate to the new API for reliable availability semantics. `toLegacyProviderStatus()` is a lossy compatibility projection for older output contracts, not an availability check. Doctor includes optional `serviceStatus` evidence alongside legacy `providerStatus`; its new `fetchServiceStatuses` injection takes precedence over legacy `fetchStatuses`, which remains supported without additional network requests.
+
 ### Check Claude peak-hours state
 
 ```typescript
@@ -670,6 +734,26 @@ const tail = createJsonlTail({
 tail.start();
 ```
 
+`SessionWatcherCallbacks.onBatchComplete` is also available through `createWatcher()`. Save aggregation state only after a complete event batch and only when the state includes the full history (a completed replay or a compatible restored checkpoint). Live-only state is incomplete and must not replace a full-history checkpoint. JSONL positions end at complete lines; Codex readers reconstruct parser context when seeking. OpenCode's SQLite timestamp cursor does not persist row-version deduplication, so the dashboards replay OpenCode history instead of restoring a snapshot.
+
+### Search a workspace and diagnose its provider
+
+```typescript
+import { CodexProvider, searchSessions, runDoctor } from 'sidekick-shared';
+
+const provider = new CodexProvider();
+const controller = new AbortController();
+const matches = await searchSessions(provider, 'authentication', {
+  projectPath: '/path/to/project',
+  signal: controller.signal,
+  maxResults: 20,
+});
+const report = await runDoctor({ cwd: '/path/to/project', provider: 'codex' });
+console.log(matches, report.sessionProvider, report.checks);
+```
+
+`projectPath` resolves the workspace canonically and takes precedence over the legacy `projectSlug`. Cancellation is checked between session reads; it does not interrupt an in-progress synchronous provider read. `HealthReport.sessionProvider` is optional for compatibility. `getSessionDiagnostics()` remains a Claude Code path diagnostic; use `runDoctor()` for provider-aware checks.
+
 ### Poll quota with backoff
 
 ```typescript

package/dist/browser.d.ts

@@ -39,3 +39,6 @@ export { applySessionSummary, isFileImported, markFileImported, removeSessionSum
 export type { ApplySessionSummaryOptions, SessionSummaryFromStatsOptions } from './historicalStore';
 export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
 export type { FailingToolTrend, FailingToolTrendRow, FailingToolWindow } from './failingTools';
+export { diagnoseProviderFailure } from './providerFailure';
+export type { ProviderCredentialKind, ProviderAuthenticationEvidence, ProviderFailureInput, ProviderFailureCode, ProviderRecoveryAction, ProviderRetryAfter, ProviderFailureEvidence, ProviderFailureDiagnosis, } from './providerFailure';
+export type { ProviderServiceSeverity, ProviderServiceComponent, ProviderServiceIncident, ProviderServiceStatusFailureReason, ObservedProviderServiceStatus, UnavailableProviderServiceStatus, ProviderServiceStatus, FetchProviderServiceStatusOptions, } from './providerServiceStatusTypes';

package/dist/browser.js

@@ -10,7 +10,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION = exports.resolveModelAlias = exports.registerModelAlias = exports.importResolvedModelCatalog = exports.exportResolvedModelCatalog = exports.formatCost = exports.sortModelIds = exports.compareModelIds = exports.getModelDisplayInfo = exports.shortModelName = exports.mergeCostSources = exports.calculateCostWithProvenance = exports.calculateCostWithPricing = exports.calculateCost = exports.getModelInfo = exports.resolveModelPricing = exports.getModelPricing = exports.parseModelId = exports.segmentAssistantTurn = exports.reasoningSummary = exports.isAssistantTurnSubagentTool = exports.extractTurnSubagents = exports.assistantTurnEventsFromSessionEvents = exports.SESSION_PROVIDER_IDS = exports.RUNTIME_QUOTA_PROVIDER_IDS = exports.QUOTA_PROVIDER_IDS = exports.MODEL_PROVIDER_IDS = exports.ACCOUNT_PROVIDER_IDS = exports.createSessionContextProjector = exports.calculateSessionContextPressure = exports.buildSessionContextSnapshot = exports.parseMcpToolName = exports.parseLocalDateKey = exports.formatTokenCount = exports.formatLocalDateKey = exports.formatDurationMs = exports.addLocalDays = exports.projectSessionTranscript = exports.estimateSerializedTokens = exports.estimateTextTokens = exports.TOKEN_TOTAL_LABEL = exports.TOKEN_CONTEXT_LABEL = exports.sumTokenTotals = exports.summarizeTokens = exports.calculateNormalizedUsageCost = exports.extractNormalizedUsage = exports.normalizeProviderUsage = exports.DEFAULT_CONTEXT_WINDOW = exports.resolveModelContextWindow = exports.getModelContextWindowSize = void 0;
-exports.mergeFailingToolWindows = exports.failingToolTrend = exports.FAILING_TOOL_TREND_ARROWS = exports.sessionSummaryFromStats = exports.removeSessionSummary = exports.markFileImported = exports.isFileImported = exports.applySessionSummary = exports.weekKey = exports.usageBucketKey = exports.summarizeUsageRows = exports.bucketUsage = exports.findActiveBillingBlock = exports.computeBillingBlocks = exports.BILLING_BLOCK_DURATION_MS = void 0;
+exports.diagnoseProviderFailure = exports.mergeFailingToolWindows = exports.failingToolTrend = exports.FAILING_TOOL_TREND_ARROWS = exports.sessionSummaryFromStats = exports.removeSessionSummary = exports.markFileImported = exports.isFileImported = exports.applySessionSummary = exports.weekKey = exports.usageBucketKey = exports.summarizeUsageRows = exports.bucketUsage = exports.findActiveBillingBlock = exports.computeBillingBlocks = exports.BILLING_BLOCK_DURATION_MS = void 0;
 var modelContext_1 = require("./modelContext");
 Object.defineProperty(exports, "getModelContextWindowSize", { enumerable: true, get: function () { return modelContext_1.getModelContextWindowSize; } });
 Object.defineProperty(exports, "resolveModelContextWindow", { enumerable: true, get: function () { return modelContext_1.resolveModelContextWindow; } });
@@ -92,3 +92,5 @@ var failingTools_1 = require("./failingTools");
 Object.defineProperty(exports, "FAILING_TOOL_TREND_ARROWS", { enumerable: true, get: function () { return failingTools_1.FAILING_TOOL_TREND_ARROWS; } });
 Object.defineProperty(exports, "failingToolTrend", { enumerable: true, get: function () { return failingTools_1.failingToolTrend; } });
 Object.defineProperty(exports, "mergeFailingToolWindows", { enumerable: true, get: function () { return failingTools_1.mergeFailingToolWindows; } });
+var providerFailure_1 = require("./providerFailure");
+Object.defineProperty(exports, "diagnoseProviderFailure", { enumerable: true, get: function () { return providerFailure_1.diagnoseProviderFailure; } });

package/dist/doctor.d.ts

@@ -1,6 +1,8 @@
 import { type ActiveAccountStatus } from './accountStatus';
 import { type ProjectIdentity } from './paths';
 import { type ProviderStatusState } from './providerStatus';
+import type { ProviderServiceStatus } from './providerServiceStatusTypes';
+import type { ProviderId } from './providers/types';
 import { type OpenCodeDbRuntimeStatus } from './providers/openCodeDatabase';
 export type HealthCheckStatus = 'ok' | 'warning' | 'error' | 'info';
 export interface HealthCheck {
@@ -38,12 +40,25 @@ export interface HealthReport {
         claude: ProviderStatusState;
         openai: ProviderStatusState;
     };
+    serviceStatus?: {
+        claude: ProviderServiceStatus;
+        openai: ProviderServiceStatus;
+    };
+    /** Legacy Claude Code path diagnostics, retained for compatibility. */
     sessions: SessionDiagnostics;
+    sessionProvider?: ProviderId;
 }
 export interface DoctorOptions {
     cwd?: string;
+    /** Session provider to diagnose; defaults to auto-detection. */
+    provider?: ProviderId | 'auto';
     deprecatedSettings?: DeprecatedSetting[];
     openCodeStatus?: OpenCodeDbRuntimeStatus;
+    fetchServiceStatuses?: () => Promise<{
+        claude: ProviderServiceStatus;
+        openai: ProviderServiceStatus;
+    }>;
+    /** Legacy injection; does not establish service evidence availability. */
     fetchStatuses?: () => Promise<{
         claude: ProviderStatusState;
         openai: ProviderStatusState;

package/dist/doctor.js

@@ -43,7 +43,10 @@ const accountStatus_1 = require("./accountStatus");
 const paths_1 = require("./paths");
 const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
 const providerStatus_1 = require("./providerStatus");
+const providerServiceStatus_1 = require("./providerServiceStatus");
 const openCode_1 = require("./providers/openCode");
+const factory_1 = require("./providers/factory");
+const detect_1 = require("./providers/detect");
 const openCodeDatabase_1 = require("./providers/openCodeDatabase");
 /** Collects the Claude Code path-resolution detail used by both host surfaces. */
 function getSessionDiagnostics(workspacePath) {
@@ -100,21 +103,95 @@ function statusUnavailable() {
         updatedAt: new Date().toISOString(),
     };
 }
+async function checkSessionProvider(providerId, workspacePath) {
+    const { providers } = (0, factory_1.createSessionProviders)({ providerIds: [providerId] });
+    const provider = providers[0];
+    const title = `Session discovery (${provider?.displayName ?? providerId})`;
+    try {
+        if (!provider)
+            throw new Error(`${providerId} could not be initialized.`);
+        const sessions = provider.listSessionFilesAsync
+            ? await provider.listSessionFilesAsync(workspacePath)
+            : provider.findAllSessions(workspacePath);
+        if (sessions.length > 0) {
+            return {
+                id: 'session_discovery',
+                status: 'ok',
+                title,
+                message: `Found ${sessions.length} ${provider.displayName} session${sessions.length === 1 ? '' : 's'} for ${workspacePath}.`,
+            };
+        }
+        const operation = provider.getLastOperationStatus?.();
+        const runtime = provider.getRuntimeStatus?.();
+        const issue = operation && !operation.usable
+            ? operation.runtimeStatus
+            : runtime && !runtime.available
+                ? runtime
+                : undefined;
+        return {
+            id: 'session_discovery',
+            status: 'warning',
+            title,
+            message: issue?.message ?? `No ${provider.displayName} sessions found for ${workspacePath}.`,
+            repair: issue?.kind === 'sqlite_missing'
+                ? 'Install sqlite3 and ensure it is on PATH, then rerun sidekick doctor.'
+                : `Start ${provider.displayName} in this project, or inspect ${provider.getSessionDirectory(workspacePath)}.`,
+        };
+    }
+    catch (error) {
+        return {
+            id: 'session_discovery',
+            status: 'warning',
+            title,
+            message: error instanceof Error ? error.message : String(error),
+            repair: `Check ${providerId} session storage permissions and rerun sidekick doctor.`,
+        };
+    }
+    finally {
+        for (const candidate of providers)
+            candidate.dispose();
+    }
+}
 async function runDoctor(options = {}) {
     const project = (0, paths_1.resolveProjectIdentity)(options.cwd);
     const sessions = getSessionDiagnostics(project.cwd);
-    const accounts = (0, accountStatus_1.getActiveAccountStatus)();
+    const accounts = (0, accountStatus_1.getActiveAccountStatus)(undefined, { selfHeal: false });
+    const sessionProvider = options.provider && options.provider !== 'auto' ? options.provider : (0, detect_1.detectProvider)();
     let openCode = options.openCodeStatus;
     if (!openCode) {
         const database = new openCodeDatabase_1.OpenCodeDatabase((0, openCode_1.getOpenCodeDataDir)());
         database.open();
         openCode = database.getRuntimeStatus();
+        database.close();
     }
-    const providerStatus = await (options.fetchStatuses ??
-        (async () => {
-            const [claude, openai] = await Promise.all([(0, providerStatus_1.fetchProviderStatus)(), (0, providerStatus_1.fetchOpenAIStatus)()]);
-            return { claude, openai };
-        }))().catch(() => ({ claude: statusUnavailable(), openai: statusUnavailable() }));
+    const serviceStatus = options.fetchServiceStatuses || !options.fetchStatuses
+        ? await (options.fetchServiceStatuses ??
+            (async () => {
+                const [claude, openai] = await Promise.all([
+                    (0, providerServiceStatus_1.fetchProviderServiceStatus)('claude-code'),
+                    (0, providerServiceStatus_1.fetchProviderServiceStatus)('codex'),
+                ]);
+                return { claude, openai };
+            }))().catch(() => {
+            const unavailable = (provider) => ({
+                availability: 'unavailable',
+                provider,
+                checkedAt: new Date().toISOString(),
+                sourceUrl: `https://status.${provider === 'codex' ? 'openai' : 'claude'}.com/api/v2/summary.json`,
+                reason: 'network_error',
+            });
+            return { claude: unavailable('claude-code'), openai: unavailable('codex') };
+        })
+        : undefined;
+    const providerStatus = serviceStatus
+        ? {
+            claude: (0, providerStatus_1.toLegacyProviderStatus)(serviceStatus.claude),
+            openai: (0, providerStatus_1.toLegacyProviderStatus)(serviceStatus.openai),
+        }
+        : await options.fetchStatuses().catch(() => ({
+            claude: statusUnavailable(),
+            openai: statusUnavailable(),
+        }));
     const checks = [];
     checks.push(project.hasLegacyMismatch
         ? {
@@ -130,20 +207,7 @@ async function runDoctor(options = {}) {
             title: 'Project identity',
             message: `Canonical slug: ${project.canonicalSlug}`,
         });
-    checks.push(sessions.discoveredSessionDir
-        ? {
-            id: 'session_discovery',
-            status: 'ok',
-            title: 'Session discovery',
-            message: `Found Claude Code sessions at ${sessions.discoveredSessionDir}.`,
-        }
-        : {
-            id: 'session_discovery',
-            status: 'warning',
-            title: 'Session discovery',
-            message: `No Claude Code session directory found for ${project.cwd}.`,
-            repair: `Start Claude Code in this project, or inspect ${sessions.expectedSessionDir}.`,
-        });
+    checks.push(await checkSessionProvider(sessionProvider, project.resolvedCwd));
     const openCodeCheck = openCode.available
         ? {
             id: 'opencode_sqlite',
@@ -167,33 +231,66 @@ async function runDoctor(options = {}) {
                     ? 'Install sqlite3 and ensure the sqlite3 executable is on PATH, then rerun sidekick doctor.'
                     : 'Make sqlite3 executable and verify the OpenCode database is readable.',
             };
+    if (sessionProvider !== 'opencode' && openCodeCheck.status === 'warning') {
+        openCodeCheck.status = 'info';
+        openCodeCheck.message += ' This does not affect the selected session provider.';
+    }
     checks.push(openCodeCheck);
     checks.push({
         id: 'accounts',
-        status: accounts.ok ? 'ok' : 'warning',
+        status: accounts.ok ? 'ok' : 'info',
         title: 'Accounts and credentials',
         message: accounts.ok
             ? `Detected ${[accounts.claude.present && 'Claude', accounts.codex.present && 'Codex'].filter(Boolean).join(' and ')} credentials.`
             : (accounts.error ?? 'No Claude or Codex credentials were detected.'),
         ...(!accounts.ok
-            ? { repair: 'Sign in with claude or codex, then rerun sidekick doctor.' }
+            ? {
+                repair: 'Sign in with claude or codex to refresh account quota. Existing sessions can be monitored without saved credentials.',
+            }
             : {}),
     });
-    const unavailableProviders = Object.entries(providerStatus)
-        .filter(([, status]) => status.description === 'Status unavailable')
-        .map(([name]) => name);
-    const degradedProviders = Object.entries(providerStatus)
-        .filter(([, status]) => status.indicator !== 'none')
-        .map(([name]) => name);
+    const unavailableProviders = serviceStatus
+        ? Object.entries(serviceStatus)
+            .filter(([, status]) => status.availability === 'unavailable')
+            .map(([name]) => name)
+        : Object.entries(providerStatus)
+            .filter(([, status]) => status.description === 'Status unavailable')
+            .map(([name]) => name);
+    const degradedProviders = serviceStatus
+        ? Object.entries(serviceStatus)
+            .filter(([, status]) => status.availability === 'observed' && status.severity !== 'none')
+            .map(([name]) => name)
+        : Object.entries(providerStatus)
+            .filter(([, status]) => status.indicator !== 'none')
+            .map(([name]) => name);
+    const partialProviders = serviceStatus
+        ? Object.entries(serviceStatus)
+            .filter(([, status]) => status.availability === 'observed' && status.incidents === null)
+            .map(([name]) => name)
+        : [];
+    const observations = [
+        ...(degradedProviders.length
+            ? [`Public vendor degradation reported for: ${degradedProviders.join(', ')}.`]
+            : []),
+        ...(unavailableProviders.length
+            ? [`Status pages unavailable for: ${unavailableProviders.join(', ')}.`]
+            : []),
+        ...(partialProviders.length
+            ? [`Incident information unavailable for: ${partialProviders.join(', ')}.`]
+            : []),
+    ];
     checks.push({
         id: 'provider_api',
-        status: degradedProviders.length > 0 ? 'warning' : unavailableProviders.length > 0 ? 'info' : 'ok',
-        title: 'Provider API status',
-        message: degradedProviders.length > 0
-            ? `Provider incidents reported for: ${degradedProviders.join(', ')}.`
-            : unavailableProviders.length > 0
-                ? `Status pages unavailable for: ${unavailableProviders.join(', ')}.`
-                : 'Claude and OpenAI status pages report normal operation.',
+        status: degradedProviders.includes(sessionProvider === 'codex' ? 'openai' : sessionProvider === 'claude-code' ? 'claude' : '')
+            ? 'warning'
+            : observations.length
+                ? 'info'
+                : 'ok',
+        title: 'Public provider service status',
+        message: (observations.length
+            ? observations.join(' ')
+            : 'Claude and OpenAI status pages report normal operation.') +
+            ' Public status does not establish request connectivity or authentication.',
     });
     const deprecatedSettings = options.deprecatedSettings ?? [];
     checks.push({
@@ -225,7 +322,9 @@ async function runDoctor(options = {}) {
         accounts,
         openCode,
         providerStatus,
+        ...(serviceStatus ? { serviceStatus } : {}),
         sessions,
+        sessionProvider,
     };
 }
 function formatHealthReport(report) {

package/dist/index.d.ts

@@ -97,7 +97,7 @@ export type { DebugLogEntry, DebugLogFile, DebugLogLevel } from './parsers/debug
 export { OpenCodeDatabase } from './providers/openCodeDatabase';
 export { CodexDatabase } from './providers/codexDatabase';
 export { searchSessions } from './search/sessionSearch';
-export type { SearchResult } from './search/sessionSearch';
+export type { SearchResult, SessionSearchOptions } from './search/sessionSearch';
 export { FilterEngine } from './search/advancedFilter';
 export type { FilterMode, FilterState, HighlightFormat as FilterHighlightFormat, } from './search/advancedFilter';
 export { composeContext } from './context/composer';
@@ -233,7 +233,7 @@ export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHisto
 export { activeProviderAccountStatusSchema, activeAccountStatusSchema, } from './schemas/accountStatus';
 export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, } from './schemas/accountManager';
 export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './schemas/assistantTurn';
-export { fetchProviderStatus, fetchOpenAIStatus } from './providerStatus';
+export { fetchProviderStatus, fetchOpenAIStatus, toLegacyProviderStatus } from './providerStatus';
 export type { ProviderStatusState } from './providerStatus';
 export { formatHealthReport, getSessionDiagnostics, runDoctor } from './doctor';
 export type { DeprecatedSetting, DoctorOptions, HealthCheck, HealthCheckStatus, HealthReport, SessionDiagnostics, } from './doctor';
@@ -241,3 +241,7 @@ export { _resetPeakHoursCache, createPeakHoursNotApplicableState, DEFAULT_PEAK_H
 export type { FetchPeakHoursOptions, PeakHoursState } from './peakHours';
 export { FAILING_TOOL_TREND_ARROWS, failingToolTrend, mergeFailingToolWindows, } from './failingTools';
 export type { FailingToolTrend, FailingToolTrendRow, FailingToolWindow } from './failingTools';
+export { diagnoseProviderFailure } from './providerFailure';
+export type { ProviderCredentialKind, ProviderAuthenticationEvidence, ProviderFailureInput, ProviderFailureCode, ProviderRecoveryAction, ProviderRetryAfter, ProviderFailureEvidence, ProviderFailureDiagnosis, } from './providerFailure';
+export type { ProviderServiceSeverity, ProviderServiceComponent, ProviderServiceIncident, ProviderServiceStatusFailureReason, ObservedProviderServiceStatus, UnavailableProviderServiceStatus, ProviderServiceStatus, FetchProviderServiceStatusOptions, } from './providerServiceStatusTypes';
+export { fetchProviderServiceStatus } from './providerServiceStatus';

package/dist/index.js

@@ -11,7 +11,7 @@ exports.finalizeAccountLogin = exports.getAccountLoginStatusAsync = exports.getA
 exports.FIVE_HOUR_WINDOW_MS = exports.AutoSwitchController = exports.decideAutoSwitch = exports.DEFAULT_AUTO_SWITCH_CONFIG = exports.removeLauncher = exports.writeLauncher = exports.isShellHookInstalled = exports.uninstallShellHook = exports.installShellHook = exports.setTerminalActiveProfile = exports.removeCodexAccount = exports.switchToCodexAccountAsync = exports.switchToCodexAccount = exports.finalizeCodexAccountAsync = exports.finalizeCodexAccount = exports.prepareCodexAccountAsync = exports.prepareCodexAccount = exports.getCodexExecutionEnv = exports.resolveSidekickCodexHome = exports.resolveActiveCodexAccount = exports.getActiveCodexAccount = exports.listCodexAccounts = exports.getSystemCodexHome = exports.getCodexMonitoringHomes = exports.getCodexProfileHome = exports.getCodexProfilesDir = exports.readClaudeProfileIdentity = exports.isClaudeProfileAuthenticated = exports.claudeKeychainService = exports.claudeKeychainSuffix = exports.getClaudeProfileHome = exports.getClaudeProfilesDir = exports.onAccountsChanged = exports.getActiveAccountStatus = exports.ACCOUNT_PROVIDER_IDS = exports.removeSavedAccountProfile = exports.replaceSavedAccountProfiles = exports.setActiveSavedAccount = exports.upsertSavedAccountProfile = exports.getActiveSavedAccount = exports.listSavedAccountProfiles = exports.writeSavedAccountRegistry = exports.readSavedAccountRegistry = exports.getAccountsDir = exports.resolveClaudeLoginCommand = exports.listAllAccounts = exports.switchAccountAsync = exports.switchAccount = exports.spawnAccountLogin = exports.finalizeAccountLoginAsync = void 0;
 exports.calculateCostWithPricing = exports.calculateCost = exports.getModelInfo = exports.resolveModelPricing = exports.getModelPricing = exports.parseModelId = exports.DEFAULT_CONTEXT_WINDOW = exports.resolveModelContextWindow = exports.getModelContextWindowSize = exports.selectStatuslineAccount = exports.formatStatusline = exports.estimateTimeToQuota = exports.BurnRateCalculator = exports.RUNTIME_QUOTA_PROVIDER_IDS = exports.MultiProviderQuotaService = exports.resolveZaiQuota = exports.readZaiCredentials = exports.quotaStateFromZaiQuotaLimitPayload = exports.fetchZaiQuotaFromApi = exports.CodexQuotaWatcher = exports.resolveCodexQuotaFromLocalSources = exports.resolveCodexQuota = exports.readLatestCodexQuotaFromRollouts = exports.quotaFromCodexRateLimits = exports.fetchCodexQuotaFromApi = exports.fetchCodexResetCreditsFromApi = exports.getWorkspaceIdFromPath = exports.pruneQuotaHistory = exports.readQuotaHistoryDailyBuckets = exports.readQuotaHistoryRange = exports.appendQuotaHistorySample = exports.quotaFromStatuslinePayload = exports.parseClaudeStatuslinePayload = exports.evaluateQuotaThresholds = exports.describeQuotaThresholdAlert = exports.DEFAULT_QUOTA_THRESHOLDS = exports.QUOTA_FRESH_MAX_AGE_MS = exports.QUOTA_AGING_MAX_AGE_MS = exports.formatQuotaAge = exports.classifyQuotaFreshness = exports.resolveQuota = exports.writeQuotaSnapshot = exports.readQuotaSnapshot = exports.QuotaPoller = exports.describeQuotaFailure = exports.withQuotaProjections = exports.projectQuotaWindow = exports.fetchQuota = exports.SEVEN_DAY_WINDOW_MS = exports.QUOTA_PROVIDER_IDS = void 0;
 exports.providerQuotaStateSchema = exports.runtimeQuotaProviderSchema = exports.quotaFailureDescriptorSchema = exports.peakHoursStateSchema = exports.codexResetCreditsSnapshotSchema = exports.codexResetCreditSchema = exports.quotaSourceSchema = exports.quotaProviderIdSchema = exports.quotaFailureKindSchema = exports.quotaStateSchema = exports.quotaWindowSchema = exports.extractSessionEvents = exports.permissionModeSchema = exports.sessionEventSchema = exports.sessionMessageSchema = exports.messageUsageSchema = exports.ToolCallTracker = exports.extractToolCalls = exports.extractToolCall = exports.extractErrorMessage = exports.categorizeError = exports.gatherAssetsForCwd = exports.codexSessions = exports.readCodexAssets = exports.claudeSessions = exports.readClaudeAssets = exports.extractCommands = exports.extractFilePaths = exports.extractUrls = exports.extractTokenUsage = exports.getObservedContextWindowPath = exports.recordObservedContextWindow = exports.loadObservedContextWindows = exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmContextWindows = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = exports.RESOLVED_MODEL_CATALOG_SCHEMA_VERSION = exports.resolveModelAlias = exports.registerModelAlias = exports.importResolvedModelCatalog = exports.exportResolvedModelCatalog = exports.MODEL_PROVIDER_IDS = exports.formatCost = exports.sortModelIds = exports.compareModelIds = exports.getModelDisplayInfo = exports.shortModelName = exports.mergeCostSources = exports.calculateCostWithProvenance = void 0;
-exports.mergeFailingToolWindows = exports.failingToolTrend = exports.FAILING_TOOL_TREND_ARROWS = exports.scopePeakHoursToSessionProvider = exports.PEAK_HOURS_DESCRIPTION = exports.PEAK_HOURS_CACHE_MS = exports.isClaudeCodeSessionProvider = exports.getScheduledPeakHoursState = exports.fetchPeakHoursStatus = exports.DEFAULT_PEAK_HOURS_TIMEOUT_MS = exports.createPeakHoursNotApplicableState = exports._resetPeakHoursCache = exports.runDoctor = exports.getSessionDiagnostics = exports.formatHealthReport = exports.fetchOpenAIStatus = exports.fetchProviderStatus = exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = void 0;
+exports.fetchProviderServiceStatus = exports.diagnoseProviderFailure = exports.mergeFailingToolWindows = exports.failingToolTrend = exports.FAILING_TOOL_TREND_ARROWS = exports.scopePeakHoursToSessionProvider = exports.PEAK_HOURS_DESCRIPTION = exports.PEAK_HOURS_CACHE_MS = exports.isClaudeCodeSessionProvider = exports.getScheduledPeakHoursState = exports.fetchPeakHoursStatus = exports.DEFAULT_PEAK_HOURS_TIMEOUT_MS = exports.createPeakHoursNotApplicableState = exports._resetPeakHoursCache = exports.runDoctor = exports.getSessionDiagnostics = exports.formatHealthReport = exports.toLegacyProviderStatus = exports.fetchOpenAIStatus = exports.fetchProviderStatus = exports.assistantTurnToolRefSchema = exports.assistantTurnToolGroupStepSchema = exports.assistantTurnTimelineItemSchema = exports.assistantTurnSubagentStatusSchema = exports.assistantTurnSubagentSchema = exports.assistantTurnReasoningTimelineItemSchema = exports.assistantTurnProjectionSchema = exports.assistantTurnProcessStepSchema = exports.assistantTurnProcessSchema = exports.assistantTurnNarrationStepSchema = exports.assistantTurnEventTypeSchema = exports.assistantTurnEventSchema = exports.listAllAccountsResultSchema = exports.savedAccountProfileSchema = exports.accountEntrySchema = exports.accountLoginStatusSchema = exports.beginAccountLoginResultSchema = exports.accountManagerResultSchema = exports.accountProviderIdSchema = exports.activeAccountStatusSchema = exports.activeProviderAccountStatusSchema = exports.quotaHistoryDailyBucketSchema = exports.quotaHistorySampleSchema = exports.quotaHistoryRuntimeProviderSchema = exports.providerQuotaMapSchema = exports.zaiProviderQuotaStateSchema = exports.codexProviderQuotaStateSchema = exports.claudeProviderQuotaStateSchema = void 0;
 var usageNormalization_1 = require("./usageNormalization");
 Object.defineProperty(exports, "normalizeProviderUsage", { enumerable: true, get: function () { return usageNormalization_1.normalizeProviderUsage; } });
 Object.defineProperty(exports, "extractNormalizedUsage", { enumerable: true, get: function () { return usageNormalization_1.extractNormalizedUsage; } });
@@ -615,6 +615,7 @@ Object.defineProperty(exports, "assistantTurnToolRefSchema", { enumerable: true,
 var providerStatus_1 = require("./providerStatus");
 Object.defineProperty(exports, "fetchProviderStatus", { enumerable: true, get: function () { return providerStatus_1.fetchProviderStatus; } });
 Object.defineProperty(exports, "fetchOpenAIStatus", { enumerable: true, get: function () { return providerStatus_1.fetchOpenAIStatus; } });
+Object.defineProperty(exports, "toLegacyProviderStatus", { enumerable: true, get: function () { return providerStatus_1.toLegacyProviderStatus; } });
 // Shared diagnostics / health report
 var doctor_1 = require("./doctor");
 Object.defineProperty(exports, "formatHealthReport", { enumerable: true, get: function () { return doctor_1.formatHealthReport; } });
@@ -635,3 +636,7 @@ var failingTools_1 = require("./failingTools");
 Object.defineProperty(exports, "FAILING_TOOL_TREND_ARROWS", { enumerable: true, get: function () { return failingTools_1.FAILING_TOOL_TREND_ARROWS; } });
 Object.defineProperty(exports, "failingToolTrend", { enumerable: true, get: function () { return failingTools_1.failingToolTrend; } });
 Object.defineProperty(exports, "mergeFailingToolWindows", { enumerable: true, get: function () { return failingTools_1.mergeFailingToolWindows; } });
+var providerFailure_1 = require("./providerFailure");
+Object.defineProperty(exports, "diagnoseProviderFailure", { enumerable: true, get: function () { return providerFailure_1.diagnoseProviderFailure; } });
+var providerServiceStatus_1 = require("./providerServiceStatus");
+Object.defineProperty(exports, "fetchProviderServiceStatus", { enumerable: true, get: function () { return providerServiceStatus_1.fetchProviderServiceStatus; } });

package/dist/node.d.ts

@@ -38,3 +38,5 @@ export { listSessionPreviews, listSessionPreviewsAsync, readSessionPreview, read
 export type { AsyncSessionPreviewOptions, ListSessionPreviewsAsyncOptions, ListSessionPreviewsOptions, ReadSessionPreviewAsyncOptions, ReadSessionPreviewOptions, SessionPreview, SessionPreviewListResult, SessionPreviewReadResult, } from './sessionPreviews';
 export { ObservedSessionCollector, observedSessionSourceFromProvider, fileFingerprint, fileFingerprintParts, } from './observedSessionCollector';
 export type { KnownObservedSessionFingerprint, ObservedSessionChange, ObservedSessionChangeBatch, ObservedSessionChangeType, ObservedSessionReference, ObservedSessionFingerprintParts, ObservedSessionSourceSubscribeOptions, ObservedSessionSubscribeOptions, ObservedSessionCollectionSource, ProviderObservedSessionCollectionSource, ObservedSessionDiagnosticKind, ObservedSessionDiagnosticPhase, ObservedSessionDiagnosticSeverity, ObservedSessionDiagnostic, ObservedSessionCollection, ObservedSessionCollectorOptions, } from './observedSessionCollector';
+export type { ProviderServiceSeverity, ProviderServiceComponent, ProviderServiceIncident, ProviderServiceStatusFailureReason, ObservedProviderServiceStatus, UnavailableProviderServiceStatus, ProviderServiceStatus, FetchProviderServiceStatusOptions, } from './providerServiceStatusTypes';
+export { fetchProviderServiceStatus } from './providerServiceStatus';

package/dist/node.js

@@ -8,7 +8,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readSessionPreviewAsync = exports.readSessionPreview = exports.listSessionPreviewsAsync = exports.listSessionPreviews = exports.readCodexHistory = exports.walkRolloutFilesAsync = exports.walkRolloutFiles = exports.findCodexRolloutFile = exports.weekKey = exports.usageBucketKey = exports.summarizeUsageRows = exports.bucketUsage = exports.importSessionHistory = exports.ACTIVE_SESSION_MTIME_THRESHOLD_MS = exports.sessionSummaryFromStats = exports.removeSessionSummary = exports.markFileImported = exports.isFileImported = exports.applySessionSummary = exports.pruneUsageCache = exports.getUsageCacheDir = exports.collectUsageEvents = exports.USAGE_CACHE_VERSION = exports.MAX_USAGE_CACHE_FILES = exports.findActiveBillingBlock = exports.computeBillingBlocks = exports.BILLING_BLOCK_DURATION_MS = exports.writeStateFile = exports.readStateFile = exports.quotaToStateFile = exports.getStateFilePath = exports.billingBlockToStateFile = exports.STATE_FILE_SCHEMA_VERSION = exports.STATE_FILE_NAME = exports.sessionFingerprintParts = exports.fingerprintString = exports.readSessionReportInputs = exports.readSessionFileStats = exports.providerContextSizeFn = exports.firstUserPrompt = exports.computeSessionFileStats = exports.readSessionTranscript = exports.listRecentSessions = exports.getObservedContextWindowPath = exports.recordObservedContextWindow = exports.loadObservedContextWindows = exports.LITELLM_CATALOG_URL = exports.normalizeLiteLlmContextWindows = exports.normalizeLiteLlmCatalog = exports.hydratePricingCatalog = void 0;
-exports.fileFingerprintParts = exports.fileFingerprint = exports.observedSessionSourceFromProvider = exports.ObservedSessionCollector = void 0;
+exports.fetchProviderServiceStatus = exports.fileFingerprintParts = exports.fileFingerprint = exports.observedSessionSourceFromProvider = exports.ObservedSessionCollector = void 0;
 var pricingCatalog_1 = require("./pricingCatalog");
 Object.defineProperty(exports, "hydratePricingCatalog", { enumerable: true, get: function () { return pricingCatalog_1.hydratePricingCatalog; } });
 Object.defineProperty(exports, "normalizeLiteLlmCatalog", { enumerable: true, get: function () { return pricingCatalog_1.normalizeLiteLlmCatalog; } });
@@ -80,3 +80,5 @@ Object.defineProperty(exports, "ObservedSessionCollector", { enumerable: true, g
 Object.defineProperty(exports, "observedSessionSourceFromProvider", { enumerable: true, get: function () { return observedSessionCollector_1.observedSessionSourceFromProvider; } });
 Object.defineProperty(exports, "fileFingerprint", { enumerable: true, get: function () { return observedSessionCollector_1.fileFingerprint; } });
 Object.defineProperty(exports, "fileFingerprintParts", { enumerable: true, get: function () { return observedSessionCollector_1.fileFingerprintParts; } });
+var providerServiceStatus_1 = require("./providerServiceStatus");
+Object.defineProperty(exports, "fetchProviderServiceStatus", { enumerable: true, get: function () { return providerServiceStatus_1.fetchProviderServiceStatus; } });