@wardby/cli 0.6.0 → 0.8.0

package/dist/providers/coding-proxy/memory-ledger.js

@@ -5,10 +5,12 @@ function cloneSession(session) {
         allowedModels: [...session.allowedModels],
         deadlineAt: new Date(session.deadlineAt),
         budgetExhaustedAt: session.budgetExhaustedAt ? new Date(session.budgetExhaustedAt) : null,
+        budgetRefusal: session.budgetRefusal ? { ...session.budgetRefusal } : null,
         upstreamFailure: session.upstreamFailure ?? null,
         terms: session.terms
             ? { version: session.terms.version, entry: { ...session.terms.entry, efforts: [...session.terms.entry.efforts] } }
             : null,
+        mcpTools: session.mcpTools ? structuredClone(session.mcpTools) : null,
     };
 }
 function cloneRequest(request) {
@@ -20,24 +22,43 @@ function cloneRequest(request) {
 }
 /** Deterministic contract adapter. Sharing one instance simulates a proxy restart. */
 export class MemoryProxyLedger {
+    options;
     sessions = new Map();
     sessionByCapability = new Map();
+    sessionByMcpToken = new Map();
     requests = new Map();
     requestBySessionKey = new Map();
+    startedAt = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
     async createSession(input) {
         if ([...this.sessions.values()].some((session) => session.runId === input.runId)) {
             throw new Error("proxy_session_exists");
         }
         if (this.sessionByCapability.has(input.capabilityHash))
             throw new Error("proxy_capability_collision");
+        if (input.mcpTokenHash !== undefined && this.sessionByMcpToken.has(input.mcpTokenHash)) {
+            throw new Error("proxy_mcp_token_collision");
+        }
         const session = {
             ...input,
             allowedModels: [...input.allowedModels],
             status: "active",
             terms: input.terms ? normalizeProxyModelTerms(input.terms) : null,
+            mcpTools: input.mcpTools ? structuredClone(input.mcpTools) : null,
+            mcpTokenHash: input.mcpTokenHash ?? null,
+            mcpCallCount: 0,
         };
         this.sessions.set(session.id, session);
         this.sessionByCapability.set(session.capabilityHash, session.id);
+        if (session.mcpTokenHash !== null)
+            this.sessionByMcpToken.set(session.mcpTokenHash, session.id);
+    }
+    async findSessionByMcpTokenHash(mcpTokenHash) {
+        const id = this.sessionByMcpToken.get(mcpTokenHash);
+        const session = id ? this.sessions.get(id) : undefined;
+        return session ? cloneSession(session) : undefined;
     }
     async findSessionByCapabilityHash(capabilityHash) {
         const id = this.sessionByCapability.get(capabilityHash);
@@ -54,22 +75,47 @@ export class MemoryProxyLedger {
         const existingId = this.requestBySessionKey.get(lookupKey);
         if (existingId)
             return { outcome: "duplicate", request: cloneRequest(this.requests.get(existingId)) };
-        let committedOrHeld = 0;
+        let spent = 0;
+        let heldReserved = 0;
+        let heldUncertain = 0;
+        let done = 0;
         for (const request of this.requests.values()) {
             if (request.sessionId !== input.sessionId)
                 continue;
-            if (request.status === "completed")
-                committedOrHeld += request.actualCostUsd;
-            if (request.status === "reserved" || request.status === "uncertain")
-                committedOrHeld += request.reservationUsd;
+            // An uncertain request settled at an estimate counts at it; one without an estimate keeps its hold.
+            const settled = request.status === "completed" || (request.status === "uncertain" && request.costEstimated);
+            if (settled) {
+                spent += request.actualCostUsd;
+                done += 1;
+            }
+            else if (request.status === "reserved")
+                heldReserved += request.reservationUsd;
+            else if (request.status === "uncertain")
+                heldUncertain += request.reservationUsd;
         }
+        const committedOrHeld = spent + heldReserved + heldUncertain;
         if (committedOrHeld + input.reservationUsd >= session.budgetUsd) {
-            session.budgetExhaustedAt ??= new Date(input.now);
-            return { outcome: "budget_exhausted" };
+            const details = {
+                budgetUsd: session.budgetUsd,
+                spentUsd: spent,
+                heldReservedUsd: heldReserved,
+                heldUncertainUsd: heldUncertain,
+                refusedHoldUsd: input.reservationUsd,
+                ...(input.reservationBasis ? { refusedHoldBasis: input.reservationBasis } : {}),
+                ...(input.ceilingUsd !== undefined ? { refusedHoldCeilingUsd: input.ceilingUsd } : {}),
+                model: input.model,
+                turn: done + 1,
+            };
+            if (!session.budgetExhaustedAt) {
+                session.budgetExhaustedAt = new Date(input.now);
+                session.budgetRefusal = { source: "proxy", ...details };
+            }
+            return { outcome: "budget_exhausted", details };
         }
         const request = { ...input, pricing: { ...input.pricing }, status: "reserved" };
         this.requests.set(request.id, request);
         this.requestBySessionKey.set(lookupKey, request.id);
+        this.startedAt.set(request.id, new Date(input.now));
         return { outcome: "reserved", request: cloneRequest(request) };
     }
     async complete(requestId, usage, actualCostUsd, upstreamStatus) {
@@ -86,6 +132,7 @@ export class MemoryProxyLedger {
         request.actualCostUsd = actualCostUsd;
         request.usage = { ...usage };
         request.upstreamStatus = upstreamStatus;
+        request.costEstimated = false;
         return cloneRequest(request);
     }
     async release(requestId, upstreamStatus) {
@@ -95,12 +142,52 @@ export class MemoryProxyLedger {
         request.status = "released";
         request.upstreamStatus = upstreamStatus;
     }
-    async markUncertain(requestId, upstreamStatus) {
+    async markUncertain(requestId, upstreamStatus, estimate) {
         const request = this.requiredRequest(requestId);
         if (request.status !== "reserved")
             return;
         request.status = "uncertain";
         request.upstreamStatus = upstreamStatus;
+        if (estimate) {
+            request.actualCostUsd = estimate.costUsd;
+            request.usage = { ...estimate.usage };
+            request.costEstimated = true;
+        }
+    }
+    async settlementHints(sessionId, model) {
+        const outputs = [];
+        for (const request of this.requests.values()) {
+            if (request.sessionId !== sessionId || request.model !== model)
+                continue;
+            if (request.status !== "completed" || !request.usage)
+                continue;
+            outputs.push(request.usage.outputTokens);
+        }
+        outputs.sort((a, b) => a - b);
+        return {
+            // The lower middle for an even count, as Postgres's percentile_disc(0.5).
+            ...(outputs.length > 0 ? { medianOutputTokens: outputs[Math.ceil(outputs.length / 2) - 1] } : {}),
+        };
+    }
+    async previousReply(sessionId, conversationKey) {
+        let latest;
+        // Map iteration follows insertion order: the last match is the latest request.
+        for (const request of this.requests.values()) {
+            if (request.sessionId !== sessionId || request.conversationKey !== conversationKey)
+                continue;
+            if (request.status === "completed" || request.status === "uncertain")
+                latest = request;
+        }
+        if (!latest)
+            return null;
+        return {
+            model: latest.model,
+            status: latest.status,
+            costEstimated: latest.costEstimated === true,
+            ...(latest.usage ? { usage: { ...latest.usage } } : {}),
+            requestBytes: latest.requestBytes ?? null,
+            startedAt: this.startedAt.get(latest.id) ?? new Date(0),
+        };
     }
     async cancelSession(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -110,6 +197,10 @@ export class MemoryProxyLedger {
     async budgetExhausted(sessionId) {
         return Boolean(this.sessions.get(sessionId)?.budgetExhaustedAt);
     }
+    async budgetRefusal(sessionId) {
+        const refusal = this.sessions.get(sessionId)?.budgetRefusal;
+        return refusal ? { ...refusal } : null;
+    }
     async recordUpstreamFailure(sessionId, code) {
         const session = this.sessions.get(sessionId);
         if (session)

package/dist/providers/coding-proxy/metering.d.ts

@@ -17,9 +17,25 @@ export declare function safeUpstreamErrorCode(record: Record<string, unknown>):
 /** Accumulates Anthropic's split input/output usage until message_stop. */
 export declare class AnthropicSseUsageTracker {
     private startUsage?;
+    /** message_start's output count: a placeholder (usually 1), not a running count. */
+    private startOutputTokens?;
+    /** message_delta's running output count. */
     private outputTokens?;
     private stopped;
     consume(frame: string): TerminalUsage;
+    /**
+     * What a cut stream reported before its message_stop: start usage (input incl. cache reads), the
+     * output count message_delta reported, and message_start's output count as a floor only.
+     */
+    partial(): {
+        readUsage?: {
+            inputTokens: number;
+            cachedInputTokens: number;
+            cacheWriteTokens: number;
+        };
+        reportedOutputTokens?: number;
+        outputFloorTokens?: number;
+    };
 }
 /** The rates a request is billed at, tagged with their version. Picks only the price fields: a catalog entry's routing/shape fields stay out of the ledger. */
 export declare function pricingSnapshot(version: string, pricing: ModelPricing): PricingSnapshot;

package/dist/providers/coding-proxy/metering.js

@@ -134,6 +134,9 @@ function sseEvent(frame) {
 /** Accumulates Anthropic's split input/output usage until message_stop. */
 export class AnthropicSseUsageTracker {
     startUsage;
+    /** message_start's output count: a placeholder (usually 1), not a running count. */
+    startOutputTokens;
+    /** message_delta's running output count. */
     outputTokens;
     stopped = false;
     consume(frame) {
@@ -156,8 +159,9 @@ export class AnthropicSseUsageTracker {
                 tokenCount(record.cache_read_input_tokens ?? 0, "cache_read_input_tokens");
                 tokenCount(record.cache_creation_input_tokens ?? 0, "cache_creation_input_tokens");
                 this.startUsage = record;
-                if (record.output_tokens !== undefined)
-                    this.outputTokens = tokenCount(record.output_tokens, "output_tokens");
+                if (record.output_tokens !== undefined) {
+                    this.startOutputTokens = tokenCount(record.output_tokens, "output_tokens");
+                }
                 return { terminal: false };
             }
             case "message_delta": {
@@ -168,19 +172,38 @@ export class AnthropicSseUsageTracker {
                 return { terminal: false };
             }
             case "message_stop": {
-                if (this.stopped || !this.startUsage || this.outputTokens === undefined) {
+                const outputTokens = this.outputTokens ?? this.startOutputTokens;
+                if (this.stopped || !this.startUsage || outputTokens === undefined) {
                     return { terminal: true };
                 }
                 this.stopped = true;
                 return {
                     terminal: true,
-                    usage: parseAnthropicAuthoritativeUsage({ ...this.startUsage, output_tokens: this.outputTokens }),
+                    usage: parseAnthropicAuthoritativeUsage({ ...this.startUsage, output_tokens: outputTokens }),
                 };
             }
             default:
                 return { terminal: false };
         }
     }
+    /**
+     * What a cut stream reported before its message_stop: start usage (input incl. cache reads), the
+     * output count message_delta reported, and message_start's output count as a floor only.
+     */
+    partial() {
+        if (!this.startUsage)
+            return this.outputTokens === undefined ? {} : { reportedOutputTokens: this.outputTokens };
+        const cached = tokenCount(this.startUsage.cache_read_input_tokens ?? 0, "cache_read_input_tokens");
+        return {
+            readUsage: {
+                inputTokens: tokenCount(this.startUsage.input_tokens, "input_tokens") + cached,
+                cachedInputTokens: cached,
+                cacheWriteTokens: tokenCount(this.startUsage.cache_creation_input_tokens ?? 0, "cache_creation_input_tokens"),
+            },
+            ...(this.outputTokens !== undefined ? { reportedOutputTokens: this.outputTokens } : {}),
+            ...(this.startOutputTokens !== undefined ? { outputFloorTokens: this.startOutputTokens } : {}),
+        };
+    }
 }
 /** The rates a request is billed at, tagged with their version. Picks only the price fields: a catalog entry's routing/shape fields stay out of the ledger. */
 export function pricingSnapshot(version, pricing) {

package/dist/providers/coding-proxy/prisma-ledger.d.ts

@@ -1,5 +1,5 @@
 import type { PrismaClient } from "#prisma";
-import type { CreateProxySessionInput, ProxyLedger, ProxyRequest, ProxySession, ProxyUsage, ReserveProxyRequestInput, ReserveProxyRequestResult } from "./types.js";
+import type { CreateProxySessionInput, PreviousReply, ProxyLedger, ProxyRefusalRecord, ProxyRequest, ProxySession, ProxyUsage, ReserveProxyRequestInput, ReserveProxyRequestResult } from "./types.js";
 export type PrismaProxyLedgerDb = Pick<PrismaClient, "$transaction" | "$queryRaw" | "$executeRaw">;
 /** How long a ledger transaction waits for a pool connection (Prisma's
  *  default is 2 s). A model request fails outright when this runs out, so it
@@ -20,12 +20,26 @@ export declare class PrismaProxyLedger implements ProxyLedger {
     private transaction;
     createSession(input: CreateProxySessionInput): Promise<void>;
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
+    findSessionByMcpTokenHash(mcpTokenHash: string): Promise<ProxySession | undefined>;
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
     complete(requestId: string, usage: ProxyUsage, actualCostUsd: number, upstreamStatus: number): Promise<ProxyRequest>;
+    /**
+     * Recomputes the run's totals (Run) and this model's usage (RunModelUsage) from its settled
+     * requests: completed ones and uncertain ones settled at an estimate. Set, never incremented.
+     */
+    private recomputeRunTotals;
     release(requestId: string, upstreamStatus: number): Promise<void>;
-    markUncertain(requestId: string, upstreamStatus?: number): Promise<void>;
+    markUncertain(requestId: string, upstreamStatus?: number, estimate?: {
+        usage: ProxyUsage;
+        costUsd: number;
+    }): Promise<void>;
+    settlementHints(sessionId: string, model: string): Promise<{
+        medianOutputTokens?: number;
+    }>;
+    previousReply(sessionId: string, conversationKey: string): Promise<PreviousReply | null>;
     cancelSession(sessionId: string): Promise<void>;
     budgetExhausted(sessionId: string): Promise<boolean>;
+    budgetRefusal(sessionId: string): Promise<ProxyRefusalRecord | null>;
     recordUpstreamFailure(sessionId: string, code: string): Promise<void>;
     upstreamFailure(sessionId: string): Promise<string | null>;
     getRequest(requestId: string): Promise<ProxyRequest | null>;