dsh-better-display 0.3.4 → 0.3.6

package/src/client/tool-activity.ts

@@ -264,6 +264,48 @@ export function activityPhase(entry: Pick<ToolActivityEntry, 'block' | 'draft'>,
   return 'returned';
 }
 
+/**
+ * First-seen time for calls the host has not stamped yet. A draft that
+ * precedes a landed call carries no timestamp, so without this memory the
+ * running clock would restart at zero on every remount — e.g. switching to
+ * another conversation and back while the call is still preparing. Keyed by
+ * call id, dropped when the call leaves the running phases.
+ */
+const clockFirstSeen = new Map<string, number>();
+const CLOCK_FIRST_SEEN_LIMIT = 512;
+
+/**
+ * Session-stamped start of a call, or null while only a draft exists.
+ * A settled result carries `callTime`, the paired tool/call event's time; a
+ * still-running call head stamps the same instant in its own `time` field.
+ */
+export function callStartTime(entry: Pick<ToolActivityEntry, 'block'>): number | null {
+  const block = entry.block;
+  if (!block) return null;
+  return 'kind' in block ? block.callTime : block.time;
+}
+
+/**
+ * The instant a still-running call's elapsed clock counts from. The stamped
+ * time wins so a remounted view keeps counting from the real start; an
+ * un-stamped draft falls back to when this view first saw that call id, which
+ * survives remounts for the same reason.
+ */
+export function runningClockBase(callId: string, block: ToolCallBlock | undefined, now = Date.now()): number {
+  const stamped = callStartTime({ block });
+  if (stamped != null) return stamped;
+  const seen = clockFirstSeen.get(callId);
+  if (seen !== undefined) return seen;
+  if (clockFirstSeen.size >= CLOCK_FIRST_SEEN_LIMIT) clockFirstSeen.delete(clockFirstSeen.keys().next().value!);
+  clockFirstSeen.set(callId, now);
+  return now;
+}
+
+/** Forget a call's first-seen time once its clock is no longer live. */
+export function forgetCallClock(callId: string): void {
+  clockFirstSeen.delete(callId);
+}
+
 export function activitySummary(entry: Pick<ToolActivityEntry, 'block' | 'draft'>) {
   const { name, raw } = toolIdentity(entry);
   const args = inputFields(raw);

package/tests/tool-clock.test.ts

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { callStartTime, forgetCallClock, runningClockBase } from '../src/client/tool-activity.ts';
+import type { RunningToolCall, ToolResultNode } from '@deepseek-ai/dsh-client-ui-conversation/client';
+
+const startedCall = (callId: string, time: number): RunningToolCall => ({
+  phase: 'start', callId, name: 'bash', turn: 1, step: 0, time, argsRaw: '{"command":"sleep 60"}', subCalls: [],
+});
+const resultOf = (callId: string, callTime: number | null, time: number): ToolResultNode => ({
+  kind: 'tool-result', seq: 1, callId, time, callTime,
+  call: { name: 'bash', argsRaw: '{"command":"sleep 60"}' },
+  content: [], isError: false, subCalls: [],
+});
+
+test('a dispatched call counts from its stamped start, not the mount time', () => {
+  // The view remounts long after the tool/call event: base must stay the
+  // session-stamped time, so the clock shows the real elapsed seconds.
+  const block = startedCall('c1', 1_000);
+  assert.equal(callStartTime({ block }), 1_000);
+  assert.equal(runningClockBase('c1', block, 60_000), 1_000);
+});
+
+test('a draft-only call keeps the same base across remounts', () => {
+  // A draft carries no timestamp; first-seen is remembered per call id so
+  // remounting the view does not zero the clock.
+  assert.equal(runningClockBase('c2', undefined, 10_000), 10_000);
+  assert.equal(runningClockBase('c2', undefined, 30_000), 10_000);
+});
+
+test('a landed call head wins over the remembered draft time', () => {
+  runningClockBase('c3', undefined, 10_000);
+  assert.equal(runningClockBase('c3', startedCall('c3', 8_000), 20_000), 8_000);
+});
+
+test('settling forgets the first-seen time so the id can be reused safely', () => {
+  runningClockBase('c4', undefined, 10_000);
+  forgetCallClock('c4');
+  assert.equal(runningClockBase('c4', undefined, 40_000), 40_000);
+});
+
+test('a settled result still reports its paired call time', () => {
+  assert.equal(callStartTime({ block: resultOf('c5', 1_000, 5_000) }), 1_000);
+  // A result whose call fell outside the window stamps nothing.
+  assert.equal(callStartTime({ block: resultOf('c6', null, 5_000) }), null);
+});