dsh-context 0.7.3 → 0.9.0

package/lib/index.js

@@ -1,3 +1,6 @@
+// src/host/timeline.ts
+import { z } from "zod";
+
 // src/host/pricing.ts
 var CHARS_PER_TOKEN = 4;
 var BLOCK_OVERHEAD = 4;
@@ -64,6 +67,8 @@ function isInjection(source) {
 // src/host/fold.ts
 var MAX_REQUEST_STEPS = 1500;
 var MAX_KEPT_TURNS = 300;
+var MAX_EVENTS = 400;
+var MAX_NODES = 200;
 function trimToLastTurns(requests, maxTurns) {
   let runs = 0;
   let start = requests.length;
@@ -79,27 +84,43 @@ function trimToLastTurns(requests, maxTurns) {
   }
   return requests.slice(start);
 }
-function createFold() {
+function countTurnRuns(requests) {
+  let runs = 0;
+  let prevTurn;
+  for (const r of requests) {
+    if (r.turn !== prevTurn) {
+      runs++;
+      prevTurn = r.turn;
+    }
+  }
+  return runs;
+}
+function trimState(st) {
+  if (countTurnRuns(st.requests) > MAX_KEPT_TURNS) {
+    st.requests = trimToLastTurns(st.requests, MAX_KEPT_TURNS);
+  }
+  if (st.requests.length > MAX_REQUEST_STEPS) {
+    st.requests = st.requests.slice(-MAX_REQUEST_STEPS);
+  }
+  if (st.events.length > MAX_EVENTS) st.events = st.events.slice(-MAX_EVENTS);
+}
+function createTimelineState() {
   return {
-    n: 0,
-    // number of log events already folded
     surface: [],
-    // { seq, cat, tokens, form?, text?, tool?, err?, skill?, calls? }
     sums: { user: 0, inject: 0, assistant: 0, tool: 0 },
     systemTokens: 0,
     toolsTokens: 0,
     toolList: [],
-    // { name, tokens }
     model: void 0,
     provider: void 0,
     lastModel: void 0,
     contextWindow: void 0,
+    pressureTokens: void 0,
+    sampledSurfaceTokens: void 0,
+    occupancyWindow: void 0,
     requests: [],
-    // one entry per answered model call
     events: [],
-    // notable context events (structured; the Client labels them)
     callNames: {}
-    // callId -> tool name
   };
 }
 function categoryOf(type, message) {
@@ -129,9 +150,12 @@ function applySurface(st, ev, type, data, message) {
       if (names.length > 0) node.calls = names.slice(0, 3);
     }
   } else if (type === "tool/result") {
+    const srcId = source?.callId;
+    const srcName = typeof srcId === "string" ? st.callNames[srcId] : void 0;
     const block = message?.content?.[0];
-    const tname = block && block.callId !== void 0 ? st.callNames[block.callId] : void 0;
-    if (tname) node.tool = tname;
+    const blockId = block?.toolCallId;
+    if (srcName) node.tool = srcName;
+    else if (typeof blockId === "string") node.tool = st.callNames[blockId];
     if (data?.error) node.err = true;
   } else if (source?.kind === "skill-invocation") {
     node.skill = typeof source.name === "string" ? source.name : "?";
@@ -147,8 +171,22 @@ function applySurface(st, ev, type, data, message) {
     const utext = firstText(message?.content);
     if (utext !== "") node.text = utext;
   }
+  const shadowedSeqs = st.pendingShadowedSeqs;
+  st.pendingShadowedSeqs = void 0;
   const op = ev.surfaceOp;
   if (op !== null && typeof op === "object" && op.op === "replace") {
+    if (Array.isArray(shadowedSeqs) && shadowedSeqs.length > 0) {
+      const shadowed = new Set(shadowedSeqs);
+      const kept = [];
+      for (const n of st.surface) {
+        if (shadowed.has(n.seq)) st.sums[n.cat] -= n.tokens;
+        else kept.push(n);
+      }
+      st.surface = kept;
+      st.sums[cat] += node.tokens;
+      st.surface.push(node);
+      return node;
+    }
     let si = -1;
     let ei = -1;
     for (let i = 0; i < st.surface.length; i++) {
@@ -169,149 +207,189 @@ function applySurface(st, ev, type, data, message) {
   st.sums[cat] += node.tokens;
   return node;
 }
-function foldInto(st, events) {
-  for (let e = st.n; e < events.length; e++) {
-    const ev = events[e];
-    if (ev === null || typeof ev !== "object") continue;
-    const data = ev.data;
-    switch (ev.type) {
-      case "request/header": {
-        const header = data?.header ?? {};
-        const tools = Array.isArray(header.tools) ? header.tools : [];
-        st.toolList = tools.map((t) => ({
-          name: typeof t.name === "string" ? t.name : "?",
-          tokens: estimateToolSchema(t)
-        }));
-        st.toolsTokens = estimateToolsTotal(tools);
-        st.systemTokens = estimateSystem(header.system);
-        if (header.config && typeof header.config.model === "string") st.model = header.config.model;
-        if (header.config && typeof header.config.provider === "string") st.provider = header.config.provider;
-        if (data?.reason === "change" && st.model && st.lastModel && st.model !== st.lastModel) {
-          st.events.push({ seq: ev.seq, time: ev.time, kind: "model", from: st.lastModel, to: st.model });
-        }
-        if (st.model) st.lastModel = st.model;
-        break;
-      }
-      case "request/context":
-        if (data && typeof data.contextWindow === "number") st.contextWindow = data.contextWindow;
-        if (data && typeof data.model === "string") st.model = data.model;
-        if (data && typeof data.provider === "string") st.provider = data.provider;
-        break;
-      case "tool/call":
-        if (data && data.callId !== void 0 && typeof data.name === "string") st.callNames[String(data.callId)] = data.name;
-        break;
-      case "user/message": {
-        const msg = data;
-        const node = applySurface(st, ev, ev.type, data, msg);
-        const source = msg?.source;
-        if (isInjection(source)) {
-          const rec = {
-            seq: ev.seq,
-            time: ev.time,
-            kind: "inject",
-            form: source.form || "context",
-            tokens: node.tokens
-          };
-          if (source.kind === "skill-invocation") {
-            rec.sub = "skill";
-            rec.name = typeof source.name === "string" ? source.name : "?";
-          } else if (typeof source.plugin === "string" && source.plugin !== "") {
-            rec.name = source.plugin;
-          }
-          st.events.push(rec);
-        }
-        break;
+function pressureOf(usage) {
+  if (usage === void 0 || typeof usage.inputTokens !== "number") return void 0;
+  return usage.inputTokens + (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0);
+}
+function sampleUsage(st, usage) {
+  const pressureTokens = pressureOf(usage);
+  if (pressureTokens === void 0) return;
+  st.pressureTokens = pressureTokens;
+  st.sampledSurfaceTokens = st.sums.user + st.sums.inject + st.sums.assistant + st.sums.tool;
+}
+function applyTimeline(state, event) {
+  let st;
+  const ensure = () => st ??= {
+    ...state,
+    surface: [...state.surface],
+    sums: { ...state.sums },
+    toolList: [...state.toolList],
+    requests: [...state.requests],
+    events: [...state.events],
+    callNames: { ...state.callNames }
+  };
+  const data = event.data;
+  switch (event.type) {
+    case "request/header": {
+      const header = data?.header ?? {};
+      const tools = Array.isArray(header.tools) ? header.tools : [];
+      const s = ensure();
+      s.toolList = tools.map((t) => ({
+        name: typeof t.name === "string" ? t.name : "?",
+        tokens: estimateToolSchema(t)
+      }));
+      s.toolsTokens = estimateToolsTotal(tools);
+      s.systemTokens = estimateSystem(header.system);
+      if (header.config && typeof header.config.model === "string") s.model = header.config.model;
+      if (header.config && typeof header.config.provider === "string") s.provider = header.config.provider;
+      if (data?.reason === "change" && s.model && s.lastModel && s.model !== s.lastModel) {
+        s.events.push({ seq: event.seq, time: event.time, kind: "model", from: s.lastModel, to: s.model });
       }
-      case "tool/result": {
-        const toolMsg = data?.message ?? null;
-        applySurface(st, ev, ev.type, data, toolMsg);
-        break;
+      if (s.model) s.lastModel = s.model;
+      break;
+    }
+    case "request/context": {
+      const s = ensure();
+      if (data && typeof data.contextWindow === "number") s.contextWindow = data.contextWindow;
+      if (data && typeof data.model === "string") s.model = data.model;
+      if (data && typeof data.provider === "string") s.provider = data.provider;
+      s.occupancyWindow = data && typeof data.contextWindow === "number" ? data.contextWindow : void 0;
+      break;
+    }
+    case "tool/call": {
+      if (data && data.callId !== void 0 && typeof data.name === "string") {
+        const s = ensure();
+        s.callNames[String(data.callId)] = data.name;
       }
-      case "assistant/message": {
-        const usage = data?.usage;
-        const total = st.systemTokens + st.toolsTokens + st.sums.user + st.sums.inject + st.sums.assistant + st.sums.tool;
-        const record = {
-          turn: data && typeof data.turn === "number" ? data.turn : void 0,
-          step: data && typeof data.step === "number" ? data.step : void 0,
-          time: ev.time,
-          seq: ev.seq,
-          system: st.systemTokens,
-          tools: st.toolsTokens,
-          user: st.sums.user,
-          inject: st.sums.inject,
-          assistant: st.sums.assistant,
-          tool: st.sums.tool,
-          total
+      break;
+    }
+    case "user/message": {
+      const msg = data;
+      const s = ensure();
+      const node = applySurface(s, event, event.type, data, msg);
+      const source = msg?.source;
+      if (isInjection(source)) {
+        const rec = {
+          seq: event.seq,
+          time: event.time,
+          kind: "inject",
+          form: source.form || "context",
+          tokens: node.tokens
         };
-        if (usage && typeof usage.inputTokens === "number") {
-          record.prompt = usage.inputTokens + (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0);
-          if (typeof usage.outputTokens === "number") record.output = usage.outputTokens;
+        if (source.kind === "skill-invocation") {
+          rec.sub = "skill";
+          rec.name = typeof source.name === "string" ? source.name : "?";
+        } else if (typeof source.plugin === "string" && source.plugin !== "") {
+          rec.name = source.plugin;
         }
-        st.requests.push(record);
-        const asstMsg = data?.message ?? null;
-        applySurface(st, ev, ev.type, data, asstMsg);
-        break;
+        s.events.push(rec);
       }
-      case "compaction/summary":
-        st.events.push({
-          seq: ev.seq,
-          time: ev.time,
-          kind: "compaction",
-          tokens: data && typeof data.shadowedTokenCount === "number" ? data.shadowedTokenCount : 0,
-          count: data && Array.isArray(data.shadowedSeqs) ? data.shadowedSeqs.length : 0
-        });
-        break;
-      case "compaction/prune":
-        st.events.push({
-          seq: ev.seq,
-          time: ev.time,
-          kind: "prune",
-          tokens: data && typeof data.shadowedTokenCount === "number" ? data.shadowedTokenCount : 0
-        });
-        break;
-      default:
-        break;
+      break;
+    }
+    case "tool/result": {
+      const toolMsg = data?.message ?? null;
+      const s = ensure();
+      applySurface(s, event, event.type, data, toolMsg);
+      break;
+    }
+    case "assistant/chunk": {
+      const chunk = data?.chunk;
+      if (chunk !== void 0 && chunk.type === "usage") {
+        const s = ensure();
+        sampleUsage(s, chunk.usage);
+      }
+      break;
     }
+    case "assistant/message": {
+      const usage = data?.usage;
+      const s = ensure();
+      sampleUsage(s, usage);
+      const total = s.systemTokens + s.toolsTokens + s.sums.user + s.sums.inject + s.sums.assistant + s.sums.tool;
+      const record = {
+        turn: data && typeof data.turn === "number" ? data.turn : void 0,
+        step: data && typeof data.step === "number" ? data.step : void 0,
+        time: event.time,
+        seq: event.seq,
+        system: s.systemTokens,
+        tools: s.toolsTokens,
+        user: s.sums.user,
+        inject: s.sums.inject,
+        assistant: s.sums.assistant,
+        tool: s.sums.tool,
+        total
+      };
+      if (usage && typeof usage.inputTokens === "number") {
+        record.prompt = usage.inputTokens + (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0);
+        if (typeof usage.outputTokens === "number") record.output = usage.outputTokens;
+      }
+      s.requests.push(record);
+      const asstMsg = data?.message ?? null;
+      applySurface(s, event, event.type, data, asstMsg);
+      break;
+    }
+    case "compaction/summary":
+    case "compaction/prune": {
+      const s = ensure();
+      if (data && Array.isArray(data.shadowedSeqs)) {
+        s.pendingShadowedSeqs = data.shadowedSeqs.filter((x) => typeof x === "number");
+      }
+      s.events.push({
+        seq: event.seq,
+        time: event.time,
+        kind: event.type === "compaction/summary" ? "compaction" : "prune",
+        tokens: data && typeof data.shadowedTokenCount === "number" ? data.shadowedTokenCount : 0,
+        ...event.type === "compaction/summary" && data && Array.isArray(data.shadowedSeqs) ? { count: data.shadowedSeqs.length } : {}
+      });
+      break;
+    }
+    default:
+      return state;
   }
-  st.n = events.length;
-  if (st.requests.length > MAX_REQUEST_STEPS) {
-    st.requests = trimToLastTurns(st.requests, MAX_KEPT_TURNS);
-    if (st.requests.length > MAX_REQUEST_STEPS) st.requests = st.requests.slice(-MAX_REQUEST_STEPS);
+  if (st !== void 0) {
+    trimState(st);
+    return st;
   }
-  if (st.events.length > 400) st.events = st.events.slice(-400);
+  return state;
 }
-
-// src/host/snapshot.ts
-function buildResult(st) {
-  const surfaceTotal = st.sums.user + st.sums.inject + st.sums.assistant + st.sums.tool;
+function buildTimelineView(state) {
+  const surfaceTotal = state.sums.user + state.sums.inject + state.sums.assistant + state.sums.tool;
+  const projectedTokens = state.pressureTokens !== void 0 && state.sampledSurfaceTokens !== void 0 ? Math.max(0, state.pressureTokens + surfaceTotal - state.sampledSurfaceTokens) : void 0;
   const result = {
     ok: true,
-    model: st.model,
-    provider: st.provider,
-    contextWindow: st.contextWindow,
+    model: state.model,
+    provider: state.provider,
+    contextWindow: state.contextWindow,
     current: {
-      system: st.systemTokens,
-      tools: st.toolsTokens,
-      user: st.sums.user,
-      inject: st.sums.inject,
-      assistant: st.sums.assistant,
-      tool: st.sums.tool,
-      total: surfaceTotal + st.systemTokens + st.toolsTokens
+      system: state.systemTokens,
+      tools: state.toolsTokens,
+      user: state.sums.user,
+      inject: state.sums.inject,
+      assistant: state.sums.assistant,
+      tool: state.sums.tool,
+      total: surfaceTotal + state.systemTokens + state.toolsTokens
     },
-    toolList: st.toolList,
-    requests: st.requests,
-    events: st.events,
+    occupancy: {
+      ...state.pressureTokens === void 0 ? {} : { pressureTokens: state.pressureTokens },
+      surfaceTokens: surfaceTotal,
+      ...state.sampledSurfaceTokens === void 0 ? {} : { sampledSurfaceTokens: state.sampledSurfaceTokens },
+      ...projectedTokens === void 0 ? {} : { projectedTokens },
+      ...state.occupancyWindow === void 0 ? {} : { contextWindow: state.occupancyWindow }
+    },
+    toolList: state.toolList,
+    requests: state.requests.map((r) => ({ ...r })),
+    events: state.events.map((e) => ({ ...e })),
     nodes: [],
     droppedNodes: 0
   };
-  const MAX_NODES = 200;
-  result.droppedNodes = Math.max(0, st.surface.length - MAX_NODES);
-  result.nodes = st.surface.slice(-MAX_NODES);
+  result.droppedNodes = Math.max(0, state.surface.length - MAX_NODES);
+  result.nodes = state.surface.slice(-MAX_NODES);
+  const requests = result.requests;
+  const events = result.events;
   let ri = 0;
-  for (const ev of result.events) {
-    while (ri < result.requests.length && result.requests[ri].seq <= ev.seq) ri++;
-    const next = result.requests[ri];
-    const prev = ri > 0 ? result.requests[ri - 1] : void 0;
+  for (const ev of events) {
+    while (ri < requests.length && requests[ri].seq <= ev.seq) ri++;
+    const next = requests[ri];
+    const prev = ri > 0 ? requests[ri - 1] : void 0;
     if (next !== void 0 && typeof next.turn === "number" && typeof next.step === "number") {
       ev.turn = next.turn;
       ev.step = next.step;
@@ -323,68 +401,97 @@ function buildResult(st) {
   }
   return result;
 }
-async function computeSnapshot(ctx, states, sessionId) {
-  let st = states.get(sessionId);
-  if (st === void 0) {
-    st = { fold: createFold(), count: -1, result: null };
-    states.set(sessionId, st);
-  }
-  const sessions = ctx.get("sessions");
-  const sessionQuery = ctx.get("sessionQuery");
-  const live = sessions !== void 0 ? sessions.get(sessionId) : void 0;
-  let events;
-  if (live !== void 0) {
-    events = live.events;
-  } else {
-    if (sessionQuery === void 0) throw new Error("session is not live and sessionQuery is unavailable");
-    if (st.result !== null && st.count >= 0) {
-      const records = await sessionQuery.listEvents(sessionId);
-      if (records.length === st.count) return st.result;
-    }
-    const snapshot = await sessionQuery.readSession(sessionId);
-    events = snapshot && Array.isArray(snapshot.events) ? snapshot.events : [];
-  }
-  if (events.length === st.count && st.result !== null) return st.result;
-  if (events.length < st.fold.n) st.fold = createFold();
-  foldInto(st.fold, events);
-  st.count = events.length;
-  st.result = buildResult(st.fold);
-  return st.result;
-}
+
+// src/host/timeline.ts
+var surfaceNodeSchema = z.object({
+  seq: z.number().int().nonnegative(),
+  time: z.number().optional(),
+  cat: z.enum(["user", "inject", "assistant", "tool"]),
+  tokens: z.number().int().nonnegative(),
+  form: z.string().optional(),
+  text: z.string().optional(),
+  tool: z.string().optional(),
+  err: z.boolean().optional(),
+  skill: z.string().optional(),
+  calls: z.array(z.string()).optional()
+}).strict();
+var requestRecordSchema = z.object({
+  turn: z.number().optional(),
+  step: z.number().optional(),
+  time: z.number(),
+  seq: z.number(),
+  system: z.number().int().nonnegative(),
+  tools: z.number().int().nonnegative(),
+  user: z.number().int().nonnegative(),
+  inject: z.number().int().nonnegative(),
+  assistant: z.number().int().nonnegative(),
+  tool: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+  prompt: z.number().int().nonnegative().optional(),
+  output: z.number().int().nonnegative().optional(),
+  stepCount: z.number().int().positive().optional()
+}).strict();
+var contextEventSchema = z.object({
+  seq: z.number(),
+  time: z.number(),
+  kind: z.enum(["compaction", "prune", "inject", "model"]),
+  form: z.string().optional(),
+  tokens: z.number().optional(),
+  count: z.number().optional(),
+  sub: z.string().optional(),
+  name: z.string().optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  fromTurn: z.number().optional(),
+  fromStep: z.number().optional(),
+  turn: z.number().optional(),
+  step: z.number().optional()
+}).strict();
+var currentSchema = z.object({
+  system: z.number().int().nonnegative(),
+  tools: z.number().int().nonnegative(),
+  user: z.number().int().nonnegative(),
+  inject: z.number().int().nonnegative(),
+  assistant: z.number().int().nonnegative(),
+  tool: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative()
+}).strict();
+var occupancySchema = z.object({
+  pressureTokens: z.number().int().nonnegative().optional(),
+  surfaceTokens: z.number().int().nonnegative(),
+  sampledSurfaceTokens: z.number().int().nonnegative().optional(),
+  projectedTokens: z.number().int().nonnegative().optional(),
+  contextWindow: z.number().int().positive().optional()
+}).strict();
+var contextTimelineSchema = z.object({
+  ok: z.literal(true),
+  model: z.string().optional(),
+  provider: z.string().optional(),
+  contextWindow: z.number().optional(),
+  current: currentSchema,
+  occupancy: occupancySchema.optional(),
+  toolList: z.array(z.object({ name: z.string(), tokens: z.number().int().nonnegative() }).strict()),
+  requests: z.array(requestRecordSchema),
+  events: z.array(contextEventSchema),
+  nodes: z.array(surfaceNodeSchema),
+  droppedNodes: z.number().int().nonnegative()
+}).strict();
+var contextTimelineDefinition = {
+  key: "contextTimeline",
+  schema: contextTimelineSchema,
+  init: () => createTimelineState(),
+  apply: (state, event) => applyTimeline(state, event),
+  view: (state) => buildTimelineView(state),
+  stateVersion: 1
+};
 
 // src/host/index.ts
 var name = "dsh-context";
-var inject = ["connection"];
+var inject = ["sessionProjections"];
 function apply(ctx) {
-  const states = /* @__PURE__ */ new Map();
-  ctx.effect(() => {
-    return ctx.connection.rpc.handle(
-      "/dsh-context",
-      async (endpoint, payload) => {
-        try {
-          if (endpoint !== "snapshot") {
-            return { ok: false, error: { code: "internal", message: `unknown endpoint: ${endpoint}`, details: {} } };
-          }
-          const sessionId = payload !== null && typeof payload === "object" ? payload.sessionId : void 0;
-          if (typeof sessionId !== "string" || sessionId === "") {
-            return { ok: false, error: { code: "internal", message: "missing sessionId", details: {} } };
-          }
-          const value = await computeSnapshot(ctx, states, sessionId);
-          return { ok: true, value };
-        } catch (err) {
-          return {
-            ok: false,
-            error: {
-              code: "internal",
-              message: err instanceof Error ? err.message : String(err),
-              details: {}
-            }
-          };
-        }
-      },
-      { authority: "trusted-host" }
-    );
-  }, "dsh-context: rpc channel");
+  ctx.inject(["sessionProjections"], (projectionCtx) => {
+    projectionCtx.sessionProjections.register(contextTimelineDefinition);
+  });
 }
 export {
   apply,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-context",
-  "version": "0.7.3",
-  "description": "Context insight panel for DeepSeek Harness: see what the model's context window is made of and how it evolves — composition, per-request history, compactions, injections, and model switches.",
+  "version": "0.9.0",
+  "description": "Context insight panel for DeepSeek Harness: see what the model's context window is made of and how it evolves — composition, per-request history, compactions, injections, and model switches. Streamed through the harness's session-projection pipeline.",
   "author": "bowenliang123",
   "repository": {
     "type": "git",
@@ -56,8 +56,15 @@
     "ui"
   ],
   "license": "Apache-2.0",
+  "dependencies": {
+    "zod": "^4.4.3"
+  },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-projection": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-token-meter": "0.1.0-rc.6",
     "@types/react": "^18.3.31",
     "esbuild": "^0.28.2",
     "husky": "^9.1.7",