newmark-agent 0.5.14 → 0.6.0

package/dist/core/conversationListEvent.d.ts

@@ -0,0 +1,6 @@
+import type { Agent } from './agent';
+import type { AgentWorkEvent } from './types';
+import type { WorkspaceInfo } from './workspace';
+/** Directory changes are workspace metadata, never a turn or selection command. */
+export declare function conversationListEvent(agent: Pick<Agent, 'listWorkspaceConversationStates'>, workspace: WorkspaceInfo): AgentWorkEvent;
+//# sourceMappingURL=conversationListEvent.d.ts.map

package/dist/core/conversationListEvent.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conversationListEvent = conversationListEvent;
+const crypto_1 = require("crypto");
+/** Directory changes are workspace metadata, never a turn or selection command. */
+function conversationListEvent(agent, workspace) {
+    return {
+        id: (0, crypto_1.randomUUID)(), type: 'conversation_list', stateScope: 'workspace',
+        workspaceId: String(workspace.id || workspace.path), conversationId: '',
+        conversations: agent.listWorkspaceConversationStates(workspace),
+        content: '', mode: '', model: '', timestamp: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=conversationListEvent.js.map

package/dist/core/electronUtilityAgentClient.d.ts

@@ -92,7 +92,10 @@ export declare class ElectronUtilityAgentClient {
     start(): Promise<void>;
     private startNewChild;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(): Promise<UtilityAgentSnapshotResult>;
+    snapshot(options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;

package/dist/core/electronUtilityAgentClient.js

@@ -1010,9 +1010,9 @@ class ElectronUtilityAgentClient {
         await this.start();
         return await this.request('prompt', { ...params, target: this.checkedTarget(params.target) }, 0);
     }
-    async snapshot() {
+    async snapshot(options = {}) {
         await this.start();
-        return await this.requestTargetSnapshot();
+        return await this.requestTargetSnapshot(options);
     }
     async rewind(messageIndex) {
         await this.start();
@@ -1222,8 +1222,8 @@ class ElectronUtilityAgentClient {
         ]);
         return confirmed || this.child !== child;
     }
-    async requestTargetSnapshot() {
-        const snapshot = await this.request('snapshot', { target: this.target }, 15_000);
+    async requestTargetSnapshot(options = {}) {
+        const snapshot = await this.request('snapshot', { target: this.target, options }, 15_000);
         if (snapshot?.target?.runtimeKey !== this.target.runtimeKey) {
             throw new Error('Electron utility runtime snapshot target mismatch');
         }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -7,7 +7,10 @@ export interface ElectronTargetRuntimeClient {
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;
     setHostToolHandler(handler: UtilityHostToolHandler | null): void;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(): Promise<UtilityAgentSnapshotResult>;
+    snapshot(options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(runId?: string): Promise<UtilityAgentStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
@@ -69,7 +72,10 @@ export declare class ElectronUtilityRuntimePool {
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;
     setHostToolHandler(handler: UtilityHostToolHandler | null): void;
     prompt(params: UtilityPromptRequest): Promise<UtilityAgentPromptResult>;
-    snapshot(target: ConversationRuntimeTarget): Promise<UtilityAgentSnapshotResult>;
+    snapshot(target: ConversationRuntimeTarget, options?: {
+        window?: number;
+        before?: number;
+    }): Promise<UtilityAgentSnapshotResult>;
     rewind(target: ConversationRuntimeTarget, messageIndex: number): Promise<UtilityConversationRewindResult>;
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<ElectronPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;

package/dist/core/electronUtilityRuntimePool.js

@@ -50,14 +50,20 @@ class ElectronUtilityRuntimePool {
             this.release(entry, true);
         }
     }
-    async snapshot(target) {
+    async snapshot(target, options = {}) {
         const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         let scheduleIdle = false;
         try {
-            if (entry.stopIntent)
+            const customWindow = options.before != null || (options.window != null && options.window !== 200);
+            if (entry.stopIntent) {
+                if (customWindow)
+                    throw new Error('Earlier history is temporarily unavailable while this conversation is stopping. Retry after it stops.');
                 return this.supervisorSnapshot(entry);
-            const result = await entry.client.snapshot();
-            entry.lastSnapshot = result;
+            }
+            const result = await entry.client.snapshot(options);
+            // A fetched older page must not replace the latest supervisor snapshot.
+            if (!customWindow)
+                entry.lastSnapshot = result;
             if (result.runtime?.runId)
                 entry.lastRunId = result.runtime.runId;
             if (result.runtime?.generation)
@@ -185,7 +191,7 @@ class ElectronUtilityRuntimePool {
         }
     }
     async queueAction(target, action, input = {}) {
-        const entry = await this.acquireExisting(target);
+        const entry = await this.acquire((0, conversationTarget_1.normalizeConversationTarget)(target));
         if (!entry || !entry.client.queueAction)
             throw new Error('Target conversation is not running');
         try {

package/dist/core/installUpdate.js

@@ -601,11 +601,12 @@ function runMsiExec(args) {
 }
 function windowsCommandQuote(value) {
     const text = String(value);
-    return /\s/.test(text) ? `"${text.replace(/"/g, '\\"')}"` : text;
+    return `"${text.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/g, '$1$1')}"`;
 }
 function runElevatedMsiExec(args) {
     const argumentString = args.map(arg => windowsCommandQuote(arg)).join(' ');
     const script = [
+        '$ErrorActionPreference = "Stop"',
         `$argumentList = '${argumentString.replace(/'/g, "''")}'`,
         '$process = Start-Process -FilePath "msiexec.exe" -ArgumentList $argumentList -Verb RunAs -Wait -PassThru',
         'Write-Output ("EXITCODE:" + $process.ExitCode)',
@@ -614,7 +615,8 @@ function runElevatedMsiExec(args) {
     const stdout = String(result.stdout || '');
     const match = stdout.match(/EXITCODE:(\d+)/);
     return {
-        exitCode: match ? Number(match[1]) : (result.status === null ? -1 : result.status),
+        // A shell exit of 0 without the MSI completion marker is not installation.
+        exitCode: match ? Number(match[1]) : -1,
         stdout,
         stderr: String(result.stderr || ''),
     };
@@ -633,17 +635,39 @@ function uninstallNewmarkProduct(productCode, logPath) {
     };
 }
 function installMsiPackage(msiPath, options = {}) {
-    const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-install-${process.pid}-${Date.now()}.log`);
-    const args = ['/i', path.resolve(msiPath), '/qn', '/norestart', '/l*v', logPath];
-    let result = runMsiExec(args);
-    if (result.exitCode !== 0 && result.exitCode !== 3010 && options.allowElevate !== false)
-        result = runElevatedMsiExec(args);
-    const ok = result.exitCode === 0 || result.exitCode === 3010;
+    const logDir = path.resolve(options.logDir || os.tmpdir());
+    fs.mkdirSync(logDir, { recursive: true });
+    const evidence = fs.mkdtempSync(path.join(logDir, 'newmark-msi-install-'));
+    const logPath = path.join(evidence, 'result.json');
+    // The same verified workflow owns CLI, GUI, and developer installs. MSI major
+    // upgrades handle old ProductCodes; only an already-installed exact ProductCode
+    // uses REINSTALL=ALL + vamus. Fresh installs must select ADDLOCAL=ALL instead.
+    const helperCandidates = [
+        path.join(process.resourcesPath || path.dirname(process.execPath), 'installer', 'install-windows-msi.ps1'),
+        path.resolve(__dirname, '..', '..', 'scripts', 'install-windows-msi.ps1'),
+    ];
+    const helper = helperCandidates.find(candidate => fs.existsSync(candidate) && !candidate.includes(`${path.sep}app.asar${path.sep}`));
+    if (!helper)
+        return { ok: false, exitCode: -1, logPath, error: 'Verified MSI installer helper is missing from this application.' };
+    const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', helper,
+        '-MsiPath', path.resolve(msiPath), '-EvidenceDirectory', evidence];
+    if (options.allowElevate === false)
+        args.push('-NoElevate');
+    // Node passes argv directly; no Start-Process ArgumentList array re-parsing.
+    // Do not detach or impose a timeout which abandons an active MSI transaction.
+    const result = (0, child_process_1.spawnSync)('powershell.exe', args, { encoding: 'utf-8', windowsHide: true });
+    let completion = {};
+    try {
+        completion = JSON.parse(fs.readFileSync(logPath, 'utf-8').replace(/^\uFEFF/, ''));
+    }
+    catch { /* Missing evidence is failure. */ }
+    const ok = result.status === 0 && completion.Success === true;
+    const exitCode = ok ? (completion.Steps?.some(step => step.ExitCode === 3010) ? 3010 : 0) : (result.status || -1);
     return {
         ok,
-        exitCode: result.exitCode,
+        exitCode,
         logPath,
-        error: ok ? undefined : `msiexec install exited ${result.exitCode}`,
+        error: ok ? undefined : (completion.Error || result.error?.message || String(result.stderr || '').trim() || 'MSI installation has no verified completion receipt.'),
     };
 }
 function findLegacyNewmarkExecutables(excludeRoots = []) {
@@ -752,29 +776,17 @@ function executeManagedMsiInstall(msiPath, options = {}) {
         ? stopNewmarkProcesses(plan.runningProcesses.map(process => process.pid))
         : { stopped: [], errors: [] };
     const uninstalled = [];
-    if (options.uninstallPrevious !== false) {
-        for (const product of plan.installedProducts) {
-            const logPath = path.join(options.logDir || os.tmpdir(), `newmark-msi-uninstall-${product.productCode}-${process.pid}-${Date.now()}.log`);
-            const uninstallResult = uninstallNewmarkProduct(product.productCode, logPath);
-            if (!uninstallResult.ok) {
-                return {
-                    ok: false,
-                    plan,
-                    stopped: stopResult.stopped,
-                    uninstalled,
-                    removedLegacy: [],
-                    exitCode: uninstallResult.exitCode,
-                    logPath: uninstallResult.logPath,
-                    error: `Failed to uninstall previous Newmark version ${product.productCode}: ${uninstallResult.error}`,
-                };
-            }
-            uninstalled.push(product.productCode);
-        }
-    }
+    // AllowSameVersionUpgrades removes related old products within one MSI/UAC
+    // transaction. Pre-uninstalling here caused multiple prompts and a fresh
+    // product incorrectly sent through the old REINSTALL-only path.
     const removeResult = plan.legacyExecutables.length
         ? removeLegacyNewmarkExecutables(plan.legacyExecutables)
         : { removed: [], errors: [] };
     const installResult = installMsiPackage(plan.msiPath, { logDir: options.logDir, allowElevate: options.allowElevate });
+    if (installResult.ok) {
+        const remaining = new Set(listInstalledNewmarkProducts().map(product => product.productCode));
+        uninstalled.push(...plan.installedProducts.filter(product => !remaining.has(product.productCode)).map(product => product.productCode));
+    }
     return {
         ok: installResult.ok,
         plan,

package/dist/core/modelResponseHealth.d.ts

@@ -0,0 +1,17 @@
+import type { LLMProvider } from '../llm/provider';
+export type ResponseFacet = 'text' | 'vision' | 'tools';
+export type ModelResponseHealth = Partial<Record<ResponseFacet, {
+    ok: boolean;
+    at: string;
+}>>;
+export interface ResponseHealthIdentity {
+    providerId: string;
+    modelId: string;
+    endpoint: string;
+    protocol: string;
+    credential: string;
+}
+export declare function readModelResponseHealth(root: string, identity: ResponseHealthIdentity): ModelResponseHealth;
+export declare function recordModelResponseHealth(root: string, identity: ResponseHealthIdentity, updates: Partial<Record<ResponseFacet, boolean>>): void;
+export declare function observeModelResponses(provider: LLMProvider, record: (updates: Partial<Record<ResponseFacet, boolean>>) => void): LLMProvider;
+//# sourceMappingURL=modelResponseHealth.d.ts.map

package/dist/core/modelResponseHealth.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readModelResponseHealth = readModelResponseHealth;
+exports.recordModelResponseHealth = recordModelResponseHealth;
+exports.observeModelResponses = observeModelResponses;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const facets = ['text', 'vision', 'tools'];
+let lastReceiptStamp = 0;
+const cache = new Map();
+function directory(root, identity) {
+    const key = (0, crypto_1.createHash)('sha256').update(JSON.stringify(identity)).digest('hex');
+    return path.join(root, 'Runtime', 'model-response-health', key);
+}
+function records(dir) {
+    try {
+        return fs.readdirSync(dir).filter(name => /^\d{16}-[a-f0-9-]+\.json$/.test(name)).sort().reverse().flatMap(name => {
+            try {
+                return [{ name, health: JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8')) }];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function readModelResponseHealth(root, identity) {
+    const dir = directory(root, identity), saved = cache.get(dir);
+    let revision = -1;
+    try {
+        revision = fs.statSync(dir).mtimeMs;
+    }
+    catch { /* no observations yet */ }
+    if (saved && saved.until > Date.now() && saved.revision === revision)
+        return saved.health;
+    const health = {};
+    for (const record of records(dir))
+        for (const facet of facets) {
+            const entry = record.health[facet];
+            if (!health[facet] && entry && typeof entry.ok === 'boolean')
+                health[facet] = entry;
+        }
+    if (cache.size > 512)
+        cache.clear();
+    cache.set(dir, { until: Date.now() + 150, revision, health });
+    return health;
+}
+function recordModelResponseHealth(root, identity, updates) {
+    // Immutable, atomic receipts merge independently across GUI/utility/WSL
+    // workers. A text result never overwrites a vision/tool result. No secrets,
+    // request bodies or server error text enter the observation files.
+    const dir = directory(root, identity), now = Date.now(), health = {};
+    for (const facet of facets)
+        if (typeof updates[facet] === 'boolean')
+            health[facet] = { ok: updates[facet], at: new Date(now).toISOString() };
+    if (!Object.keys(health).length)
+        return;
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+        const latestStamp = Number(records(dir)[0]?.name.split('-')[0] || 0);
+        lastReceiptStamp = Math.max(now * 1000, lastReceiptStamp + 1, latestStamp + 1);
+        const file = path.join(dir, `${String(lastReceiptStamp).padStart(16, '0')}-${(0, crypto_1.randomUUID)()}.json`);
+        fs.writeFileSync(file + '.tmp', JSON.stringify(health));
+        fs.renameSync(file + '.tmp', file);
+        const counts = {};
+        for (const [index, record] of records(dir).entries()) {
+            let keep = index < 4;
+            for (const facet of facets)
+                if (record.health[facet]) {
+                    counts[facet] = (counts[facet] || 0) + 1;
+                    if (counts[facet] <= 2)
+                        keep = true;
+                }
+            if (!keep) {
+                try {
+                    fs.unlinkSync(path.join(dir, record.name));
+                }
+                catch { /* another writer may have pruned it */ }
+            }
+        }
+        cache.delete(dir);
+    }
+    catch { /* Diagnostic persistence must never break input or transport. */ }
+}
+function hasImage(value) {
+    if (Array.isArray(value))
+        return value.some(hasImage);
+    if (!value || typeof value !== 'object')
+        return false;
+    const entry = value;
+    return ['image_url', 'input_image', 'image'].includes(String(entry.type || '')) || hasImage(entry.content);
+}
+function failedFacet(error, images) {
+    const text = String(error).toLowerCase();
+    if (/image|vision|multimodal/.test(text) && images)
+        return 'vision';
+    if (/tools?\b|tool[_ -]?(call|choice|use)|function[_ -]?call/.test(text))
+        return 'tools';
+    return 'text';
+}
+function observeModelResponses(provider, record) {
+    const report = (updates) => { try {
+        record(updates);
+    }
+    catch { /* observation only */ } };
+    const chat = provider.chat.bind(provider);
+    provider.chat = async (...args) => {
+        const images = hasImage(args[1]);
+        try {
+            const response = await chat(...args);
+            if (response.trim())
+                report({ text: true, ...(images ? { vision: true } : {}) });
+            else
+                report({ text: false });
+            return response;
+        }
+        catch (error) {
+            if (!args[5]?.aborted && error?.name !== 'AbortError')
+                report({ [failedFacet(error, images)]: false });
+            throw error;
+        }
+    };
+    const stream = provider.chatStreamWithTools.bind(provider);
+    provider.chatStreamWithTools = async function* (...args) {
+        const images = hasImage(args[1]);
+        let meaningful = false, tools = false, failed = false;
+        try {
+            for await (const token of stream(...args)) {
+                if (token.providerError === true) {
+                    failed = true;
+                    report({ [failedFacet(token.text, images)]: false });
+                }
+                if (token.type === 'text' && token.text?.trim())
+                    meaningful = true;
+                if (token.type === 'tool_call') {
+                    meaningful = true;
+                    tools = true;
+                }
+                yield token;
+            }
+            if (!failed && !args[6]?.aborted) {
+                if (meaningful)
+                    report({ text: true, ...(images ? { vision: true } : {}), ...(tools || args[5].length ? { tools: true } : {}) });
+                else
+                    report({ text: false });
+            }
+        }
+        catch (error) {
+            if (!failed && !args[6]?.aborted && error?.name !== 'AbortError')
+                report({ [failedFacet(error, images)]: false });
+            throw error;
+        }
+    };
+    return provider;
+}
+//# sourceMappingURL=modelResponseHealth.js.map

package/dist/core/providerUsageAccounting.d.ts

@@ -0,0 +1,47 @@
+/** Measured provider counters. Missing values are tracked separately from zero. */
+export interface Counter {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+}
+export interface Reported {
+    input: boolean;
+    output: boolean;
+    cacheRead: boolean;
+    cacheWrite: boolean;
+}
+export type UsageInput = Partial<Counter> & {
+    reported?: Partial<Reported>;
+};
+/** JSON-persistable conversation coverage; totals remain owned by the caller. */
+export interface Accounting {
+    requests: number;
+    inputReportedRequests: number;
+    outputReportedRequests: number;
+    /** Requests with both input/cache read reported and cache read <= input. */
+    cacheReportedRequests: number;
+    cacheEligibleInputTokens: number;
+    cacheReadTokens: number;
+    hasLegacyTotals: boolean;
+    lastInputTokens: number | null;
+}
+/** Retain this handle for all cumulative usage events from one provider request. */
+export interface AccountingRequest {
+    usage: Counter;
+    reported: Reported;
+}
+export declare function createAccounting(legacyTotals?: Partial<Counter> | null): Accounting;
+export declare function beginAccountingRequest(accounting: Accounting): AccountingRequest;
+/**
+ * Provider stream usage is cumulative per request, including partial updates.
+ * Replacing each reported field contributes only its delta, including negative
+ * corrections. Unreported/invalid fields never erase a previous measurement.
+ */
+export declare function applyAccountingUsage(accounting: Accounting, totals: Counter, request: AccountingRequest, input: UsageInput): void;
+export declare function ratioSummary(accounting: Accounting): {
+    totalRatio: number | null;
+    knownRatio: number | null;
+    denominator: number;
+};
+//# sourceMappingURL=providerUsageAccounting.d.ts.map

package/dist/core/providerUsageAccounting.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAccounting = createAccounting;
+exports.beginAccountingRequest = beginAccountingRequest;
+exports.applyAccountingUsage = applyAccountingUsage;
+exports.ratioSummary = ratioSummary;
+const fields = ['input', 'output', 'cacheRead', 'cacheWrite'];
+function createAccounting(legacyTotals) {
+    return {
+        requests: 0,
+        inputReportedRequests: 0,
+        outputReportedRequests: 0,
+        cacheReportedRequests: 0,
+        cacheEligibleInputTokens: 0,
+        cacheReadTokens: 0,
+        // Old persisted zeros do not establish whether any cache fields were reported.
+        hasLegacyTotals: legacyTotals != null,
+        lastInputTokens: null,
+    };
+}
+function beginAccountingRequest(accounting) {
+    accounting.requests++;
+    return {
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        reported: { input: false, output: false, cacheRead: false, cacheWrite: false },
+    };
+}
+function validCachePair(request) {
+    return request.reported.input && request.reported.cacheRead
+        && request.usage.cacheRead <= request.usage.input;
+}
+/**
+ * Provider stream usage is cumulative per request, including partial updates.
+ * Replacing each reported field contributes only its delta, including negative
+ * corrections. Unreported/invalid fields never erase a previous measurement.
+ */
+function applyAccountingUsage(accounting, totals, request, input) {
+    const hadInput = request.reported.input;
+    const hadOutput = request.reported.output;
+    const hadPair = validCachePair(request);
+    const previousEligibleInput = hadPair ? request.usage.input : 0;
+    const previousEligibleCache = hadPair ? request.usage.cacheRead : 0;
+    for (const field of fields) {
+        const value = input[field];
+        // Older internal callers supply actual numeric fields without metadata.
+        // Once metadata exists, only its explicit true flags represent reporting.
+        const reported = input.reported === undefined || input.reported[field] === true;
+        if (!reported || typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+            continue;
+        totals[field] += value - request.usage[field];
+        request.usage[field] = value;
+        request.reported[field] = true;
+        if (field === 'input')
+            accounting.lastInputTokens = value;
+    }
+    accounting.inputReportedRequests += Number(request.reported.input) - Number(hadInput);
+    accounting.outputReportedRequests += Number(request.reported.output) - Number(hadOutput);
+    const hasPair = validCachePair(request);
+    accounting.cacheReportedRequests += Number(hasPair) - Number(hadPair);
+    accounting.cacheEligibleInputTokens += (hasPair ? request.usage.input : 0) - previousEligibleInput;
+    accounting.cacheReadTokens += (hasPair ? request.usage.cacheRead : 0) - previousEligibleCache;
+}
+function ratioSummary(accounting) {
+    const denominator = accounting.cacheEligibleInputTokens;
+    const knownRatio = denominator > 0 ? accounting.cacheReadTokens / denominator : null;
+    const complete = !accounting.hasLegacyTotals && accounting.requests > 0
+        && accounting.inputReportedRequests === accounting.requests
+        && accounting.cacheReportedRequests === accounting.requests;
+    return { totalRatio: complete ? knownRatio : null, knownRatio, denominator };
+}
+//# sourceMappingURL=providerUsageAccounting.js.map

package/dist/core/requestContextEstimate.d.ts

@@ -0,0 +1,18 @@
+/** A local estimate of the actual submitted prompt, never a billing/tokenizer claim. */
+export interface RequestContextEstimate {
+    requestId: string;
+    runId: string;
+    model: string;
+    at: string;
+    estimatedTokens: number;
+    longHistoryTokens: number;
+    buildBlockTokens: number;
+    systemPromptTokens: number;
+    toolSchemaTokens: number;
+    hasImages: boolean;
+    messageCount: number;
+    inputTokens?: number;
+    cacheReadTokens?: number;
+}
+export declare function estimateSubmittedContext(messages: Array<Record<string, unknown>>, systemPrompt: string, tools: unknown[], buildBlockStart: number): Omit<RequestContextEstimate, 'requestId' | 'runId' | 'model' | 'at'>;
+//# sourceMappingURL=requestContextEstimate.d.ts.map

package/dist/core/requestContextEstimate.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSubmittedContext = estimateSubmittedContext;
+function textTokens(text) {
+    const nonAscii = text.length - text.replace(/[\u0080-\uFFFF]/g, '').length;
+    return Math.ceil((text.length - nonAscii) / 4 + nonAscii);
+}
+function estimateSubmittedContext(messages, systemPrompt, tools, buildBlockStart) {
+    let longHistoryTokens = 0;
+    let buildBlockTokens = 0;
+    let hasImages = false;
+    const boundary = Math.max(0, Math.min(messages.length, buildBlockStart));
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        let content = '';
+        if (typeof message.content === 'string')
+            content = message.content;
+        else if (Array.isArray(message.content)) {
+            for (const item of message.content) {
+                if (!item || typeof item !== 'object')
+                    continue;
+                const part = item;
+                if (part.type === 'image_url' || part.type === 'image' || part.type === 'input_image') {
+                    // Image tokens depend on provider/model/resolution. Base64 size is
+                    // not token usage; expose incomplete local estimation explicitly.
+                    hasImages = true;
+                }
+                else if (typeof part.text === 'string')
+                    content += part.text;
+                else
+                    content += JSON.stringify(part);
+            }
+        }
+        else if (message.content)
+            content = JSON.stringify(message.content);
+        const calls = Array.isArray(message.tool_calls) ? JSON.stringify(message.tool_calls) : '';
+        const count = 6 + textTokens(content) + textTokens(calls)
+            + (calls ? Math.ceil(calls.length / 6) : 0)
+            + textTokens(String(message.name || '') + String(message.tool_call_id || ''));
+        if (index < boundary)
+            longHistoryTokens += count;
+        else
+            buildBlockTokens += count;
+    }
+    const systemPromptTokens = systemPrompt ? 6 + textTokens(systemPrompt) : 0;
+    const toolText = tools.length ? JSON.stringify(tools) : '';
+    const toolSchemaTokens = toolText ? textTokens(toolText) + Math.ceil(toolText.length / 6) : 0;
+    return {
+        estimatedTokens: longHistoryTokens + buildBlockTokens + systemPromptTokens + toolSchemaTokens,
+        longHistoryTokens, buildBlockTokens, systemPromptTokens, toolSchemaTokens,
+        hasImages, messageCount: messages.length,
+    };
+}
+//# sourceMappingURL=requestContextEstimate.js.map