termux-dev 1.8.1 → 1.9.0

package/dist/cli/usage-panel.js

@@ -128,10 +128,23 @@ function buildRows(d, iw, detail) {
     const note = costNote(s);
     if (note && detail === 'full')
         line('  ' + palette.faint(truncateWidth(note, iw - 2)));
+    if (s.restoredCost && detail === 'full') {
+        line('  ' + palette.faint(truncateWidth(`Includes ${formatMoney(s.restoredCost, { estimated: s.costState.estimated })} from before this chat was resumed; the lines below count only since devx started.`, iw - 2)));
+    }
     const tokens = iw >= 40 ? `${fmtTokens(s.promptTokens)} in · ${fmtTokens(s.completionTokens)} out` : `${fmtTokens(s.promptTokens)}/${fmtTokens(s.completionTokens)}`;
     pair('Tokens', palette.text(tokens));
-    if (s.cacheReadTokens > 0 && detail !== 'min')
-        pair('Cached input', palette.text(fmtTokens(s.cacheReadTokens)));
+    if (detail !== 'min') {
+        // What the money was paid for. Every request resends the whole conversation, so the input
+        // is usually the biggest part, and the cache is what makes it cheaper.
+        const money = (v) => s.costParts && v !== undefined && iw >= 40 ? palette.faint('  ' + formatMoney(v, { estimated: s.costState.estimated })) : '';
+        const paid = (label, tokens, v) => pair(label, palette.text(fmtTokens(tokens)) + money(v));
+        paid('  Input', s.uncachedTokens, s.costParts?.input);
+        if (s.cacheReadTokens > 0)
+            paid('  Cached input', s.cacheReadTokens, s.costParts?.cacheRead);
+        if (s.cacheWriteTokens > 0)
+            paid('  Cache writes', s.cacheWriteTokens, s.costParts?.cacheWrite);
+        paid('  Output', s.completionTokens, s.costParts?.output);
+    }
     pair('Requests', palette.text(String(s.requestsCount)));
     // ── traffic
     if (detail === 'full') {
@@ -221,7 +234,7 @@ export function runUsagePanel(data, options = {}) {
                 return;
             closed = true;
             input.off('data', onData);
-            output.off?.('resize', draw);
+            stopWatching();
             block.erase();
             if (!wasRaw)
                 input.setRawMode?.(false);
@@ -236,7 +249,7 @@ export function runUsagePanel(data, options = {}) {
             }
         };
         input.on('data', onData);
-        output.on?.('resize', draw);
+        const stopWatching = block.watchResize(draw);
         draw();
     });
 }

package/dist/cli/width.js

@@ -176,3 +176,21 @@ export function wrapText(text, width) {
     const unbreakable = text.split(/\s+/).some((word) => displayWidth(word) > width);
     return unbreakable ? wrapWidth(text, width) : wrapWords(text, width);
 }
+/**
+ * How many rows up the top of a block is from the cursor, once the terminal is `cols` wide.
+ *
+ * A block drawn at one width is re-wrapped by the terminal when the window is resized: a line that
+ * was as wide as the old window now takes several rows, so counting the lines of the block is not
+ * enough to get back to its top (the top stays on screen and the block shows up twice).
+ *
+ * @param lineWidths visible width of each line of the block as it was drawn
+ * @param cursorRow  the line the cursor is on
+ * @param cursorCol  the column of the cursor in that line
+ */
+export function rowsToTop(lineWidths, cursorRow, cursorCol, cols) {
+    const width = Math.max(1, cols);
+    let rows = 0;
+    for (let i = 0; i < cursorRow && i < lineWidths.length; i++)
+        rows += Math.max(1, Math.ceil(lineWidths[i] / width));
+    return rows + Math.floor(Math.max(0, cursorCol) / width);
+}

package/dist/core/background.js

@@ -0,0 +1,390 @@
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { StringDecoder } from 'string_decoder';
+export const MAX_BACKGROUND_TASKS = 8;
+/** What is kept of the output of one task; older text is dropped. */
+export const MAX_BUFFER = 200_000;
+/** The most a single read gives back to the model. */
+export const MAX_READ_CHARS = 8000;
+const MAX_NOTES_PER_TASK = 12;
+const NOTE_TAIL_CHARS = 1500;
+const MATCH_DEBOUNCE_MS = 400;
+/** Strips colour codes and carriage-return redraws so the model reads text, not terminal noise. */
+export function cleanOutput(text) {
+    return text
+        .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+        .replace(/[^\n]*\r(?!\n)/g, '')
+        .replace(/\r/g, '');
+}
+function compileRegex(source) {
+    if (!source)
+        return undefined;
+    try {
+        return new RegExp(source, 'i');
+    }
+    catch {
+        throw new Error(`Invalid regular expression: ${source}`);
+    }
+}
+export function formatDuration(ms) {
+    const s = Math.max(0, Math.round(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+    return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+}
+export class BackgroundManager extends EventEmitter {
+    tasks = new Map();
+    counter = 0;
+    notes = [];
+    // ───────────────────────── starting and stopping ─────────────────────────
+    start(command, options = {}) {
+        if (!command || !command.trim())
+            throw new Error('command is required');
+        if (this.running().length >= MAX_BACKGROUND_TASKS) {
+            throw new Error(`Too many background tasks running (${MAX_BACKGROUND_TASKS}). Stop one first (action "stop").`);
+        }
+        const watch = compileRegex(options.notifyOn);
+        this.installExitHook();
+        const isWin = process.platform === 'win32';
+        const cwd = options.cwd || process.cwd();
+        const proc = spawn(command, { shell: true, cwd, detached: !isWin, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        const id = `bg${++this.counter}`;
+        const info = {
+            id,
+            label: (options.label || command).replace(/\s+/g, ' ').trim().slice(0, 60),
+            command,
+            cwd,
+            pid: proc.pid,
+            status: 'running',
+            code: null,
+            startedAt: Date.now(),
+            outputChars: 0,
+            watching: options.notifyOn || undefined,
+        };
+        let finish;
+        const done = new Promise((resolve) => { finish = resolve; });
+        const task = {
+            info, proc, buffer: '', trimmed: 0, readCursor: 0, scanFrom: 0, pendingLine: '', watch,
+            notes: 0, matchedLines: [], stopRequested: false, timedOut: false, done,
+        };
+        this.tasks.set(id, task);
+        const decoders = { out: new StringDecoder('utf8'), err: new StringDecoder('utf8') };
+        proc.stdout.on('data', (d) => this.append(task, decoders.out.write(d)));
+        proc.stderr.on('data', (d) => this.append(task, decoders.err.write(d)));
+        let ended = false;
+        const end = (status, code) => {
+            if (ended)
+                return;
+            ended = true;
+            this.append(task, decoders.out.end() + decoders.err.end());
+            this.flushPendingLine(task);
+            clearTimeout(task.killTimer);
+            clearTimeout(task.runtimeTimer);
+            info.status = task.stopRequested ? 'stopped' : status;
+            info.code = code;
+            info.endedAt = Date.now();
+            this.flushMatches(task);
+            // A task the model stopped itself needs no note; anything else does.
+            if (!task.stopRequested || task.timedOut)
+                this.addNote(task, 'exit', this.exitNote(task));
+            this.emit('change', this.snapshot(task));
+            finish();
+        };
+        proc.on('error', () => end('failed', null));
+        proc.on('close', (code) => end(code === 0 ? 'exited' : 'failed', code));
+        // A child that got away can keep the pipes open for good: do not wait for them for long.
+        proc.on('exit', (code) => {
+            setTimeout(() => {
+                proc.stdout?.destroy();
+                proc.stderr?.destroy();
+                end(code === 0 ? 'exited' : 'failed', code);
+            }, 400).unref();
+        });
+        if (options.maxRuntimeSeconds && options.maxRuntimeSeconds > 0) {
+            task.runtimeTimer = setTimeout(() => { task.timedOut = true; void this.stop(id); }, options.maxRuntimeSeconds * 1000);
+            task.runtimeTimer.unref();
+        }
+        this.emit('change', this.snapshot(task));
+        return this.snapshot(task);
+    }
+    /** Stops a task (SIGTERM, then SIGKILL after a second). Resolves when it is gone. */
+    async stop(id) {
+        const task = this.must(id);
+        if (task.info.status !== 'running')
+            return this.snapshot(task);
+        task.stopRequested = true;
+        this.killTree(task, false);
+        task.killTimer = setTimeout(() => this.killTree(task, true), 1000);
+        task.killTimer.unref();
+        await Promise.race([task.done, new Promise((r) => setTimeout(r, 2500).unref())]);
+        return this.snapshot(task);
+    }
+    async stopAll() {
+        const running = this.running();
+        await Promise.all(running.map((t) => this.stop(t.id).catch(() => null)));
+        return running.length;
+    }
+    /** Forgets finished tasks (their output is gone with them). */
+    clearFinished() {
+        let n = 0;
+        for (const [id, task] of this.tasks) {
+            if (task.info.status !== 'running') {
+                this.tasks.delete(id);
+                n++;
+            }
+        }
+        if (n)
+            this.emit('change');
+        return n;
+    }
+    // ───────────────────────── looking at tasks ─────────────────────────
+    list() {
+        return [...this.tasks.values()].map((t) => this.snapshot(t));
+    }
+    running() {
+        return this.list().filter((t) => t.status === 'running');
+    }
+    get(id) {
+        const task = this.tasks.get(id);
+        return task ? this.snapshot(task) : undefined;
+    }
+    /** The output of a task as text for the model or the screen. */
+    read(id, options = {}) {
+        const task = this.must(id);
+        const grep = compileRegex(options.grep);
+        let from;
+        if (options.mode === 'tail')
+            from = task.trimmed;
+        else
+            from = Math.max(task.readCursor, task.trimmed);
+        let text = task.buffer.slice(from - task.trimmed);
+        if (options.mode !== 'tail')
+            task.readCursor = task.trimmed + task.buffer.length;
+        let lines = cleanOutput(text).split('\n');
+        if (lines.length && lines[lines.length - 1] === '')
+            lines.pop();
+        if (grep)
+            lines = lines.filter((l) => grep.test(l));
+        const want = Math.max(1, Math.min(Math.floor(options.lines ?? (options.mode === 'tail' ? 40 : 200)), 1000));
+        let omitted = 0;
+        if (lines.length > want) {
+            omitted = lines.length - want;
+            lines = lines.slice(-want);
+        }
+        text = lines.join('\n');
+        if (text.length > MAX_READ_CHARS) {
+            omitted += text.slice(0, text.length - MAX_READ_CHARS).split('\n').length - 1;
+            text = text.slice(-MAX_READ_CHARS).replace(/^[^\n]*\n/, '');
+        }
+        return { text, omitted };
+    }
+    /**
+     * Waits until the task ends, a line matches `pattern`, the time is up or the turn is cancelled.
+     * Lines the model has already read do not count; lines it has not read yet do.
+     */
+    wait(id, options = {}) {
+        const task = this.must(id);
+        const pattern = compileRegex(options.pattern);
+        const timeoutMs = Math.min(Math.max(options.timeoutSeconds ?? 60, 1), 600) * 1000;
+        return new Promise((resolve) => {
+            let timer;
+            // Output nobody has read yet counts: a line that came while the model was busy elsewhere is not lost.
+            let scan = Math.max(task.readCursor, task.trimmed);
+            const finish = (result) => {
+                clearTimeout(timer);
+                options.signal?.removeEventListener('abort', onAbort);
+                this.removeListener(`data:${id}`, onData);
+                resolve(result);
+            };
+            const onAbort = () => finish({ reason: 'aborted' });
+            const onClose = () => finish({ reason: 'exit' });
+            void task.done.then(onClose);
+            const onData = () => {
+                if (!pattern)
+                    return;
+                const start = Math.max(scan, task.trimmed);
+                const chunk = cleanOutput(task.buffer.slice(start - task.trimmed));
+                const lastNl = chunk.lastIndexOf('\n');
+                if (lastNl < 0)
+                    return;
+                scan = start + lastNl + 1;
+                const hit = chunk.slice(0, lastNl).split('\n').find((l) => pattern.test(l));
+                if (hit !== undefined)
+                    finish({ reason: 'match', line: hit.trim() });
+            };
+            if (task.info.status !== 'running')
+                return resolve({ reason: 'exit' });
+            if (options.signal?.aborted)
+                return resolve({ reason: 'aborted' });
+            timer = setTimeout(() => finish({ reason: 'timeout' }), timeoutMs);
+            options.signal?.addEventListener('abort', onAbort, { once: true });
+            this.on(`data:${id}`, onData);
+            onData();
+        });
+    }
+    // ───────────────────────── notes for the model ─────────────────────────
+    hasNotes() {
+        return this.notes.length > 0;
+    }
+    /** The notes since the last call, as one message for the model (or '' when there are none). */
+    takeNotes() {
+        if (this.notes.length === 0)
+            return '';
+        const text = this.notes.map((n) => n.text).join('\n\n');
+        this.notes = [];
+        // What the prompt frame shows about unreported news is gone now: let it redraw.
+        this.emit('change');
+        return `[devx · background tasks]\n${text}`;
+    }
+    /**
+     * Tasks that ended badly and whose news the model has not received yet. The prompt frame shows
+     * this number: it goes away once devx has told the model about the failure.
+     */
+    unreportedFailures() {
+        const ids = new Set();
+        for (const note of this.notes) {
+            if (note.kind === 'exit' && this.tasks.get(note.taskId)?.info.status === 'failed')
+                ids.add(note.taskId);
+        }
+        return ids.size;
+    }
+    // ───────────────────────── internals ─────────────────────────
+    must(id) {
+        const task = this.tasks.get(String(id));
+        if (!task) {
+            const known = [...this.tasks.keys()].join(', ');
+            throw new Error(`No background task "${id}"${known ? ` (known: ${known})` : ' (none started)'}`);
+        }
+        return task;
+    }
+    snapshot(task) {
+        return { ...task.info, outputChars: task.trimmed + task.buffer.length };
+    }
+    append(task, text) {
+        if (!text)
+            return;
+        task.buffer += text;
+        if (task.buffer.length > MAX_BUFFER * 1.5) {
+            const cut = task.buffer.length - MAX_BUFFER;
+            task.buffer = task.buffer.slice(cut);
+            task.trimmed += cut;
+        }
+        if (task.watch)
+            this.scanLines(task, text);
+        this.emit(`data:${task.info.id}`);
+        this.emit('output', task.info.id);
+    }
+    scanLines(task, text) {
+        const parts = cleanOutput(task.pendingLine + text).split('\n');
+        task.pendingLine = parts.pop() ?? '';
+        for (const line of parts) {
+            if (task.watch.test(line))
+                this.matched(task, line);
+        }
+    }
+    flushPendingLine(task) {
+        if (task.watch && task.pendingLine && task.watch.test(task.pendingLine))
+            this.matched(task, task.pendingLine);
+        task.pendingLine = '';
+    }
+    matched(task, line) {
+        task.matchedLines.push(line.trim().slice(0, 300));
+        if (task.matchedLines.length > 20)
+            task.matchedLines.shift();
+        clearTimeout(task.matchTimer);
+        task.matchTimer = setTimeout(() => this.flushMatches(task), MATCH_DEBOUNCE_MS);
+        task.matchTimer.unref();
+    }
+    flushMatches(task) {
+        clearTimeout(task.matchTimer);
+        if (task.matchedLines.length === 0)
+            return;
+        const lines = task.matchedLines.splice(0);
+        const shown = lines.slice(-5).map((l) => `  ${l}`).join('\n');
+        this.addNote(task, 'match', {
+            summary: `${task.info.id} · ${lines[lines.length - 1]}`,
+            text: `${task.info.id} "${task.info.label}" printed ${lines.length} line${lines.length === 1 ? '' : 's'} matching /${task.info.watching}/:\n${shown}`,
+        });
+    }
+    exitNote(task) {
+        const { id, label, code, startedAt, endedAt } = task.info;
+        const how = task.timedOut ? 'was stopped: its time limit ran out' : code === 0 ? 'finished (exit code 0)' : code === null ? 'stopped unexpectedly' : `failed (exit code ${code})`;
+        const after = formatDuration((endedAt ?? Date.now()) - startedAt);
+        const tail = this.tailForNote(task);
+        return {
+            summary: `${id} ${code === 0 ? 'finished' : code === null ? 'stopped' : `failed · exit ${code}`} · ${after}`,
+            text: `${id} "${label}" ${how} after ${after}.${tail ? `\nLast output:\n${tail}` : ''}`,
+        };
+    }
+    tailForNote(task) {
+        const text = cleanOutput(task.buffer).trimEnd();
+        return text.length > NOTE_TAIL_CHARS ? '…' + text.slice(-NOTE_TAIL_CHARS).replace(/^[^\n]*\n/, '') : text;
+    }
+    addNote(task, kind, body) {
+        task.notes++;
+        // A chatty watcher must not flood the conversation: after a dozen notes only the end is reported.
+        if (kind === 'match' && task.notes > MAX_NOTES_PER_TASK)
+            return;
+        const note = { taskId: task.info.id, kind, ...body };
+        this.notes.push(note);
+        this.emit('note', note);
+    }
+    killTree(task, force) {
+        const pid = task.proc.pid;
+        if (!pid || task.info.status !== 'running')
+            return;
+        if (process.platform === 'win32') {
+            const killer = spawn('taskkill', ['/pid', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+            killer.on('error', () => task.proc.kill());
+            return;
+        }
+        try {
+            process.kill(-pid, force ? 'SIGKILL' : 'SIGTERM');
+        }
+        catch (err) {
+            if (err.code !== 'ESRCH') {
+                try {
+                    task.proc.kill(force ? 'SIGKILL' : 'SIGTERM');
+                }
+                catch { }
+            }
+        }
+    }
+    /** Nothing started by devx may outlive it. */
+    installExitHook() {
+        liveManagers.add(this);
+        if (exitHookInstalled)
+            return;
+        exitHookInstalled = true;
+        process.on('exit', () => {
+            for (const manager of liveManagers)
+                manager.killAllNow();
+        });
+    }
+    /** Synchronous: used when the process is exiting. */
+    killAllNow() {
+        for (const task of this.tasks.values()) {
+            if (task.info.status === 'running')
+                this.killTree(task, true);
+        }
+    }
+}
+const liveManagers = new Set();
+let exitHookInstalled = false;
+let instance = null;
+export function getBackgroundManager() {
+    if (!instance) {
+        instance = new BackgroundManager();
+        instance.setMaxListeners(50);
+    }
+    return instance;
+}
+/** For tests: a fresh manager. */
+export function resetBackgroundManager() {
+    void instance?.stopAll();
+    instance = null;
+}

package/dist/core/config-merge.js

@@ -0,0 +1,67 @@
+/**
+ * Saving the user's config when several devx processes run at once.
+ *
+ * Every process keeps its own copy of ~/.devxrc.json in memory. Writing that copy back whole would
+ * let the process that saves last overwrite what the others changed meanwhile (theme, API keys,
+ * "Always" permissions, the default model...). So a save writes only what THIS process changed
+ * since it last looked at the file (`base` -> `mine`) on top of what is on disk now (`disk`).
+ */
+const isPlain = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+function isPrimitiveList(v) {
+    return Array.isArray(v) && v.every((x) => x === null || ['string', 'number', 'boolean'].includes(typeof x));
+}
+/** Structural equality for JSON-like values. */
+export function sameValue(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameValue(x, b[i]));
+    if (isPlain(a) && isPlain(b)) {
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+        for (const k of keys)
+            if (!sameValue(a[k], b[k]))
+                return false;
+        return true;
+    }
+    return false;
+}
+/** A deep copy that is safe to keep as a baseline. */
+export function cloneConfig(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+/**
+ * `disk` with the changes that `base` -> `mine` made applied to it.
+ *  - a value that did not change is left as it is on disk (another process may have changed it);
+ *  - objects (apiKeys, trustedProjects...) are merged key by key;
+ *  - lists of plain values (the bash allowlist) get what this process added and lose what it removed.
+ */
+export function mergeConfigChanges(base, mine, disk) {
+    const result = { ...disk };
+    const keys = new Set([...Object.keys(base), ...Object.keys(mine)]);
+    for (const key of keys) {
+        const b = base[key];
+        const m = mine[key];
+        if (sameValue(b, m))
+            continue;
+        if (m === undefined) {
+            delete result[key];
+        }
+        else if (isPlain(m) && (b === undefined || isPlain(b)) && (disk[key] === undefined || isPlain(disk[key]))) {
+            result[key] = mergeConfigChanges(isPlain(b) ? b : {}, m, isPlain(disk[key]) ? disk[key] : {});
+        }
+        else if (isPrimitiveList(m) && (b === undefined || isPrimitiveList(b)) && (disk[key] === undefined || isPrimitiveList(disk[key]))) {
+            const old = b ?? [];
+            const now = m;
+            const added = now.filter((x) => !old.includes(x));
+            const removed = old.filter((x) => !now.includes(x));
+            // Emptying a list ("/permissions clear") really empties it.
+            result[key] = m.length === 0
+                ? []
+                : [...new Set([...(disk[key] ?? []).filter((x) => !removed.includes(x)), ...added])];
+        }
+        else {
+            result[key] = m;
+        }
+    }
+    return result;
+}

package/dist/core/context-stats.js

@@ -23,6 +23,7 @@ export function contextBreakdown(messages, definitions, limit) {
         user, assistant, toolResults,
         images, imageCount,
         total,
+        inUse: messages.some((m) => m.role !== 'system') ? total : 0,
         compactAt: Math.floor(limit * CONTEXT_USAGE_RATIO),
         free: Math.max(0, limit - total),
     };

package/dist/core/cost.js

@@ -12,8 +12,8 @@
  */
 const PER_MILLION = 1_000_000;
 const finite = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0;
-/** The cost of the tokens at the given rates. */
-export function computeCost(rates, usage) {
+/** The cost of the tokens at the given rates, split by what was paid for. */
+export function costParts(rates, usage) {
     const prompt = Math.max(0, usage.promptTokens || 0);
     const tier = rates.tier && prompt > rates.tier.over ? rates.tier : null;
     const input = tier?.input ?? rates.input;
@@ -23,17 +23,31 @@ export function computeCost(rates, usage) {
     const read = Math.min(prompt, Math.max(0, usage.cacheReadTokens || 0));
     const written = Math.min(prompt - read, Math.max(0, usage.cacheWriteTokens || 0));
     const plain = prompt - read - written;
-    // Without a cache price the cached tokens cost as much as ordinary input.
-    let cost = plain * input + read * (cacheRead ?? input) + written * (cacheWrite ?? input);
     const completion = Math.max(0, usage.completionTokens || 0);
     const reasoning = Math.min(completion, Math.max(0, usage.reasoningTokens || 0));
-    if (rates.reasoning !== undefined && reasoning > 0) {
-        cost += (completion - reasoning) * output + reasoning * rates.reasoning;
-    }
-    else {
-        cost += completion * output;
-    }
-    return cost / PER_MILLION;
+    const out = rates.reasoning !== undefined && reasoning > 0
+        ? (completion - reasoning) * output + reasoning * rates.reasoning
+        : completion * output;
+    // Without a cache price the cached tokens cost as much as ordinary input.
+    return {
+        input: (plain * input) / PER_MILLION,
+        cacheRead: (read * (cacheRead ?? input)) / PER_MILLION,
+        cacheWrite: (written * (cacheWrite ?? input)) / PER_MILLION,
+        output: out / PER_MILLION,
+    };
+}
+/** The cost of the tokens at the given rates. */
+export function computeCost(rates, usage) {
+    const p = costParts(rates, usage);
+    return p.input + p.cacheRead + p.cacheWrite + p.output;
+}
+/** The same parts scaled so that they add up to `total` (the cost the provider reported). */
+export function scaleParts(parts, total) {
+    const sum = parts.input + parts.cacheRead + parts.cacheWrite + parts.output;
+    if (!(sum > 0) || !Number.isFinite(total))
+        return undefined;
+    const k = total / sum;
+    return { input: parts.input * k, cacheRead: parts.cacheRead * k, cacheWrite: parts.cacheWrite * k, output: parts.output * k };
 }
 /** A price as the OpenRouter list writes it: USD per token, often a string. */
 function perToken(value) {