dsh-context 0.22.2 → 0.24.0

package/lib/index.d.ts

@@ -329,6 +329,12 @@ interface TimelineState {
   cost?: SessionCostUsage;
   /** Newest `gone` among archive entries dropped by the retention bounds. */
   archiveFloor?: number;
+  /**
+   * Tool callId → name, armed by `tool/call` and DELETED when its
+   * `tool/result` folds in (one result per call, in log order) — the map
+   * stays at pending-call size instead of growing for the session's whole
+   * lifetime (it is persisted state, shallow-copied by every fold step).
+   */
   callNames: Record<string, string>;
   /**
    * Seq list of the surface nodes the next replacement will shadow, armed by

package/lib/index.js

@@ -39,11 +39,149 @@ function resolveBounds(config) {
 	return Config.parse(config ?? {});
 }
 //#endregion
+//#region src/shared/imageTokens.ts
+/**
+* Per-image token estimate for DeepSeek's vision model — a faithful port of
+* the official "图片 Token 计算器" (Image Token Calculator) shipped on the
+* DeepSeek API docs (https://api-docs.deepseek.com/zh-cn/quick_start/token_usage),
+* which implements the provider's own image→token conversion:
+*
+*   - every image is aspect-preserved rescaled before entering the model:
+*     below ~384×384 total pixels it is enlarged, above it is shrunk;
+*   - tokens follow the patch grid (patch 14px, downsample 3), so every
+*     image costs at least 117 and at most ~384 tokens (the documented cap).
+*
+* Verified against the docs calculator itself: 2048×1365→313, 800×600→341,
+* 2048×2048→349, 512×512→201, 100×100→117, 1920×1080→369, 400×900→249.
+* The DSH request pipeline's own 640k-pixel pre-resize does not change the
+* result (the provider formula rescales to the same patch grid), so the
+* durable attachment dimensions can be fed in directly.
+*
+* Pure math shared by the Host fold (message pricing) and the Client
+* (attachment card token badges) — no dependencies, never mutates.
+*/
+const PATCH_SIZE = 14;
+const DOWNSAMPLE_RATIO = 3;
+const MAX_WH_RATIO = 8;
+/** ~384×384 total pixels: smaller images are enlarged before patching. */
+const MIN_PIXELS = 147456;
+const floorDiv = (a, b) => Math.floor(a / b);
+const ceilDiv = (a, b) => Math.floor((a + b - 1) / b);
+/** Token count of one patch grid (rows×cols) under the v4 layout rule. */
+function gridTokens(rows, cols) {
+	let n = rows * (cols + 1) + 2;
+	if (rows % 2 === 1) n += cols + 1;
+	n += ceilDiv(rows, 2) * (cols + 1) % 2 * 2;
+	return n;
+}
+/** Solve the largest in-grid resize whose token count fits `budget`. */
+function solveResizeRatio(height, width, budget) {
+	const ratio = height / width;
+	const gridW = Math.sqrt((budget - 2) / ratio + .25) - .5;
+	const gridH = gridW * ratio;
+	const unit = 42;
+	let bestHeight;
+	let bestWidth;
+	if (gridW < 1) {
+		let rows = floorDiv(budget - 2, 2);
+		if (rows % 2 === 1) rows -= 1;
+		bestWidth = unit;
+		bestHeight = rows * unit;
+	} else if (gridH < 2) {
+		const cols = floorDiv(budget - 2, 2) - 1;
+		if (cols <= 1) throw new Error("image tokens: budget too small to solve");
+		bestHeight = 84;
+		bestWidth = cols * unit;
+	} else {
+		const cols = Math.trunc(gridW);
+		let rows = Math.trunc(gridH);
+		if (rows % 2 === 1) rows -= 1;
+		const scale = Math.min(cols * unit / width, rows * unit / height);
+		bestWidth = Math.trunc(width * scale / PATCH_SIZE) * PATCH_SIZE;
+		bestHeight = Math.trunc(height * scale / PATCH_SIZE) * PATCH_SIZE;
+	}
+	const nLlmH = ceilDiv(floorDiv(bestHeight, PATCH_SIZE), DOWNSAMPLE_RATIO);
+	const nLlmW = ceilDiv(floorDiv(bestWidth, PATCH_SIZE), DOWNSAMPLE_RATIO);
+	return {
+		nLlmH,
+		nLlmW,
+		bestHeight,
+		bestWidth,
+		numTokens: gridTokens(nLlmH, nLlmW)
+	};
+}
+/** Resize so the patch grid fits the cap, then re-add the pad reserve. */
+function safeResize(height, width, paddedHeight, paddedWidth) {
+	const nLlmH = ceilDiv(floorDiv(paddedHeight, PATCH_SIZE), DOWNSAMPLE_RATIO);
+	const nLlmW = ceilDiv(floorDiv(paddedWidth, PATCH_SIZE), DOWNSAMPLE_RATIO);
+	const pad = 3;
+	const budget = 381;
+	let result = {
+		nLlmH,
+		nLlmW,
+		bestHeight: paddedHeight,
+		bestWidth: paddedWidth,
+		numTokens: gridTokens(nLlmH, nLlmW)
+	};
+	if (result.numTokens > budget) {
+		result = solveResizeRatio(height, width, budget);
+		let nextBudget = budget;
+		while (result.numTokens > budget) {
+			nextBudget -= 1;
+			result = solveResizeRatio(height, width, nextBudget);
+		}
+	}
+	result.numTokens += pad;
+	return result;
+}
+function calcResizeInner(width, height) {
+	let w = width;
+	let h = height;
+	if (w > h * MAX_WH_RATIO) w = h * MAX_WH_RATIO;
+	const pixels = w * h;
+	if (pixels < MIN_PIXELS && pixels > 0) {
+		const scale = Math.sqrt(MIN_PIXELS / pixels);
+		w = Math.trunc(w * scale);
+		h = Math.trunc(h * scale);
+	}
+	const paddedWidth = ceilDiv(w, PATCH_SIZE) * PATCH_SIZE;
+	const paddedHeight = ceilDiv(h, PATCH_SIZE) * PATCH_SIZE;
+	return safeResize(h, w, paddedHeight, paddedWidth);
+}
+/**
+* Estimate the tokens one image consumes in a DeepSeek vision request, from
+* its pixel dimensions. Returns null for non-positive/non-finite dimensions
+* or when the official iteration fails to converge — callers fall back to
+* the generic structural price.
+*/
+function estimateImageTokens(width, height) {
+	if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return null;
+	try {
+		let result = calcResizeInner(width, height);
+		for (let i = 1; i < 10; i++) {
+			const next = calcResizeInner(result.bestWidth, result.bestHeight);
+			if (next.nLlmH === result.nLlmH && next.nLlmW === result.nLlmW && next.bestHeight === result.bestHeight && next.bestWidth === result.bestWidth && next.numTokens === result.numTokens) return result.numTokens;
+			result = next;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/host/pricing.ts
 /**
 * Token pricing — the same fixed-density heuristic as the harness's own
 * token-meter (`dsh-token-meter/estimate.ts`): ~4 chars ≈ 1 token, +4 per
 * content block, +4 role framing. Pure functions over message payloads.
+*
+* One deliberate refinement over the meter: `image` blocks. The meter prices
+* them through its generic JSON branch (~40 tokens for the durable ref),
+* while DeepSeek's vision model actually bills 117-384 tokens per image by
+* pixel dimensions (https://api-docs.deepseek.com/zh-cn/guides/vision/).
+* Image blocks therefore price through the official docs calculator port
+* (shared/imageTokens.ts), falling back to the meter's JSON price when the
+* attachment's dimensions are unknown.
 */
 const CHARS_PER_TOKEN = 4;
 const BLOCK_OVERHEAD = 4;
@@ -66,6 +204,12 @@ function estimateBlocks(blocks) {
 		case "tool-result":
 			tokens += estimateBlocks(block.content) + BLOCK_OVERHEAD;
 			break;
+		case "image": {
+			const ref = block.attachment;
+			const priced = ref !== null && typeof ref === "object" && typeof ref.width === "number" && typeof ref.height === "number" ? estimateImageTokens(ref.width, ref.height) : null;
+			tokens += (priced ?? Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN)) + BLOCK_OVERHEAD;
+			break;
+		}
 		default: tokens += BLOCK_OVERHEAD + Math.ceil(JSON.stringify(block).length / CHARS_PER_TOKEN);
 	}
 	return tokens;
@@ -304,6 +448,11 @@ function applySurface(st, ev, type, data, message) {
 		const blockId = (message?.content?.[0])?.toolCallId;
 		if (srcName) node.tool = srcName;
 		else if (typeof blockId === "string") node.tool = st.callNames[blockId];
+		if (typeof srcId === "string" || typeof blockId === "string") {
+			const kept = {};
+			for (const k in st.callNames) if (k !== srcId && k !== blockId) kept[k] = st.callNames[k];
+			st.callNames = kept;
+		}
 		if (data?.error) node.err = true;
 	} else if (source?.kind === "skill-invocation") node.skill = typeof source.name === "string" ? source.name : "?";
 	else if (source?.kind === "plugin") {
@@ -791,7 +940,7 @@ function createContextTimelineDefinition(config) {
 		},
 		init: () => createTimelineState(),
 		apply: (state, event) => applyTimeline(state, event, bounds),
-		stateVersion: 5
+		stateVersion: 6
 	};
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-context",
-  "version": "0.22.2",
+  "version": "0.24.0",
   "description": "A DeepSeek Harness plugin for context insight and management, with context dashboard and context command, for understanding how the context is made of, and how it evolves.",
   "author": "bowenliang123",
   "repository": {