@deepseek-ai/dsh-experimental-session-inspector 0.2.1-alpha.1

package/lib/types/client/views/session-log/model.d.ts

@@ -0,0 +1,54 @@
+/** Incremental raw Session rows with lossless Assistant stream children. */
+import type { SessionEventSource } from '@deepseek-ai/dsh-api-session-controller/client';
+import { type ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { InspectorRecord, InspectorRow } from '../table-model.ts';
+import type { InspectorPickTarget } from '../chat-node/pick-match.ts';
+import type { SessionLogAnchor } from './chat-target.ts';
+/** Session-owned log projection; subscriptions exist only while the table is observed. */
+export declare class SessionLogModel implements ObservableSnapshot<readonly InspectorRow[]> {
+    private readonly source;
+    private readonly rows;
+    private readonly records;
+    private readonly roots;
+    private readonly attempts;
+    private groups;
+    /** Preserve live-to-durable row identities only while their rows remain in the loaded window. */
+    private readonly settledRoots;
+    private readonly streams;
+    private revision;
+    private subscribers;
+    private disconnect;
+    /**
+     * @param source - The existing Session window, shared with Chat and Trajectory.
+     */
+    constructor(source: SessionEventSource);
+    /** @returns Stable table order; row contents have independent sources. */
+    getSnapshot: () => readonly InspectorRow[];
+    /**
+     * Recover an event's placement without interpreting formatted table cells.
+     * @param key - Selected root or delta row.
+     * @returns The owning event and chunk, or undefined if the row is unavailable.
+     */
+    chatAnchor(key: string): SessionLogAnchor | undefined;
+    /**
+     * Resolve a picked Chat object in the loaded log, without creating synthetic records.
+     * @param target - DOM identity enriched with the owning Chat Node's sequence and Turn/Step.
+     * @returns Tool call, exact anchor, Assistant, Step, or Turn row; reasoning parts prefer a block-start child.
+     */
+    pick(target: InspectorPickTarget): string | undefined;
+    /** @param listener - Structural invalidation callback. @returns Subscription disposer. */
+    subscribe: (listener: () => void) => (() => void);
+    /**
+     * Obtain a cached row source, initially empty when its record is unavailable.
+     * @param key - Stable table row identity.
+     * @returns Its independently observable raw data.
+     */
+    row: (key: string) => ObservableSnapshot<InspectorRecord | undefined>;
+    private put;
+    private accept;
+    private prune;
+    private root;
+    private add;
+    private addChunk;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/types/client/views/session-log/stream.d.ts

@@ -0,0 +1,37 @@
+/** Block-indexed hierarchy for one live or durable Assistant stream. */
+import type { StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { InspectorRow } from '../table-model.ts';
+/** Keeps original delta rows under their blocks and a bounded reasoning prefix for folded headers. */
+export declare class AssistantLogStream {
+    private readonly parent;
+    private readonly blocks;
+    private count;
+    /** @param parent - Stable Assistant event or live-attempt row identity. */
+    constructor(parent: string);
+    /**
+     * Count all received chunks, including children of folded blocks.
+     * @returns Number of original chunks received by this stream.
+     */
+    get length(): number;
+    /**
+     * Add one original chunk and update the matching block's disclosure state.
+     * Chunks without a loaded block-start remain direct Assistant children.
+     * @param chunk - Original chunk, correlated by block index.
+     * @returns One row insertion, an optional replaced block header, and its folded preview.
+     */
+    append(chunk: StreamChunk): {
+        readonly key: string;
+        readonly index: number;
+        readonly position: number;
+        readonly row: InspectorRow;
+        readonly header?: {
+            readonly position: number;
+            readonly row: InspectorRow;
+        };
+        readonly collapsed?: {
+            readonly key: string;
+            readonly summary: string;
+        };
+    };
+}
+//# sourceMappingURL=stream.d.ts.map

package/lib/types/client/views/table-layout.d.ts

@@ -0,0 +1,56 @@
+/** Live folding preserves the visible anchor and places unused viewport space after all data rows. */
+import type { InspectorRow, InspectorTableHierarchy } from './table-model.ts';
+/** Fixed table row and header height, in CSS pixels. */
+export declare const INSPECTOR_ROW_HEIGHT = 30;
+/** One data row in the virtual scroll layout. */
+export type InspectorTableItem = {
+    readonly key: string;
+    readonly rowIndex: number;
+    readonly size: number;
+    readonly row: InspectorRow;
+};
+/** Last committed scroll geometry, measured before a source update. */
+export interface InspectorViewport {
+    readonly offset: number;
+    readonly height: number;
+}
+/** A disclosure row's measured position relative to the scroll viewport. */
+export interface InspectorRowAnchor {
+    readonly key: string;
+    readonly top: number;
+}
+/** View-local spacing; constructing without a predecessor resets retained blank areas. */
+export declare class InspectorTableLayout {
+    private readonly hierarchy;
+    /** Visible data rows and their virtual sizes; excludes the table header and trailing space. */
+    readonly items: readonly InspectorTableItem[];
+    /** Whether a live block closure shortened the previous visible hierarchy. */
+    readonly preservedCollapse: boolean;
+    /** Trailing space in CSS pixels retained to keep the viewport anchor stable. */
+    readonly bottomPadding: number;
+    /** Anchored scroll offset in CSS pixels, or undefined when no anchor adjustment is needed. */
+    readonly scrollOffset: number | undefined;
+    private readonly minimumExtent;
+    private readonly rowIndexes;
+    /**
+     * @param hierarchy - Current visible data rows.
+     * @param previous - Previous committed layout, omitted after manual disclosure changes.
+     * @param viewport - Scroll geometry before the current row change.
+     * @param anchor - Clicked disclosure row to retain at its measured viewport position.
+     */
+    constructor(hierarchy: InspectorTableHierarchy, previous?: InspectorTableLayout, viewport?: InspectorViewport, anchor?: InspectorRowAnchor);
+    /**
+     * Keep the enclosing headers visible above the first visible data row.
+     * @param itemIndex - First visible virtual item.
+     * @returns Ancestor indexes in the virtual layout.
+     */
+    stickyIndexes(itemIndex: number): readonly number[];
+    /**
+     * Resolve each sticky level below the table header and already occupied sticky rows.
+     * @param offset - Scroll offset in CSS pixels.
+     * @returns Active ancestor indexes, outermost first.
+     */
+    stickyIndexesAtOffset(offset: number): readonly number[];
+    private anchorOffset;
+}
+//# sourceMappingURL=table-layout.d.ts.map

package/lib/types/client/views/table-model.d.ts

@@ -0,0 +1,76 @@
+/** Row identities and raw values shared by the two virtual inspector tables. */
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+/** One table position; children immediately follow their parent. */
+export interface InspectorRow {
+    readonly key: string;
+    readonly parent?: string;
+    readonly depth: number;
+    /** Disclosure default; a block lifecycle transition resets any earlier user override. */
+    readonly disclosure?: 'open' | 'closed';
+}
+/** One user disclosure choice, valid only for the lifecycle state in which it was made. */
+export interface InspectorDisclosure {
+    readonly state: InspectorRow['disclosure'];
+    readonly collapsed: boolean;
+}
+/**
+ * Resolve a manual choice or the block lifecycle default.
+ * @param row - Current row metadata.
+ * @param choices - Table-local user choices.
+ * @returns Whether the row's descendants are hidden.
+ */
+export declare function inspectorRowCollapsed(row: InspectorRow, choices: ReadonlyMap<string, InspectorDisclosure>): boolean;
+/** Table-local hierarchy index for disclosure and virtualized sticky ancestors. */
+export declare class InspectorTableHierarchy {
+    /** Depth-first row order with folded descendants omitted. */
+    readonly rows: readonly InspectorRow[];
+    private readonly byKey;
+    private readonly branches;
+    /**
+     * @param rows - Complete depth-first row order.
+     * @param choices - Table-local disclosure overrides.
+     */
+    constructor(rows: readonly InspectorRow[], choices: ReadonlyMap<string, InspectorDisclosure>);
+    /**
+     * Identify rows that own descendants or an explicit disclosure state.
+     * @param key - Row identity.
+     * @returns Whether this row owns a disclosure.
+     */
+    isBranch(key: string): boolean;
+    /**
+     * Find the current row's visible parent headers, including itself when it is a header.
+     * @param index - First row at the viewport's scroll offset.
+     * @returns Ordered indexes retained above the virtual viewport.
+     */
+    stickyIndexes(index: number): readonly number[];
+}
+/** Raw data and compact metadata for one independently updated row. */
+export interface InspectorRecord {
+    readonly type: string;
+    readonly identity: string;
+    readonly location: string;
+    /** Unix epoch milliseconds. */
+    readonly time?: number;
+    readonly value: unknown;
+    /** Owner-supplied preview for domain-specific field formatting. */
+    readonly summary?: string;
+    /** Parent summary used only while its children are folded. */
+    readonly collapsedSummary?: string;
+}
+/** Converts a keyed source without changing snapshot identity on unchanged input. */
+export declare class InspectorRecordSource<T> implements ObservableSnapshot<InspectorRecord | undefined> {
+    private readonly source;
+    private readonly project;
+    private previous;
+    private snapshot;
+    /**
+     * @param source - Existing keyed business source.
+     * @param project - Raw metadata projection, evaluated only after its input changes.
+     */
+    constructor(source: ObservableSnapshot<T | undefined>, project: (value: T) => InspectorRecord);
+    /** @returns Stable metadata for the current raw value. */
+    getSnapshot: () => InspectorRecord | undefined;
+    /** @param listener - Row invalidation callback. @returns Its disposer. */
+    subscribe: (listener: () => void) => (() => void);
+}
+//# sourceMappingURL=table-model.d.ts.map

package/lib/types/client/views/type-filter.d.ts

@@ -0,0 +1,41 @@
+/** Confirmed type filtering preserves the ancestors needed to inspect matching nested rows. */
+import type { InspectorRow } from './table-model.ts';
+/** Filtered row order and the distinction between matches and contextual ancestors. */
+export interface InspectorTypeMatches {
+    readonly rows: readonly InspectorRow[];
+    readonly matches: ReadonlySet<string>;
+}
+/** Case-insensitive containment filter; optional surrounding stars have the same meaning as omission. */
+export declare class InspectorTypeFilter {
+    /** Trimmed type fragment without optional surrounding stars; preserves the entered case. */
+    readonly query: string;
+    private readonly needle;
+    /** @param query - Type fragment; empty text or only stars clears filtering. */
+    constructor(query: string);
+    /**
+     * Distinguish a type restriction from an empty or all-stars query.
+     * @returns Whether this filter restricts the table.
+     */
+    get active(): boolean;
+    /**
+     * Match a type by case-insensitive containment, accepting all types when filtering is inactive.
+     * @param type - Current raw type, absent while its record is unavailable.
+     * @returns Whether the record matches the filter.
+     */
+    matches(type: string | undefined): boolean;
+    /**
+     * Retain matching rows and their ancestors; matching descendants start visible even under closed blocks.
+     * @param rows - Complete loaded hierarchy, before user disclosure choices.
+     * @param typeOf - Current type reader, independent of React row subscriptions.
+     * @returns Matching rows and contextual ancestors in their original order.
+     */
+    apply(rows: readonly InspectorRow[], typeOf: (key: string) => string | undefined): InspectorTypeMatches;
+    /**
+     * Resolve candidates asynchronously from all loaded rows, not the already filtered subset.
+     * @param rows - Complete loaded row list.
+     * @param typeOf - Current raw type reader.
+     * @returns Distinct matching types in deterministic order.
+     */
+    suggest(rows: readonly InspectorRow[], typeOf: (key: string) => string | undefined): Promise<readonly string[]>;
+}
+//# sourceMappingURL=type-filter.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Host discovery entry for the Session Inspector browser plugin. */
+/** Mount the inert Host half; Session inspection belongs to the Client. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Session Log",
+    "description": "Enable analysis of the current session's raw data and grouped chat messages in the session sidebar."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "会话数据诊断",
+    "description": "在会话侧边栏启用当前会话的原始数据和聊天分组数据分析功能"
+  }
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@deepseek-ai/dsh-experimental-session-inspector",
+  "description": "Experimental virtualized Session log and live Chat group/node inspectors",
+  "version": "0.2.1-alpha.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/experimental/session-inspector"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./locale/*.json": "./locale/*.json",
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-session",
+        "@deepseek-ai/dsh-client-ui-renderer"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "locale/*.json",
+    "lib/index.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.1.0",
+    "@types/react-dom": "~18.3.0",
+    "react-dom": "^18.2.0",
+    "@tanstack/react-virtual": "^3.14.9",
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "@deepseek-ai/dsh-client-test-runtime": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-store": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-sidebar-right": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-session": "0.2.1-alpha.1",
+    "@deepseek-ai/cordis": "~4.0.5-alpha.1",
+    "@deepseek-ai/dsh-client-locale": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-llm": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.1-alpha.1"
+  },
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
+}