@syghar/dsh-ninfer-context 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# dsh-ninfer-context
+
+This plugin is a compatible replacement for DSH's `token-meter` service. It
+keeps the `tokenUsage`, `contextPressure`, and `contextBreakdown` projections
+unchanged, but treats a completed `ninfer` usage report as the authoritative
+context anchor even when it is lower than the fixed-density heuristic.
+
+That makes the existing compaction engine and context-used widget agree with
+the actual OpenAI-compatible usage returned by ninfer. Surface changes after
+the last provider sample are still estimated until the next ninfer response;
+the provider anchor is never fabricated before ninfer reports usage.

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# Replace DSH's heuristic-only token meter. The service keeps the same
+# tokenMeter/contextPressure contracts used by compaction and the stock UI.
+- id: token-meter
+  name: '@syghar/dsh-ninfer-context'

package/lib/index.mjs

@@ -0,0 +1,344 @@
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { BlockAssembler, deepFreeze } from "@deepseek-ai/dsh-llm";
+import { canonicalHeader, deriveEventMessage, headerEquals, isSurfaceEvent } from "@deepseek-ai/dsh-session";
+import { z as zod } from "zod";
+
+const CHARS_PER_TOKEN = 4;
+const BLOCK_OVERHEAD = 4;
+
+function estimateContent(blocks) {
+  let tokens = 0;
+  for (const block of blocks) switch (block.type) {
+    case "text":
+    case "reasoning":
+      tokens += Math.ceil(block.text.length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+      break;
+    case "tool-call":
+      tokens += Math.ceil(block.name.length / CHARS_PER_TOKEN) + Math.ceil(block.arguments.length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+      break;
+    case "tool-result":
+      tokens += estimateContent(block.content) + BLOCK_OVERHEAD;
+      break;
+    default:
+      tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN);
+  }
+  return tokens;
+}
+
+function estimateMessage(message) {
+  return estimateContent(message.content) + 4;
+}
+
+function estimateSystemTokens(header) {
+  return header?.system === undefined ? 0 : Math.ceil(header.system.length / CHARS_PER_TOKEN) + 4;
+}
+
+function estimateToolsTokens(header) {
+  return header?.tools === undefined || header.tools.length === 0
+    ? 0
+    : Math.ceil(JSON.stringify(header.tools).length / CHARS_PER_TOKEN) + BLOCK_OVERHEAD;
+}
+
+function estimateHeader(header) {
+  return estimateSystemTokens(header) + estimateToolsTokens(header);
+}
+
+function foldSurfaceProjection(claim, event) {
+  if (event.type === "compaction/summary" || event.type === "compaction/prune") {
+    const { shadowedRange, shadowedTokenCount } = event.data;
+    return { deltaTokens: 0, claim: { start: shadowedRange.start, end: shadowedRange.end, tokens: shadowedTokenCount } };
+  }
+  if (!isSurfaceEvent(event)) return { deltaTokens: 0, claim: undefined };
+  const message = deriveEventMessage(event);
+  const tokens = message === null ? 0 : estimateMessage(message);
+  const op = event.surfaceOp;
+  if (op === "append") return { deltaTokens: tokens, claim: undefined };
+  if (claim === undefined) return { deltaTokens: 0, claim: undefined };
+  if (claim.start !== op.start || claim.end !== op.end) {
+    throw new Error(`ninfer context: replace at seq ${event.seq} over range ${op.start}-${op.end} has no adjacent shadow price`);
+  }
+  return { deltaTokens: tokens - claim.tokens, claim: undefined };
+}
+
+const contextBreakdownProjectionDefinition = {
+  key: "contextBreakdown",
+  schema: zod.object({
+    systemTokens: zod.number().int().nonnegative(),
+    toolsTokens: zod.number().int().nonnegative(),
+    messageTokens: zod.number().int().nonnegative()
+  }).strict(),
+  init: () => ({ systemTokens: 0, toolsTokens: 0, messageTokens: 0 }),
+  apply: (state, event) => {
+    const fold = foldSurfaceProjection(state.claim, event);
+    let systemTokens = state.systemTokens;
+    let toolsTokens = state.toolsTokens;
+    if (event.type === "request/header") {
+      const header = canonicalHeader(event.data.header);
+      systemTokens = estimateSystemTokens(header);
+      toolsTokens = estimateToolsTokens(header);
+    }
+    if (systemTokens === state.systemTokens && toolsTokens === state.toolsTokens && fold.deltaTokens === 0 && fold.claim === undefined && state.claim === undefined) return state;
+    return {
+      systemTokens,
+      toolsTokens,
+      messageTokens: state.messageTokens + fold.deltaTokens,
+      ...(fold.claim === undefined ? {} : { claim: fold.claim })
+    };
+  },
+  view: ({ systemTokens, toolsTokens, messageTokens }) => ({ systemTokens, toolsTokens, messageTokens }),
+  stateVersion: 2
+};
+
+const zeroBuckets = () => ({ uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
+const bucketsFrom = (usage) => ({
+  uncachedInputTokens: usage.inputTokens,
+  outputTokens: usage.outputTokens,
+  cacheReadTokens: usage.cacheReadTokens ?? 0,
+  cacheWriteTokens: usage.cacheWriteTokens ?? 0
+});
+const bucketsEqual = (left, right) => left.uncachedInputTokens === right.uncachedInputTokens && left.outputTokens === right.outputTokens && left.cacheReadTokens === right.cacheReadTokens && left.cacheWriteTokens === right.cacheWriteTokens;
+const addReplacing = (totals, previous, next) => ({
+  uncachedInputTokens: totals.uncachedInputTokens - (previous?.uncachedInputTokens ?? 0) + next.uncachedInputTokens,
+  outputTokens: totals.outputTokens - (previous?.outputTokens ?? 0) + next.outputTokens,
+  cacheReadTokens: totals.cacheReadTokens - (previous?.cacheReadTokens ?? 0) + next.cacheReadTokens,
+  cacheWriteTokens: totals.cacheWriteTokens - (previous?.cacheWriteTokens ?? 0) + next.cacheWriteTokens
+});
+const projectionSchema = zod.object({
+  uncachedInputTokens: zod.number().int().nonnegative(),
+  outputTokens: zod.number().int().nonnegative(),
+  cacheReadTokens: zod.number().int().nonnegative(),
+  cacheWriteTokens: zod.number().int().nonnegative()
+}).strict();
+const pressureSchema = zod.object({
+  pressureTokens: zod.number().int().nonnegative().optional(),
+  projectedTokens: zod.number().int().nonnegative().optional(),
+  contextWindow: zod.number().int().positive().optional()
+}).strict();
+const pressureFrom = (usage) => usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+const usageOf = (event) => event.type === "assistant/chunk" && event.data.chunk.type === "usage"
+  ? event.data.chunk.usage
+  : event.type === "assistant/message" ? event.data.usage : undefined;
+
+const tokenUsageProjectionDefinition = {
+  key: "tokenUsage",
+  schema: projectionSchema,
+  init: () => ({ totals: zeroBuckets(), last: null }),
+  apply: (state, event) => {
+    let turn;
+    let step;
+    let usage;
+    if (event.type === "assistant/chunk" && event.data.chunk.type === "usage") {
+      ({ turn, step } = event.data);
+      usage = event.data.chunk.usage;
+    } else if (event.type === "assistant/message" && event.data.usage !== undefined) {
+      ({ turn, step, usage } = event.data);
+    } else return state;
+    const buckets = bucketsFrom(usage);
+    const previous = state.last !== null && state.last.turn === turn && state.last.step === step ? state.last.buckets : undefined;
+    if (previous !== undefined && bucketsEqual(previous, buckets)) return state;
+    return { totals: addReplacing(state.totals, previous, buckets), last: { turn, step, buckets } };
+  },
+  view: (state) => state.totals,
+  stateVersion: 1
+};
+
+const contextPressureProjectionDefinition = {
+  key: "contextPressure",
+  schema: pressureSchema,
+  init: () => ({ surfaceTokens: 0 }),
+  apply: (state, event) => {
+    const fold = foldSurfaceProjection(state.claim, event);
+    let next = state;
+    if (event.type === "request/context") {
+      const contextWindow = event.data.contextWindow;
+      if (contextWindow !== state.contextWindow) {
+        if (contextWindow !== undefined) next = { ...next, contextWindow };
+        else {
+          const { contextWindow: _removed, ...withoutContextWindow } = next;
+          next = withoutContextWindow;
+        }
+      }
+    }
+    const usage = usageOf(event);
+    if (usage !== undefined) {
+      const pressureTokens = pressureFrom(usage);
+      if (pressureTokens !== next.pressureTokens || next.sampledSurfaceTokens !== next.surfaceTokens) {
+        next = { ...next, pressureTokens, sampledSurfaceTokens: next.surfaceTokens };
+      }
+    }
+    if (fold.deltaTokens !== 0) next = { ...next, surfaceTokens: next.surfaceTokens + fold.deltaTokens };
+    if (state.claim === undefined && fold.claim === undefined) return next;
+    const { claim: _expired, ...withoutClaim } = next;
+    return fold.claim === undefined ? withoutClaim : { ...withoutClaim, claim: fold.claim };
+  },
+  view: ({ contextWindow, pressureTokens, surfaceTokens, sampledSurfaceTokens }) => ({
+    ...(contextWindow === undefined ? {} : { contextWindow }),
+    ...(pressureTokens === undefined ? {} : { pressureTokens }),
+    ...(pressureTokens === undefined || sampledSurfaceTokens === undefined ? {} : { projectedTokens: Math.max(0, pressureTokens + surfaceTokens - sampledSurfaceTokens) })
+  }),
+  stateVersion: 4
+};
+
+function foldSurfaceTokens(nodes, event) {
+  const message = deriveEventMessage(event);
+  const tokens = message === null ? 0 : estimateMessage(message);
+  const op = event.surfaceOp;
+  if (op === "append") return { tokens, nodes: [...nodes, { seq: event.seq, tokens }], deltaTokens: tokens };
+  const startIdx = nodes.findIndex((node) => node.seq === op.start);
+  const endIdx = nodes.findIndex((node) => node.seq === op.end);
+  if (startIdx === -1 || endIdx === -1 || startIdx > endIdx) throw new Error(`ninfer context: replace at seq ${event.seq} has invalid current range ${op.start}-${op.end}`);
+  const removed = nodes.slice(startIdx, endIdx + 1).reduce((total, node) => total + node.tokens, 0);
+  const next = [...nodes];
+  next.splice(startIdx, endIdx - startIdx + 1, { seq: event.seq, tokens });
+  return { tokens, nodes: next, deltaTokens: tokens - removed };
+}
+
+function usageTokens(usage) {
+  return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0) + usage.outputTokens;
+}
+
+function optionalHeaderEquals(left, right) {
+  if (left === undefined || right === undefined) return left === right;
+  return headerEquals(left, right);
+}
+
+function validateConfigKeys(config) {
+  for (const key of Object.keys(config)) throw new Error(`TokenMeterConfig: unknown key "${key}" (no settings are supported)`);
+}
+
+function isAuthoritativeNinfer(header) {
+  return header?.config?.provider === "ninfer";
+}
+
+class TokenMeter extends Service {
+  static Config = z.object({});
+  states = new WeakMap();
+
+  constructor(ctx, config = {}) {
+    super(ctx, "tokenMeter");
+    validateConfigKeys(config);
+    ctx.inject(["sessionProjections"], (projectionCtx) => {
+      projectionCtx.sessionProjections.register(tokenUsageProjectionDefinition);
+      projectionCtx.sessionProjections.register(contextPressureProjectionDefinition);
+      projectionCtx.sessionProjections.register(contextBreakdownProjectionDefinition);
+    });
+    ctx.on("session/event", (session) => {
+      if (this.states.has(session)) this._sync(session);
+    });
+  }
+
+  measure(session, requestHeader) {
+    const state = this._sync(session);
+    const header = requestHeader === undefined ? state.header : canonicalHeader(requestHeader);
+    const anchor = state.anchor;
+    let baseline;
+    let surfaceDeltaTokens;
+    if (anchor !== undefined && optionalHeaderEquals(anchor.header, header)) {
+      baseline = anchor.baseline;
+      surfaceDeltaTokens = state.surfaceTokens - anchor.surfaceTokens;
+    } else if (header === undefined && state.surfaceTokens === 0) {
+      baseline = { kind: "none", tokens: 0 };
+      surfaceDeltaTokens = 0;
+    } else {
+      baseline = { kind: "estimated", tokens: estimateHeader(header) + state.surfaceTokens };
+      surfaceDeltaTokens = 0;
+    }
+    return deepFreeze(structuredClone({
+      logRevision: state.consumedEvents,
+      baseline,
+      surfaceDeltaTokens,
+      totalTokens: Math.max(0, baseline.tokens + surfaceDeltaTokens),
+      surfaceTokens: state.surfaceTokens,
+      nodes: state.surface
+    }));
+  }
+
+  estimateMessage(message) {
+    return estimateMessage(message);
+  }
+
+  _sync(session) {
+    let state = this.states.get(session);
+    if (state === undefined) {
+      state = { consumedEvents: 0, header: undefined, surface: [], surfaceTokens: 0, stepStart: undefined, anchor: undefined };
+      this.states.set(session, state);
+    }
+    while (state.consumedEvents < session.events.length) {
+      const event = session.events[state.consumedEvents];
+      this._foldEvent(session, state, event);
+      state.consumedEvents += 1;
+    }
+    return state;
+  }
+
+  _foldEvent(session, state, event) {
+    let nextHeader = state.header;
+    let nextStepStart = state.stepStart;
+    let nextAnchor = state.anchor;
+    switch (event.type) {
+      case "request/header":
+        nextHeader = canonicalHeader(event.data.header);
+        break;
+      case "step/start":
+        if (state.stepStart !== undefined) throw new Error(`ninfer context: step/start at seq ${event.seq} arrived before turn ${state.stepStart.turn}/step ${state.stepStart.step} ended`);
+        nextStepStart = { ...event.data, surfaceTokens: state.surfaceTokens };
+        break;
+      case "step/end":
+        if (state.stepStart === undefined || state.stepStart.turn !== event.data.turn || state.stepStart.step !== event.data.step) throw new Error(`ninfer context: step/end at seq ${event.seq} has no matching step/start event`);
+        nextStepStart = undefined;
+        break;
+      default:
+        break;
+    }
+    const surface = isSurfaceEvent(event) ? foldSurfaceTokens(state.surface, event) : undefined;
+    if (event.type === "assistant/message") {
+      const stepStart = state.stepStart;
+      if (stepStart === undefined || stepStart.turn !== event.data.turn || stepStart.step !== event.data.step) throw new Error(`ninfer context: assistant/message at seq ${event.seq} has no matching step/start event`);
+      const eventTokens = surface.tokens;
+      if (event.data.usage !== undefined && nextHeader !== undefined) {
+        const providerAssistantTokens = this._estimateProviderAssistant(session, event, eventTokens);
+        const anchorSurfaceTokens = stepStart.surfaceTokens + providerAssistantTokens;
+        const providerTokens = usageTokens(event.data.usage);
+        const estimatedAnchorTokens = estimateHeader(nextHeader) + anchorSurfaceTokens;
+        nextAnchor = {
+          header: nextHeader,
+          surfaceTokens: anchorSurfaceTokens,
+          baseline: isAuthoritativeNinfer(nextHeader) || providerTokens >= estimatedAnchorTokens
+            ? { kind: "usage", tokens: providerTokens, usage: event.data.usage }
+            : { kind: "estimated", tokens: estimatedAnchorTokens }
+        };
+      } else {
+        const anchorSurfaceTokens = stepStart.surfaceTokens + eventTokens;
+        nextAnchor = { header: nextHeader, surfaceTokens: anchorSurfaceTokens, baseline: { kind: "estimated", tokens: estimateHeader(nextHeader) + anchorSurfaceTokens } };
+      }
+    }
+    state.header = nextHeader;
+    state.stepStart = nextStepStart;
+    if (surface !== undefined) {
+      state.surface = surface.nodes;
+      state.surfaceTokens += surface.deltaTokens;
+    }
+    state.anchor = nextAnchor;
+  }
+
+  _estimateProviderAssistant(session, event, durableEventTokens) {
+    const sourceSeqs = event.sourceEventSeqs;
+    if (sourceSeqs === undefined) return durableEventTokens;
+    const assembler = new BlockAssembler();
+    const seen = new Set();
+    for (const seq of sourceSeqs) {
+      if (seq >= event.seq) throw new Error(`ninfer context: assistant/message at seq ${event.seq} source seq ${seq} is not earlier`);
+      if (seen.has(seq)) throw new Error(`ninfer context: assistant/message at seq ${event.seq} repeats source seq ${seq}`);
+      seen.add(seq);
+      const sourceEvent = session.events[seq];
+      if (sourceEvent.type !== "assistant/chunk") throw new Error(`ninfer context: assistant/message at seq ${event.seq} source seq ${seq} is not assistant/chunk`);
+      if (sourceEvent.data.turn !== event.data.turn || sourceEvent.data.step !== event.data.step) throw new Error(`ninfer context: assistant/message at seq ${event.seq} source seq ${seq} belongs to another step`);
+      assembler.push(sourceEvent.data.chunk);
+    }
+    const providerContent = assembler.blocks();
+    return providerContent.length === 0 ? 0 : estimateContent(providerContent) + 4;
+  }
+}
+
+export { TokenMeter, TokenMeter as default };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@syghar/dsh-ninfer-context",
+  "description": "Provider-anchored DSH token meter for ninfer context usage",
+  "version": "0.1.0",
+  "author": "Sygmei",
+  "license": "MIT",
+  "files": ["lib", "cordis.patch.yml", "README.md"],
+  "repository": { "type": "git", "url": "git+https://github.com/Sygmei/dsh-plugins-collection.git", "directory": "plugins/dsh-ninfer-context" },
+  "homepage": "https://github.com/Sygmei/dsh-plugins-collection/tree/main/plugins/dsh-ninfer-context",
+  "bugs": { "url": "https://github.com/Sygmei/dsh-plugins-collection/issues" },
+  "publishConfig": { "access": "public" },
+  "type": "module",
+  "main": "lib/index.mjs",
+  "exports": {
+    ".": { "default": "./lib/index.mjs" },
+    "./package.json": "./package.json"
+  },
+  "dsh": { "bundle": { "patch": "./cordis.patch.yml" } },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "zod": "^3.25.76"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.8"
+  }
+}