sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/report/index.js

@@ -0,0 +1,7 @@
+/**
+ * Public API for the report module.
+ */
+export { parseTranscript, parseTranscriptFromEvents } from './transcriptParser';
+export { generateHtmlReport } from './htmlReportGenerator';
+export { openInBrowser } from './openBrowser';
+export { escapeHtml, simpleMarkdownToHtml, highlightCodeBlock } from './htmlHelpers';

package/dist/esm/report/logo.js

@@ -0,0 +1,2 @@
+/** Sidekick logo as a base64-encoded PNG data URI (64x64). */
+export const SIDEKICK_LOGO_BASE64 = 'data:image/png;base64,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';

package/dist/esm/report/openBrowser.js

@@ -0,0 +1,19 @@
+/**
+ * Cross-platform browser opener for HTML report files.
+ */
+import { execFile } from 'child_process';
+/** Open a file path in the default system browser. */
+export function openInBrowser(filePath) {
+    const url = `file://${filePath}`;
+    switch (process.platform) {
+        case 'darwin':
+            execFile('open', [url]);
+            break;
+        case 'win32':
+            execFile('rundll32.exe', ['url.dll,FileProtocolHandler', url]);
+            break;
+        default:
+            execFile('xdg-open', [url]);
+            break;
+    }
+}

package/dist/esm/report/sessionReportInputs.js

@@ -0,0 +1,33 @@
+/**
+ * Everything an HTML session report needs, from one read of the session.
+ *
+ * `sidekick report`, the CLI dashboard's report action, and the extension used
+ * to replay a session through a watcher for metrics and then parse the file a
+ * second time for the transcript. This reads the provider's canonical events
+ * once and derives both.
+ *
+ * @module report/sessionReportInputs
+ */
+import { EventAggregator } from '../aggregation/EventAggregator';
+import { providerContextSizeFn } from '../sessionStats';
+import { scanSessionSubagents } from '../sessionTokenTotals';
+import { parseTranscriptFromEvents } from './transcriptParser';
+/** Read a session once and build the aggregator metrics and report transcript from it. */
+export function readSessionReportInputs(provider, sessionPath) {
+    const reader = provider.createReader(sessionPath);
+    const events = reader.readAll();
+    reader.flush();
+    const aggregator = new EventAggregator({
+        providerId: provider.id,
+        computeContextSize: providerContextSizeFn(provider),
+    });
+    for (const event of events)
+        aggregator.processEvent(event);
+    return {
+        sessionPath,
+        events,
+        metrics: aggregator.getMetrics(),
+        transcript: parseTranscriptFromEvents(events),
+        subagents: scanSessionSubagents(provider, sessionPath),
+    };
+}

package/dist/esm/report/transcriptParser.js

@@ -0,0 +1,83 @@
+/** Report compatibility adapters over the canonical transcript projection. */
+import * as fs from 'node:fs';
+import { JsonlParser } from '../parsers/jsonl';
+import { extractSessionEvents } from '../schemas/sessionEvent';
+import { projectSessionTranscript } from '../transcript';
+/** Parse a Claude Code JSONL session through the canonical provider reader. */
+export function parseTranscript(sessionPath) {
+    try {
+        const events = [];
+        const parser = new JsonlParser({
+            onEvent: (raw) => events.push(...extractSessionEvents(raw)),
+        });
+        parser.processChunk(fs.readFileSync(sessionPath, 'utf8'));
+        parser.flush();
+        return parseTranscriptFromEvents(events);
+    }
+    catch {
+        return [];
+    }
+}
+/** Project canonical provider events into the legacy report transcript shape. */
+export function parseTranscriptFromEvents(events) {
+    return projectSessionTranscript(events, { fidelity: 'full' }).messages.map((message) => ({
+        type: message.role === 'tool' ? 'system' : message.role,
+        timestamp: message.timestamp,
+        sourceLabel: message.sourceLabel,
+        model: message.model,
+        usage: message.usage
+            ? {
+                input_tokens: message.usage.uncachedInputTokens,
+                output_tokens: message.usage.outputTokens,
+                cache_creation_input_tokens: message.usage.cacheWriteTokens || undefined,
+                cache_read_input_tokens: message.usage.cacheReadTokens || undefined,
+            }
+            : undefined,
+        content: message.content.flatMap(toReportBlock),
+    }));
+}
+function toReportBlock(block) {
+    switch (block.type) {
+        case 'text':
+            return block.text ? [{ type: 'text', text: block.text }] : [];
+        case 'thinking':
+            return block.text ? [{ type: 'thinking', text: block.text }] : [];
+        case 'tool_use':
+            return [
+                {
+                    type: 'tool_use',
+                    toolName: block.toolName ?? 'unknown',
+                    toolInput: block.input && typeof block.input === 'object'
+                        ? block.input
+                        : {},
+                    toolUseId: block.toolUseId,
+                },
+            ];
+        case 'tool_result':
+            return [
+                {
+                    type: 'tool_result',
+                    toolUseId: block.toolUseId,
+                    output: reportToolOutput(block.output),
+                    isError: block.isError,
+                },
+            ];
+        case 'image':
+            return [{ type: 'image', text: block.text ?? '[Image content]' }];
+        case 'unknown':
+            return [];
+    }
+}
+function reportToolOutput(output) {
+    if (typeof output === 'string')
+        return output;
+    if (Array.isArray(output)) {
+        return output
+            .flatMap((part) => part && typeof part === 'object' && part.type === 'text'
+            ? [String(part.text ?? '')]
+            : [])
+            .filter(Boolean)
+            .join('\n');
+    }
+    return JSON.stringify(output ?? '');
+}

package/dist/esm/report/types.js

@@ -0,0 +1,4 @@
+/**
+ * Report-specific types for HTML session report generation.
+ */
+export {};

package/dist/esm/schemas/accountManager.js

@@ -0,0 +1,204 @@
+/**
+ * Zod schemas for runtime validation of account management payloads.
+ *
+ * These schemas mirror the TypeScript interfaces in `accounts.ts`,
+ * `accountRegistry.ts`, and `accountManager.ts` (keep in sync when those
+ * change). They let consumers validate account-management IPC payloads
+ * without hand-mirroring the interfaces.
+ *
+ * @module schemas/accountManager
+ */
+import { z } from 'zod';
+import { ACCOUNT_PROVIDER_IDS } from '../providerIds';
+// ── AccountProviderId ──
+export const accountProviderIdSchema = z.enum(ACCOUNT_PROVIDER_IDS);
+// ── AccountManagerResult ──
+export const accountManagerResultSchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    warning: z.string().optional(),
+    needsLogin: z.boolean().optional(),
+    profileId: z.string().optional(),
+    codexHome: z.string().optional(),
+});
+// ── BeginAccountLoginResult ──
+const beginAccountLoginSuccessSchema = z.object({
+    success: z.literal(true),
+    loginId: z.string(),
+    alreadyComplete: z.boolean().optional(),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    envUnset: z.array(z.string()).optional(),
+    configDir: z.string().optional(),
+    existingAccountId: z.string().optional(),
+});
+const beginAccountLoginFailureSchema = z.object({
+    success: z.literal(false),
+    error: z.string(),
+});
+export const beginAccountLoginResultSchema = z.union([
+    beginAccountLoginSuccessSchema,
+    beginAccountLoginFailureSchema,
+]);
+// ── AccountLoginStatus ──
+export const accountLoginStatusSchema = z.object({
+    state: z.enum(['pending', 'authenticated', 'failed']),
+    email: z.string().optional(),
+    error: z.string().optional(),
+});
+// ── AccountEntry ──
+export const accountEntrySchema = z.object({
+    uuid: z.string(),
+    email: z.string(),
+    label: z.string().optional(),
+    addedAt: z.string(),
+});
+// ── SavedAccountProfile ──
+const accountIdentityMetadataSchema = z.object({
+    email: z.string().optional(),
+    workspaceId: z.string().optional(),
+    planType: z.string().optional(),
+    authMode: z.enum(['chatgpt', 'api-key', 'unknown']).optional(),
+    origin: z.enum(['login', 'manual', 'live-sync', 'migration']).optional(),
+});
+export const savedAccountProfileSchema = z.object({
+    id: z.string(),
+    providerId: accountProviderIdSchema,
+    addedAt: z.string(),
+    label: z.string().optional(),
+    email: z.string().optional(),
+    providerAccountId: z.string().optional(),
+    metadata: accountIdentityMetadataSchema.optional(),
+});
+// ── ListAllAccountsResult ──
+export const listAllAccountsResultSchema = z.object({
+    claude: z.array(accountEntrySchema),
+    codex: z.array(savedAccountProfileSchema),
+    activeByProvider: z.object({
+        'claude-code': z.string().nullable(),
+        codex: z.string().nullable(),
+    }),
+});
+// ── Account health ──
+export const accountHealthStateSchema = z.enum([
+    'fresh',
+    'expiring',
+    'expired',
+    'unknown',
+    'missing',
+]);
+export const accountHealthSourceSchema = z.enum([
+    'live-sync',
+    'login',
+    'switch',
+    'keepalive',
+    'migration',
+]);
+export const accountHealthSidecarSchema = z.object({
+    version: z.literal(1),
+    capturedAt: z.number(),
+    accessExpiresAt: z.number().optional(),
+    refreshExpiresAt: z.number().optional(),
+    refreshExpiryEstimated: z.boolean().optional(),
+    lastRefreshAt: z.number().optional(),
+    hasRefreshToken: z.boolean().optional(),
+    authMode: z.enum(['chatgpt', 'api-key', 'oauth']).optional(),
+    refreshFp: z.string().optional(),
+    source: accountHealthSourceSchema,
+});
+export const accountHealthSchema = z.object({
+    providerId: accountProviderIdSchema,
+    accountId: z.string(),
+    state: accountHealthStateSchema,
+    accessExpiresAt: z.number().optional(),
+    refreshExpiresAt: z.number().optional(),
+    refreshExpiryEstimated: z.boolean().optional(),
+    lastRefreshAt: z.number().optional(),
+    checkedAt: z.number(),
+    isLive: z.boolean(),
+    reason: z.string().optional(),
+});
+export const accountViewSchema = z.object({
+    id: z.string(),
+    providerId: accountProviderIdSchema,
+    label: z.string().optional(),
+    email: z.string().optional(),
+    planType: z.string().optional(),
+    isActive: z.boolean(),
+    health: accountHealthSchema,
+    source: z.enum(['registered', 'learned']),
+    addedAt: z.string(),
+});
+// ── Running consumers / switch result ──
+export const runningProcessSchema = z.object({
+    pid: z.number(),
+    name: z.string(),
+    command: z.string(),
+});
+export const accountConsumerKindSchema = z.enum([
+    'claude-cli',
+    'claude-desktop',
+    'codex-cli',
+    'codex-app',
+    'vscode-extension-host',
+]);
+export const runningAccountConsumerSchema = z.object({
+    kind: accountConsumerKindSchema,
+    pids: z.array(z.number()),
+    switched: z.boolean(),
+    reachability: z.string(),
+});
+export const switchAccountResultSchema = accountManagerResultSchema.extend({
+    provider: accountProviderIdSchema,
+    accountId: z.string(),
+    previousAccountId: z.string().nullable(),
+    verified: z.boolean(),
+    verification: z.enum(['store', 'cli', 'none', 'failed']),
+    health: accountHealthSchema.optional(),
+    warnings: z.array(z.string()),
+    hints: z.array(z.string()),
+    runningConsumers: z.array(runningAccountConsumerSchema),
+    undoToken: z.string().optional(),
+    alreadyActive: z.boolean().optional(),
+    email: z.string().optional(),
+});
+export const lastSwitchRecordSchema = z.object({
+    token: z.string(),
+    provider: accountProviderIdSchema,
+    from: z.string().nullable(),
+    to: z.string(),
+    at: z.string(),
+});
+// ── Sync report ──
+export const providerSyncReportSchema = z.object({
+    registered: z.object({ id: z.string(), email: z.string().optional() }).optional(),
+    folded: z.string().optional(),
+    repointed: z.string().optional(),
+    merged: z.array(z.string()).optional(),
+    demoted: z.string().optional(),
+    repaired: z.string().optional(),
+    journal: z.enum(['finished', 'rolled-back', 'cleared']).optional(),
+    skipped: z.string().optional(),
+    warnings: z.array(z.string()),
+});
+export const syncReportSchema = z.object({
+    claude: providerSyncReportSchema,
+    codex: providerSyncReportSchema,
+    ranAt: z.number(),
+    reason: z.enum(['startup', 'watch', 'poll', 'pre-switch', 'manual']),
+});
+// ── Launch env ──
+export const accountLaunchEnvSchema = z.object({
+    provider: accountProviderIdSchema,
+    accountId: z.string(),
+    label: z.string().optional(),
+    email: z.string().optional(),
+    home: z.string(),
+    env: z.record(z.string(), z.string()),
+    envUnset: z.array(z.string()),
+    command: z.enum(['claude', 'codex']),
+    health: accountHealthSchema,
+    warnings: z.array(z.string()),
+    error: z.string().optional(),
+});

package/dist/esm/schemas/accountStatus.js

@@ -0,0 +1,25 @@
+/**
+ * Zod schemas for runtime validation of active account status.
+ *
+ * These schemas mirror the TypeScript interfaces in `accountStatus.ts`
+ * (keep in sync when those change). They let consumers validate account
+ * status payloads at process/IPC boundaries without hand-mirroring the
+ * interfaces.
+ *
+ * @module schemas/accountStatus
+ */
+import { z } from 'zod';
+// ── ActiveProviderAccountStatus ──
+export const activeProviderAccountStatusSchema = z.object({
+    present: z.boolean(),
+    accountId: z.string().optional(),
+    email: z.string().optional(),
+    label: z.string().optional(),
+});
+// ── ActiveAccountStatus ──
+export const activeAccountStatusSchema = z.object({
+    ok: z.boolean(),
+    claude: activeProviderAccountStatusSchema,
+    codex: activeProviderAccountStatusSchema,
+    error: z.string().optional(),
+});

package/dist/esm/schemas/assistantTurn.js

@@ -0,0 +1,74 @@
+/**
+ * Zod schemas for browser-safe assistant turn projections.
+ *
+ * These schemas mirror `turns/assistantTurn.ts` and validate the compact
+ * process/answer shape used at UI and IPC boundaries.
+ */
+import { z } from 'zod';
+export const assistantTurnEventTypeSchema = z.enum([
+    'text',
+    'thinking',
+    'tool_use',
+    'tool_result',
+    'status',
+    'error',
+    'delta',
+    'progress',
+]);
+export const assistantTurnEventSchema = z.object({
+    eventType: assistantTurnEventTypeSchema,
+    content: z.string(),
+    deltaKind: z.enum(['text', 'thinking', 'tool_input']).optional(),
+    toolName: z.string().optional(),
+    toolInput: z.unknown().optional(),
+    toolUseId: z.string().optional(),
+});
+export const assistantTurnToolRefSchema = z.object({
+    toolName: z.string(),
+    toolInput: z.string().optional(),
+    toolUseId: z.string().optional(),
+});
+export const assistantTurnNarrationStepSchema = z.object({
+    kind: z.literal('narration'),
+    text: z.string(),
+});
+export const assistantTurnToolGroupStepSchema = z.object({
+    kind: z.literal('toolGroup'),
+    tools: z.array(assistantTurnToolRefSchema),
+});
+export const assistantTurnProcessStepSchema = z.discriminatedUnion('kind', [
+    assistantTurnNarrationStepSchema,
+    assistantTurnToolGroupStepSchema,
+]);
+export const assistantTurnReasoningTimelineItemSchema = z.object({
+    kind: z.literal('reasoning'),
+    text: z.string(),
+});
+export const assistantTurnTimelineItemSchema = z.discriminatedUnion('kind', [
+    assistantTurnReasoningTimelineItemSchema,
+    assistantTurnNarrationStepSchema,
+    assistantTurnToolGroupStepSchema,
+]);
+export const assistantTurnProcessSchema = z.object({
+    steps: z.array(assistantTurnProcessStepSchema),
+});
+export const assistantTurnSubagentStatusSchema = z.enum([
+    'running',
+    'completed',
+    'failed',
+]);
+export const assistantTurnSubagentSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    agentType: z.string().optional(),
+    status: assistantTurnSubagentStatusSchema,
+});
+export const assistantTurnProjectionSchema = z.object({
+    schemaVersion: z.literal(2),
+    answer: z.string(),
+    reasoning: z.string(),
+    reasoningBlocks: z.array(z.string()),
+    process: assistantTurnProcessSchema,
+    timeline: z.array(assistantTurnTimelineItemSchema),
+    subagents: z.array(assistantTurnSubagentSchema),
+});

package/dist/esm/schemas/index.js

@@ -0,0 +1,25 @@
+/**
+ * Schemas entry (`sidekick-shared/schemas`).
+ *
+ * Pure zod runtime validation for the data shapes that cross process/IPC
+ * boundaries: session events, quota state, quota history, account status,
+ * and assistant turn projections. No node:fs / node:path — safe to bundle
+ * for browser runtimes, and lean enough that importing it does not drag in
+ * the rest of the library.
+ *
+ * The mirrored TypeScript interfaces are re-exported as types so this
+ * subpath is self-sufficient for boundary-validation modules.
+ */
+export { ACCOUNT_PROVIDER_IDS, QUOTA_PROVIDER_IDS, RUNTIME_QUOTA_PROVIDER_IDS, SESSION_PROVIDER_IDS, } from '../providerIds';
+export { messageUsageSchema, sessionMessageSchema, sessionEventSchema, permissionModeSchema, extractSessionEvents, userSessionEventSchema, assistantSessionEventSchema, summarySessionEventSchema, systemSessionEventSchema, toolUseSessionEventSchema, toolResultSessionEventSchema, } from './sessionEvent';
+export { normalizedUsageSchema, normalizedUsageCostSchema } from './usageNormalization';
+export { tokenEstimateSchema } from './tokenEstimation';
+export { providerAuthenticationEvidenceSchema, providerFailureEvidenceSchema, providerRetryAfterSchema, providerFailureDiagnosisSchema, } from './providerFailure';
+export { transcriptSourceProvenanceSchema, canonicalTranscriptBlockSchema, canonicalToolCallSchema, canonicalTranscriptMessageSchema, canonicalSessionTranscriptSchema, } from './transcript';
+export { observationProvenanceV1Schema, observedAgentSessionV1Schema, observedValueV1Schema, pendingUserRequestV1Schema, providerCapabilitiesV1Schema, providerSessionAdapterV1Schema, sessionEvidenceRefV1Schema, } from './observedSessionV1';
+export { quotaWindowSchema, quotaStateSchema, quotaFailureKindSchema, quotaProviderIdSchema, quotaSourceSchema, codexResetCreditSchema, codexResetCreditsSnapshotSchema, peakHoursStateSchema, quotaFailureDescriptorSchema, runtimeQuotaProviderSchema, providerQuotaStateSchema, claudeProviderQuotaStateSchema, codexProviderQuotaStateSchema, zaiProviderQuotaStateSchema, providerQuotaMapSchema, } from './quota';
+export { quotaHistoryRuntimeProviderSchema, quotaHistorySampleSchema, quotaHistoryDailyBucketSchema, } from './quotaHistory';
+export { activeProviderAccountStatusSchema, activeAccountStatusSchema } from './accountStatus';
+export { accountProviderIdSchema, accountManagerResultSchema, beginAccountLoginResultSchema, accountLoginStatusSchema, accountEntrySchema, savedAccountProfileSchema, listAllAccountsResultSchema, accountHealthStateSchema, accountHealthSourceSchema, accountHealthSidecarSchema, accountHealthSchema, accountViewSchema, runningProcessSchema, accountConsumerKindSchema, runningAccountConsumerSchema, switchAccountResultSchema, lastSwitchRecordSchema, providerSyncReportSchema, syncReportSchema, accountLaunchEnvSchema, } from './accountManager';
+export { assistantTurnEventSchema, assistantTurnEventTypeSchema, assistantTurnNarrationStepSchema, assistantTurnProcessSchema, assistantTurnProcessStepSchema, assistantTurnProjectionSchema, assistantTurnReasoningTimelineItemSchema, assistantTurnSubagentSchema, assistantTurnSubagentStatusSchema, assistantTurnTimelineItemSchema, assistantTurnToolGroupStepSchema, assistantTurnToolRefSchema, } from './assistantTurn';
+export { sidekickStateFileSchema, stateFileAccountSchema, stateFileBillingBlockSchema, stateFileContextSchema, stateFileQuotaSchema, stateFileQuotaWindowSchema, stateFileSessionSchema, stateFileWriterSchema, } from './stateFile';

package/dist/esm/schemas/observedSessionV1.js

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { SESSION_PROVIDER_IDS } from '../providerIds';
+export const observationProvenanceV1Schema = z.enum(['reported', 'estimated', 'inferred']);
+export const sessionEvidenceRefV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    provider: z.enum(SESSION_PROVIDER_IDS),
+    sessionId: z.string().min(1),
+    sourcePath: z.string().optional(),
+    eventIndex: z.number().int().nonnegative().optional(),
+    eventId: z.string().optional(),
+    timestamp: z.string().optional(),
+});
+export const observedValueV1Schema = (value) => z.object({
+    value,
+    provenance: observationProvenanceV1Schema,
+    confidence: z.number().min(0).max(1),
+    evidence: z.array(sessionEvidenceRefV1Schema),
+});
+export const pendingUserRequestV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    id: z.string().min(1),
+    provider: z.enum(SESSION_PROVIDER_IDS),
+    sessionId: z.string().min(1),
+    kind: observedValueV1Schema(z.enum(['prompt_response', 'tool_approval', 'question'])),
+    requestedAt: observedValueV1Schema(z.string()),
+    prompt: observedValueV1Schema(z.string().nullable()),
+});
+export const observedAgentSessionV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    identity: z.object({
+        provider: z.enum(SESSION_PROVIDER_IDS),
+        sessionId: z.string().min(1),
+        sourcePath: z.string(),
+    }),
+    cwd: observedValueV1Schema(z.string()),
+    model: observedValueV1Schema(z.string().nullable()),
+    activity: observedValueV1Schema(z.enum(['active', 'idle', 'ended', 'unknown'])),
+    usage: z.object({
+        inputTokens: observedValueV1Schema(z.number().nonnegative()),
+        outputTokens: observedValueV1Schema(z.number().nonnegative()),
+        cacheReadTokens: observedValueV1Schema(z.number().nonnegative()),
+        cacheWriteTokens: observedValueV1Schema(z.number().nonnegative()),
+        normalized: observedValueV1Schema(z.object({
+            uncachedInputTokens: z.number().finite().nonnegative(),
+            cacheReadTokens: z.number().finite().nonnegative(),
+            cacheWriteTokens: z.number().finite().nonnegative(),
+            outputTokens: z.number().finite().nonnegative(),
+            reasoningTokens: z.number().finite().nonnegative(),
+            cacheInclusiveInputTokens: z.number().finite().nonnegative(),
+            billableOutputTokens: z.number().finite().nonnegative(),
+            totalTokens: z.number().finite().nonnegative(),
+        })).optional(),
+        costUsd: observedValueV1Schema(z.number().nonnegative().nullable()),
+    }),
+    pendingUserRequest: pendingUserRequestV1Schema.nullable(),
+    contentObservedAt: z.string().optional(),
+    observedAt: z.string(),
+});
+export const providerCapabilitiesV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    provider: z.enum(SESSION_PROVIDER_IDS),
+    resume: observedValueV1Schema(z.boolean()),
+    forkLineage: observedValueV1Schema(z.boolean()),
+    quotaSource: observedValueV1Schema(z.enum(['api', 'session', 'mixed', 'none'])),
+    assetExtraction: observedValueV1Schema(z.boolean()),
+});
+export const providerSessionAdapterV1Schema = z.custom((value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const adapter = value;
+    return (adapter.schemaVersion === 1 &&
+        typeof adapter.discover === 'function' &&
+        typeof adapter.read === 'function' &&
+        typeof adapter.watch === 'function' &&
+        typeof adapter.dispose === 'function' &&
+        providerCapabilitiesV1Schema.safeParse(adapter.capabilities).success);
+}, { message: 'Invalid ProviderSessionAdapterV1 contract' });

package/dist/esm/schemas/providerFailure.js

@@ -0,0 +1,37 @@
+/**
+ * Zod schema for runtime validation of provider-failure diagnoses.
+ *
+ * The enums are built from the same `as const` arrays that define the
+ * TypeScript unions in `providerFailure.ts`, so a new failure code or recovery
+ * action reaches the schema without a second edit.
+ *
+ * @module schemas/providerFailure
+ */
+import { z } from 'zod';
+import { ACCOUNT_PROVIDER_IDS } from '../providerIds';
+import { PROVIDER_AUTHENTICATION_SOURCES, PROVIDER_AUTHENTICATION_STATES, PROVIDER_CREDENTIAL_KINDS, PROVIDER_FAILURE_CODES, PROVIDER_FAILURE_EVIDENCE_SOURCES, PROVIDER_RECOVERY_ACTIONS, } from '../providerFailure';
+export const providerAuthenticationEvidenceSchema = z.object({
+    credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
+    state: z.enum(PROVIDER_AUTHENTICATION_STATES),
+    checkedAt: z.string(),
+    source: z.enum(PROVIDER_AUTHENTICATION_SOURCES),
+});
+export const providerFailureEvidenceSchema = z.object({
+    source: z.enum(PROVIDER_FAILURE_EVIDENCE_SOURCES),
+    rule: z.enum(PROVIDER_FAILURE_CODES),
+    checkedAt: z.string().optional(),
+});
+export const providerRetryAfterSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('delay'), delayMs: z.number() }),
+    z.object({ kind: z.literal('date'), at: z.string() }),
+]);
+export const providerFailureDiagnosisSchema = z.object({
+    provider: z.enum(ACCOUNT_PROVIDER_IDS),
+    credentialKind: z.enum(PROVIDER_CREDENTIAL_KINDS),
+    diagnosis: z.enum(PROVIDER_FAILURE_CODES),
+    recovery: z.enum(PROVIDER_RECOVERY_ACTIONS),
+    evidence: z.array(providerFailureEvidenceSchema),
+    authentication: providerAuthenticationEvidenceSchema.optional(),
+    httpStatus: z.number().optional(),
+    retryAfter: providerRetryAfterSchema.optional(),
+});