@duckmind/dm-darwin-x64 0.34.0 → 0.34.2

package/extensions/dm-alps/src/features/bottom-input/status.ts

@@ -19,6 +19,14 @@ export type ContextUsage = {
 	percent?: number;
 };
 
+export type DuckmindCreditsSnapshot = {
+	usage: number | null;
+	remaining: number | null;
+	limit: number | null;
+	isFreeTier?: boolean | null;
+	fetchedAt?: number | null;
+};
+
 export type BottomInputStatusState = {
 	ctx: any;
 	footerData?: any;
@@ -51,6 +59,7 @@ export type BottomInputStatusRender = {
 };
 
 export const CONTEXT_BAR_WIDTH = 10;
+const CREDIT_BAR_WIDTH = 10;
 const CONTEXT_COLORS = {
 	normal: "#00afaf",
 	warning: "#febc38",
@@ -73,19 +82,26 @@ export function renderBottomInputStatus(input: BottomInputStatusState): BottomIn
 	const safeWidth = Math.max(1, Math.floor(input.width));
 	const enabled = input.beautifiedInputEnabled;
 	const extensionStatuses = getVisibleExtensionStatuses(input.footerData);
+	const usage = readContextUsageSnapshot(input.ctx, input.isStreaming, input.liveUsage, input.latestAssistantUsage);
+	const lastPromptStatusLines = renderLastPromptStatusLines(input, usage, safeWidth);
 	if (!enabled) {
 		return {
 			topLines: [],
 			secondaryLines: renderExtensionStatusLines(extensionStatuses, safeWidth, input.theme),
-			lastPromptLines: renderLastPromptLines(input.lastPrompt, safeWidth, input.theme),
+			lastPromptLines: [...lastPromptStatusLines, ...renderLastPromptLines(input.lastPrompt, safeWidth, input.theme)],
 			frameStatus: emptyFrameStatus(),
-			cacheKey: JSON.stringify({ width: safeWidth, enabled: false, lastPrompt: input.lastPrompt, extensionStatuses }),
+			cacheKey: JSON.stringify({
+				width: safeWidth,
+				enabled: false,
+				lastPrompt: input.lastPrompt,
+				extensionStatuses,
+				lastPromptStatusLines: lastPromptStatusLines.map(stripAnsi),
+			}),
 		};
 	}
 
 	const icons = input.icons ?? getBottomInputIcons();
 	const elapsedSeconds = Math.floor(Math.max(0, input.now - input.sessionStartTime) / 1000);
-	const usage = readContextUsageSnapshot(input.ctx, input.isStreaming, input.liveUsage, input.latestAssistantUsage);
 	const modelName = readModelName(input.ctx);
 	const thinking = readThinkingLevel(input.ctx) ?? input.currentThinkingLevel ?? readThinkingLevelFromSession(input.ctx);
 	const cacheKey = JSON.stringify({
@@ -97,13 +113,14 @@ export function renderBottomInputStatus(input: BottomInputStatusState): BottomIn
 		elapsedSeconds,
 		lastPrompt: input.lastPrompt,
 		extensionStatuses,
+		lastPromptStatusLines: lastPromptStatusLines.map(stripAnsi),
 		icons,
 	});
 
 	return {
 		topLines: [],
 		secondaryLines: renderExtensionStatusLines(extensionStatuses, safeWidth, input.theme),
-		lastPromptLines: renderLastPromptLines(input.lastPrompt, safeWidth, input.theme),
+		lastPromptLines: [...lastPromptStatusLines, ...renderLastPromptLines(input.lastPrompt, safeWidth, input.theme)],
 		frameStatus: renderFrameStatus({ ...input, width: safeWidth, icons }, modelName, thinking, usage),
 		cacheKey,
 	};
@@ -139,6 +156,16 @@ export function renderLastPromptLines(prompt: string, width: number, theme: Them
 	return [truncateToWidth(`${prefix}${safeFg(theme, "muted", value)}`, safeWidth, "…", false)];
 }
 
+export function renderLastPromptStatusLines(input: BottomInputStatusState, usage = readContextUsageSnapshot(input.ctx, input.isStreaming, input.liveUsage, input.latestAssistantUsage), width = input.width): string[] {
+	const safeWidth = Math.max(1, Math.floor(width));
+	if (!normalizePromptText(input.lastPrompt)) return [];
+	if (safeWidth < 10) return [];
+
+	const statusLine = renderContextCostLine(input, usage, safeWidth);
+	const creditsLine = renderDuckmindCreditsLine(input, safeWidth);
+	return [statusLine, creditsLine].filter((line): line is string => typeof line === "string" && visibleWidth(stripAnsi(line)) > 0);
+}
+
 export function getVisibleExtensionStatuses(footerData: any): string[] {
 	let statuses: unknown;
 	try {
@@ -236,6 +263,66 @@ function renderContextSegment(usage: ContextUsage | null): string | null {
 	return applyHexColor(CONTEXT_COLORS.normal, formatTokens(usage.tokens));
 }
 
+function renderContextCostLine(input: BottomInputStatusState, usage: ContextUsage | null, width: number): string {
+	const contextText = formatContextStatus(input.ctx, usage);
+	const costInfo = readModelCostInfo(input.ctx);
+	const costText = formatModelCostInline(costInfo);
+	const left = safeFg(input.theme, "muted", contextText);
+	const right = safeFg(input.theme, costInfo.color, costText, costInfo.color === "success" ? "accent" : "text");
+	return renderEdgeAlignedLine(left, right, width);
+}
+
+function renderDuckmindCreditsLine(input: BottomInputStatusState, width: number): string | null {
+	if (!isDuckmindProvider(input.ctx)) return null;
+	const credits = readDuckmindCredits(input.footerData);
+	if (!credits) return null;
+
+	const left = [
+		safeFg(input.theme, "muted", "Credits Remaining"),
+		renderCreditProgressBar(credits, input.theme),
+		safeFg(input.theme, "accent", formatCreditNumber(credits.remaining)),
+	].join(" ");
+	const right = `${safeFg(input.theme, "muted", "Credits Used")} ${safeFg(input.theme, "accent", formatCreditNumber(credits.usage))} ${safeFg(input.theme, "muted", "• Credit")}`;
+	return renderEdgeAlignedLine(left, right, width);
+}
+
+function formatContextStatus(ctx: any, usage: ContextUsage | null): string {
+	const tokens = usage?.tokens ?? 0;
+	const contextWindow = usage?.contextWindow ?? readModelContextWindow(ctx);
+	const mode = `(${readContextManagementMode(ctx)})`;
+	if (contextWindow > 0) {
+		const usagePercent = usage?.percent;
+		const percent = typeof usagePercent === "number" && Number.isFinite(usagePercent)
+			? usagePercent
+			: (tokens / contextWindow) * 100;
+		return `${Math.max(0, percent).toFixed(1)}%/${formatTokens(contextWindow)} ${mode}`;
+	}
+	return `${formatTokens(tokens)} ${mode}`;
+}
+
+function readContextManagementMode(ctx: any): string {
+	const candidates: unknown[] = [];
+	try {
+		candidates.push(ctx?.getAutoCompactionEnabled?.());
+	} catch {
+		// Ignore optional API probes; older runtimes do not expose this value.
+	}
+	try {
+		candidates.push(ctx?.autoCompactionEnabled, ctx?.autoCompactEnabled, ctx?.session?.autoCompactionEnabled, ctx?.session?.autoCompactEnabled);
+	} catch {
+		// Keep the display stable if the host shape changes.
+	}
+	for (const candidate of candidates) {
+		if (candidate === true) return "auto";
+		if (candidate === false) return "manual";
+		if (typeof candidate === "string") {
+			const normalized = candidate.trim().toLowerCase();
+			if (normalized === "auto" || normalized === "manual" || normalized === "off") return normalized;
+		}
+	}
+	return "auto";
+}
+
 function renderElapsedSegment(theme: ThemeLike, startedAt: number, now: number, icons: BottomInputIconSet): string | null {
 	const elapsed = Math.max(0, now - startedAt);
 	if (elapsed < 1000) return null;
@@ -349,6 +436,135 @@ function readModelName(ctx: any): string | null {
 	}
 }
 
+type ModelCostInfo = {
+	label: string;
+	color: "success" | "muted" | "warning" | "error";
+	inputPerMillion: number | null;
+	outputPerMillion: number | null;
+};
+
+function readModelCostInfo(ctx: any): ModelCostInfo {
+	let model: any;
+	try {
+		model = ctx?.model;
+	} catch {
+		model = null;
+	}
+	if (model?.id === "@preset/free") return classifyModelCost(0, 0);
+	const input = toFiniteNumber(model?.cost?.input);
+	const output = toFiniteNumber(model?.cost?.output);
+	return classifyModelCost(input, output);
+}
+
+function classifyModelCost(inputPerMillion: number | null, outputPerMillion: number | null): ModelCostInfo {
+	if (inputPerMillion === null || outputPerMillion === null) {
+		return { label: "Unknown Cost", color: "muted", inputPerMillion: null, outputPerMillion: null };
+	}
+	if (inputPerMillion === 0 && outputPerMillion === 0) {
+		return { label: "Free", color: "success", inputPerMillion, outputPerMillion };
+	}
+	if (inputPerMillion > 20 || outputPerMillion > 100) {
+		return { label: "Critical Cost", color: "error", inputPerMillion, outputPerMillion };
+	}
+	if (inputPerMillion > 10 || outputPerMillion > 30) {
+		return { label: "High Cost", color: "error", inputPerMillion, outputPerMillion };
+	}
+	if ((inputPerMillion >= 1 && inputPerMillion <= 10) || (outputPerMillion >= 5 && outputPerMillion <= 30)) {
+		return { label: "Moderate Cost", color: "warning", inputPerMillion, outputPerMillion };
+	}
+	if (inputPerMillion < 1 && outputPerMillion < 5) {
+		return { label: "Low Cost", color: "success", inputPerMillion, outputPerMillion };
+	}
+	return { label: "Unknown Cost", color: "muted", inputPerMillion, outputPerMillion };
+}
+
+function formatModelCostInline(info: ModelCostInfo): string {
+	return `${info.label} ${formatUsd(info.inputPerMillion)}/M in · ${formatUsd(info.outputPerMillion)}/M out`;
+}
+
+function formatUsd(value: number | null): string {
+	if (value === null) return "n/a";
+	if (value === 0) return "$0";
+	if (value >= 100) return `$${value.toFixed(0)}`;
+	if (value >= 10) return `$${value.toFixed(1).replace(/\.0$/, "")}`;
+	if (value >= 1) return `$${value.toFixed(2).replace(/0$/, "").replace(/\.$/, "")}`;
+	return `$${value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "")}`;
+}
+
+function readDuckmindCredits(footerData: any): DuckmindCreditsSnapshot | null {
+	let raw: unknown;
+	try {
+		raw = footerData?.getDuckmindCredits?.();
+	} catch {
+		return null;
+	}
+	if (!isRecord(raw)) return null;
+	const usage = toFiniteNumber(raw.usage);
+	const remaining = toFiniteNumber(raw.remaining);
+	const limit = toFiniteNumber(raw.limit);
+	if (usage === null && remaining === null && limit === null) return null;
+	return {
+		usage,
+		remaining,
+		limit,
+		isFreeTier: typeof raw.isFreeTier === "boolean" ? raw.isFreeTier : null,
+		fetchedAt: toFiniteNumber(raw.fetchedAt),
+	};
+}
+
+function renderCreditProgressBar(credits: DuckmindCreditsSnapshot, theme: ThemeLike): string {
+	const remaining = credits.remaining ?? 0;
+	const limit = credits.limit && credits.limit > 0 ? credits.limit : (remaining > 0 ? remaining : 0);
+	const percent = limit > 0 ? Math.max(0, Math.min(100, (remaining / limit) * 100)) : 0;
+	const filledCells = Math.round((percent / 100) * CREDIT_BAR_WIDTH);
+	const filled = "█".repeat(filledCells);
+	const empty = "░".repeat(Math.max(0, CREDIT_BAR_WIDTH - filledCells));
+	const color = percent <= 15 ? "error" : percent <= 35 ? "warning" : "success";
+	return `${safeFg(theme, "muted", "[")}${safeFg(theme, color, filled, "accent")}${safeFg(theme, "borderMuted", empty)}${safeFg(theme, "muted", "]")}`;
+}
+
+function isDuckmindProvider(ctx: any): boolean {
+	let values: unknown[] = [];
+	try {
+		const model = ctx?.model;
+		values = [
+			model?.provider,
+			model?.provider?.id,
+			model?.provider?.name,
+			model?.providerName,
+			model?.baseUrl,
+			model?.id,
+			ctx?.provider,
+			ctx?.provider?.id,
+			ctx?.provider?.name,
+			ctx?.provider?.baseUrl,
+		];
+	} catch {
+		return false;
+	}
+	return values.some((value) => typeof value === "string" && /duckmind|openrouter|@preset\//i.test(value));
+}
+
+function renderEdgeAlignedLine(left: string, right: string, width: number): string {
+	const safeWidth = Math.max(1, Math.floor(width));
+	if (safeWidth <= 1) return truncateToWidth(left || right, safeWidth, "…", false);
+	const minGap = 2;
+	let rightPart = right;
+	let leftPart = left;
+	const originalLeftWidth = visibleWidth(leftPart);
+	const originalRightWidth = visibleWidth(rightPart);
+	if (originalLeftWidth + minGap + originalRightWidth > safeWidth) {
+		const rightBudget = Math.max(0, Math.min(originalRightWidth, Math.floor(safeWidth * 0.55)));
+		rightPart = rightBudget > 0 ? truncateToWidth(rightPart, rightBudget, "…", false) : "";
+		const leftBudget = Math.max(0, safeWidth - visibleWidth(rightPart) - (rightPart ? minGap : 0));
+		leftPart = leftBudget > 0 ? truncateToWidth(leftPart, leftBudget, "…", false) : "";
+	}
+	if (!leftPart) return truncateToWidth(rightPart, safeWidth, "…", false);
+	if (!rightPart) return truncateToWidth(leftPart, safeWidth, "…", false);
+	const gap = Math.max(1, safeWidth - visibleWidth(leftPart) - visibleWidth(rightPart));
+	return truncateToWidth(`${leftPart}${" ".repeat(gap)}${rightPart}`, safeWidth, "…", false);
+}
+
 export function renderContextBar(percent: number, color = CONTEXT_COLORS.normal): string {
 	const clamped = Math.max(0, Math.min(100, percent));
 	const filledCells = Math.floor((clamped / 100) * CONTEXT_BAR_WIDTH);
@@ -382,6 +598,23 @@ function formatDuration(ms: number): string {
 	return `${seconds}s`;
 }
 
+function formatCreditNumber(value: number | null): string {
+	if (value === null || !Number.isFinite(value)) return "n/a";
+	const abs = Math.abs(value);
+	if (abs >= 1000) return value.toFixed(0);
+	if (abs >= 100) return value.toFixed(1).replace(/\.0$/, "");
+	return value.toFixed(2).replace(/0+$/, "").replace(/\.$/, "");
+}
+
+function toFiniteNumber(value: unknown): number | null {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+}
+
 function safeFg(theme: ThemeLike, token: string, text: string, fallback = "text"): string {
 	try {
 		return theme.fg(token, text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckmind/dm-darwin-x64",
-  "version": "0.34.0",
+  "version": "0.34.2",
   "description": "DuckMind (dm) binary payload for darwin x64",
   "license": "MIT",
   "os": [