sidekick-shared 0.18.4 → 0.19.0

package/dist/modelInfo.js

@@ -44,10 +44,26 @@ const modelContext_1 = require("./modelContext");
  * Sources:
  *   - Anthropic: https://www.anthropic.com/pricing
  *   - OpenAI: https://openai.com/api/pricing/
- * Snapshot taken: 2026-04-17. Runtime LiteLLM hydration refreshes this.
+ * Snapshot taken: 2026-06-09. Runtime LiteLLM hydration refreshes this.
+ *
+ * Anthropic keys appear in both dashed (`claude-opus-4-8`, the real model-ID
+ * form) and dotted (`claude-opus-4.8`, the LiteLLM catalog form) spellings —
+ * prefix matching cannot bridge the two, so both are needed.
  */
 const PRICING_TABLE = {
     // ── Anthropic: Claude ──
+    'claude-fable-5': {
+        inputCostPerMillion: 10.0,
+        outputCostPerMillion: 50.0,
+        cacheWriteCostPerMillion: 12.5,
+        cacheReadCostPerMillion: 1.0,
+    },
+    'claude-haiku-4-5': {
+        inputCostPerMillion: 1.0,
+        outputCostPerMillion: 5.0,
+        cacheWriteCostPerMillion: 1.25,
+        cacheReadCostPerMillion: 0.1,
+    },
     'claude-haiku-4.5': {
         inputCostPerMillion: 1.0,
         outputCostPerMillion: 5.0,
@@ -60,12 +76,24 @@ const PRICING_TABLE = {
         cacheWriteCostPerMillion: 1.0,
         cacheReadCostPerMillion: 0.08,
     },
+    'claude-sonnet-4-6': {
+        inputCostPerMillion: 3.0,
+        outputCostPerMillion: 15.0,
+        cacheWriteCostPerMillion: 3.75,
+        cacheReadCostPerMillion: 0.3,
+    },
     'claude-sonnet-4.6': {
         inputCostPerMillion: 3.0,
         outputCostPerMillion: 15.0,
         cacheWriteCostPerMillion: 3.75,
         cacheReadCostPerMillion: 0.3,
     },
+    'claude-sonnet-4-5': {
+        inputCostPerMillion: 3.0,
+        outputCostPerMillion: 15.0,
+        cacheWriteCostPerMillion: 3.75,
+        cacheReadCostPerMillion: 0.3,
+    },
     'claude-sonnet-4.5': {
         inputCostPerMillion: 3.0,
         outputCostPerMillion: 15.0,
@@ -78,11 +106,41 @@ const PRICING_TABLE = {
         cacheWriteCostPerMillion: 3.75,
         cacheReadCostPerMillion: 0.3,
     },
+    'claude-opus-4-8': {
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
+    },
+    'claude-opus-4.8': {
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
+    },
+    'claude-opus-4-7': {
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
+    },
+    'claude-opus-4.7': {
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
+    },
+    'claude-opus-4-6': {
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
+    },
     'claude-opus-4.6': {
-        inputCostPerMillion: 15.0,
-        outputCostPerMillion: 75.0,
-        cacheWriteCostPerMillion: 18.75,
-        cacheReadCostPerMillion: 1.5,
+        inputCostPerMillion: 5.0,
+        outputCostPerMillion: 25.0,
+        cacheWriteCostPerMillion: 6.25,
+        cacheReadCostPerMillion: 0.5,
     },
     'claude-opus-4.5': {
         inputCostPerMillion: 5.0,
@@ -90,6 +148,7 @@ const PRICING_TABLE = {
         cacheWriteCostPerMillion: 6.25,
         cacheReadCostPerMillion: 0.5,
     },
+    // Opus 4.0 / 4.1 — pre-4.5 pricing tier
     'claude-opus-4': {
         inputCostPerMillion: 15.0,
         outputCostPerMillion: 75.0,
@@ -199,7 +258,7 @@ function _clearPricingOverrides() {
     overrideSortedKeys = [];
 }
 // ── Model ID Parsing ──
-const CLAUDE_RE = /^claude-(haiku|sonnet|opus)-([0-9.]+)/i;
+const CLAUDE_RE = /^claude-(haiku|sonnet|opus|fable)-([0-9.]+)/i;
 const LEGACY_CLAUDE_RE = /^claude-([0-9]+(?:[-.][0-9]+)?)-(haiku|sonnet|opus)(?:-|$)/i;
 const GPT_RE = /^gpt-([0-9][0-9.A-Za-z-]*)/i;
 const O_SERIES_RE = /^o([0-9]+)(-mini|-pro)?/i;
@@ -390,9 +449,10 @@ function shortModelName(modelId) {
     return modelId;
 }
 const CLAUDE_FAMILY_RANK = {
-    opus: 0,
-    sonnet: 1,
-    haiku: 2,
+    fable: 0,
+    opus: 1,
+    sonnet: 2,
+    haiku: 3,
 };
 function versionRank(version) {
     if (!version)

package/dist/parsers/codexParser.d.ts

@@ -44,6 +44,8 @@ export declare class CodexRolloutParser {
     private modelContextWindow;
     private lastRateLimits;
     private inPlanMode;
+    private emittedToolUseIds;
+    private patchExpandedToolUseIds;
     /** Get stored session metadata. */
     getSessionMeta(): CodexSessionMeta | null;
     /** Get current model from turn_context. */

package/dist/parsers/codexParser.js

@@ -17,6 +17,22 @@ exports.normalizeCodexToolName = normalizeCodexToolName;
 exports.normalizeCodexToolInput = normalizeCodexToolInput;
 exports.extractPatchFilePaths = extractPatchFilePaths;
 const openCodeParser_1 = require("./openCodeParser");
+function normalizeRateLimits(rateLimits) {
+    if (!rateLimits?.primary && !rateLimits?.secondary)
+        return undefined;
+    return {
+        primary: rateLimits.primary ? {
+            usedPercent: rateLimits.primary.used_percent || 0,
+            windowMinutes: rateLimits.primary.window_minutes || 0,
+            resetsAt: rateLimits.primary.resets_at || 0,
+        } : undefined,
+        secondary: rateLimits.secondary ? {
+            usedPercent: rateLimits.secondary.used_percent || 0,
+            windowMinutes: rateLimits.secondary.window_minutes || 0,
+            resetsAt: rateLimits.secondary.resets_at || 0,
+        } : undefined,
+    };
+}
 /**
  * Codex-specific tool name normalization.
  * Extends the shared normalizeToolName with Codex-specific mappings.
@@ -105,6 +121,8 @@ class CodexRolloutParser {
     modelContextWindow = null;
     lastRateLimits = null;
     inPlanMode = false;
+    emittedToolUseIds = new Set();
+    patchExpandedToolUseIds = new Map();
     /** Get stored session metadata. */
     getSessionMeta() {
         return this.sessionMeta;
@@ -131,7 +149,7 @@ class CodexRolloutParser {
     convertLine(line) {
         switch (line.type) {
             case 'session_meta':
-                return this.handleSessionMeta(line.payload);
+                return this.handleSessionMeta(line.timestamp, line.payload);
             case 'response_item':
                 return this.handleResponseItem(line.timestamp, line.payload);
             case 'compacted':
@@ -154,11 +172,25 @@ class CodexRolloutParser {
         this.modelContextWindow = null;
         this.lastRateLimits = null;
         this.inPlanMode = false;
+        this.emittedToolUseIds.clear();
+        this.patchExpandedToolUseIds.clear();
     }
     // --- Handlers ---
-    handleSessionMeta(payload) {
+    handleSessionMeta(timestamp, payload) {
         this.sessionMeta = payload;
-        return [];
+        const text = payload.base_instructions?.text?.trim();
+        if (!text)
+            return [];
+        return [{
+                type: 'system',
+                message: {
+                    role: 'system',
+                    id: `${payload.id}:base-instructions`,
+                    sourceLabel: 'base instructions',
+                    content: [{ type: 'text', text }],
+                },
+                timestamp,
+            }];
     }
     handleResponseItem(timestamp, payload) {
         // payload IS the item directly (no .item wrapper)
@@ -210,6 +242,18 @@ class CodexRolloutParser {
                     timestamp,
                 }];
         }
+        if (item.role === 'developer' || item.role === 'system') {
+            return [{
+                    type: 'system',
+                    message: {
+                        role: item.role,
+                        id: item.id,
+                        sourceLabel: item.role,
+                        content: [{ type: 'text', text }],
+                    },
+                    timestamp,
+                }];
+        }
         return [];
     }
     handleReasoning(timestamp, item) {
@@ -239,6 +283,7 @@ class CodexRolloutParser {
         }
         const canonicalName = normalizeCodexToolName(item.name);
         const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedArgs);
+        this.emittedToolUseIds.add(item.call_id);
         return [{
                 type: 'assistant',
                 message: {
@@ -274,6 +319,7 @@ class CodexRolloutParser {
     }
     handleLocalShellCall(timestamp, item) {
         const command = item.action?.command?.join(' ') || '';
+        this.emittedToolUseIds.add(item.call_id);
         return [{
                 type: 'assistant',
                 message: {
@@ -299,6 +345,11 @@ class CodexRolloutParser {
             const filePaths = extractPatchFilePaths(item.input);
             if (filePaths.length === 0)
                 return [];
+            const toolUseIds = filePaths.map(fp => `${item.call_id}-${fp}`);
+            this.patchExpandedToolUseIds.set(item.call_id, toolUseIds);
+            for (const id of toolUseIds) {
+                this.emittedToolUseIds.add(id);
+            }
             return filePaths.map(fp => ({
                 type: 'assistant',
                 message: {
@@ -328,6 +379,7 @@ class CodexRolloutParser {
         }
         const canonicalName = normalizeCodexToolName(item.name);
         const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedInput);
+        this.emittedToolUseIds.add(item.call_id);
         return [{
                 type: 'assistant',
                 message: {
@@ -357,21 +409,23 @@ class CodexRolloutParser {
         catch {
             isError = parsePlainTextFailure(item.output);
         }
-        return [{
-                type: 'user',
-                message: {
-                    role: 'user',
-                    id: `${item.call_id}:result`,
-                    content: [{
-                            type: 'tool_result',
-                            tool_use_id: item.call_id,
-                            content: item.output,
-                            is_error: isError,
-                            duration,
-                        }],
-                },
-                timestamp,
-            }];
+        const toolUseIds = this.patchExpandedToolUseIds.get(item.call_id) ?? [item.call_id];
+        this.patchExpandedToolUseIds.delete(item.call_id);
+        return toolUseIds.map(toolUseId => ({
+            type: 'user',
+            message: {
+                role: 'user',
+                id: `${toolUseId}:result`,
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: toolUseId,
+                        content: item.output,
+                        is_error: isError,
+                        duration,
+                    }],
+            },
+            timestamp,
+        }));
     }
     handleCompacted(timestamp, payload) {
         return [{
@@ -407,7 +461,7 @@ class CodexRolloutParser {
                 }
                 // Usage data is nested under info.last_token_usage (info can be null)
                 const usage = e.info?.last_token_usage || e.info?.total_token_usage;
-                return this.handleTokenCount(timestamp, usage ?? null);
+                return this.handleTokenCount(timestamp, usage ?? null, e.rate_limits);
             }
             // agent_message and user_message are suppressed — they duplicate
             // response_item/message events which carry richer metadata (id, content parts, role).
@@ -427,25 +481,28 @@ class CodexRolloutParser {
                 this.pendingExecCommands.delete(e.call_id);
                 const command = pending?.command?.join(' ') || '';
                 const events = [];
-                events.push({
-                    type: 'assistant',
-                    message: {
-                        role: 'assistant',
-                        id: `exec-${e.call_id}`,
-                        model: this.currentModel || undefined,
-                        content: [{
-                                type: 'tool_use',
-                                id: e.call_id,
-                                name: 'Bash',
-                                input: {
-                                    command,
-                                    workdir: pending?.workdir,
-                                    _sidekickRawToolName: 'exec_command',
-                                },
-                            }],
-                    },
-                    timestamp: pending?.timestamp || timestamp,
-                });
+                if (!this.emittedToolUseIds.has(e.call_id)) {
+                    this.emittedToolUseIds.add(e.call_id);
+                    events.push({
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `exec-${e.call_id}`,
+                            model: this.currentModel || undefined,
+                            content: [{
+                                    type: 'tool_use',
+                                    id: e.call_id,
+                                    name: 'Bash',
+                                    input: {
+                                        command,
+                                        workdir: pending?.workdir,
+                                        _sidekickRawToolName: 'exec_command',
+                                    },
+                                }],
+                        },
+                        timestamp: pending?.timestamp || timestamp,
+                    });
+                }
                 const output = [e.stdout, e.stderr].filter(Boolean).join('\n') || '';
                 events.push({
                     type: 'user',
@@ -481,24 +538,28 @@ class CodexRolloutParser {
                 this.pendingMcpToolCalls.delete(e.call_id);
                 const toolName = pendingMcp?.tool_name || 'McpTool';
                 const events = [];
-                events.push({
-                    type: 'assistant',
-                    message: {
-                        role: 'assistant',
-                        id: `mcp-${e.call_id}`,
-                        model: this.currentModel || undefined,
-                        content: [{
-                                type: 'tool_use',
-                                id: e.call_id,
-                                name: normalizeCodexToolName(toolName),
-                                input: {
-                                    ...(pendingMcp?.arguments || {}),
-                                    _sidekickRawToolName: toolName,
-                                },
-                            }],
-                    },
-                    timestamp: pendingMcp?.timestamp || timestamp,
-                });
+                if (!this.emittedToolUseIds.has(e.call_id)) {
+                    this.emittedToolUseIds.add(e.call_id);
+                    events.push({
+                        type: 'assistant',
+                        message: {
+                            role: 'assistant',
+                            id: `mcp-${e.call_id}`,
+                            model: this.currentModel || undefined,
+                            content: [{
+                                    type: 'tool_use',
+                                    id: e.call_id,
+                                    name: normalizeCodexToolName(toolName),
+                                    input: {
+                                        ...(pendingMcp?.arguments || {}),
+                                        _sidekickRawToolName: toolName,
+                                        _sidekickMcpServerName: pendingMcp?.server_name,
+                                    },
+                                }],
+                        },
+                        timestamp: pendingMcp?.timestamp || timestamp,
+                    });
+                }
                 events.push({
                     type: 'user',
                     message: {
@@ -626,27 +687,32 @@ class CodexRolloutParser {
                 return [];
         }
     }
-    handleTokenCount(timestamp, usage) {
-        if (!usage)
+    handleTokenCount(timestamp, usage, rateLimits) {
+        const normalizedRateLimits = normalizeRateLimits(rateLimits);
+        if (!usage && !normalizedRateLimits)
             return [];
-        const mappedUsage = {
+        const mappedUsage = usage ? {
             input_tokens: usage.input_tokens || 0,
             output_tokens: usage.output_tokens || 0,
             cache_read_input_tokens: usage.cached_input_tokens || 0,
             cache_creation_input_tokens: 0,
             reasoning_tokens: usage.reasoning_output_tokens || 0,
-        };
-        this.lastTokenUsage = usage;
+        } : undefined;
+        if (usage) {
+            this.lastTokenUsage = usage;
+        }
         return [{
-                type: 'assistant',
+                type: 'system',
                 message: {
-                    role: 'assistant',
+                    role: 'system',
                     id: `token-count-${timestamp}`,
+                    sourceLabel: 'token count',
                     model: this.currentModel || undefined,
                     usage: mappedUsage,
                     content: [],
                 },
                 timestamp,
+                rateLimits: normalizedRateLimits,
             }];
     }
 }

package/dist/providers/claudeCode.d.ts

@@ -7,6 +7,7 @@
  *
  * Ported from sidekick-vscode/src/services/providers/ClaudeCodeSessionProvider.ts
  */
+import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { SessionProviderBase, SessionReader, SessionFileStats, SearchHit, ProjectFolderInfo, ProviderId } from './types';
 /**
@@ -38,6 +39,7 @@ export declare class ClaudeCodeProvider implements SessionProviderBase {
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
     readSessionStats(sessionPath: string): SessionFileStats;
+    readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
     getContextWindowLimit(modelId?: string): number;
     /** Set a runtime-reported context window limit (overrides static map). */
     setDynamicContextWindowLimit(limit: number): void;

package/dist/providers/claudeCode.js

@@ -46,6 +46,7 @@ exports.ClaudeCodeProvider = void 0;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const sessionContext_1 = require("../context/sessionContext");
 const jsonl_1 = require("../parsers/jsonl");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
 const subagentScanner_1 = require("../parsers/subagentScanner");
@@ -408,6 +409,9 @@ class ClaudeCodeProvider {
             reportedCost,
         };
     }
+    readSessionContextSnapshot(sessionPath, options = {}) {
+        return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);
+    }
     // --- Optional methods ---
     getContextWindowLimit(modelId) {
         if (this.dynamicContextWindowLimit)

package/dist/providers/codex.d.ts

@@ -8,6 +8,7 @@
  *
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
+import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
 import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileStats, ProviderId } from './types';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
@@ -48,6 +49,7 @@ export declare class CodexProvider implements SessionProviderBase {
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
     readSessionStats(sessionPath: string): SessionFileStats;
+    readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
     getContextWindowLimit(modelId?: string): number;
     getCurrentUsageSnapshot(_sessionPath: string): TokenUsage | null;
     computeContextSize(usage: TokenUsage): number;