sidekick-shared 0.23.1 → 0.24.0

package/dist/schemas/usageNormalization.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const normalizedUsageSchema: z.ZodObject<{
+    uncachedInputTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNumber;
+    reasoningIncludedInOutput: z.ZodBoolean;
+    cacheInclusiveInputTokens: z.ZodNumber;
+    billableOutputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    model: z.ZodOptional<z.ZodString>;
+    reportedCostUsd: z.ZodOptional<z.ZodNumber>;
+    provenance: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        semantics: z.ZodEnum<{
+            "anthropic-additive-cache": "anthropic-additive-cache";
+            "openai-inclusive-cache": "openai-inclusive-cache";
+            "sidekick-disjoint": "sidekick-disjoint";
+        }>;
+        source: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const normalizedUsageCostSchema: z.ZodObject<{
+    costUsd: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<{
+        unpriced: "unpriced";
+        "provider-reported": "provider-reported";
+        "explicit-pricing": "explicit-pricing";
+        "model-catalog": "model-catalog";
+    }>;
+    modelId: z.ZodOptional<z.ZodString>;
+    usage: z.ZodObject<{
+        uncachedInputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        reasoningIncludedInOutput: z.ZodBoolean;
+        cacheInclusiveInputTokens: z.ZodNumber;
+        billableOutputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        model: z.ZodOptional<z.ZodString>;
+        reportedCostUsd: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodObject<{
+            provider: z.ZodOptional<z.ZodString>;
+            semantics: z.ZodEnum<{
+                "anthropic-additive-cache": "anthropic-additive-cache";
+                "openai-inclusive-cache": "openai-inclusive-cache";
+                "sidekick-disjoint": "sidekick-disjoint";
+            }>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/schemas/usageNormalization.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizedUsageCostSchema = exports.normalizedUsageSchema = void 0;
+const zod_1 = require("zod");
+const normalizedUsageObjectSchema = zod_1.z.object({
+    uncachedInputTokens: zod_1.z.number().finite().nonnegative(),
+    cacheReadTokens: zod_1.z.number().finite().nonnegative(),
+    cacheWriteTokens: zod_1.z.number().finite().nonnegative(),
+    outputTokens: zod_1.z.number().finite().nonnegative(),
+    reasoningTokens: zod_1.z.number().finite().nonnegative(),
+    reasoningIncludedInOutput: zod_1.z.boolean(),
+    cacheInclusiveInputTokens: zod_1.z.number().finite().nonnegative(),
+    billableOutputTokens: zod_1.z.number().finite().nonnegative(),
+    totalTokens: zod_1.z.number().finite().nonnegative(),
+    model: zod_1.z.string().optional(),
+    reportedCostUsd: zod_1.z.number().finite().nonnegative().optional(),
+    provenance: zod_1.z.object({
+        provider: zod_1.z.string().optional(),
+        semantics: zod_1.z.enum(['anthropic-additive-cache', 'openai-inclusive-cache', 'sidekick-disjoint']),
+        source: zod_1.z.string().optional(),
+    }),
+});
+exports.normalizedUsageSchema = normalizedUsageObjectSchema.superRefine((usage, context) => {
+    const expectedInput = usage.uncachedInputTokens + usage.cacheReadTokens + usage.cacheWriteTokens;
+    const expectedOutput = usage.outputTokens + (usage.reasoningIncludedInOutput ? 0 : usage.reasoningTokens);
+    if (usage.cacheInclusiveInputTokens !== expectedInput) {
+        context.addIssue({ code: 'custom', message: 'cacheInclusiveInputTokens is inconsistent' });
+    }
+    if (usage.billableOutputTokens !== expectedOutput) {
+        context.addIssue({ code: 'custom', message: 'billableOutputTokens is inconsistent' });
+    }
+    if (usage.totalTokens !== expectedInput + expectedOutput) {
+        context.addIssue({ code: 'custom', message: 'totalTokens is inconsistent' });
+    }
+});
+exports.normalizedUsageCostSchema = zod_1.z.object({
+    costUsd: zod_1.z.number().finite().nonnegative().nullable(),
+    source: zod_1.z.enum(['provider-reported', 'explicit-pricing', 'model-catalog', 'unpriced']),
+    modelId: zod_1.z.string().optional(),
+    usage: exports.normalizedUsageSchema,
+});

package/dist/sessionTranscripts.d.ts

@@ -0,0 +1,16 @@
+import type { SessionProviderBase, ProviderId } from './providers/types';
+import { type CanonicalSessionTranscript, type ProjectSessionTranscriptOptions } from './transcript';
+export interface ProviderSessionIndex {
+    provider: ProviderId;
+    sessionId: string;
+    sessionPath: string;
+    label: string | null;
+    modifiedAt: string;
+}
+export interface ListRecentSessionsOptions {
+    limit?: number;
+}
+/** List recent sessions using the provider's existing discovery and metadata APIs. */
+export declare function listRecentSessions(provider: SessionProviderBase, workspacePath: string, options?: ListRecentSessionsOptions): ProviderSessionIndex[];
+/** Read a canonical transcript through a provider's existing reader. */
+export declare function readSessionTranscript(provider: SessionProviderBase, sessionPath: string, options?: Omit<ProjectSessionTranscriptOptions, 'provider' | 'sessionId' | 'sourcePath'>): CanonicalSessionTranscript;

package/dist/sessionTranscripts.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRecentSessions = listRecentSessions;
+exports.readSessionTranscript = readSessionTranscript;
+const node_fs_1 = require("node:fs");
+const transcript_1 = require("./transcript");
+/** List recent sessions using the provider's existing discovery and metadata APIs. */
+function listRecentSessions(provider, workspacePath, options = {}) {
+    const limit = Math.max(0, options.limit ?? 20);
+    return provider
+        .findAllSessions(workspacePath)
+        .map((sessionPath) => ({
+        provider: provider.id,
+        sessionId: provider.getSessionId(sessionPath),
+        sessionPath,
+        label: provider.extractSessionLabel(sessionPath),
+        modifiedAt: sessionModifiedAt(provider, sessionPath).toISOString(),
+    }))
+        .sort((left, right) => right.modifiedAt.localeCompare(left.modifiedAt))
+        .slice(0, limit);
+}
+function sessionModifiedAt(provider, sessionPath) {
+    const metadata = provider.getSessionMetadata?.(sessionPath);
+    if (metadata)
+        return metadata.mtime;
+    try {
+        return (0, node_fs_1.statSync)(sessionPath).mtime;
+    }
+    catch {
+        return new Date(0);
+    }
+}
+/** Read a canonical transcript through a provider's existing reader. */
+function readSessionTranscript(provider, sessionPath, options = {}) {
+    const reader = provider.createReader(sessionPath);
+    try {
+        return (0, transcript_1.projectSessionTranscript)(reader.readAll(), {
+            ...options,
+            provider: provider.id,
+            sessionId: provider.getSessionId(sessionPath),
+            sourcePath: sessionPath,
+        });
+    }
+    finally {
+        reader.flush();
+    }
+}

package/dist/tokenEstimation.d.ts

@@ -0,0 +1,24 @@
+export type TokenEstimationMethod = 'exact' | 'sidekick-fallback-v1';
+export type TokenEstimationConfidence = 'exact' | 'medium' | 'low';
+export interface ExactTokenCounterContext {
+    model?: string;
+}
+export type ExactTokenCounter = (text: string, context: ExactTokenCounterContext) => number | null | undefined;
+export interface TokenEstimationOptions extends ExactTokenCounterContext {
+    exactCounter?: ExactTokenCounter;
+}
+export interface TokenEstimate {
+    count: number;
+    method: TokenEstimationMethod;
+    confidence: TokenEstimationConfidence;
+    provenance: string;
+}
+/**
+ * Estimate tokens without bundling a tokenizer.
+ *
+ * Fallback v1 counts Latin/source-code runs at 3.5 UTF-16 characters per
+ * token, CJK code points at one token, emoji at two, and other non-ASCII code
+ * points at one. The result is deliberately conservative for context budgets.
+ */
+export declare function estimateTextTokens(text: string, options?: TokenEstimationOptions): TokenEstimate;
+export declare function estimateSerializedTokens(value: unknown, options?: TokenEstimationOptions): TokenEstimate;

package/dist/tokenEstimation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTextTokens = estimateTextTokens;
+exports.estimateSerializedTokens = estimateSerializedTokens;
+const CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const EMOJI = /\p{Extended_Pictographic}/u;
+/**
+ * Estimate tokens without bundling a tokenizer.
+ *
+ * Fallback v1 counts Latin/source-code runs at 3.5 UTF-16 characters per
+ * token, CJK code points at one token, emoji at two, and other non-ASCII code
+ * points at one. The result is deliberately conservative for context budgets.
+ */
+function estimateTextTokens(text, options = {}) {
+    if (text.length === 0) {
+        return { count: 0, method: 'sidekick-fallback-v1', confidence: 'medium', provenance: 'empty' };
+    }
+    let exact;
+    try {
+        exact = options.exactCounter?.(text, { model: options.model });
+    }
+    catch {
+        exact = undefined;
+    }
+    if (typeof exact === 'number' && Number.isFinite(exact) && exact >= 0) {
+        return {
+            count: Math.ceil(exact),
+            method: 'exact',
+            confidence: 'exact',
+            provenance: options.model ?? 'injected-counter',
+        };
+    }
+    let asciiChars = 0;
+    let conservativeTokens = 0;
+    for (const codePoint of text) {
+        if (EMOJI.test(codePoint))
+            conservativeTokens += 2;
+        else if (CJK.test(codePoint))
+            conservativeTokens += 1;
+        else if ((codePoint.codePointAt(0) ?? 128) <= 127)
+            asciiChars += codePoint.length;
+        else
+            conservativeTokens += 1;
+    }
+    const count = Math.ceil(asciiChars / 3.5) + conservativeTokens;
+    return {
+        count: Number.isFinite(count) && count >= 0 ? count : 0,
+        method: 'sidekick-fallback-v1',
+        confidence: conservativeTokens > 0 ? 'low' : 'medium',
+        provenance: 'chars-per-token-3.5+cjk1+emoji2',
+    };
+}
+function estimateSerializedTokens(value, options = {}) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value) ?? '';
+    }
+    catch {
+        serialized = String(value);
+    }
+    return estimateTextTokens(serialized, options);
+}

package/dist/transcript.d.ts

@@ -0,0 +1,92 @@
+import type { ProviderId } from './providers/types';
+import type { SessionEvent } from './types/sessionEvent';
+import { type NormalizedUsage, type NormalizedUsageCost } from './usageNormalization';
+export type TranscriptFidelity = 'snippet' | 'full';
+export interface TranscriptSourceProvenance {
+    provider?: ProviderId | string;
+    sessionId?: string;
+    sourcePath?: string;
+    source?: string;
+    eventIndex: number;
+    eventType: SessionEvent['type'];
+    eventId?: string;
+}
+export interface CanonicalTranscriptBlock {
+    type: 'text' | 'thinking' | 'tool_use' | 'tool_result' | 'image' | 'unknown';
+    text?: string;
+    toolName?: string;
+    toolUseId?: string;
+    input?: unknown;
+    output?: unknown;
+    isError?: boolean;
+    command?: string;
+    truncated?: boolean;
+    raw?: unknown;
+}
+export interface CanonicalTranscriptMessage {
+    id?: string;
+    role: 'user' | 'assistant' | 'system' | 'summary' | 'tool';
+    timestamp: string;
+    model?: string;
+    sourceLabel?: string;
+    content: CanonicalTranscriptBlock[];
+    text: string;
+    usage?: NormalizedUsage;
+    cost?: NormalizedUsageCost;
+    tools: CanonicalToolCall[];
+    commands: string[];
+    source: TranscriptSourceProvenance;
+}
+export interface CanonicalToolCall {
+    id?: string;
+    name: string;
+    timestamp: string;
+    input?: unknown;
+    output?: unknown;
+    isError?: boolean;
+    command?: string;
+    source: TranscriptSourceProvenance;
+}
+export interface CanonicalTranscriptUsageTotals {
+    uncachedInputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    outputTokens: number;
+    reasoningTokens: number;
+    cacheInclusiveInputTokens: number;
+    billableOutputTokens: number;
+    totalTokens: number;
+}
+export interface CanonicalSessionTranscript {
+    provider?: ProviderId | string;
+    sessionId?: string;
+    sourcePath?: string;
+    startedAt?: string;
+    endedAt?: string;
+    models: string[];
+    messages: CanonicalTranscriptMessage[];
+    tools: CanonicalToolCall[];
+    commands: string[];
+    usage: {
+        events: NormalizedUsage[];
+        costs: NormalizedUsageCost[];
+        totals: CanonicalTranscriptUsageTotals;
+        totalCostUsd: number | null;
+    };
+    provenance: {
+        source: 'session-events';
+        fidelity: TranscriptFidelity;
+        eventCount: number;
+    };
+}
+export interface ProjectSessionTranscriptOptions {
+    provider?: ProviderId | string;
+    sessionId?: string;
+    sourcePath?: string;
+    fidelity?: TranscriptFidelity;
+    /** Maximum characters per text/serialized block in snippet mode. Default 2000. */
+    maxContentChars?: number;
+    includeUnknownBlocks?: boolean;
+}
+/** Project canonical provider events into a bounded or full-fidelity transcript. */
+export declare function projectSessionTranscript(events: SessionEvent[], options?: ProjectSessionTranscriptOptions): CanonicalSessionTranscript;

package/dist/transcript.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSessionTranscript = projectSessionTranscript;
+const usageNormalization_1 = require("./usageNormalization");
+const EMPTY_TOTALS = {
+    uncachedInputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheInclusiveInputTokens: 0,
+    billableOutputTokens: 0,
+    totalTokens: 0,
+};
+/** Project canonical provider events into a bounded or full-fidelity transcript. */
+function projectSessionTranscript(events, options = {}) {
+    const fidelity = options.fidelity ?? 'snippet';
+    const requestedMax = options.maxContentChars ?? 2_000;
+    const maxContentChars = Number.isFinite(requestedMax) ? Math.max(0, requestedMax) : 2_000;
+    const messages = [];
+    const tools = [];
+    const commands = [];
+    const models = new Set();
+    const usageEvents = [];
+    const usageCosts = [];
+    const totals = { ...EMPTY_TOTALS };
+    const toolsById = new Map();
+    events.forEach((event, eventIndex) => {
+        const message = event.message;
+        const source = {
+            provider: options.provider ?? event.providerMetadata?.providerId,
+            sessionId: options.sessionId,
+            sourcePath: options.sourcePath,
+            source: event.providerMetadata?.source,
+            eventIndex,
+            eventType: event.type,
+            eventId: message?.id,
+        };
+        const usage = (0, usageNormalization_1.extractNormalizedUsage)(event) ?? undefined;
+        if (usage) {
+            usageEvents.push(usage);
+            addUsage(totals, usage);
+        }
+        const cost = usage
+            ? (0, usageNormalization_1.calculateNormalizedUsageCost)({ usage, modelId: message?.model })
+            : undefined;
+        if (cost)
+            usageCosts.push(cost);
+        if (message?.model)
+            models.add(message.model);
+        const blocks = contentBlocks(message?.content, fidelity, maxContentChars, options.includeUnknownBlocks);
+        if (event.type === 'summary' && event.summary && blocks.length === 0) {
+            blocks.push({ type: 'text', ...boundedText(event.summary, fidelity, maxContentChars) });
+        }
+        if (event.type === 'tool_use') {
+            blocks.push({
+                type: 'tool_use',
+                toolName: event.tool.name,
+                input: boundedValue(event.tool.input, fidelity, maxContentChars),
+            });
+        }
+        if (event.type === 'tool_result') {
+            blocks.push({
+                type: 'tool_result',
+                toolUseId: event.result.tool_use_id,
+                output: boundedValue(event.result.output, fidelity, maxContentChars),
+                isError: event.result.is_error,
+            });
+        }
+        const messageTools = [];
+        for (const block of blocks) {
+            if (block.type === 'tool_use' && block.toolName) {
+                const command = block.command ?? commandFromTool(block.toolName, block.input);
+                const call = {
+                    id: block.toolUseId,
+                    name: block.toolName,
+                    timestamp: event.timestamp,
+                    input: block.input,
+                    command,
+                    source,
+                };
+                tools.push(call);
+                messageTools.push(call);
+                if (call.id)
+                    toolsById.set(call.id, call);
+                if (command)
+                    commands.push(command);
+            }
+            else if (block.type === 'tool_result' && block.toolUseId) {
+                const call = toolsById.get(block.toolUseId);
+                if (call) {
+                    call.output = block.output;
+                    call.isError = block.isError;
+                }
+            }
+        }
+        if (blocks.length === 0 && !usage && event.type !== 'summary')
+            return;
+        messages.push({
+            id: message?.id,
+            role: roleForEvent(event),
+            timestamp: event.timestamp,
+            model: message?.model,
+            sourceLabel: message?.sourceLabel,
+            content: blocks,
+            text: blocks
+                .filter((block) => block.type === 'text' || block.type === 'thinking')
+                .map((block) => block.text ?? '')
+                .filter(Boolean)
+                .join('\n'),
+            usage,
+            cost,
+            tools: messageTools,
+            commands: messageTools.flatMap((tool) => (tool.command ? [tool.command] : [])),
+            source,
+        });
+    });
+    return {
+        provider: options.provider,
+        sessionId: options.sessionId,
+        sourcePath: options.sourcePath,
+        startedAt: events[0]?.timestamp,
+        endedAt: events.at(-1)?.timestamp,
+        models: [...models],
+        messages,
+        tools,
+        commands: [...new Set(commands)],
+        usage: {
+            events: usageEvents,
+            costs: usageCosts,
+            totals,
+            totalCostUsd: usageCosts.length > 0 && usageCosts.every((cost) => cost.costUsd !== null)
+                ? usageCosts.reduce((sum, cost) => sum + (cost.costUsd ?? 0), 0)
+                : null,
+        },
+        provenance: { source: 'session-events', fidelity, eventCount: events.length },
+    };
+}
+function roleForEvent(event) {
+    if (event.type === 'summary')
+        return 'summary';
+    if (event.type === 'system')
+        return 'system';
+    if (event.type === 'tool_use' || event.type === 'tool_result')
+        return 'tool';
+    return event.type;
+}
+function contentBlocks(content, fidelity, maxChars, includeUnknown = false) {
+    if (typeof content === 'string')
+        return [{ type: 'text', ...boundedText(content, fidelity, maxChars) }];
+    if (!Array.isArray(content))
+        return [];
+    const result = [];
+    for (const raw of content) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const block = raw;
+        if (block.type === 'text' && typeof block.text === 'string') {
+            result.push({ type: 'text', ...boundedText(block.text, fidelity, maxChars) });
+        }
+        else if ((block.type === 'thinking' || block.type === 'reasoning') &&
+            (typeof block.thinking === 'string' || typeof block.text === 'string')) {
+            result.push({
+                type: 'thinking',
+                ...boundedText(String(block.thinking ?? block.text), fidelity, maxChars),
+            });
+        }
+        else if (block.type === 'tool_use' && typeof block.name === 'string') {
+            result.push({
+                type: 'tool_use',
+                toolName: block.name,
+                toolUseId: typeof block.id === 'string' ? block.id : undefined,
+                input: boundedValue(block.input, fidelity, maxChars),
+                command: commandFromTool(block.name, block.input),
+            });
+        }
+        else if (block.type === 'tool_result') {
+            result.push({
+                type: 'tool_result',
+                toolUseId: typeof block.tool_use_id === 'string' ? block.tool_use_id : undefined,
+                output: boundedValue(block.content, fidelity, maxChars),
+                isError: block.is_error === true,
+            });
+        }
+        else if (block.type === 'image') {
+            result.push({
+                type: 'image',
+                text: '[Image content]',
+                ...(fidelity === 'full' ? { raw } : {}),
+            });
+        }
+        else if (includeUnknown) {
+            result.push({ type: 'unknown', raw: boundedValue(raw, fidelity, maxChars) });
+        }
+    }
+    return result;
+}
+function boundedText(text, fidelity, maxChars) {
+    if (fidelity === 'full' || text.length <= maxChars)
+        return { text, truncated: false };
+    return { text: text.slice(0, maxChars), truncated: true };
+}
+function boundedValue(value, fidelity, maxChars) {
+    if (fidelity === 'full' || value === undefined)
+        return value;
+    if (typeof value === 'string')
+        return boundedText(value, fidelity, maxChars).text;
+    try {
+        const json = JSON.stringify(value);
+        return json.length <= maxChars ? value : json.slice(0, maxChars);
+    }
+    catch {
+        return String(value).slice(0, maxChars);
+    }
+}
+function commandFromTool(name, input) {
+    if (!input || typeof input !== 'object')
+        return undefined;
+    const value = input;
+    if (!['bash', 'shell', 'execcommand', 'exec_command', 'local_shell'].includes(name.toLowerCase())) {
+        return undefined;
+    }
+    if (typeof value.command === 'string')
+        return value.command;
+    if (Array.isArray(value.command))
+        return value.command.map(String).join(' ');
+    if (typeof value.cmd === 'string')
+        return value.cmd;
+    return undefined;
+}
+function addUsage(total, usage) {
+    total.uncachedInputTokens += usage.uncachedInputTokens;
+    total.cacheReadTokens += usage.cacheReadTokens;
+    total.cacheWriteTokens += usage.cacheWriteTokens;
+    total.outputTokens += usage.outputTokens;
+    total.reasoningTokens += usage.reasoningTokens;
+    total.cacheInclusiveInputTokens += usage.cacheInclusiveInputTokens;
+    total.billableOutputTokens += usage.billableOutputTokens;
+    total.totalTokens += usage.totalTokens;
+}

package/dist/types/observedSessionV1.d.ts

@@ -1,5 +1,6 @@
 import type { SessionEvent } from './sessionEvent';
 import type { ProviderId, SessionProviderBase } from '../providers/types';
+import type { CanonicalTranscriptUsageTotals } from '../transcript';
 export type ObservationProvenanceV1 = 'reported' | 'estimated' | 'inferred';
 export interface SessionEvidenceRefV1 {
     schemaVersion: 1;
@@ -40,7 +41,8 @@ export interface ObservedAgentSessionV1 {
         outputTokens: ObservedValueV1<number>;
         cacheReadTokens: ObservedValueV1<number>;
         cacheWriteTokens: ObservedValueV1<number>;
-        costUsd: ObservedValueV1<number>;
+        normalized?: ObservedValueV1<CanonicalTranscriptUsageTotals>;
+        costUsd: ObservedValueV1<number | null>;
     };
     pendingUserRequest: PendingUserRequestV1 | null;
     observedAt: string;

package/dist/types/observedSessionV1.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.derivePendingUserRequestV1 = derivePendingUserRequestV1;
 exports.createProviderSessionAdapterV1 = createProviderSessionAdapterV1;
+const transcript_1 = require("../transcript");
 function evidence(provider, sessionId, sourcePath, event, eventIndex) {
     return [
         {
@@ -121,11 +122,18 @@ function createProviderSessionAdapterV1(sessionProvider, options = {}) {
         async read(sessionPath, cwd = '') {
             const stats = sessionProvider.readSessionStats(sessionPath);
             const events = sessionProvider.createReader(sessionPath).readAll();
+            const transcript = (0, transcript_1.projectSessionTranscript)(events, {
+                provider: sessionProvider.id,
+                sessionId: stats.sessionId,
+                sourcePath: sessionPath,
+            });
             const refs = evidence(sessionProvider.id, stats.sessionId, sessionPath);
             const model = Object.entries(stats.modelUsage).sort((left, right) => right[1].calls - left[1].calls)[0]?.[0] ?? null;
             const metadata = sessionProvider.getSessionMetadata?.(sessionPath);
             const modifiedAt = metadata?.mtime.getTime() ?? Date.parse(stats.endTime);
             const recent = Number.isFinite(modifiedAt) && Date.now() - modifiedAt < 2 * 60_000;
+            const allCostsReported = transcript.usage.costs.length > 0 &&
+                transcript.usage.costs.every((cost) => cost.source === 'provider-reported');
             return {
                 schemaVersion: 1,
                 identity: {
@@ -141,7 +149,12 @@ function createProviderSessionAdapterV1(sessionProvider, options = {}) {
                     outputTokens: observed(stats.tokens.output, 'reported', 1, refs),
                     cacheReadTokens: observed(stats.tokens.cacheRead, 'reported', 1, refs),
                     cacheWriteTokens: observed(stats.tokens.cacheWrite, 'reported', 1, refs),
-                    costUsd: observed(stats.reportedCost, stats.reportedCost > 0 ? 'reported' : 'estimated', stats.reportedCost > 0 ? 1 : 0.5, refs),
+                    normalized: observed(transcript.usage.totals, 'reported', 1, refs),
+                    costUsd: observed(transcript.usage.totalCostUsd, allCostsReported
+                        ? 'reported'
+                        : transcript.usage.totalCostUsd === null
+                            ? 'inferred'
+                            : 'estimated', allCostsReported ? 1 : transcript.usage.totalCostUsd === null ? 0.5 : 0.9, refs),
                 },
                 pendingUserRequest: derivePendingUserRequestV1(sessionProvider.id, stats.sessionId, sessionPath, events),
                 observedAt: new Date().toISOString(),