dsh-watcher 0.4.3 → 0.5.1

package/lib/types/insights/projection.d.ts

@@ -1,367 +0,0 @@
-import { z } from 'zod';
-import type { Context } from '@deepseek-ai/cordis';
-export declare const viewSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    sessionId: z.ZodString;
-    seq: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-    totals: z.ZodObject<{
-        calls: z.ZodNumber;
-        reported: z.ZodNumber;
-        exactTotals: z.ZodNumber;
-        tokens: z.ZodNumber;
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        cacheRead: z.ZodNumber;
-        cacheWrite: z.ZodNumber;
-        reasoning: z.ZodNumber;
-        reasoningReports: z.ZodNumber;
-        modelMs: z.ZodNumber;
-        timedCalls: z.ZodNumber;
-        firstMs: z.ZodNumber;
-        firstSamples: z.ZodNumber;
-        reasoningMs: z.ZodNumber;
-        tools: z.ZodNumber;
-        toolErrors: z.ZodNumber;
-        toolMs: z.ZodNumber;
-        bashMs: z.ZodOptional<z.ZodNumber>;
-        retries: z.ZodNumber;
-    }, z.core.$strip>;
-    models: z.ZodArray<z.ZodObject<{
-        calls: z.ZodNumber;
-        reported: z.ZodNumber;
-        exactTotals: z.ZodNumber;
-        tokens: z.ZodNumber;
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        cacheRead: z.ZodNumber;
-        cacheWrite: z.ZodNumber;
-        reasoning: z.ZodNumber;
-        reasoningReports: z.ZodNumber;
-        modelMs: z.ZodNumber;
-        timedCalls: z.ZodNumber;
-        firstMs: z.ZodNumber;
-        firstSamples: z.ZodNumber;
-        reasoningMs: z.ZodNumber;
-        tools: z.ZodNumber;
-        toolErrors: z.ZodNumber;
-        toolMs: z.ZodNumber;
-        bashMs: z.ZodOptional<z.ZodNumber>;
-        retries: z.ZodNumber;
-        provider: z.ZodString;
-        model: z.ZodString;
-        effort: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    turn: z.ZodNullable<z.ZodObject<{
-        number: z.ZodNumber;
-        startedAt: z.ZodNumber;
-        endedAt: z.ZodNullable<z.ZodNumber>;
-        steps: z.ZodNumber;
-        stats: z.ZodObject<{
-            calls: z.ZodNumber;
-            reported: z.ZodNumber;
-            exactTotals: z.ZodNumber;
-            tokens: z.ZodNumber;
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-            cacheRead: z.ZodNumber;
-            cacheWrite: z.ZodNumber;
-            reasoning: z.ZodNumber;
-            reasoningReports: z.ZodNumber;
-            modelMs: z.ZodNumber;
-            timedCalls: z.ZodNumber;
-            firstMs: z.ZodNumber;
-            firstSamples: z.ZodNumber;
-            reasoningMs: z.ZodNumber;
-            tools: z.ZodNumber;
-            toolErrors: z.ZodNumber;
-            toolMs: z.ZodNumber;
-            bashMs: z.ZodOptional<z.ZodNumber>;
-            retries: z.ZodNumber;
-        }, z.core.$strip>;
-        route: z.ZodOptional<z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    pending: z.ZodNullable<z.ZodObject<{
-        turn: z.ZodNumber;
-        step: z.ZodNumber;
-        start: z.ZodNullable<z.ZodNumber>;
-        reasoningFirst: z.ZodNullable<z.ZodNumber>;
-        reasoningLast: z.ZodNullable<z.ZodNumber>;
-        lastContentAt: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strip>>;
-    findings: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodString;
-        turn: z.ZodNumber;
-        seqs: z.ZodArray<z.ZodNumber>;
-        steps: z.ZodArray<z.ZodNumber>;
-        title: z.ZodString;
-        detail: z.ZodString;
-    }, z.core.$strip>>;
-    findingCount: z.ZodNumber;
-}, z.core.$strip>;
-declare const stateSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    sessionId: z.ZodString;
-    skip: z.ZodNumber;
-    seq: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-    route: z.ZodObject<{
-        provider: z.ZodString;
-        model: z.ZodString;
-        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-    totals: z.ZodObject<{
-        calls: z.ZodNumber;
-        reported: z.ZodNumber;
-        exactTotals: z.ZodNumber;
-        tokens: z.ZodNumber;
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        cacheRead: z.ZodNumber;
-        cacheWrite: z.ZodNumber;
-        reasoning: z.ZodNumber;
-        reasoningReports: z.ZodNumber;
-        modelMs: z.ZodNumber;
-        timedCalls: z.ZodNumber;
-        firstMs: z.ZodNumber;
-        firstSamples: z.ZodNumber;
-        reasoningMs: z.ZodNumber;
-        tools: z.ZodNumber;
-        toolErrors: z.ZodNumber;
-        toolMs: z.ZodNumber;
-        bashMs: z.ZodOptional<z.ZodNumber>;
-        retries: z.ZodNumber;
-    }, z.core.$strip>;
-    models: z.ZodArray<z.ZodObject<{
-        calls: z.ZodNumber;
-        reported: z.ZodNumber;
-        exactTotals: z.ZodNumber;
-        tokens: z.ZodNumber;
-        input: z.ZodNumber;
-        output: z.ZodNumber;
-        cacheRead: z.ZodNumber;
-        cacheWrite: z.ZodNumber;
-        reasoning: z.ZodNumber;
-        reasoningReports: z.ZodNumber;
-        modelMs: z.ZodNumber;
-        timedCalls: z.ZodNumber;
-        firstMs: z.ZodNumber;
-        firstSamples: z.ZodNumber;
-        reasoningMs: z.ZodNumber;
-        tools: z.ZodNumber;
-        toolErrors: z.ZodNumber;
-        toolMs: z.ZodNumber;
-        bashMs: z.ZodOptional<z.ZodNumber>;
-        retries: z.ZodNumber;
-        provider: z.ZodString;
-        model: z.ZodString;
-    }, z.core.$strip>>;
-    turn: z.ZodNullable<z.ZodObject<{
-        number: z.ZodNumber;
-        startedAt: z.ZodNumber;
-        endedAt: z.ZodNullable<z.ZodNumber>;
-        steps: z.ZodNumber;
-        stats: z.ZodObject<{
-            calls: z.ZodNumber;
-            reported: z.ZodNumber;
-            exactTotals: z.ZodNumber;
-            tokens: z.ZodNumber;
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-            cacheRead: z.ZodNumber;
-            cacheWrite: z.ZodNumber;
-            reasoning: z.ZodNumber;
-            reasoningReports: z.ZodNumber;
-            modelMs: z.ZodNumber;
-            timedCalls: z.ZodNumber;
-            firstMs: z.ZodNumber;
-            firstSamples: z.ZodNumber;
-            reasoningMs: z.ZodNumber;
-            tools: z.ZodNumber;
-            toolErrors: z.ZodNumber;
-            toolMs: z.ZodNumber;
-            bashMs: z.ZodOptional<z.ZodNumber>;
-            retries: z.ZodNumber;
-        }, z.core.$strip>;
-        route: z.ZodOptional<z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    open: z.ZodNullable<z.ZodObject<{
-        turn: z.ZodNumber;
-        step: z.ZodNumber;
-        start: z.ZodNullable<z.ZodNumber>;
-        first: z.ZodNullable<z.ZodNumber>;
-        reasoningFirst: z.ZodNullable<z.ZodNumber>;
-        reasoningLast: z.ZodNullable<z.ZodNumber>;
-        lastContentAt: z.ZodNullable<z.ZodNumber>;
-        usage: z.ZodNullable<z.ZodObject<{
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-            cacheRead: z.ZodNumber;
-            cacheWrite: z.ZodNumber;
-            reasoning: z.ZodNullable<z.ZodNumber>;
-            tokens: z.ZodNumber;
-            exact: z.ZodBoolean;
-        }, z.core.$strip>>;
-        route: z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    tools: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        start: z.ZodNumber;
-        seq: z.ZodNumber;
-        step: z.ZodNumber;
-        route: z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-            effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>;
-        signature: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-    previousFailure: z.ZodNullable<z.ZodObject<{
-        signature: z.ZodString;
-        resultHash: z.ZodString;
-        turn: z.ZodNumber;
-        seqs: z.ZodArray<z.ZodNumber>;
-        steps: z.ZodArray<z.ZodNumber>;
-    }, z.core.$strip>>;
-    findings: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodString;
-        turn: z.ZodNumber;
-        seqs: z.ZodArray<z.ZodNumber>;
-        steps: z.ZodArray<z.ZodNumber>;
-        title: z.ZodString;
-        detail: z.ZodString;
-    }, z.core.$strip>>;
-    findingCount: z.ZodNumber;
-    wire: z.ZodObject<{
-        version: z.ZodLiteral<1>;
-        sessionId: z.ZodString;
-        seq: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-        totals: z.ZodObject<{
-            calls: z.ZodNumber;
-            reported: z.ZodNumber;
-            exactTotals: z.ZodNumber;
-            tokens: z.ZodNumber;
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-            cacheRead: z.ZodNumber;
-            cacheWrite: z.ZodNumber;
-            reasoning: z.ZodNumber;
-            reasoningReports: z.ZodNumber;
-            modelMs: z.ZodNumber;
-            timedCalls: z.ZodNumber;
-            firstMs: z.ZodNumber;
-            firstSamples: z.ZodNumber;
-            reasoningMs: z.ZodNumber;
-            tools: z.ZodNumber;
-            toolErrors: z.ZodNumber;
-            toolMs: z.ZodNumber;
-            bashMs: z.ZodOptional<z.ZodNumber>;
-            retries: z.ZodNumber;
-        }, z.core.$strip>;
-        models: z.ZodArray<z.ZodObject<{
-            calls: z.ZodNumber;
-            reported: z.ZodNumber;
-            exactTotals: z.ZodNumber;
-            tokens: z.ZodNumber;
-            input: z.ZodNumber;
-            output: z.ZodNumber;
-            cacheRead: z.ZodNumber;
-            cacheWrite: z.ZodNumber;
-            reasoning: z.ZodNumber;
-            reasoningReports: z.ZodNumber;
-            modelMs: z.ZodNumber;
-            timedCalls: z.ZodNumber;
-            firstMs: z.ZodNumber;
-            firstSamples: z.ZodNumber;
-            reasoningMs: z.ZodNumber;
-            tools: z.ZodNumber;
-            toolErrors: z.ZodNumber;
-            toolMs: z.ZodNumber;
-            bashMs: z.ZodOptional<z.ZodNumber>;
-            retries: z.ZodNumber;
-            provider: z.ZodString;
-            model: z.ZodString;
-            effort: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        turn: z.ZodNullable<z.ZodObject<{
-            number: z.ZodNumber;
-            startedAt: z.ZodNumber;
-            endedAt: z.ZodNullable<z.ZodNumber>;
-            steps: z.ZodNumber;
-            stats: z.ZodObject<{
-                calls: z.ZodNumber;
-                reported: z.ZodNumber;
-                exactTotals: z.ZodNumber;
-                tokens: z.ZodNumber;
-                input: z.ZodNumber;
-                output: z.ZodNumber;
-                cacheRead: z.ZodNumber;
-                cacheWrite: z.ZodNumber;
-                reasoning: z.ZodNumber;
-                reasoningReports: z.ZodNumber;
-                modelMs: z.ZodNumber;
-                timedCalls: z.ZodNumber;
-                firstMs: z.ZodNumber;
-                firstSamples: z.ZodNumber;
-                reasoningMs: z.ZodNumber;
-                tools: z.ZodNumber;
-                toolErrors: z.ZodNumber;
-                toolMs: z.ZodNumber;
-                bashMs: z.ZodOptional<z.ZodNumber>;
-                retries: z.ZodNumber;
-            }, z.core.$strip>;
-            route: z.ZodOptional<z.ZodObject<{
-                provider: z.ZodString;
-                model: z.ZodString;
-                effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-        pending: z.ZodNullable<z.ZodObject<{
-            turn: z.ZodNumber;
-            step: z.ZodNumber;
-            start: z.ZodNullable<z.ZodNumber>;
-            reasoningFirst: z.ZodNullable<z.ZodNumber>;
-            reasoningLast: z.ZodNullable<z.ZodNumber>;
-            lastContentAt: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>>;
-        findings: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            kind: z.ZodString;
-            turn: z.ZodNumber;
-            seqs: z.ZodArray<z.ZodNumber>;
-            steps: z.ZodArray<z.ZodNumber>;
-            title: z.ZodString;
-            detail: z.ZodString;
-        }, z.core.$strip>>;
-        findingCount: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type InsightsView = z.infer<typeof viewSchema>;
-type InsightsState = z.infer<typeof stateSchema>;
-declare module '@deepseek-ai/dsh-session-projection/types' {
-    interface SessionProjectionStateMap {
-        watcherInsights: InsightsState;
-    }
-    interface SessionProjectionMap {
-        watcherInsights: InsightsView;
-    }
-}
-export declare function installProjection(ctx: Context): void;
-export {};
-//# sourceMappingURL=projection.d.ts.map

package/lib/types/observation/fold.d.ts

@@ -1,207 +0,0 @@
-import type { ConversationNode, ConversationViewSnapshotStore, RunningToolCall } from '@deepseek-ai/dsh-client-ui-conversation/client';
-import type { ChatSnapshot } from '@deepseek-ai/dsh-client-ui-chat/client';
-import type { SessionPendingInteractionBase } from '@deepseek-ai/dsh-client-ui-session/client';
-import { type ModelStepTrace } from './model-trace.ts';
-/** Watcher-owned projection assembled from the public RC1 Session and Conversation stores. */
-export interface WatcherSnapshot {
-    readonly views: ConversationViewSnapshotStore;
-    readonly chat: ChatSnapshot;
-    readonly nodes: readonly ConversationNode[];
-    readonly turnTimings: ReadonlyMap<number, {
-        readonly startTime: number;
-        readonly endTime?: number;
-    }>;
-    readonly runningCalls: readonly RunningToolCall[];
-    readonly pending: readonly SessionPendingInteractionBase[];
-    readonly blank: boolean;
-    readonly running: boolean;
-    readonly hasMore: boolean;
-}
-/** One truthful lifecycle state. Result presence alone never means success. */
-export type WorkStatus = 'running' | 'waiting' | 'success' | 'failure' | 'returned' | 'interrupted' | 'unknown';
-/** User-facing phases used by the compact work rail. */
-export type WorkPhase = 'request' | 'steering' | 'plan' | 'investigate' | 'build' | 'verify' | 'activate' | 'desktop' | 'answer' | 'model' | 'wait' | 'failure' | 'other';
-export type WorkSource = 'tool' | 'user' | 'steering' | 'assistant' | 'artifact' | 'interaction' | 'turn' | 'model';
-export type WorkPresentation = {
-    kind: 'terminal';
-    command: string;
-    cwd: string | null;
-    output: string;
-    exitCode: number | null;
-    signal: string | null;
-    running: boolean;
-} | {
-    kind: 'read';
-    label: string;
-    lang: string | null;
-    lines: readonly {
-        number: number;
-        text: string;
-    }[];
-    totalLines: number;
-} | {
-    kind: 'diff';
-    diffs: {
-        path: string;
-        oldText: string | null;
-        newText: string;
-    }[];
-} | {
-    kind: 'json';
-    data: object | unknown[];
-} | {
-    kind: 'text';
-    text: string;
-} | {
-    kind: 'image';
-    attachment: unknown;
-} | {
-    kind: 'empty';
-};
-/** Immutable evidence for one recorded occurrence. */
-export interface WorkItem {
-    id: string;
-    seq: number;
-    resultSeq: number | null;
-    time: number;
-    resultTime: number | null;
-    turn: number;
-    step: number;
-    source: WorkSource;
-    phase: WorkPhase;
-    status: WorkStatus;
-    title: string;
-    subtitle: string;
-    toolName: string | null;
-    callId: string | null;
-    args: Record<string, unknown>;
-    argsRaw: string | null;
-    rawText: string;
-    rawValue: unknown;
-    presentation: WorkPresentation;
-    durationMs: number | null;
-    exitCode: number | null;
-    signal: string | null;
-    signature: string | null;
-    intentKey: string | null;
-    target: string | null;
-    retryOf: string | null;
-    retryIndex: number;
-    iterationIndex: number;
-    recoveredBy: string | null;
-}
-export interface WorkStep {
-    id: string;
-    turn: number;
-    step: number;
-    phase: WorkPhase;
-    status: WorkStatus;
-    title: string;
-    subtitle: string;
-    items: readonly WorkItem[];
-    parallel: boolean;
-    executionCount: number;
-    retryCount: number;
-    iterationCount: number;
-    unconfirmedFailureCount: number;
-    firstSeq: number;
-    lastSeq: number;
-    startTime: number | null;
-    endTime: number | null;
-    model: ModelStepTrace | null;
-}
-/** One consecutive phase inside one Turn. Every child Step remains addressable. */
-export interface WorkGroup {
-    id: string;
-    turn: number;
-    phase: WorkPhase;
-    status: WorkStatus;
-    title: string;
-    subtitle: string;
-    steps: readonly WorkStep[];
-    items: readonly WorkItem[];
-    executionCount: number;
-    parallelStepCount: number;
-    retryCount: number;
-    iterationCount: number;
-    unconfirmedFailureCount: number;
-    firstSeq: number;
-    lastSeq: number;
-    startTime: number | null;
-    endTime: number | null;
-}
-export interface WorkTurn {
-    turn: number;
-    status: WorkStatus;
-    groups: readonly WorkGroup[];
-    startTime: number | null;
-    endTime: number | null;
-}
-export interface WorkPicture {
-    nodes: readonly WorkGroup[];
-    turns: readonly WorkTurn[];
-    now: {
-        phase: WorkPhase;
-        label: string;
-        status: WorkStatus;
-    };
-    actionCount: number;
-    stepCount: number;
-    turnCount: number;
-    parallelStepCount: number;
-    retryCount: number;
-    iterationCount: number;
-    pendingCount: number;
-    unconfirmedFailureCount: number;
-    running: boolean;
-    partialHistory: boolean;
-}
-interface ToolPair {
-    callId: string;
-    seq: number;
-    resultSeq: number | null;
-    time: number;
-    resultTime: number | null;
-    turn: number;
-    step: number;
-    name: string;
-    args: Record<string, unknown>;
-    argsRaw: string;
-    result: unknown;
-    meta: unknown;
-    callView: unknown;
-    resultView: unknown;
-    orphan: boolean;
-}
-interface EventLike {
-    type: string;
-    seq?: number;
-    time?: number;
-    data?: unknown;
-}
-export declare const EMPTY_PICTURE: WorkPicture;
-/** Stable exact signature used only for evidence-backed retry detection. */
-export declare function normalizedSignature(toolName: string, args: Record<string, unknown>): string;
-/** Public RC1 Session/Conversation projection to occurrence-preserving tool pairs. */
-export declare function pairsFromSnapshot(snapshot: WatcherSnapshot): ToolPair[];
-/** Pair every log call/result and preserve an orphan result instead of dropping it. */
-export declare function pairTools(events: readonly EventLike[]): ToolPair[];
-export declare function phaseTitle(phase: WorkPhase): string;
-/** Fold the official RC8 snapshot without flattening Turn/Step identity. */
-export declare function foldSnapshot(snapshot: WatcherSnapshot, options?: {
-    running?: boolean;
-}): WorkPicture;
-/**
- * Retain every occurrence already observed in this mounted page while the
- * official RC8 window advances. Latest evidence wins by stable occurrence id,
- * so running → result updates one row instead of duplicating or removing it.
- */
-export declare function mergeObservedPictures(previous: WorkPicture, current: WorkPicture): WorkPicture;
-/** Fold a full session JSONL replay, including approvals, steering, images, and orphan results. */
-export declare function foldEvents(events: readonly EventLike[], options?: {
-    running?: boolean;
-}): WorkPicture;
-/** Parse valid JSONL lines and skip only a torn final line. */
-export declare function parseJsonl(text: string): EventLike[];
-export {};
-//# sourceMappingURL=fold.d.ts.map

package/lib/types/observation/model-trace.d.ts

@@ -1,96 +0,0 @@
-/** One timestamped provider-exposed reasoning fragment. */
-export interface ReasoningFragment {
-    readonly seq: number;
-    readonly time: number;
-    readonly text: string;
-}
-interface ModelAttemptEvidence {
-    readonly attempt: number;
-    /** Only the first attempt has an authoritative request-entry boundary. */
-    readonly startedAt: number | null;
-    readonly firstTokenTime: number | null;
-    readonly firstReasoningTime: number | null;
-    readonly lastReasoningTime: number | null;
-    readonly firstOutputTime: number | null;
-    readonly reasoningText: string;
-    readonly fragments: readonly ReasoningFragment[];
-}
-export type ModelAttempt = ModelAttemptEvidence & ({
-    readonly kind: 'running';
-} | {
-    readonly kind: 'complete';
-    readonly endedAt: number;
-} | {
-    readonly kind: 'retried';
-    readonly endedAt: number;
-    readonly retry: number;
-    readonly retryDelayMs: number;
-} | {
-    readonly kind: 'interrupted';
-    readonly endedAt: number;
-});
-type ModelAttempts = readonly [ModelAttempt, ...ModelAttempt[]];
-/** Provider/model evidence owned by one authoritative DSH Step. */
-export interface ModelStepTrace {
-    readonly turn: number;
-    readonly step: number;
-    /** Stable identity anchor: the first model event observed for this Step. */
-    readonly startSeq: number;
-    /** Mutable activity cursor: the newest model event folded into this trace. */
-    readonly lastSeq: number;
-    readonly startTime: number | null;
-    readonly attempts: ModelAttempts;
-    readonly reasoningTokens: number | null;
-}
-export type ModelStageMetrics = {
-    readonly kind: 'measured' | 'partial';
-    readonly live: boolean;
-    readonly totalMs: number | null;
-    readonly firstResponseMs: number | null;
-    readonly visibleReasoningMs: number | null;
-    readonly outputMs: number | null;
-    readonly unattributedMs: number | null;
-};
-type ModelTraceEventBase = {
-    readonly turn: number;
-    readonly step: number;
-    readonly seq: number;
-    readonly time: number;
-    readonly lastSeq?: number;
-};
-export type ModelTraceEvent = ModelTraceEventBase & ({
-    readonly kind: 'step-start';
-} | {
-    readonly kind: 'reasoning-delta';
-    readonly text: string;
-    readonly fragments?: readonly ReasoningFragment[];
-} | {
-    readonly kind: 'output-delta';
-} | {
-    readonly kind: 'usage';
-    readonly reasoningTokens: number | null;
-} | {
-    readonly kind: 'message';
-    readonly reasoningText: string | null;
-    readonly reasoningTokens: number | null;
-} | {
-    readonly kind: 'retry';
-    readonly retry: number;
-    readonly delayMs: number;
-} | {
-    readonly kind: 'step-end';
-});
-/** Expand one Session/Conversation value into the model-stage events it carries. */
-export declare function modelTraceEventsOf(value: unknown): ModelTraceEvent[];
-/** Parse only the first model-stage event carried by one value. */
-export declare function modelTraceEventOf(value: unknown): ModelTraceEvent | null;
-export declare function startModelStepTrace(event: ModelTraceEventBase): ModelStepTrace;
-/** Fold one normalized event without discarding reasoning from a retried attempt. */
-export declare function updateModelStepTrace(trace: ModelStepTrace, event: ModelTraceEvent): ModelStepTrace;
-/** Fold raw Session-like values for golden replay and boundary tests. */
-export declare function foldModelTraceEvents(values: readonly unknown[]): ReadonlyMap<string, ModelStepTrace>;
-/** Derive additive display segments without calling unobserved latency Thinking. */
-export declare function modelStageMetrics(trace: ModelStepTrace, now: number): ModelStageMetrics;
-export declare function hasReasoningEvidence(trace: ModelStepTrace): boolean;
-export {};
-//# sourceMappingURL=model-trace.d.ts.map