devchain-cli 0.10.4 → 0.11.0

package/dist/server/modules/session-reader/dtos/index.d.ts

@@ -0,0 +1,2 @@
+export type { TokenUsage, TextContentBlock, ThinkingContentBlock, ToolCallContentBlock, ToolResultContentBlock, ImageContentBlock, UnifiedContentBlock, UnifiedToolCall, UnifiedToolResult, UnifiedMessageRole, UnifiedMessage, PhaseTokenBreakdown, UnifiedMetrics, UnifiedSession, SubagentMatchMethod, UnifiedProcess, } from './unified-session.types';
+export { isTextContent, isThinkingContent, isToolCallContent, isToolResultContent, isImageContent, } from './unified-session.types';

package/dist/server/modules/session-reader/dtos/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageContent = exports.isToolResultContent = exports.isToolCallContent = exports.isThinkingContent = exports.isTextContent = void 0;
+var unified_session_types_1 = require("./unified-session.types");
+Object.defineProperty(exports, "isTextContent", { enumerable: true, get: function () { return unified_session_types_1.isTextContent; } });
+Object.defineProperty(exports, "isThinkingContent", { enumerable: true, get: function () { return unified_session_types_1.isThinkingContent; } });
+Object.defineProperty(exports, "isToolCallContent", { enumerable: true, get: function () { return unified_session_types_1.isToolCallContent; } });
+Object.defineProperty(exports, "isToolResultContent", { enumerable: true, get: function () { return unified_session_types_1.isToolResultContent; } });
+Object.defineProperty(exports, "isImageContent", { enumerable: true, get: function () { return unified_session_types_1.isImageContent; } });
+//# sourceMappingURL=index.js.map

package/dist/server/modules/session-reader/dtos/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/modules/session-reader/dtos/index.ts"],"names":[],"mappings":";;;AA0BA,iEAOiC;AAL/B,sHAAA,aAAa,OAAA;AACb,0HAAA,iBAAiB,OAAA;AACjB,0HAAA,iBAAiB,OAAA;AACjB,4HAAA,mBAAmB,OAAA;AACnB,uHAAA,cAAc,OAAA"}

package/dist/server/modules/session-reader/dtos/unified-chunk.types.d.ts

@@ -0,0 +1,92 @@
+import type { UnifiedMessage } from './unified-session.types';
+export interface ChunkMetrics {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    totalTokens: number;
+    messageCount: number;
+    durationMs: number;
+    costUsd: number;
+}
+export type UnifiedSemanticStepType = 'thinking' | 'tool_call' | 'tool_result' | 'output' | 'subagent' | 'interruption';
+export interface UnifiedSemanticStepContent {
+    thinkingText?: string;
+    toolName?: string;
+    toolInput?: Record<string, unknown>;
+    toolCallId?: string;
+    toolResultContent?: string | unknown[];
+    isTruncated?: boolean;
+    fullLength?: number;
+    isError?: boolean;
+    outputText?: string;
+    subagentId?: string;
+    subagentDescription?: string;
+    interruptionText?: string;
+    sourceModel?: string;
+}
+export interface UnifiedSemanticStep {
+    id: string;
+    type: UnifiedSemanticStepType;
+    startTime: Date;
+    durationMs: number;
+    content: UnifiedSemanticStepContent;
+    tokens?: {
+        input: number;
+        output: number;
+        cached?: number;
+    };
+    estimatedTokens?: number;
+    sourceMessageId?: string;
+    context: 'main' | 'subagent';
+}
+export interface TurnSummary {
+    thinkingCount: number;
+    toolCallCount: number;
+    subagentCount: number;
+    outputCount: number;
+}
+export interface UnifiedTurn {
+    id: string;
+    assistantMessageId: string;
+    model?: string;
+    timestamp: Date;
+    steps: UnifiedSemanticStep[];
+    summary: TurnSummary;
+    tokens?: {
+        input: number;
+        output: number;
+        cached?: number;
+    };
+    durationMs: number;
+}
+export type UnifiedChunkType = 'user' | 'ai' | 'system' | 'compact';
+interface BaseChunk {
+    id: string;
+    type: UnifiedChunkType;
+    startTime: Date;
+    endTime: Date;
+    messages: UnifiedMessage[];
+    metrics: ChunkMetrics;
+}
+export interface UserChunk extends BaseChunk {
+    type: 'user';
+}
+export interface AIChunk extends BaseChunk {
+    type: 'ai';
+    semanticSteps: UnifiedSemanticStep[];
+    turns: UnifiedTurn[];
+}
+export interface SystemChunk extends BaseChunk {
+    type: 'system';
+}
+export interface CompactChunk extends BaseChunk {
+    type: 'compact';
+}
+export type UnifiedChunk = UserChunk | AIChunk | SystemChunk | CompactChunk;
+export type MessageCategory = 'user' | 'ai' | 'system' | 'compact' | 'hardNoise';
+export declare function isUserChunk(chunk: UnifiedChunk): chunk is UserChunk;
+export declare function isAIChunk(chunk: UnifiedChunk): chunk is AIChunk;
+export declare function isSystemChunk(chunk: UnifiedChunk): chunk is SystemChunk;
+export declare function isCompactChunk(chunk: UnifiedChunk): chunk is CompactChunk;
+export {};

package/dist/server/modules/session-reader/dtos/unified-chunk.types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserChunk = isUserChunk;
+exports.isAIChunk = isAIChunk;
+exports.isSystemChunk = isSystemChunk;
+exports.isCompactChunk = isCompactChunk;
+function isUserChunk(chunk) {
+    return chunk.type === 'user';
+}
+function isAIChunk(chunk) {
+    return chunk.type === 'ai';
+}
+function isSystemChunk(chunk) {
+    return chunk.type === 'system';
+}
+function isCompactChunk(chunk) {
+    return chunk.type === 'compact';
+}
+//# sourceMappingURL=unified-chunk.types.js.map

package/dist/server/modules/session-reader/dtos/unified-chunk.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-chunk.types.js","sourceRoot":"","sources":["../../../../src/modules/session-reader/dtos/unified-chunk.types.ts"],"names":[],"mappings":";;AA4IA,kCAEC;AAED,8BAEC;AAED,sCAEC;AAED,wCAEC;AAdD,SAAgB,WAAW,CAAC,KAAmB;IAC7C,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;AAC/B,CAAC;AAED,SAAgB,SAAS,CAAC,KAAmB;IAC3C,OAAO,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC;AAC7B,CAAC;AAED,SAAgB,aAAa,CAAC,KAAmB;IAC/C,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;AACjC,CAAC;AAED,SAAgB,cAAc,CAAC,KAAmB;IAChD,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC;AAClC,CAAC"}

package/dist/server/modules/session-reader/dtos/unified-session.types.d.ts

@@ -0,0 +1,118 @@
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+}
+export interface TextContentBlock {
+    type: 'text';
+    text: string;
+}
+export interface ThinkingContentBlock {
+    type: 'thinking';
+    thinking: string;
+    signature?: string;
+}
+export interface ToolCallContentBlock {
+    type: 'tool_call';
+    toolCallId: string;
+    toolName: string;
+    input: Record<string, unknown>;
+}
+export interface ToolResultContentBlock {
+    type: 'tool_result';
+    toolCallId: string;
+    content: string | unknown[];
+    isError: boolean;
+    isTruncated?: boolean;
+    fullLength?: number;
+}
+export interface ImageContentBlock {
+    type: 'image';
+    mediaType: string;
+    data: string;
+}
+export type UnifiedContentBlock = TextContentBlock | ThinkingContentBlock | ToolCallContentBlock | ToolResultContentBlock | ImageContentBlock;
+export interface UnifiedToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+    isTask: boolean;
+    taskDescription?: string;
+    taskSubagentType?: string;
+}
+export interface UnifiedToolResult {
+    toolCallId: string;
+    content: string | unknown[];
+    isError: boolean;
+    isTruncated?: boolean;
+    fullLength?: number;
+}
+export type UnifiedMessageRole = 'user' | 'assistant' | 'system';
+export interface UnifiedMessage {
+    id: string;
+    parentId: string | null;
+    role: UnifiedMessageRole;
+    timestamp: Date;
+    content: UnifiedContentBlock[];
+    usage?: TokenUsage;
+    model?: string;
+    toolCalls: UnifiedToolCall[];
+    toolResults: UnifiedToolResult[];
+    isMeta: boolean;
+    isSidechain: boolean;
+    isCompactSummary?: boolean;
+    sourceToolUseId?: string;
+}
+export interface PhaseTokenBreakdown {
+    phaseNumber: number;
+    contribution: number;
+    peakTokens: number;
+    postCompaction?: number;
+    compactionMessageId?: string;
+}
+export interface UnifiedMetrics {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    totalTokens: number;
+    totalContextConsumption: number;
+    compactionCount: number;
+    phaseBreakdowns: PhaseTokenBreakdown[];
+    visibleContextTokens: number;
+    totalContextTokens: number;
+    contextWindowTokens: number;
+    costUsd: number;
+    primaryModel: string;
+    modelsUsed?: string[];
+    durationMs: number;
+    messageCount: number;
+    isOngoing: boolean;
+}
+export interface UnifiedSession {
+    id: string;
+    providerName: string;
+    filePath: string;
+    messages: UnifiedMessage[];
+    metrics: UnifiedMetrics;
+    isOngoing: boolean;
+    chunks?: import('./unified-chunk.types').UnifiedChunk[];
+    warnings?: string[];
+}
+export type SubagentMatchMethod = 'result' | 'description' | 'positional';
+export interface UnifiedProcess {
+    id: string;
+    toolCallId: string;
+    description?: string;
+    subagentType?: string;
+    filePath: string;
+    session: UnifiedSession;
+    matchMethod: SubagentMatchMethod;
+    isParallel: boolean;
+}
+export declare function isTextContent(block: UnifiedContentBlock): block is TextContentBlock;
+export declare function isThinkingContent(block: UnifiedContentBlock): block is ThinkingContentBlock;
+export declare function isToolCallContent(block: UnifiedContentBlock): block is ToolCallContentBlock;
+export declare function isToolResultContent(block: UnifiedContentBlock): block is ToolResultContentBlock;
+export declare function isImageContent(block: UnifiedContentBlock): block is ImageContentBlock;

package/dist/server/modules/session-reader/dtos/unified-session.types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextContent = isTextContent;
+exports.isThinkingContent = isThinkingContent;
+exports.isToolCallContent = isToolCallContent;
+exports.isToolResultContent = isToolResultContent;
+exports.isImageContent = isImageContent;
+function isTextContent(block) {
+    return block.type === 'text';
+}
+function isThinkingContent(block) {
+    return block.type === 'thinking';
+}
+function isToolCallContent(block) {
+    return block.type === 'tool_call';
+}
+function isToolResultContent(block) {
+    return block.type === 'tool_result';
+}
+function isImageContent(block) {
+    return block.type === 'image';
+}
+//# sourceMappingURL=unified-session.types.js.map

package/dist/server/modules/session-reader/dtos/unified-session.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-session.types.js","sourceRoot":"","sources":["../../../../src/modules/session-reader/dtos/unified-session.types.ts"],"names":[],"mappings":";;AAqNA,sCAEC;AAED,8CAEC;AAED,8CAEC;AAED,kDAEC;AAED,wCAEC;AAlBD,SAAgB,aAAa,CAAC,KAA0B;IACtD,OAAO,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC;AAC/B,CAAC;AAED,SAAgB,iBAAiB,CAAC,KAA0B;IAC1D,OAAO,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC;AACnC,CAAC;AAED,SAAgB,iBAAiB,CAAC,KAA0B;IAC1D,OAAO,KAAK,CAAC,IAAI,KAAK,WAAW,CAAC;AACpC,CAAC;AAED,SAAgB,mBAAmB,CAAC,KAA0B;IAC5D,OAAO,KAAK,CAAC,IAAI,KAAK,aAAa,CAAC;AACtC,CAAC;AAED,SAAgB,cAAc,CAAC,KAA0B;IACvD,OAAO,KAAK,CAAC,IAAI,KAAK,OAAO,CAAC;AAChC,CAAC"}

package/dist/server/modules/session-reader/parsers/claude-jsonl.parser.d.ts

@@ -0,0 +1,15 @@
+import type { UnifiedMessage, UnifiedMetrics } from '../dtos/unified-session.types';
+import type { PricingServiceInterface } from '../services/pricing.interface';
+export interface ClaudeParseResult {
+    messages: UnifiedMessage[];
+    metrics: UnifiedMetrics;
+    bytesRead: number;
+    warnings?: string[];
+}
+export interface ClaudeParseOptions {
+    maxMessages?: number;
+    byteOffset?: number;
+    includeToolCalls?: boolean;
+    pricingService?: PricingServiceInterface;
+}
+export declare function parseClaudeJsonl(filePath: string, options?: ClaudeParseOptions): Promise<ClaudeParseResult>;

package/dist/server/modules/session-reader/parsers/claude-jsonl.parser.js

@@ -0,0 +1,363 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudeJsonl = parseClaudeJsonl;
+const fs = __importStar(require("node:fs"));
+const readline = __importStar(require("node:readline"));
+const logger_1 = require("../../../common/logging/logger");
+const estimate_content_tokens_1 = require("../adapters/utils/estimate-content-tokens");
+const logger = (0, logger_1.createLogger)('ClaudeJsonlParser');
+const MAX_LINE_BYTES = 10 * 1024 * 1024;
+const FILTERED_TYPES = new Set(['summary', 'file-history-snapshot', 'queue-operation', 'progress']);
+async function parseClaudeJsonl(filePath, options) {
+    const byteOffset = options?.byteOffset ?? 0;
+    const maxMessages = options?.maxMessages;
+    const includeToolCalls = options?.includeToolCalls ?? true;
+    const pricing = options?.pricingService;
+    const messages = [];
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCacheRead = 0;
+    let totalCacheCreation = 0;
+    let costUsd = 0;
+    let firstTimestamp;
+    let lastTimestamp;
+    let primaryModel = '';
+    const modelsSet = new Set();
+    const compaction = {
+        lastMainAssistantInputTokens: 0,
+        awaitingPostCompaction: false,
+        phases: [],
+        compactionCount: 0,
+        currentPhaseNumber: 1,
+    };
+    let visibleContextTokens = 0;
+    let totalContextTokens = 0;
+    let lastAssistantStopReason = null;
+    let oversizedLineCount = 0;
+    let bytesRead = byteOffset;
+    const stream = fs.createReadStream(filePath, {
+        start: byteOffset,
+        encoding: 'utf8',
+    });
+    const rl = readline.createInterface({
+        input: stream,
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of rl) {
+            const lineBytes = Buffer.byteLength(line, 'utf8') + 1;
+            bytesRead += lineBytes;
+            if (!line.trim())
+                continue;
+            if (lineBytes > MAX_LINE_BYTES) {
+                logger.warn({ filePath, lineBytes, byteOffset: bytesRead - lineBytes, snippet: line.slice(0, 200) }, 'Skipping oversized JSONL line (>10MB)');
+                oversizedLineCount++;
+                continue;
+            }
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                logger.warn({ filePath }, 'Skipping malformed JSONL line');
+                continue;
+            }
+            if (!entry.type || FILTERED_TYPES.has(entry.type))
+                continue;
+            if (entry.type === 'system')
+                continue;
+            if (entry.type !== 'user' && entry.type !== 'assistant')
+                continue;
+            const ts = entry.timestamp ? new Date(entry.timestamp) : new Date();
+            if (!firstTimestamp || ts < firstTimestamp)
+                firstTimestamp = ts;
+            if (!lastTimestamp || ts > lastTimestamp)
+                lastTimestamp = ts;
+            const msg = entry.message;
+            if (!msg)
+                continue;
+            const unified = buildUnifiedMessage(entry, ts, includeToolCalls);
+            if (!unified)
+                continue;
+            if (!entry.isSidechain) {
+                visibleContextTokens += (0, estimate_content_tokens_1.estimateMessageTokens)(unified.content);
+            }
+            if (entry.type === 'assistant' && msg.usage) {
+                const usage = msg.usage;
+                const input = usage.input_tokens ?? 0;
+                const output = usage.output_tokens ?? 0;
+                const cacheRead = usage.cache_read_input_tokens ?? 0;
+                const cacheCreation = usage.cache_creation_input_tokens ?? 0;
+                totalInput += input;
+                totalOutput += output;
+                totalCacheRead += cacheRead;
+                totalCacheCreation += cacheCreation;
+                if (pricing && msg.model) {
+                    costUsd += pricing.calculateMessageCost(msg.model, input, output, cacheRead, cacheCreation);
+                }
+                if (msg.model && msg.model !== '<synthetic>') {
+                    primaryModel = msg.model;
+                    modelsSet.add(msg.model);
+                }
+                lastAssistantStopReason = msg.stop_reason ?? null;
+                if (!entry.isSidechain) {
+                    const inputTokens = input + cacheRead + cacheCreation;
+                    if (compaction.awaitingPostCompaction) {
+                        const currentPhase = compaction.phases[compaction.phases.length - 1];
+                        if (currentPhase) {
+                            currentPhase.postCompaction = inputTokens;
+                            currentPhase.contribution =
+                                currentPhase.peakTokens -
+                                    (compaction.phases.length > 1
+                                        ? (compaction.phases[compaction.phases.length - 2]?.postCompaction ?? 0)
+                                        : 0);
+                        }
+                        compaction.currentPhaseNumber++;
+                        compaction.awaitingPostCompaction = false;
+                    }
+                    compaction.lastMainAssistantInputTokens = inputTokens;
+                    totalContextTokens = input + output + cacheRead + cacheCreation;
+                }
+            }
+            if (entry.type === 'user' && entry.isCompactSummary && !entry.isSidechain) {
+                compaction.phases.push({
+                    phaseNumber: compaction.currentPhaseNumber,
+                    contribution: 0,
+                    peakTokens: compaction.lastMainAssistantInputTokens,
+                    compactionMessageId: entry.uuid,
+                });
+                compaction.compactionCount++;
+                compaction.awaitingPostCompaction = true;
+            }
+            messages.push(unified);
+            if (entry.type === 'user' && entry.isCompactSummary && !entry.isSidechain) {
+                visibleContextTokens = (0, estimate_content_tokens_1.estimateMessageTokens)(unified.content);
+            }
+            if (maxMessages && messages.length >= maxMessages)
+                break;
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    const lastPhase = compaction.phases[compaction.phases.length - 1];
+    if (compaction.phases.length > 0 &&
+        lastPhase?.postCompaction !== undefined &&
+        lastPhase.postCompaction > 0) {
+        const finalContribution = compaction.lastMainAssistantInputTokens - lastPhase.postCompaction;
+        compaction.phases.push({
+            phaseNumber: compaction.currentPhaseNumber,
+            contribution: finalContribution,
+            peakTokens: compaction.lastMainAssistantInputTokens,
+        });
+    }
+    else if (compaction.phases.length === 0) {
+        compaction.phases.push({
+            phaseNumber: 1,
+            contribution: compaction.lastMainAssistantInputTokens,
+            peakTokens: compaction.lastMainAssistantInputTokens,
+        });
+    }
+    if (compaction.phases.length > 0 && compaction.compactionCount > 0) {
+        compaction.phases[0].contribution = compaction.phases[0].peakTokens;
+    }
+    const totalContextConsumption = compaction.phases.reduce((sum, p) => sum + p.contribution, 0);
+    const durationMs = firstTimestamp && lastTimestamp ? lastTimestamp.getTime() - firstTimestamp.getTime() : 0;
+    const isOngoing = lastAssistantStopReason === null || lastAssistantStopReason === 'tool_use';
+    const contextWindowTokens = pricing ? pricing.getContextWindowSize(primaryModel) : 200_000;
+    const modelsUsed = modelsSet.size > 1 ? Array.from(modelsSet) : undefined;
+    const totalTokens = totalInput + totalOutput + totalCacheRead + totalCacheCreation;
+    const metrics = {
+        inputTokens: totalInput,
+        outputTokens: totalOutput,
+        cacheReadTokens: totalCacheRead,
+        cacheCreationTokens: totalCacheCreation,
+        totalTokens,
+        totalContextConsumption,
+        compactionCount: compaction.compactionCount,
+        phaseBreakdowns: compaction.phases,
+        visibleContextTokens,
+        totalContextTokens,
+        contextWindowTokens,
+        costUsd,
+        primaryModel,
+        modelsUsed,
+        durationMs,
+        messageCount: messages.length,
+        isOngoing,
+    };
+    const warnings = [];
+    if (oversizedLineCount > 0) {
+        warnings.push(`Skipped ${oversizedLineCount} oversized line${oversizedLineCount > 1 ? 's' : ''} (>10MB each)`);
+    }
+    return { messages, metrics, bytesRead, warnings: warnings.length > 0 ? warnings : undefined };
+}
+function buildUnifiedMessage(entry, timestamp, includeToolCalls) {
+    const msg = entry.message;
+    if (!msg)
+        return null;
+    const role = entry.type === 'assistant' ? 'assistant' : 'user';
+    const id = entry.uuid ?? '';
+    const parentId = entry.parentUuid ?? null;
+    const isMeta = entry.isMeta ?? false;
+    const isSidechain = entry.isSidechain ?? false;
+    const isCompactSummary = entry.isCompactSummary ?? false;
+    const model = msg.model;
+    let content = [];
+    let toolCalls = [];
+    let toolResults = [];
+    let usage;
+    if (entry.type === 'assistant') {
+        if (msg.usage) {
+            usage = {
+                input: msg.usage.input_tokens ?? 0,
+                output: msg.usage.output_tokens ?? 0,
+                cacheRead: msg.usage.cache_read_input_tokens ?? 0,
+                cacheCreation: msg.usage.cache_creation_input_tokens ?? 0,
+            };
+        }
+        if (Array.isArray(msg.content)) {
+            const extracted = extractAssistantContent(msg.content, includeToolCalls);
+            content = extracted.content;
+            toolCalls = extracted.toolCalls;
+        }
+    }
+    else if (entry.type === 'user') {
+        if (typeof msg.content === 'string') {
+            content = [{ type: 'text', text: msg.content }];
+        }
+        else if (Array.isArray(msg.content)) {
+            const extracted = extractUserContent(msg.content);
+            content = extracted.content;
+            toolResults = extracted.toolResults;
+        }
+    }
+    return {
+        id,
+        parentId,
+        role,
+        timestamp,
+        content,
+        usage,
+        model,
+        toolCalls,
+        toolResults,
+        isMeta,
+        isSidechain,
+        isCompactSummary: isCompactSummary || undefined,
+        sourceToolUseId: entry.sourceToolUseID || undefined,
+    };
+}
+function extractAssistantContent(rawContent, includeToolCalls) {
+    const content = [];
+    const toolCalls = [];
+    for (const block of rawContent) {
+        switch (block.type) {
+            case 'text':
+                if (block.text !== undefined) {
+                    content.push({ type: 'text', text: block.text });
+                }
+                break;
+            case 'thinking':
+                if (block.thinking !== undefined) {
+                    content.push({
+                        type: 'thinking',
+                        thinking: block.thinking,
+                        signature: block.signature,
+                    });
+                }
+                break;
+            case 'tool_use':
+                if (block.id && block.name) {
+                    if (includeToolCalls) {
+                        content.push({
+                            type: 'tool_call',
+                            toolCallId: block.id,
+                            toolName: block.name,
+                            input: block.input ?? {},
+                        });
+                    }
+                    toolCalls.push({
+                        id: block.id,
+                        name: block.name,
+                        input: block.input ?? {},
+                        isTask: block.name === 'Task',
+                        taskDescription: block.name === 'Task' ? block.input?.description : undefined,
+                        taskSubagentType: block.name === 'Task'
+                            ? block.input?.subagent_type
+                            : undefined,
+                    });
+                }
+                break;
+            case 'image':
+                if (block.source) {
+                    content.push({
+                        type: 'image',
+                        mediaType: block.source.media_type ?? 'image/png',
+                        data: block.source.data ?? '',
+                    });
+                }
+                break;
+        }
+    }
+    return { content, toolCalls };
+}
+function extractUserContent(rawContent) {
+    const content = [];
+    const toolResults = [];
+    for (const block of rawContent) {
+        if (block.type === 'tool_result' && block.tool_use_id) {
+            const resultContent = block.content ?? '';
+            content.push({
+                type: 'tool_result',
+                toolCallId: block.tool_use_id,
+                content: resultContent,
+                isError: block.is_error ?? false,
+            });
+            toolResults.push({
+                toolCallId: block.tool_use_id,
+                content: resultContent,
+                isError: block.is_error ?? false,
+            });
+        }
+        else if (block.type === 'text' && block.text !== undefined) {
+            content.push({ type: 'text', text: block.text });
+        }
+    }
+    return { content, toolResults };
+}
+//# sourceMappingURL=claude-jsonl.parser.js.map