@amplitude/wizard 1.0.0-beta.0

package/dist/src/lib/middleware/benchmarks/context-size-tracker.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Context size tracking plugin (context tokens in/out per phase).
+ *
+ * Context tokens out = sum of input + cache_read + cache_creation from the
+ * last assistant message's usage (per-turn, NOT aggregate).
+ * Context tokens in = previous phase's context tokens out.
+ */
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+export interface ContextSizeData {
+    /** Per-phase context size snapshots */
+    phaseSnapshots: Array<{
+        phase: string;
+        contextTokensIn?: number;
+        contextTokensOut?: number;
+        freshContext: boolean;
+    }>;
+}
+export declare class ContextSizeTrackerPlugin implements Middleware {
+    readonly name = "contextSize";
+    private phaseSnapshots;
+    private lastContextTokensOut?;
+    onPhaseTransition(fromPhase: string, _toPhase: string, ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onFinalize(_resultMessage: SDKMessage, _totalDurationMs: number, ctx: MiddlewareContext, store: MiddlewareStore): void;
+    private computeContextTokensOut;
+    private getData;
+}

package/dist/src/lib/middleware/benchmarks/context-size-tracker.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Context size tracking plugin (context tokens in/out per phase).
+ *
+ * Context tokens out = sum of input + cache_read + cache_creation from the
+ * last assistant message's usage (per-turn, NOT aggregate).
+ * Context tokens in = previous phase's context tokens out.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextSizeTrackerPlugin = void 0;
+class ContextSizeTrackerPlugin {
+    name = 'contextSize';
+    phaseSnapshots = [];
+    lastContextTokensOut;
+    onPhaseTransition(fromPhase, _toPhase, ctx, store) {
+        const tokens = ctx.get('tokens');
+        const contextTokensOut = this.computeContextTokensOut(tokens?.lastUsage);
+        this.phaseSnapshots.push({
+            phase: fromPhase,
+            contextTokensIn: ctx.currentPhaseFreshContext
+                ? undefined
+                : this.lastContextTokensOut,
+            contextTokensOut,
+            freshContext: ctx.currentPhaseFreshContext,
+        });
+        this.lastContextTokensOut = contextTokensOut;
+        store.set('contextSize', this.getData());
+    }
+    onFinalize(_resultMessage, _totalDurationMs, ctx, store) {
+        const tokens = ctx.get('tokens');
+        const contextTokensOut = this.computeContextTokensOut(tokens?.lastUsage);
+        this.phaseSnapshots.push({
+            phase: ctx.currentPhase,
+            contextTokensIn: ctx.currentPhaseFreshContext
+                ? undefined
+                : this.lastContextTokensOut,
+            contextTokensOut,
+            freshContext: ctx.currentPhaseFreshContext,
+        });
+        store.set('contextSize', this.getData());
+    }
+    computeContextTokensOut(usage) {
+        if (!usage)
+            return undefined;
+        return (Number(usage.input_tokens ?? 0) +
+            Number(usage.cache_read_input_tokens ?? 0) +
+            Number(usage.cache_creation_input_tokens ?? 0));
+    }
+    getData() {
+        return {
+            phaseSnapshots: [...this.phaseSnapshots],
+        };
+    }
+}
+exports.ContextSizeTrackerPlugin = ContextSizeTrackerPlugin;

package/dist/src/lib/middleware/benchmarks/cost-tracker.d.ts

@@ -0,0 +1,16 @@
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+export interface CostData {
+    totalCost: number;
+    phaseCosts: Array<{
+        phase: string;
+        cost: number;
+    }>;
+}
+export declare class CostTrackerPlugin implements Middleware {
+    readonly name = "cost";
+    private phaseCosts;
+    private totalCost;
+    onPhaseTransition(fromPhase: string, _toPhase: string, ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onFinalize(resultMessage: SDKMessage, _totalDurationMs: number, ctx: MiddlewareContext, store: MiddlewareStore): void;
+    private getData;
+}

package/dist/src/lib/middleware/benchmarks/cost-tracker.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostTrackerPlugin = void 0;
+/** Claude Sonnet 4.6 pricing (USD per 1M tokens) */
+const PRICE_PER_MTOK = {
+    input: 3,
+    output: 15,
+    cacheRead: 0.3,
+    cacheCreation5m: 3.75,
+    cacheCreation1h: 6,
+};
+function computeCost(inputTokens, outputTokens, cacheReadTokens, cacheCreation5m, cacheCreation1h, cacheCreationFallback) {
+    const hasBreakdown = cacheCreation5m > 0 || cacheCreation1h > 0;
+    return (inputTokens * (PRICE_PER_MTOK.input / 1e6) +
+        outputTokens * (PRICE_PER_MTOK.output / 1e6) +
+        cacheReadTokens * (PRICE_PER_MTOK.cacheRead / 1e6) +
+        (hasBreakdown
+            ? cacheCreation5m * (PRICE_PER_MTOK.cacheCreation5m / 1e6) +
+                cacheCreation1h * (PRICE_PER_MTOK.cacheCreation1h / 1e6)
+            : cacheCreationFallback * (PRICE_PER_MTOK.cacheCreation5m / 1e6)));
+}
+class CostTrackerPlugin {
+    name = 'cost';
+    phaseCosts = [];
+    totalCost = 0;
+    onPhaseTransition(fromPhase, _toPhase, ctx, store) {
+        const tokens = ctx.get('tokens');
+        const cache = ctx.get('cache');
+        const tokenSnap = tokens?.phaseSnapshots.at(-1);
+        const cacheSnap = cache?.phaseSnapshots.at(-1);
+        const totalIn = tokenSnap?.inputTokens ?? 0;
+        const read = cacheSnap?.cacheReadTokens ?? 0;
+        const creation = cacheSnap?.cacheCreationTokens ?? 0;
+        const c5m = cacheSnap?.cacheCreation5m ?? 0;
+        const c1h = cacheSnap?.cacheCreation1h ?? 0;
+        const baseIn = Math.max(0, totalIn - read - creation);
+        const phaseCost = computeCost(baseIn, tokenSnap?.outputTokens ?? 0, read, c5m, c1h, creation);
+        this.phaseCosts.push({ phase: fromPhase, cost: phaseCost });
+        this.totalCost += phaseCost;
+        store.set('cost', this.getData());
+    }
+    onFinalize(resultMessage, _totalDurationMs, ctx, store) {
+        const tokens = ctx.get('tokens');
+        const cache = ctx.get('cache');
+        const tokenSnap = tokens?.phaseSnapshots.at(-1);
+        const cacheSnap = cache?.phaseSnapshots.at(-1);
+        const totalIn = tokenSnap?.inputTokens ?? 0;
+        const read = cacheSnap?.cacheReadTokens ?? 0;
+        const creation = cacheSnap?.cacheCreationTokens ?? 0;
+        const c5m = cacheSnap?.cacheCreation5m ?? 0;
+        const c1h = cacheSnap?.cacheCreation1h ?? 0;
+        const baseIn = Math.max(0, totalIn - read - creation);
+        const lastPhaseCost = computeCost(baseIn, tokenSnap?.outputTokens ?? 0, read, c5m, c1h, creation);
+        this.phaseCosts.push({ phase: ctx.currentPhase, cost: lastPhaseCost });
+        this.totalCost += lastPhaseCost;
+        const sdkTotal = Number(resultMessage?.usage?.total_cost_usd ?? 0) ||
+            Number(resultMessage?.total_cost_usd ?? 0);
+        if (sdkTotal > 0 && this.totalCost > 0) {
+            const scale = sdkTotal / this.totalCost;
+            this.phaseCosts = this.phaseCosts.map((p) => ({
+                phase: p.phase,
+                cost: p.cost * scale,
+            }));
+            this.totalCost = sdkTotal;
+        }
+        store.set('cost', this.getData());
+    }
+    getData() {
+        return {
+            totalCost: this.totalCost,
+            phaseCosts: [...this.phaseCosts],
+        };
+    }
+}
+exports.CostTrackerPlugin = CostTrackerPlugin;

package/dist/src/lib/middleware/benchmarks/duration-tracker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Duration tracking plugin (per-phase and total).
+ */
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+export interface DurationData {
+    phaseSnapshots: Array<{
+        phase: string;
+        startTime: number;
+        endTime: number;
+        durationMs: number;
+    }>;
+    totalDurationMs: number;
+}
+export declare class DurationTrackerPlugin implements Middleware {
+    readonly name = "duration";
+    private phaseStartTime;
+    private phaseSnapshots;
+    onPhaseTransition(fromPhase: string, _toPhase: string, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onFinalize(_resultMessage: SDKMessage, totalDurationMs: number, ctx: MiddlewareContext, store: MiddlewareStore): void;
+}

package/dist/src/lib/middleware/benchmarks/duration-tracker.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Duration tracking plugin (per-phase and total).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurationTrackerPlugin = void 0;
+class DurationTrackerPlugin {
+    name = 'duration';
+    phaseStartTime = Date.now();
+    phaseSnapshots = [];
+    onPhaseTransition(fromPhase, _toPhase, _ctx, store) {
+        const now = Date.now();
+        this.phaseSnapshots.push({
+            phase: fromPhase,
+            startTime: this.phaseStartTime,
+            endTime: now,
+            durationMs: now - this.phaseStartTime,
+        });
+        this.phaseStartTime = now;
+        store.set('duration', {
+            phaseSnapshots: [...this.phaseSnapshots],
+            totalDurationMs: 0,
+        });
+    }
+    onFinalize(_resultMessage, totalDurationMs, ctx, store) {
+        const now = Date.now();
+        this.phaseSnapshots.push({
+            phase: ctx.currentPhase,
+            startTime: this.phaseStartTime,
+            endTime: now,
+            durationMs: now - this.phaseStartTime,
+        });
+        store.set('duration', {
+            phaseSnapshots: [...this.phaseSnapshots],
+            totalDurationMs,
+        });
+    }
+}
+exports.DurationTrackerPlugin = DurationTrackerPlugin;

package/dist/src/lib/middleware/benchmarks/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Plugin registry and factory.
+ *
+ * Maps plugin names to constructors and creates the ordered plugin list
+ * from a BenchmarkConfig.
+ */
+import type { Middleware, MiddlewareFactoryOptions } from '../types';
+import type { BenchmarkConfig } from '../config';
+export declare function createPluginsFromConfig(config: BenchmarkConfig, opts: MiddlewareFactoryOptions): Middleware[];

package/dist/src/lib/middleware/benchmarks/index.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Plugin registry and factory.
+ *
+ * Maps plugin names to constructors and creates the ordered plugin list
+ * from a BenchmarkConfig.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginsFromConfig = createPluginsFromConfig;
+const turn_counter_1 = require("./turn-counter");
+const token_tracker_1 = require("./token-tracker");
+const cache_tracker_1 = require("./cache-tracker");
+const compaction_tracker_1 = require("./compaction-tracker");
+const context_size_tracker_1 = require("./context-size-tracker");
+const cost_tracker_1 = require("./cost-tracker");
+const duration_tracker_1 = require("./duration-tracker");
+const summary_1 = require("./summary");
+const json_writer_1 = require("./json-writer");
+const PLUGIN_REGISTRY = {
+    turns: () => new turn_counter_1.TurnCounterPlugin(),
+    tokens: () => new token_tracker_1.TokenTrackerPlugin(),
+    cache: () => new cache_tracker_1.CacheTrackerPlugin(),
+    compactions: () => new compaction_tracker_1.CompactionTrackerPlugin(),
+    contextSize: () => new context_size_tracker_1.ContextSizeTrackerPlugin(),
+    cost: () => new cost_tracker_1.CostTrackerPlugin(),
+    duration: () => new duration_tracker_1.DurationTrackerPlugin(),
+    summary: (opts) => {
+        if (!opts.spinner)
+            throw new Error('SummaryPlugin requires a spinner');
+        return new summary_1.SummaryPlugin(opts.spinner);
+    },
+    jsonWriter: (opts) => {
+        if (!opts.outputPath)
+            throw new Error('JsonWriterPlugin requires outputPath');
+        return new json_writer_1.JsonWriterPlugin(opts.outputPath);
+    },
+};
+/**
+ * Execution order — data producers before consumers:
+ * turns (dedup) -> tokens -> cache -> compactions -> contextSize -> cost -> duration -> summary -> jsonWriter
+ */
+const PLUGIN_ORDER = [
+    'turns',
+    'tokens',
+    'cache',
+    'compactions',
+    'contextSize',
+    'cost',
+    'duration',
+    'summary',
+    'jsonWriter',
+];
+function createPluginsFromConfig(config, opts) {
+    const resolvedOpts = {
+        ...opts,
+        outputPath: opts.outputPath ?? config.output.benchmarkPath,
+    };
+    // If suppressWizardLogs is set, disable the summary plugin
+    const effectivePlugins = { ...config.plugins };
+    if (config.output.suppressWizardLogs) {
+        effectivePlugins.summary = false;
+    }
+    return PLUGIN_ORDER.filter((name) => effectivePlugins[name] !== false)
+        .map((name) => PLUGIN_REGISTRY[name])
+        .filter(Boolean)
+        .map((factory) => factory(resolvedOpts));
+}

package/dist/src/lib/middleware/benchmarks/json-writer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * JSON file output plugin.
+ *
+ * Assembles the BenchmarkData structure from all upstream plugin data
+ * and writes it to a JSON file. Returns the BenchmarkData for backward compat.
+ */
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+import type { BenchmarkData } from '../benchmark';
+export declare class JsonWriterPlugin implements Middleware {
+    readonly name = "jsonWriter";
+    private outputPath;
+    constructor(outputPath: string);
+    onFinalize(resultMessage: SDKMessage, totalDurationMs: number, ctx: MiddlewareContext, _store: MiddlewareStore): BenchmarkData;
+    private writeBenchmarkData;
+}

package/dist/src/lib/middleware/benchmarks/json-writer.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * JSON file output plugin.
+ *
+ * Assembles the BenchmarkData structure from all upstream plugin data
+ * and writes it to a JSON file. Returns the BenchmarkData for backward compat.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonWriterPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+const ui_1 = require("../../../ui");
+const chalk_1 = __importDefault(require("chalk"));
+const debug_1 = require("../../../utils/debug");
+const agent_interface_1 = require("../../agent-interface");
+/**
+ * Sum token usage across all models from the SDK's modelUsage field.
+ */
+function sumModelUsage(modelUsage) {
+    let input_tokens = 0;
+    let output_tokens = 0;
+    let cache_creation_input_tokens = 0;
+    let cache_read_input_tokens = 0;
+    for (const model of Object.values(modelUsage)) {
+        input_tokens += model.inputTokens ?? 0;
+        output_tokens += model.outputTokens ?? 0;
+        cache_creation_input_tokens += model.cacheCreationInputTokens ?? 0;
+        cache_read_input_tokens += model.cacheReadInputTokens ?? 0;
+    }
+    return {
+        input_tokens,
+        output_tokens,
+        cache_creation_input_tokens,
+        cache_read_input_tokens,
+    };
+}
+class JsonWriterPlugin {
+    name = 'jsonWriter';
+    outputPath;
+    constructor(outputPath) {
+        this.outputPath = outputPath;
+    }
+    onFinalize(resultMessage, totalDurationMs, ctx, _store) {
+        const tokens = ctx.get('tokens');
+        const cache = ctx.get('cache');
+        const turns = ctx.get('turns');
+        const cost = ctx.get('cost');
+        const duration = ctx.get('duration');
+        const compactions = ctx.get('compactions');
+        const contextSize = ctx.get('contextSize');
+        const modelUsage = resultMessage?.modelUsage ?? {};
+        const aggregateUsage = sumModelUsage(modelUsage);
+        const phaseSnapshots = duration?.phaseSnapshots ?? [];
+        const steps = [];
+        for (let i = 0; i < phaseSnapshots.length; i++) {
+            const dur = phaseSnapshots[i];
+            const tokenSnap = tokens?.phaseSnapshots[i];
+            const cacheSnap = cache?.phaseSnapshots[i];
+            const turnSnap = turns?.phaseSnapshots[i];
+            const costSnap = cost?.phaseCosts[i];
+            const compSnap = compactions?.phaseSnapshots[i];
+            const ctxSnap = contextSize?.phaseSnapshots[i];
+            const step = {
+                name: dur.phase,
+                usage: {
+                    input_tokens: tokenSnap?.inputTokens ?? 0,
+                    output_tokens: tokenSnap?.outputTokens ?? 0,
+                    cache_creation_input_tokens: cacheSnap?.cacheCreationTokens ?? 0,
+                    cache_read_input_tokens: cacheSnap?.cacheReadTokens ?? 0,
+                    ...((cacheSnap?.cacheCreation5m ?? 0) +
+                        (cacheSnap?.cacheCreation1h ?? 0) >
+                        0 && {
+                        cache_creation: {
+                            ephemeral_5m_input_tokens: cacheSnap?.cacheCreation5m ?? 0,
+                            ephemeral_1h_input_tokens: cacheSnap?.cacheCreation1h ?? 0,
+                        },
+                    }),
+                },
+                modelUsage: {},
+                totalCostUsd: costSnap?.cost ?? 0,
+                durationMs: dur.durationMs,
+                durationApiMs: 0,
+                numTurns: turnSnap?.turns ?? 0,
+                ...(ctxSnap?.contextTokensIn !== undefined && {
+                    contextTokensIn: ctxSnap.contextTokensIn,
+                }),
+                ...(ctxSnap?.contextTokensOut !== undefined && {
+                    contextTokensOut: ctxSnap.contextTokensOut,
+                }),
+                ...(compSnap && compSnap.compactions > 0
+                    ? {
+                        compactions: compSnap.compactions,
+                        compactionPreTokens: compSnap.preTokens,
+                    }
+                    : {}),
+            };
+            steps.push(step);
+        }
+        const totalTurns = turns?.totalTurns ?? 0;
+        const totalCost = cost?.totalCost ?? 0;
+        const totalCompactions = compactions?.totalCompactions ?? 0;
+        const fromModelUsage = aggregateUsage.input_tokens +
+            aggregateUsage.cache_read_input_tokens +
+            aggregateUsage.cache_creation_input_tokens;
+        const inputTokens = fromModelUsage > 0
+            ? fromModelUsage
+            : (tokens?.totalInput ?? 0) +
+                (cache?.totalRead ?? 0) +
+                (cache?.totalCreation ?? 0);
+        const outputTokens = aggregateUsage.output_tokens > 0
+            ? aggregateUsage.output_tokens
+            : tokens?.totalOutput ?? 0;
+        const benchmark = {
+            timestamp: new Date().toISOString(),
+            steps,
+            totals: {
+                totalCostUsd: totalCost,
+                durationMs: totalDurationMs,
+                inputTokens,
+                outputTokens,
+                numTurns: resultMessage?.num_turns ?? totalTurns,
+                totalCompactions,
+                totalCacheReadTokens: cache?.totalRead ?? 0,
+                totalCacheCreation5mTokens: cache?.totalCreation5m ?? 0,
+                totalCacheCreation1hTokens: cache?.totalCreation1h ?? 0,
+            },
+        };
+        this.writeBenchmarkData(benchmark);
+        return benchmark;
+    }
+    writeBenchmarkData(data) {
+        try {
+            fs_1.default.writeFileSync(this.outputPath, JSON.stringify(data, null, 2));
+            (0, debug_1.logToFile)(`Benchmark data written to ${this.outputPath}`);
+            (0, ui_1.getUI)().log.info(`${chalk_1.default.blue('●')} ${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} Results written to ${this.outputPath}`);
+        }
+        catch (error) {
+            (0, debug_1.logToFile)('Failed to write benchmark data:', error);
+        }
+    }
+}
+exports.JsonWriterPlugin = JsonWriterPlugin;

package/dist/src/lib/middleware/benchmarks/summary.d.ts

@@ -0,0 +1,9 @@
+import { type SpinnerHandle } from '../../../ui';
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage } from '../types';
+export declare class SummaryPlugin implements Middleware {
+    readonly name = "summary";
+    private spinner;
+    constructor(spinner: SpinnerHandle);
+    onPhaseTransition(fromPhase: string, toPhase: string, ctx: MiddlewareContext, _store: MiddlewareStore): void;
+    onFinalize(_resultMessage: SDKMessage, totalDurationMs: number, ctx: MiddlewareContext, _store: MiddlewareStore): void;
+}

package/dist/src/lib/middleware/benchmarks/summary.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummaryPlugin = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ui_1 = require("../../../ui");
+const agent_interface_1 = require("../../agent-interface");
+function fmtDuration(ms) {
+    const s = Math.round(ms / 1000);
+    const m = Math.floor(s / 60);
+    return m > 0 ? `${m}m ${s % 60}s` : `${s}s`;
+}
+function fmtTok(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return n.toLocaleString();
+}
+function fmtCost(usd) {
+    if (usd > 0 && usd < 0.01)
+        return `$${usd.toFixed(4)}`;
+    return `$${usd.toFixed(2)}`;
+}
+function printPhase(s) {
+    const baseIn = Math.max(0, s.inputTokens - s.cacheRead - s.cacheCreation5m - s.cacheCreation1h);
+    return [
+        `${chalk_1.default.bold(s.phase)}: ${fmtDuration(s.durationMs)}, ${s.turns} turns, cost: ${fmtCost(s.cost)}`,
+        `  in: ${fmtTok(baseIn)}, out: ${fmtTok(s.outputTokens)}, cache_read: ${fmtTok(s.cacheRead)}, cache_5m: ${fmtTok(s.cacheCreation5m)}, cache_1h: ${fmtTok(s.cacheCreation1h)}`,
+        s.compactions > 0 ? `  ${s.compactions} compaction(s)` : null,
+        s.contextOut !== undefined ? `  ctx_out: ${fmtTok(s.contextOut)}` : null,
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+function getPhaseStats(i, ctx) {
+    const duration = ctx.get('duration');
+    const dur = duration?.phaseSnapshots[i];
+    if (!dur)
+        return null;
+    const tokens = ctx.get('tokens');
+    const turns = ctx.get('turns');
+    const cost = ctx.get('cost');
+    const compactions = ctx.get('compactions');
+    const contextSize = ctx.get('contextSize');
+    const cache = ctx.get('cache');
+    return {
+        phase: dur.phase,
+        durationMs: dur.durationMs,
+        turns: turns?.phaseSnapshots[i]?.turns ?? 0,
+        inputTokens: tokens?.phaseSnapshots[i]?.inputTokens ?? 0,
+        outputTokens: tokens?.phaseSnapshots[i]?.outputTokens ?? 0,
+        cacheRead: cache?.phaseSnapshots[i]?.cacheReadTokens ?? 0,
+        cacheCreation5m: cache?.phaseSnapshots[i]?.cacheCreation5m ?? 0,
+        cacheCreation1h: cache?.phaseSnapshots[i]?.cacheCreation1h ?? 0,
+        cost: cost?.phaseCosts[i]?.cost ?? 0,
+        compactions: compactions?.phaseSnapshots[i]?.compactions ?? 0,
+        contextOut: contextSize?.phaseSnapshots[i]?.contextTokensOut,
+    };
+}
+class SummaryPlugin {
+    name = 'summary';
+    spinner;
+    constructor(spinner) {
+        this.spinner = spinner;
+    }
+    onPhaseTransition(fromPhase, toPhase, ctx, _store) {
+        const duration = ctx.get('duration');
+        const idx = (duration?.phaseSnapshots.length ?? 1) - 1;
+        const stats = getPhaseStats(idx, ctx);
+        if (stats) {
+            this.spinner.stop(`${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} ${printPhase(stats)}`);
+        }
+        else {
+            this.spinner.stop(`${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} ${fromPhase}`);
+        }
+        (0, ui_1.getUI)().log.info(`${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} Starting phase: ${chalk_1.default.bold(toPhase)}`);
+        this.spinner.start(`Integrating Amplitude (${toPhase})...`);
+    }
+    onFinalize(_resultMessage, totalDurationMs, ctx, _store) {
+        const duration = ctx.get('duration');
+        const cost = ctx.get('cost');
+        const tokens = ctx.get('tokens');
+        const cache = ctx.get('cache');
+        const phaseCount = duration?.phaseSnapshots.length ?? 0;
+        const totalCost = cost?.totalCost ?? 0;
+        (0, ui_1.getUI)().log.info('');
+        (0, ui_1.getUI)().log.info(`${chalk_1.default.green('◇')} ${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} ${phaseCount} phases in ${fmtDuration(totalDurationMs)}, cost: ${fmtCost(totalCost)}`);
+        (0, ui_1.getUI)().log.info(`  total in: ${fmtTok(tokens?.totalInput ?? 0)}, out: ${fmtTok(tokens?.totalOutput ?? 0)}, cache_read: ${fmtTok(cache?.totalRead ?? 0)}, cache_5m: ${fmtTok(cache?.totalCreation5m ?? 0)}, cache_1h: ${fmtTok(cache?.totalCreation1h ?? 0)}`);
+        (0, ui_1.getUI)().log.info('');
+        (0, ui_1.getUI)().log.info(`${chalk_1.default.blue('●')} ${chalk_1.default.cyan(agent_interface_1.AgentSignals.BENCHMARK)} Summary by phase:`);
+        if (duration?.phaseSnapshots) {
+            for (let i = 0; i < duration.phaseSnapshots.length; i++) {
+                const stats = getPhaseStats(i, ctx);
+                if (stats) {
+                    (0, ui_1.getUI)().log.info(printPhase(stats));
+                }
+            }
+        }
+        (0, ui_1.getUI)().log.info('');
+    }
+}
+exports.SummaryPlugin = SummaryPlugin;

package/dist/src/lib/middleware/benchmarks/token-tracker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Token tracking plugin for input/output tokens.
+ *
+ * Accumulates per-turn token usage (input_tokens + cache_read_input_tokens
+ * + cache_creation_input_tokens = total input; output_tokens = output).
+ * Respects the dedup flag from TurnCounterPlugin. Cache breakdown (r/5m/1h)
+ * is tracked by CacheTrackerPlugin for reporting and pricing.
+ */
+import type { Middleware, MiddlewareContext, MiddlewareStore, SDKMessage, SDKUsage } from '../types';
+export interface TokenData {
+    phaseInput: number;
+    phaseOutput: number;
+    totalInput: number;
+    totalOutput: number;
+    /** The raw usage object from the last non-duplicate assistant message */
+    lastUsage: SDKUsage | null;
+    /** Per-phase token snapshots */
+    phaseSnapshots: Array<{
+        phase: string;
+        inputTokens: number;
+        outputTokens: number;
+        /** Number of turns in this phase that had usage (SDK may not report all) */
+        messagesWithUsage: number;
+    }>;
+}
+export declare class TokenTrackerPlugin implements Middleware {
+    readonly name = "tokens";
+    private phaseInput;
+    private phaseOutput;
+    private totalInput;
+    private totalOutput;
+    private lastUsage;
+    private phaseSnapshots;
+    private currentPhase;
+    private phaseMessagesWithUsage;
+    onMessage(message: SDKMessage, ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onPhaseTransition(fromPhase: string, toPhase: string, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    onFinalize(_resultMessage: SDKMessage, _totalDurationMs: number, _ctx: MiddlewareContext, store: MiddlewareStore): void;
+    private getData;
+}