@mars-sea/dsh-commandcode-provider 0.14.1 → 0.14.3

package/lib/index.js

@@ -38,10 +38,30 @@ function peakHour(at, windows) {
 * today, so the combination becoming real is visible before it reaches a user.
 * This ordering is a latent choice, not a verified upstream rule.
 */
-function requestRates(price, at, contextTokens, table) {
+function requestRates(price, at, contextTokens, table, peakHourCache) {
 	const tier = price.contextTiers?.find((tier) => tier.maxContext === void 0 || contextTokens <= tier.maxContext);
 	if (tier !== void 0) return tier;
-	return price.peak !== void 0 && at !== null && peakHour(at, table.peakHours) ? price.peak : price;
+	if (price.peak === void 0 || at === null) return price;
+	let peak = peakHourCache?.get(at);
+	if (peak === void 0) {
+		peak = peakHour(at, table.peakHours);
+		peakHourCache?.set(at, peak);
+	}
+	return peak ? price.peak : price;
+}
+/**
+* Price one request's token buckets against an already-resolved price row.
+*
+* Split out of the report's per-model lookup so a caller that prices the same
+* candidate model against every fact — the analytics scenario matrix — resolves
+* the price row once per model instead of once per (fact, model) pair. The
+* arithmetic lives here alone so the two callers cannot drift.
+*/
+function requestCost(tokens, price, at, table, peakHourCache) {
+	if (price.free === true) return 0;
+	const r = requestRates(price, at, tokens.uncachedInputTokens + tokens.cacheReadTokens + tokens.cacheWriteTokens, table, peakHourCache);
+	if (tokens.cacheWriteTokens > 0 && r.cacheWriteCost === void 0) return void 0;
+	return (tokens.uncachedInputTokens * r.inputCost + tokens.outputTokens * r.outputCost + tokens.cacheReadTokens * r.cacheReadCost + tokens.cacheWriteTokens * (r.cacheWriteCost ?? 0)) / 1e6;
 }
 /** Cache version and wire guard: changing bands/rates must refold historical groups. */
 function pricingKey(table) {
@@ -3257,6 +3277,7 @@ function foldRequests(session, log) {
 	}
 	return facts;
 }
+/** The zeroed accumulator `aggregate` adds into. Internal: nothing outside this module reads it. */
 const emptyMetrics = () => ({
 	sessions: 0,
 	requests: 0,
@@ -3277,17 +3298,13 @@ const emptyMetrics = () => ({
 	decodeMs: 0,
 	decodeTokens: 0
 });
-function priceRequest(f, id, table, prices) {
+function priceRequest(f, id, table, prices, peakHourCache) {
 	if (!f.tokens) return void 0;
 	const price = prices.get(id);
 	if (!price) return void 0;
-	if (price.free === true) return 0;
-	const context = f.tokens.uncachedInputTokens + f.tokens.cacheReadTokens + f.tokens.cacheWriteTokens;
-	const r = requestRates(price, f.at, context, table);
-	if (f.tokens.cacheWriteTokens > 0 && r.cacheWriteCost === void 0) return void 0;
-	return (f.tokens.uncachedInputTokens * r.inputCost + f.tokens.outputTokens * r.outputCost + f.tokens.cacheReadTokens * r.cacheReadCost + f.tokens.cacheWriteTokens * (r.cacheWriteCost ?? 0)) / 1e6;
+	return requestCost(f.tokens, price, f.at, table, peakHourCache);
 }
-function aggregate(facts, table, prices) {
+function aggregate(facts, table, prices, peakHourCache) {
 	const m = emptyMetrics();
 	m.sessions = new Set(facts.map((f) => f.session)).size;
 	for (const f of facts) {
@@ -3298,7 +3315,7 @@ function aggregate(facts, table, prices) {
 			m.usageSamples++;
 			for (const k of COST_TOKEN_KEYS) m.tokens[k] += f.tokens[k];
 		}
-		const cost = priceRequest(f, f.model, table, prices);
+		const cost = priceRequest(f, f.model, table, prices, peakHourCache);
 		if (cost !== void 0) {
 			m.pricedRequests++;
 			m.cost += cost;
@@ -3323,13 +3340,21 @@ function buildAnalytics(facts, query, table, catalog, now = Date.now()) {
 	const selected = query.mode === "range" ? facts.filter((f) => f.at >= query.from && f.at < query.to) : facts;
 	const prices = /* @__PURE__ */ new Map();
 	for (const p of table.models) for (const id of [p.id, p.slug]) if (!prices.has(id)) prices.set(id, p);
-	const totals = aggregate(selected, table, prices);
-	const models = [...new Set(selected.map((f) => f.model))].map((id) => ({
+	const peakHourCache = /* @__PURE__ */ new Map();
+	const totals = aggregate(selected, table, prices, peakHourCache);
+	const byModel = /* @__PURE__ */ new Map();
+	for (const f of selected) {
+		const bucket = byModel.get(f.model);
+		if (bucket === void 0) byModel.set(f.model, [f]);
+		else bucket.push(f);
+	}
+	const models = [...byModel].map(([id, bucket]) => ({
 		id,
-		...aggregate(selected.filter((f) => f.model === id), table, prices)
+		...aggregate(bucket, table, prices, peakHourCache)
 	})).sort((a, b) => b.cost - a.cost || a.id.localeCompare(b.id));
 	const scenarios = catalog.map((model) => {
 		let cost = 0, pricedRequests = 0, excludedRequests = 0, unknownRequests = 0;
+		const price = prices.get(model.id);
 		for (const f of selected) {
 			if (!f.tokens) {
 				unknownRequests++;
@@ -3340,7 +3365,7 @@ function buildAnalytics(facts, query, table, catalog, now = Date.now()) {
 				excludedRequests++;
 				continue;
 			}
-			const priced = priceRequest(f, model.id, table, prices);
+			const priced = price === void 0 ? void 0 : requestCost(f.tokens, price, f.at, table, peakHourCache);
 			if (priced === void 0) unknownRequests++;
 			else {
 				cost += priced;
@@ -6307,9 +6332,16 @@ const DEFAULT_API_BASE = "https://api.commandcode.ai";
 * under the historical name so existing importers are unaffected.
 */
 const DEFAULT_GENERATE_MAX_TOKENS = MAX_OUTPUT_TOKEN_LIMIT;
+/** Catalog fetch budget. Internal: both call sites are in this module. */
 const MODELS_TIMEOUT_MS = 1e4;
 /** How long the picker's plan-filter billing facts stay cached before refetching. */
 const BILLING_ACCESS_TTL_MS = 3e5;
+/**
+* How long a learned CLI-only protocol preference stays cached per account.
+* After this TTL a request may probe Provider API again, so an upgraded Go
+* account can recover without a restart.
+*/
+const PROTOCOL_CACHE_TTL_MS = 9e5;
 /** The entry-plan tier weight (`individual-go` in KNOWN_SUBSCRIPTION_PLANS). */
 const GO_TIER_WEIGHT = 0;
 /** Hard cap on account rotations within one request (one attempt per distinct key). */
@@ -6960,6 +6992,31 @@ function priceRequestImage(block, model, imageCapable) {
 	};
 }
 /**
+* Base64 payloads keyed by the cached request version itself.
+*
+* `readImageRequest()` returns one codec object per (attachment, encoder
+* target) and `requestImages()` reuses that same object for every occurrence in
+* one generation, but a history that carries an image also replays it in every
+* later message. Encoding per occurrence therefore re-base64s the same
+* multi-megabyte buffer once per replay — the single most expensive
+* per-occurrence step of an image request. Keying on the object makes an
+* occurrence a map hit, and the WeakMap ties the copy's lifetime to the
+* harness's own version cache rather than to this plugin.
+*/
+const encodedRequestImages = /* @__PURE__ */ new WeakMap();
+function encodedRequestImage(version) {
+	let encoded = encodedRequestImages.get(version);
+	if (encoded === void 0) {
+		const base64 = Buffer.from(version.data).toString("base64");
+		encoded = {
+			base64,
+			dataUrl: `data:${version.mediaType};base64,${base64}`
+		};
+		encodedRequestImages.set(version, encoded);
+	}
+	return encoded;
+}
+/**
 * Convert one image reference to the final `/alpha/generate` wire format.
 * The official CLI accepts a base64 source internally, then toWireMessages()
 * sends a data URL plus mimeType. Use the request version's media type because
@@ -6969,7 +7026,7 @@ async function imageToCommandCode(ref, readImage) {
 	const version = await readImage(ref);
 	return {
 		type: "image",
-		image: `data:${version.mediaType};base64,${Buffer.from(version.data).toString("base64")}`,
+		image: encodedRequestImage(version).dataUrl,
 		mimeType: version.mediaType
 	};
 }
@@ -7102,10 +7159,9 @@ async function messagesToCC(messages, readImage) {
 * `{ type: 'image_url', image_url: { url: 'data:...;base64,...' } }`.
 */
 async function imageToOpenAI(ref, readImage) {
-	const version = await readImage(ref);
 	return {
 		type: "image_url",
-		image_url: { url: `data:${version.mediaType};base64,${Buffer.from(version.data).toString("base64")}` }
+		image_url: { url: encodedRequestImage(await readImage(ref)).dataUrl }
 	};
 }
 /**
@@ -7172,7 +7228,7 @@ async function imageToMessages(ref, readImage) {
 		source: {
 			type: "base64",
 			media_type: version.mediaType,
-			data: Buffer.from(version.data).toString("base64")
+			data: encodedRequestImage(version).base64
 		}
 	};
 }
@@ -8174,7 +8230,7 @@ var CommandCodeAdapter = class CommandCodeAdapter extends LlmAdapter {
 	/** Cached protocol decision for a key, or undefined when expired/unknown. */
 	cachedProtocol(apiBase, apiKey) {
 		const hit = this.protocolCache.get(this.accountCacheKey(apiBase, apiKey));
-		if (hit === void 0 || Date.now() - hit.at >= 9e5) return void 0;
+		if (hit === void 0 || Date.now() - hit.at >= PROTOCOL_CACHE_TTL_MS) return void 0;
 		return hit.protocol;
 	}
 	rememberProtocol(apiBase, apiKey, protocol) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mars-sea/dsh-commandcode-provider",
-  "version": "0.14.1",
+  "version": "0.14.3",
   "description": "Unofficial DeepSeek Harness LLM provider plugin for Command Code, ported from pi-commandcode-provider (MIT). Registers the 'commandcode' provider route with a Models-page card and live model catalog.",
   "icon": "./icon.svg",
   "type": "module",
@@ -39,6 +39,7 @@
   },
   "files": [
     "lib",
+    "!lib/**/*.map",
     "assets",
     "icon.svg",
     "locale",