@wardby/cli 0.5.3 → 0.7.0

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
@@ -22,10 +22,23 @@ export declare class PrismaProxyLedger implements ProxyLedger {
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
     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>;

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

@@ -72,6 +72,13 @@ function requestFromRow(row) {
             }
             : undefined,
         upstreamStatus: row.upstreamStatus ?? undefined,
+        costEstimated: row.costEstimated === true,
+        ...(row.requestBytes !== null ? { requestBytes: row.requestBytes } : {}),
+        ...(row.ceilingUsd !== null && row.ceilingUsd !== undefined ? { ceilingUsd: Number(row.ceilingUsd) } : {}),
+        ...(row.reservationBasis === "cached" || row.reservationBasis === "full"
+            ? { reservationBasis: row.reservationBasis }
+            : {}),
+        ...(row.conversationKey !== null ? { conversationKey: row.conversationKey } : {}),
     };
 }
 async function requestById(db, id) {
@@ -79,7 +86,8 @@ async function requestById(db, id) {
     SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
            "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
            "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
-           "reasoningTokens", "upstreamStatus"
+           "reasoningTokens", "upstreamStatus", "costEstimated",
+           "requestBytes", "ceilingUsd", "reservationBasis", "conversationKey"
     FROM "CodingProxyRequest" WHERE "id" = ${id}
   `;
     return rows[0] ? requestFromRow(rows[0]) : null;
@@ -132,28 +140,54 @@ export class PrismaProxyLedger {
           SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
                  "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
                  "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
-                 "reasoningTokens", "upstreamStatus"
+                 "reasoningTokens", "upstreamStatus", "costEstimated",
+                 "requestBytes", "ceilingUsd", "reservationBasis", "conversationKey"
           FROM "CodingProxyRequest"
           WHERE "sessionId" = ${input.sessionId} AND "requestKey" = ${input.requestKey}
         `;
             if (duplicate[0])
                 return { outcome: "duplicate", request: requestFromRow(duplicate[0]) };
             const totals = await tx.$queryRaw `
-          SELECT COALESCE(SUM(
-            CASE
+          SELECT
+            COALESCE(SUM(CASE
               WHEN "status" = 'completed' THEN "actualCostUsd"
-              WHEN "status" IN ('reserved', 'uncertain') THEN "reservationUsd"
+              WHEN "status" = 'uncertain' AND "costEstimated" THEN "actualCostUsd"
               ELSE 0
-            END
-          ), 0) AS "held"
+            END), 0) AS "spent",
+            COALESCE(SUM(CASE WHEN "status" = 'reserved' THEN "reservationUsd" ELSE 0 END), 0) AS "heldReserved",
+            COALESCE(SUM(CASE
+              WHEN "status" = 'uncertain' AND NOT "costEstimated" THEN "reservationUsd"
+              ELSE 0
+            END), 0) AS "heldUncertain",
+            COUNT(*) FILTER (
+              WHERE "status" = 'completed' OR ("status" = 'uncertain' AND "costEstimated")
+            ) AS "done"
           FROM "CodingProxyRequest" WHERE "sessionId" = ${input.sessionId}
         `;
-            if (Number(totals[0]?.held ?? 0) + input.reservationUsd >= Number(row.budgetUsd)) {
+            const spentUsd = Number(totals[0]?.spent ?? 0);
+            const heldReservedUsd = Number(totals[0]?.heldReserved ?? 0);
+            const heldUncertainUsd = Number(totals[0]?.heldUncertain ?? 0);
+            if (spentUsd + heldReservedUsd + heldUncertainUsd + input.reservationUsd >= Number(row.budgetUsd)) {
+                const details = {
+                    budgetUsd: Number(row.budgetUsd),
+                    spentUsd,
+                    heldReservedUsd,
+                    heldUncertainUsd,
+                    refusedHoldUsd: input.reservationUsd,
+                    ...(input.reservationBasis ? { refusedHoldBasis: input.reservationBasis } : {}),
+                    ...(input.ceilingUsd !== undefined ? { refusedHoldCeilingUsd: input.ceilingUsd } : {}),
+                    model: input.model,
+                    turn: Number(totals[0]?.done ?? 0) + 1,
+                };
+                // The numbers of the session's first refusal only; the control plane copies them into the
+                // run's budget event (this role has no access to that table).
+                const detailsJson = JSON.stringify({ source: "proxy", ...details });
                 await tx.$executeRaw `
-            UPDATE "CodingProxySession" SET "budgetExhaustedAt" = COALESCE("budgetExhaustedAt", ${input.now})
-            WHERE "id" = ${input.sessionId}
+            UPDATE "CodingProxySession"
+            SET "budgetExhaustedAt" = ${input.now}, "budgetRefusal" = ${detailsJson}::jsonb
+            WHERE "id" = ${input.sessionId} AND "budgetExhaustedAt" IS NULL
           `;
-                return { outcome: "budget_exhausted" };
+                return { outcome: "budget_exhausted", details };
             }
             const pricing = JSON.stringify({
                 encoding: input.pricing.encoding,
@@ -165,11 +199,13 @@ export class PrismaProxyLedger {
             await tx.$executeRaw `
           INSERT INTO "CodingProxyRequest"
             ("id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
-             "reservationUsd", "pricingVersion", "pricingSnapshot", "createdAt", "updatedAt")
+             "reservationUsd", "pricingVersion", "pricingSnapshot", "requestBytes", "ceilingUsd",
+             "reservationBasis", "conversationKey", "createdAt", "updatedAt")
           VALUES
             (${input.id}, ${input.sessionId}, ${input.requestKey}, ${input.requestFingerprint}, ${input.model},
              'reserved', ${input.reservationUsd}, ${input.pricing.version}, ${pricing}::jsonb,
-             CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+             ${input.requestBytes ?? null}, ${input.ceilingUsd ?? null}, ${input.reservationBasis ?? null},
+             ${input.conversationKey ?? null}, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
         `;
             const request = await requestById(tx, input.id);
             if (!request)
@@ -189,7 +225,8 @@ export class PrismaProxyLedger {
           SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
                  "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
                  "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
-                 "reasoningTokens", "upstreamStatus"
+                 "reasoningTokens", "upstreamStatus", "costEstimated",
+                 "requestBytes", "ceilingUsd", "reservationBasis", "conversationKey"
           FROM "CodingProxyRequest" WHERE "id" = ${requestId} FOR UPDATE
         `;
             const prior = locked[0] ? requestFromRow(locked[0]) : null;
@@ -210,63 +247,73 @@ export class PrismaProxyLedger {
               "inputTokens" = ${usage.inputTokens}, "outputTokens" = ${usage.outputTokens},
               "cachedInputTokens" = ${usage.cachedInputTokens}, "cacheWriteTokens" = ${usage.cacheWriteTokens},
               "reasoningTokens" = ${usage.reasoningTokens}, "upstreamStatus" = ${upstreamStatus},
+              "costEstimated" = false,
               "completedAt" = CURRENT_TIMESTAMP, "updatedAt" = CURRENT_TIMESTAMP
           WHERE "id" = ${requestId} AND "status" IN ('reserved', 'uncertain')
         `;
-            const [updatedRun] = await tx.$queryRaw `
-          UPDATE "Run" AS r
-          SET "tokensIn" = totals."tokensIn", "tokensOut" = totals."tokensOut", "costUsd" = totals."costUsd",
-              "turns" = totals."turns"
-          FROM (
-            SELECT s."runId", COALESCE(SUM(q."inputTokens"), 0)::integer AS "tokensIn",
-                   COALESCE(SUM(q."outputTokens"), 0)::integer AS "tokensOut",
-                   COALESCE(SUM(q."actualCostUsd"), 0) AS "costUsd",
-                   COUNT(*)::integer AS "turns"
-            FROM "CodingProxySession" s
-            JOIN "CodingProxyRequest" q ON q."sessionId" = s."id" AND q."status" = 'completed'
-            WHERE s."id" = ${prior.sessionId}
-            GROUP BY s."runId"
-          ) AS totals
-          WHERE r."id" = totals."runId"
-          RETURNING r."id"
-        `;
-            // Per-model usage (RunModelUsage), recomputed for this request's model and set, never incremented.
-            // Best effort inside a savepoint: Run totals and the ledger are the budget truth, so a failed
-            // write here (e.g. a role without the RunModelUsage grant) must never fail the completion.
-            await tx.$executeRaw `SAVEPOINT run_model_usage`;
-            try {
-                await tx.$executeRaw `
-            INSERT INTO "RunModelUsage"
-              ("runId", "model", "freshInputTokens", "cachedInputTokens", "cacheWriteTokens", "outputTokens", "costUsd")
-            SELECT s."runId", q."model",
-                   COALESCE(SUM(COALESCE(q."inputTokens", 0) - COALESCE(q."cachedInputTokens", 0)), 0)::integer,
-                   COALESCE(SUM(q."cachedInputTokens"), 0)::integer,
-                   COALESCE(SUM(q."cacheWriteTokens"), 0)::integer,
-                   COALESCE(SUM(q."outputTokens"), 0)::integer,
-                   COALESCE(SUM(q."actualCostUsd"), 0)
-            FROM "CodingProxySession" s
-            JOIN "CodingProxyRequest" q ON q."sessionId" = s."id" AND q."status" = 'completed'
-            WHERE s."id" = ${prior.sessionId} AND q."model" = ${prior.model}
-            GROUP BY s."runId", q."model"
-            ON CONFLICT ("runId", "model") DO UPDATE SET
-              "freshInputTokens" = EXCLUDED."freshInputTokens",
-              "cachedInputTokens" = EXCLUDED."cachedInputTokens",
-              "cacheWriteTokens" = EXCLUDED."cacheWriteTokens",
-              "outputTokens" = EXCLUDED."outputTokens",
-              "costUsd" = EXCLUDED."costUsd"
-          `;
-                await tx.$executeRaw `RELEASE SAVEPOINT run_model_usage`;
-            }
-            catch (err) {
-                await tx.$executeRaw `ROLLBACK TO SAVEPOINT run_model_usage`;
-                log.warn({ err, runId: updatedRun?.id, sessionId: prior.sessionId, model: prior.model }, "could not record the run's model usage");
-            }
+            await this.recomputeRunTotals(tx, prior.sessionId, prior.model);
             const request = await requestById(tx, requestId);
             if (!request)
                 throw new Error("proxy_completion_not_persisted");
             return request;
         });
     }
+    /**
+     * 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.
+     */
+    async recomputeRunTotals(tx, sessionId, model) {
+        const [updatedRun] = await tx.$queryRaw `
+        UPDATE "Run" AS r
+        SET "tokensIn" = totals."tokensIn", "tokensOut" = totals."tokensOut", "costUsd" = totals."costUsd",
+            "turns" = totals."turns"
+        FROM (
+          SELECT s."runId", COALESCE(SUM(q."inputTokens"), 0)::integer AS "tokensIn",
+                 COALESCE(SUM(q."outputTokens"), 0)::integer AS "tokensOut",
+                 COALESCE(SUM(q."actualCostUsd"), 0) AS "costUsd",
+                 COUNT(*)::integer AS "turns"
+          FROM "CodingProxySession" s
+          JOIN "CodingProxyRequest" q ON q."sessionId" = s."id"
+            AND (q."status" = 'completed' OR (q."status" = 'uncertain' AND q."costEstimated"))
+          WHERE s."id" = ${sessionId}
+          GROUP BY s."runId"
+        ) AS totals
+        WHERE r."id" = totals."runId"
+        RETURNING r."id"
+      `;
+        // Per-model usage (RunModelUsage), recomputed for this request's model and set, never incremented.
+        // Best effort inside a savepoint: Run totals and the ledger are the budget truth, so a failed
+        // write here (e.g. a role without the RunModelUsage grant) must never fail the completion.
+        await tx.$executeRaw `SAVEPOINT run_model_usage`;
+        try {
+            await tx.$executeRaw `
+          INSERT INTO "RunModelUsage"
+            ("runId", "model", "freshInputTokens", "cachedInputTokens", "cacheWriteTokens", "outputTokens", "costUsd")
+          SELECT s."runId", q."model",
+                 COALESCE(SUM(COALESCE(q."inputTokens", 0) - COALESCE(q."cachedInputTokens", 0)), 0)::integer,
+                 COALESCE(SUM(q."cachedInputTokens"), 0)::integer,
+                 COALESCE(SUM(q."cacheWriteTokens"), 0)::integer,
+                 COALESCE(SUM(q."outputTokens"), 0)::integer,
+                 COALESCE(SUM(q."actualCostUsd"), 0)
+          FROM "CodingProxySession" s
+          JOIN "CodingProxyRequest" q ON q."sessionId" = s."id"
+            AND (q."status" = 'completed' OR (q."status" = 'uncertain' AND q."costEstimated"))
+          WHERE s."id" = ${sessionId} AND q."model" = ${model}
+          GROUP BY s."runId", q."model"
+          ON CONFLICT ("runId", "model") DO UPDATE SET
+            "freshInputTokens" = EXCLUDED."freshInputTokens",
+            "cachedInputTokens" = EXCLUDED."cachedInputTokens",
+            "cacheWriteTokens" = EXCLUDED."cacheWriteTokens",
+            "outputTokens" = EXCLUDED."outputTokens",
+            "costUsd" = EXCLUDED."costUsd"
+        `;
+            await tx.$executeRaw `RELEASE SAVEPOINT run_model_usage`;
+        }
+        catch (err) {
+            await tx.$executeRaw `ROLLBACK TO SAVEPOINT run_model_usage`;
+            log.warn({ err, runId: updatedRun?.id, sessionId, model }, "could not record the run's model usage");
+        }
+    }
     async release(requestId, upstreamStatus) {
         await this.db.$executeRaw `
       UPDATE "CodingProxyRequest"
@@ -274,12 +321,70 @@ export class PrismaProxyLedger {
       WHERE "id" = ${requestId} AND "status" = 'reserved'
     `;
     }
-    async markUncertain(requestId, upstreamStatus) {
-        await this.db.$executeRaw `
-      UPDATE "CodingProxyRequest"
-      SET "status" = 'uncertain', "upstreamStatus" = ${upstreamStatus ?? null}, "updatedAt" = CURRENT_TIMESTAMP
-      WHERE "id" = ${requestId} AND "status" = 'reserved'
+    async markUncertain(requestId, upstreamStatus, estimate) {
+        await this.transaction(async (tx) => {
+            const initial = await requestById(tx, requestId);
+            if (!initial)
+                return;
+            await tx.$queryRaw `
+          SELECT "id" FROM "CodingProxySession" WHERE "id" = ${initial.sessionId} FOR UPDATE
+        `;
+            const updated = await tx.$executeRaw `
+          UPDATE "CodingProxyRequest"
+          SET "status" = 'uncertain', "upstreamStatus" = ${upstreamStatus ?? null},
+              "actualCostUsd" = ${estimate?.costUsd ?? null},
+              "inputTokens" = ${estimate?.usage.inputTokens ?? null}, "outputTokens" = ${estimate?.usage.outputTokens ?? null},
+              "cachedInputTokens" = ${estimate?.usage.cachedInputTokens ?? null},
+              "cacheWriteTokens" = ${estimate?.usage.cacheWriteTokens ?? null},
+              "reasoningTokens" = ${estimate ? 0 : null},
+              "costEstimated" = ${estimate !== undefined}, "updatedAt" = CURRENT_TIMESTAMP
+          WHERE "id" = ${requestId} AND "status" = 'reserved'
+        `;
+            if (estimate && updated > 0)
+                await this.recomputeRunTotals(tx, initial.sessionId, initial.model);
+        });
+    }
+    async settlementHints(sessionId, model) {
+        const median = await this.db.$queryRaw `
+      SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY "outputTokens") AS "median"
+      FROM "CodingProxyRequest"
+      WHERE "sessionId" = ${sessionId} AND "model" = ${model} AND "status" = 'completed'
+        AND "outputTokens" IS NOT NULL
     `;
+        const medianOutputTokens = median[0]?.median ?? null;
+        return {
+            ...(medianOutputTokens !== null ? { medianOutputTokens: Number(medianOutputTokens) } : {}),
+        };
+    }
+    async previousReply(sessionId, conversationKey) {
+        const rows = await this.db.$queryRaw `
+      SELECT "model", "status", "costEstimated", "inputTokens", "outputTokens", "cachedInputTokens",
+             "cacheWriteTokens", "reasoningTokens", "requestBytes", "createdAt"
+      FROM "CodingProxyRequest"
+      WHERE "sessionId" = ${sessionId} AND "conversationKey" = ${conversationKey}
+        AND "status" IN ('completed', 'uncertain')
+      ORDER BY "createdAt" DESC LIMIT 1
+    `;
+        const row = rows[0];
+        if (!row)
+            return null;
+        const usage = row.inputTokens !== null && row.outputTokens !== null
+            ? {
+                inputTokens: row.inputTokens,
+                outputTokens: row.outputTokens,
+                cachedInputTokens: row.cachedInputTokens ?? 0,
+                cacheWriteTokens: row.cacheWriteTokens ?? 0,
+                reasoningTokens: row.reasoningTokens ?? 0,
+            }
+            : undefined;
+        return {
+            model: row.model,
+            status: row.status,
+            costEstimated: row.costEstimated === true,
+            ...(usage ? { usage } : {}),
+            requestBytes: row.requestBytes,
+            startedAt: row.createdAt,
+        };
     }
     async cancelSession(sessionId) {
         await this.db.$executeRaw `
@@ -293,6 +398,13 @@ export class PrismaProxyLedger {
     `;
         return rows.length > 0;
     }
+    async budgetRefusal(sessionId) {
+        const rows = await this.db.$queryRaw `
+      SELECT "budgetRefusal" FROM "CodingProxySession" WHERE "id" = ${sessionId}
+    `;
+        const value = rows[0]?.budgetRefusal;
+        return value && typeof value === "object" ? value : null;
+    }
     async recordUpstreamFailure(sessionId, code) {
         await this.db.$executeRaw `
       UPDATE "CodingProxySession" SET "upstreamFailure" = ${code}, "updatedAt" = CURRENT_TIMESTAMP

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

@@ -1,5 +1,5 @@
 import type { ModelPricing } from "../llm/pricing-core.js";
-import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyModelTerms, ProxyProtocol } from "./types.js";
+import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyModelTerms, ProxyProtocol, ProxyRefusalRecord } from "./types.js";
 export declare const PROXY_MAX_BODY_BYTES: number;
 export declare const PROXY_MAX_OUTPUT_TOKENS = 1000000;
 export declare const PROXY_DEFAULT_MAX_OUTPUT_TOKENS = 4096;
@@ -64,6 +64,11 @@ export interface CodingProxyOptions {
     audit?: ProxyAuditSink;
     pricing?: (model: string, protocol: ProxyProtocol) => ModelPricing;
     pricingVersion?: string;
+    /**
+     * Called with the run's id on every authenticated model request, before it is forwarded (the
+     * dependency cache's seal, ModelRequestSeal). Awaited; a failure is ignored, never the request's.
+     */
+    onModelRequest?: (runId: string) => Promise<void>;
 }
 export declare function capabilityHash(capability: string): string;
 export declare class CodingProxy {
@@ -76,11 +81,14 @@ export declare class CodingProxy {
     private readonly getPricing;
     private readonly priceVersion;
     private readonly activeRequests;
+    private readonly onModelRequest?;
     constructor(options: CodingProxyOptions);
     createSession(input: CreateCodingProxySession): Promise<CreatedCodingProxySession>;
     cancelSession(sessionId: string): Promise<void>;
     /** Whether this session's run was refused a model request for budget. */
     budgetExhausted(sessionId: string): Promise<boolean>;
+    /** The numbers behind this session's first budget refusal, if any. */
+    budgetRefusal(sessionId: string): Promise<ProxyRefusalRecord | null>;
     /** The code of the first upstream failure relayed for this session's run, if any. */
     upstreamFailure(sessionId: string): Promise<string | null>;
     execute(input: ExecuteProxyRequest, sink: ProxyResponseSink): Promise<void>;
@@ -95,4 +103,9 @@ export declare class CodingProxy {
     /** Best effort: the executor reads it to name the failure; it must never break the relay. */
     private recordUpstreamFailure;
     private markUncertain;
+    /**
+     * The best known cost of a request that broke before its final usage (interrupted.ts), or
+     * undefined when none can be made: the request then keeps its full hold. Never throws.
+     */
+    private estimateInterrupted;
 }