sidekick-shared 0.28.3 → 0.29.1

package/dist/providers/codex.js

@@ -43,8 +43,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexProvider = void 0;
-exports.findCodexRolloutFile = findCodexRolloutFile;
+exports.CodexProvider = exports.findCodexRolloutFile = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const string_decoder_1 = require("string_decoder");
@@ -56,6 +55,7 @@ const subagentStatsCache_1 = require("../parsers/subagentStatsCache");
 const rolloutWalker_1 = require("./rolloutWalker");
 const codexPaths_1 = require("../codexPaths");
 const codexRollouts_1 = require("./codexRollouts");
+Object.defineProperty(exports, "findCodexRolloutFile", { enumerable: true, get: function () { return codexRollouts_1.findCodexRolloutFile; } });
 const directoryListingCache_1 = require("./directoryListingCache");
 const diagnostics_1 = require("./diagnostics");
 const modelContext_1 = require("../modelContext");
@@ -84,29 +84,6 @@ function hasRolloutFile(dir) {
 function findRolloutFilesInConfiguredHomes(options = {}) {
     return (0, rolloutWalker_1.walkRolloutFiles)((0, codexRollouts_1.getSessionsDirs)(), options);
 }
-/**
- * Locates the rollout file for a Codex session id by walking
- * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`, then
- * `<home>/archived_sessions/`, where Codex moves the rollouts of archived
- * threads.
- *
- * Filename-only match, case-insensitive on the id — no file contents are read
- * and files are only stat'ed once their name matches, so the walk stays cheap
- * even over a large history. When the same id exists in more than one home,
- * the most recently modified copy wins. Returns `null` for an unknown, empty,
- * or whitespace id. Consumers who want the database's answer instead can query
- * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
- */
-function findCodexRolloutFile(sessionId, options = {}) {
-    const normalizedId = sessionId.trim().toLowerCase();
-    if (!normalizedId)
-        return null;
-    const sessionsDirs = options.codexHome
-        ? (0, codexPaths_1.getCodexSessionsDirs)([options.codexHome])
-        : (0, codexRollouts_1.getSessionsDirs)();
-    // Name-only filter, one walk across the homes, newest modification first.
-    return (0, rolloutWalker_1.walkRolloutFiles)(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
-}
 /** Pick the best sessions directory for UI/search entrypoints. */
 function getSessionsDir() {
     const dirs = (0, codexPaths_1.getCodexSessionsDirs)(undefined, { includeArchived: false });
@@ -329,6 +306,12 @@ class CodexReader {
     lineBuffer = '';
     _wasTruncated = false;
     decoder = new string_decoder_1.StringDecoder('utf8');
+    /**
+     * Position from `seekTo()` whose prefix still has to be parsed for model,
+     * turn, and cumulative-token context; `restoreResumeState()` supplies that
+     * context instead and clears it.
+     */
+    pendingSeek = null;
     constructor(rolloutPath, onContextWindowLimit, onRateLimits, onTokenUsage) {
         this.rolloutPath = rolloutPath;
         this.onContextWindowLimit = onContextWindowLimit;
@@ -338,9 +321,11 @@ class CodexReader {
     }
     /** Get the parser's session metadata. */
     getSessionMeta() {
+        this.settleSeek();
         return this.parser.getSessionMeta();
     }
     readNew(endPosition) {
+        this.settleSeek();
         this._wasTruncated = false;
         const events = [];
         try {
@@ -394,47 +379,51 @@ class CodexReader {
                     // Skip malformed JSON lines
                 }
             }
-            // Propagate model_context_window from token_count events to the provider.
-            // The model comes along so the value can be persisted per model — the
-            // window Codex reports is tier-specific, not the published maximum.
-            const mcw = this.parser.getModelContextWindow();
-            if (mcw && this.onContextWindowLimit) {
-                this.onContextWindowLimit(mcw, this.parser.getCurrentModel() ?? undefined);
-            }
-            // Propagate rate_limits from token_count events to the provider
-            const rateLimits = this.parser.getLastRateLimits();
-            if (rateLimits && this.onRateLimits) {
-                this.onRateLimits(rateLimits);
-            }
-            // Propagate last token usage snapshot to the provider
-            const lastUsage = this.parser.getLastTokenUsage();
-            if (lastUsage && this.onTokenUsage) {
-                const normalized = (0, usageNormalization_1.normalizeProviderUsage)({
-                    semantics: 'openai',
-                    provider: 'openai',
-                    source: 'codex-reader-snapshot',
-                    model: this.parser.getCurrentModel() || undefined,
-                    inputTokens: lastUsage.input_tokens,
-                    outputTokens: lastUsage.output_tokens,
-                    cacheReadTokens: lastUsage.cached_input_tokens,
-                    reasoningTokens: lastUsage.reasoning_output_tokens,
-                });
-                this.onTokenUsage({
-                    inputTokens: normalized.uncachedInputTokens,
-                    outputTokens: normalized.outputTokens,
-                    cacheWriteTokens: normalized.cacheWriteTokens,
-                    cacheReadTokens: normalized.cacheReadTokens,
-                    reasoningTokens: normalized.reasoningTokens,
-                    model: this.parser.getCurrentModel() || 'unknown',
-                    timestamp: new Date(),
-                });
-            }
+            this.propagateParserState();
         }
         catch {
             // Skip read errors
         }
         return events;
     }
+    /** Hands the parser's context window, rate limits, and last usage to the provider. */
+    propagateParserState() {
+        // Propagate model_context_window from token_count events to the provider.
+        // The model comes along so the value can be persisted per model — the
+        // window Codex reports is tier-specific, not the published maximum.
+        const mcw = this.parser.getModelContextWindow();
+        if (mcw && this.onContextWindowLimit) {
+            this.onContextWindowLimit(mcw, this.parser.getCurrentModel() ?? undefined);
+        }
+        // Propagate rate_limits from token_count events to the provider
+        const rateLimits = this.parser.getLastRateLimits();
+        if (rateLimits && this.onRateLimits) {
+            this.onRateLimits(rateLimits);
+        }
+        // Propagate last token usage snapshot to the provider
+        const lastUsage = this.parser.getLastTokenUsage();
+        if (lastUsage && this.onTokenUsage) {
+            const normalized = (0, usageNormalization_1.normalizeProviderUsage)({
+                semantics: 'openai',
+                provider: 'openai',
+                source: 'codex-reader-snapshot',
+                model: this.parser.getCurrentModel() || undefined,
+                inputTokens: lastUsage.input_tokens,
+                outputTokens: lastUsage.output_tokens,
+                cacheReadTokens: lastUsage.cached_input_tokens,
+                reasoningTokens: lastUsage.reasoning_output_tokens,
+            });
+            this.onTokenUsage({
+                inputTokens: normalized.uncachedInputTokens,
+                outputTokens: normalized.outputTokens,
+                cacheWriteTokens: normalized.cacheWriteTokens,
+                cacheReadTokens: normalized.cacheReadTokens,
+                reasoningTokens: normalized.reasoningTokens,
+                model: this.parser.getCurrentModel() || 'unknown',
+                timestamp: new Date(),
+            });
+        }
+    }
     readAll() {
         this.reset();
         return this.readNew();
@@ -446,11 +435,13 @@ class CodexReader {
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
         this._wasTruncated = false;
+        this.pendingSeek = null;
     }
     exists() {
         return fs.existsSync(this.rolloutPath);
     }
     flush() {
+        this.settleSeek();
         this.lineBuffer += this.decoder.end();
         // Process any remaining data in the line buffer
         if (this.lineBuffer.trim()) {
@@ -468,15 +459,45 @@ class CodexReader {
         return this.committedPosition;
     }
     seekTo(position) {
-        // Rebuild model, turn, and cumulative-token context before resuming.
-        // The prefix is parsed only; its events are already in the consumer snapshot.
         this.reset();
+        this.filePosition = position;
+        this.committedPosition = position;
+        // The prefix's context is rebuilt on the next read, unless
+        // restoreResumeState() supplies it first.
         if (position > 0)
-            this.readNew(position);
+            this.pendingSeek = position;
     }
     wasTruncated() {
         return this._wasTruncated;
     }
+    /** The parser's continuation state (see `CodexRolloutParser.exportResumeState`). */
+    getResumeState() {
+        this.settleSeek();
+        return this.parser.exportResumeState();
+    }
+    /**
+     * Restores parser state from `getResumeState()`; after `seekTo()` this
+     * replaces re-parsing the rollout up to that position.
+     */
+    restoreResumeState(state) {
+        if (!this.parser.importResumeState(state))
+            return false;
+        this.pendingSeek = null;
+        this.propagateParserState();
+        return true;
+    }
+    /**
+     * Rebuilds model, turn, and cumulative-token context for a pending
+     * `seekTo()` position. The prefix is parsed only; its events are already
+     * in the consumer snapshot.
+     */
+    settleSeek() {
+        const position = this.pendingSeek;
+        if (position === null)
+            return;
+        this.reset();
+        this.readNew(position);
+    }
 }
 // ---------------------------------------------------------------------------
 // CodexProvider — full SessionProviderBase implementation
@@ -634,7 +655,7 @@ class CodexProvider {
     }
     findSessionById(_workspacePath, sessionId) {
         try {
-            const found = findCodexRolloutFile(sessionId);
+            const found = (0, codexRollouts_1.findCodexRolloutFile)(sessionId);
             this.recordDatabaseFallback('findSessionById', true);
             return found;
         }

package/dist/providers/codexDatabase.d.ts

@@ -4,8 +4,9 @@
  */
 import type { CodexDbThread } from '../types/codex';
 import type { ProviderRuntimeStatus } from './types';
-/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
-export declare function spawnParentFromSource(source: unknown): string | undefined;
+import { codexSpawnParentFromSource as spawnParentFromSource } from '../parsers/codexRolloutOrigin';
+/** Parent thread id of a spawned subagent's `source`; one rule shared with rollout parsing. */
+export { spawnParentFromSource };
 export declare class CodexDatabase {
     private readonly dbPath;
     private sqlite3Available;

package/dist/providers/codexDatabase.js

@@ -37,35 +37,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CodexDatabase = void 0;
-exports.spawnParentFromSource = spawnParentFromSource;
+exports.CodexDatabase = exports.spawnParentFromSource = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const codexRolloutOrigin_1 = require("../parsers/codexRolloutOrigin");
+Object.defineProperty(exports, "spawnParentFromSource", { enumerable: true, get: function () { return codexRolloutOrigin_1.codexSpawnParentFromSource; } });
 /**
  * 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;
-/** Parent thread id recorded in a Codex `threads.source` JSON value, if any. */
-function spawnParentFromSource(source) {
-    let parsed = source;
-    if (typeof source === 'string') {
-        if (!source.startsWith('{'))
-            return undefined;
-        try {
-            parsed = JSON.parse(source);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return undefined;
-    const parent = parsed
-        .subagent?.thread_spawn?.parent_thread_id;
-    return typeof parent === 'string' ? parent : undefined;
-}
 class CodexDatabase {
     dbPath;
     sqlite3Available = null;
@@ -246,7 +228,7 @@ class CodexDatabase {
         if (!this.getThreadColumns().has('source'))
             return [];
         const rows = this.query('SELECT * FROM threads WHERE source LIKE ? ORDER BY created_at ASC', [`%${parentId}%`]);
-        return rows.filter((row) => spawnParentFromSource(row.source) === parentId);
+        return rows.filter((row) => (0, codexRolloutOrigin_1.codexSpawnParentFromSource)(row.source) === parentId);
     }
     /** Get the database file's mtime (ms epoch). Returns 0 if unavailable. */
     getDbMtime() {

package/dist/providers/codexRollouts.d.ts

@@ -42,3 +42,25 @@ export declare function normalizePath(input: string): string;
  * sits inside it.
  */
 export declare function listCodexSessionFilesAsync(workspacePath?: string, options?: ListSessionFilesOptions, cache?: DirectoryListingCache): Promise<SessionFileInfo[]>;
+export interface FindCodexRolloutFileOptions {
+    /**
+     * Codex home whose `sessions/` subtree to search. Defaults to every
+     * monitored home: `$CODEX_HOME` if set, else `~/.codex`, plus managed
+     * profile homes that recorded sessions.
+     */
+    codexHome?: string;
+}
+/**
+ * Locates the rollout file for a Codex session id by walking
+ * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`, then
+ * `<home>/archived_sessions/`, where Codex moves the rollouts of archived
+ * threads.
+ *
+ * Filename-only match, case-insensitive on the id — no file contents are read
+ * and files are only stat'ed once their name matches, so the walk stays cheap
+ * even over a large history. When the same id exists in more than one home,
+ * the most recently modified copy wins. Returns `null` for an unknown, empty,
+ * or whitespace id. Consumers who want the database's answer instead can query
+ * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
+ */
+export declare function findCodexRolloutFile(sessionId: string, options?: FindCodexRolloutFileOptions): string | null;

package/dist/providers/codexRollouts.js

@@ -50,6 +50,7 @@ exports.initializeCounters = initializeCounters;
 exports.cwdMatches = cwdMatches;
 exports.normalizePath = normalizePath;
 exports.listCodexSessionFilesAsync = listCodexSessionFilesAsync;
+exports.findCodexRolloutFile = findCodexRolloutFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const codexPaths_1 = require("../codexPaths");
@@ -259,3 +260,26 @@ async function listCodexSessionFilesAsync(workspacePath, options = {}, cache = n
     }
     return results;
 }
+/**
+ * Locates the rollout file for a Codex session id by walking
+ * `<home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<id>.jsonl`, then
+ * `<home>/archived_sessions/`, where Codex moves the rollouts of archived
+ * threads.
+ *
+ * Filename-only match, case-insensitive on the id — no file contents are read
+ * and files are only stat'ed once their name matches, so the walk stays cheap
+ * even over a large history. When the same id exists in more than one home,
+ * the most recently modified copy wins. Returns `null` for an unknown, empty,
+ * or whitespace id. Consumers who want the database's answer instead can query
+ * the already-public `CodexDatabase` (requires the external `sqlite3` binary).
+ */
+function findCodexRolloutFile(sessionId, options = {}) {
+    const normalizedId = sessionId.trim().toLowerCase();
+    if (!normalizedId)
+        return null;
+    const sessionsDirs = options.codexHome
+        ? (0, codexPaths_1.getCodexSessionsDirs)([options.codexHome])
+        : getSessionsDirs();
+    // Name-only filter, one walk across the homes, newest modification first.
+    return (0, rolloutWalker_1.walkRolloutFiles)(sessionsDirs, { sessionId: normalizedId })[0]?.path ?? null;
+}

package/dist/providers/openCode.js

@@ -60,7 +60,6 @@ const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const openCodeParser_1 = require("../parsers/openCodeParser");
 const openCodeDatabase_1 = require("./openCodeDatabase");
-const usageNormalization_1 = require("../usageNormalization");
 const subagentUsage_1 = require("../usage/subagentUsage");
 const zaiQuota_1 = require("../zaiQuota");
 const diagnostics_1 = require("./diagnostics");
@@ -1493,21 +1492,14 @@ class OpenCodeProvider {
                             if (tokens) {
                                 // Same semantics as the main-session parser (openCodeParser).
                                 const cache = tokens.cache;
-                                const providerID = msgData.providerID;
-                                (0, subagentUsage_1.addUsageToSubagent)(tokenTotals, (0, usageNormalization_1.normalizeProviderUsage)({
-                                    semantics: providerID === 'openai'
-                                        ? 'openai'
-                                        : providerID === 'anthropic'
-                                            ? 'anthropic'
-                                            : 'sidekick',
-                                    provider: providerID ?? 'opencode',
-                                    inputTokens: tokens.input,
-                                    outputTokens: tokens.output,
-                                    cacheReadTokens: cache?.read,
-                                    cacheWriteTokens: cache?.write,
-                                    reasoningTokens: tokens.reasoning,
-                                    reasoningIncludedInOutput: providerID === 'openai',
-                                }));
+                                (0, subagentUsage_1.addUsageToSubagent)(tokenTotals, (0, openCodeParser_1.normalizeOpenCodeUsage)({
+                                    input: tokens.input,
+                                    output: tokens.output,
+                                    cacheRead: cache?.read,
+                                    cacheWrite: cache?.write,
+                                    reasoning: tokens.reasoning,
+                                    total: tokens.total,
+                                }, msgData.providerID));
                             }
                         }
                         catch {

package/dist/providers/types.d.ts

@@ -186,6 +186,20 @@ export interface SessionReader {
     seekTo(position: number): void;
     /** Check if file was truncated (size < position). */
     wasTruncated(): boolean;
+    /**
+     * Parse state the reader needs, beyond `getPosition()`, to continue
+     * correctly after a restart: JSON-serializable data to persist together
+     * with that position (for example which Claude responses were already
+     * counted). `undefined` when the reader keeps none. Optional.
+     */
+    getResumeState?(): unknown;
+    /**
+     * Restores state from `getResumeState()`. Call it right after `seekTo()`
+     * the position that state was taken at. Returns false, changing nothing,
+     * when `state` is missing or not valid for this reader; the caller should
+     * then replay from the start instead. Optional.
+     */
+    restoreResumeState?(state: unknown): boolean;
 }
 /**
  * Expanded session provider interface (no VS Code dependencies).

package/dist/report/htmlReportGenerator.js

@@ -599,14 +599,51 @@ function renderContentBlock(block, includeThinking, includeToolDetail) {
             return '';
     }
 }
-function renderToolUse(block, includeDetail) {
+/** Prefix of the bookkeeping keys session parsers stash inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
+/**
+ * The tool's display identity and user-facing input. Entries built outside
+ * the canonical projection may still carry the parsers' `_sidekick*` keys in
+ * `toolInput`; those are hidden here and read as the raw identity.
+ */
+function toolDisplay(block) {
     const name = block.toolName || 'unknown';
+    const raw = block.toolInput;
+    let input = raw;
+    let rawToolName = block.rawToolName;
+    let mcpServerName = block.mcpServerName;
+    if (raw && Object.keys(raw).some((key) => key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))) {
+        const clean = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (!key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+                clean[key] = value;
+        }
+        input = clean;
+        if (!rawToolName && typeof raw._sidekickRawToolName === 'string') {
+            rawToolName = raw._sidekickRawToolName;
+        }
+        if (!mcpServerName && typeof raw._sidekickMcpServerName === 'string') {
+            mcpServerName = raw._sidekickMcpServerName;
+        }
+    }
+    const parts = [];
+    if (rawToolName && rawToolName.trim() && rawToolName !== name)
+        parts.push(rawToolName);
+    if (mcpServerName && mcpServerName.trim())
+        parts.push(`MCP: ${mcpServerName}`);
+    const hint = parts.length
+        ? ` <span class="tool-raw-name" style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(parts.join(' · '))}</span>`
+        : '';
+    return { name, hint, input };
+}
+function renderToolUse(block, includeDetail) {
+    const { name, hint, input } = toolDisplay(block);
     if (!includeDetail) {
-        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${(0, htmlHelpers_1.escapeHtml)(name)}</div></div>`;
+        return `<div class="tool-block" data-block-type="tool"><div style="padding:8px 12px;background:rgba(245,166,35,0.08);color:var(--accent-orange);font-family:monospace;font-size:13px;">${(0, htmlHelpers_1.escapeHtml)(name)}${hint}</div></div>`;
     }
     let inputHtml = '';
-    if (block.toolInput && Object.keys(block.toolInput).length > 0) {
-        const inputJson = JSON.stringify(block.toolInput, null, 2);
+    if (input && Object.keys(input).length > 0) {
+        const inputJson = JSON.stringify(input, null, 2);
         const highlighted = (0, htmlHelpers_1.highlightCodeBlock)(inputJson, 'json');
         inputHtml = `<div class="tool-io">
     <div class="tool-label">Input</div>
@@ -614,7 +651,7 @@ function renderToolUse(block, includeDetail) {
   </div>`;
     }
     return `<details class="tool-block" data-block-type="tool">
-  <summary>${(0, htmlHelpers_1.escapeHtml)(name)}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(block.toolUseId)}</span>` : ''}</summary>
+  <summary>${(0, htmlHelpers_1.escapeHtml)(name)}${hint}${block.toolUseId ? ` <span style="color:var(--text-muted);font-size:11px">${(0, htmlHelpers_1.escapeHtml)(block.toolUseId)}</span>` : ''}</summary>
   <div class="tool-content">
     ${inputHtml}
   </div>

package/dist/report/transcriptParser.d.ts

@@ -1,6 +1,15 @@
 /** Report compatibility adapters over the canonical transcript projection. */
 import type { SessionEvent } from '../types/sessionEvent';
-import type { TranscriptEntry } from './types';
+import type { TranscriptEntry, TranscriptContentBlock } from './types';
+/**
+ * A report tool block that also names the provider's raw tool and MCP
+ * server. Internal: the extra fields are optional and read only by the HTML
+ * renderer.
+ */
+export type ReportToolUseBlock = TranscriptContentBlock & {
+    rawToolName?: string;
+    mcpServerName?: string;
+};
 /** Parse a Claude Code JSONL session through the canonical provider reader. */
 export declare function parseTranscript(sessionPath: string): TranscriptEntry[];
 /** Project canonical provider events into the legacy report transcript shape. */

package/dist/report/transcriptParser.js

@@ -79,17 +79,19 @@ function toReportBlock(block) {
             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_use': {
+            const toolBlock = {
+                type: 'tool_use',
+                toolName: block.toolName ?? 'unknown',
+                toolInput: block.input && typeof block.input === 'object'
+                    ? block.input
+                    : {},
+                toolUseId: block.toolUseId,
+                ...(block.rawToolName ? { rawToolName: block.rawToolName } : {}),
+                ...(block.mcpServerName ? { mcpServerName: block.mcpServerName } : {}),
+            };
+            return [toolBlock];
+        }
         case 'tool_result':
             return [
                 {

package/dist/schemas/index.d.ts

@@ -12,6 +12,7 @@
  */
 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 type { ExtractSessionEventsOptions } from './sessionEvent';
 export type { MessageUsage, SessionMessage, SessionEvent, PermissionMode, } from '../types/sessionEvent';
 export { normalizedUsageSchema, normalizedUsageCostSchema } from './usageNormalization';
 export type { NormalizedUsage, NormalizedUsageCost } from '../usageNormalization';

package/dist/schemas/providerFailure.d.ts

@@ -52,6 +52,25 @@ export declare const providerFailureEvidenceSchema: z.ZodObject<{
         context_overflow: "context_overflow";
     }>;
     checkedAt: z.ZodOptional<z.ZodString>;
+    codexErrorInfo: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        contextWindowExceeded: "contextWindowExceeded";
+        sessionBudgetExceeded: "sessionBudgetExceeded";
+        usageLimitExceeded: "usageLimitExceeded";
+        rateLimitExceeded: "rateLimitExceeded";
+        serverOverloaded: "serverOverloaded";
+        cyberPolicy: "cyberPolicy";
+        httpConnectionFailed: "httpConnectionFailed";
+        responseStreamConnectionFailed: "responseStreamConnectionFailed";
+        internalServerError: "internalServerError";
+        unauthorized: "unauthorized";
+        badRequest: "badRequest";
+        threadRollbackFailed: "threadRollbackFailed";
+        sandboxError: "sandboxError";
+        responseStreamDisconnected: "responseStreamDisconnected";
+        responseTooManyFailedAttempts: "responseTooManyFailedAttempts";
+        activeTurnNotSteerable: "activeTurnNotSteerable";
+    }>>;
 }, z.core.$strip>;
 export declare const providerRetryAfterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"delay">;
@@ -98,6 +117,7 @@ export declare const providerFailureDiagnosisSchema: z.ZodObject<{
         reduce_context: "reduce_context";
         inspect_error: "inspect_error";
     }>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
     evidence: z.ZodArray<z.ZodObject<{
         source: z.ZodEnum<{
             message: "message";
@@ -122,6 +142,25 @@ export declare const providerFailureDiagnosisSchema: z.ZodObject<{
             context_overflow: "context_overflow";
         }>;
         checkedAt: z.ZodOptional<z.ZodString>;
+        codexErrorInfo: z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            contextWindowExceeded: "contextWindowExceeded";
+            sessionBudgetExceeded: "sessionBudgetExceeded";
+            usageLimitExceeded: "usageLimitExceeded";
+            rateLimitExceeded: "rateLimitExceeded";
+            serverOverloaded: "serverOverloaded";
+            cyberPolicy: "cyberPolicy";
+            httpConnectionFailed: "httpConnectionFailed";
+            responseStreamConnectionFailed: "responseStreamConnectionFailed";
+            internalServerError: "internalServerError";
+            unauthorized: "unauthorized";
+            badRequest: "badRequest";
+            threadRollbackFailed: "threadRollbackFailed";
+            sandboxError: "sandboxError";
+            responseStreamDisconnected: "responseStreamDisconnected";
+            responseTooManyFailedAttempts: "responseTooManyFailedAttempts";
+            activeTurnNotSteerable: "activeTurnNotSteerable";
+        }>>;
     }, z.core.$strip>>;
     authentication: z.ZodOptional<z.ZodObject<{
         credentialKind: z.ZodEnum<{

package/dist/schemas/providerFailure.js

@@ -23,6 +23,7 @@ exports.providerFailureEvidenceSchema = zod_1.z.object({
     source: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_EVIDENCE_SOURCES),
     rule: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_CODES),
     checkedAt: zod_1.z.string().optional(),
+    codexErrorInfo: zod_1.z.enum(providerFailure_1.CODEX_ERROR_INFO_KINDS).optional(),
 });
 exports.providerRetryAfterSchema = zod_1.z.discriminatedUnion('kind', [
     zod_1.z.object({ kind: zod_1.z.literal('delay'), delayMs: zod_1.z.number() }),
@@ -33,6 +34,7 @@ exports.providerFailureDiagnosisSchema = zod_1.z.object({
     credentialKind: zod_1.z.enum(providerFailure_1.PROVIDER_CREDENTIAL_KINDS),
     diagnosis: zod_1.z.enum(providerFailure_1.PROVIDER_FAILURE_CODES),
     recovery: zod_1.z.enum(providerFailure_1.PROVIDER_RECOVERY_ACTIONS),
+    retryable: zod_1.z.boolean().optional(),
     evidence: zod_1.z.array(exports.providerFailureEvidenceSchema),
     authentication: exports.providerAuthenticationEvidenceSchema.optional(),
     httpStatus: zod_1.z.number().optional(),