@wardby/cli 0.6.0 → 0.8.0

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

@@ -35,8 +35,26 @@ function sessionFromRow(row) {
         budgetExhaustedAt: row.budgetExhaustedAt ?? null,
         upstreamFailure: row.upstreamFailure ?? null,
         terms: sessionTerms(row),
+        mcpTools: sessionMcpTools(row),
+        mcpTokenHash: row.mcpTokenHash ?? null,
+        mcpCallCount: Number(row.mcpCallCount ?? 0),
     };
 }
+/** The session's pinned MCP tools; null when it has none. Anything but a list of pins refuses the session. */
+function sessionMcpTools(row) {
+    const stored = row.mcpTools ?? null;
+    if (stored === null)
+        return null;
+    if (!Array.isArray(stored) ||
+        !stored.every((pin) => typeof pin === "object" &&
+            pin !== null &&
+            typeof pin.exposedName === "string" &&
+            typeof pin.toolName === "string" &&
+            typeof pin.serverId === "string")) {
+        throw new Error("invalid_proxy_session_mcp_tools");
+    }
+    return stored;
+}
 /**
  * The session's stored model terms. Null only when both columns are null (a session from before
  * the catalog, which prices from the shipped fallback); terms that are partly present or cannot be
@@ -72,6 +90,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 +104,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;
@@ -101,22 +127,32 @@ export class PrismaProxyLedger {
         await this.db.$executeRaw `
       INSERT INTO "CodingProxySession"
         ("id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt",
-         "budgetUsd", "status", "registryTokenHash", "pricingVersion", "catalogEntry", "createdAt", "updatedAt")
+         "budgetUsd", "status", "registryTokenHash", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash",
+         "createdAt", "updatedAt")
       VALUES
         (${input.id}, ${input.runId}, ${input.capabilityHash}, ${input.credentialRef}, ${input.protocol}, ${models}::jsonb,
          ${input.deadlineAt}, ${input.budgetUsd}, 'active', ${input.registryTokenHash},
          ${terms?.version ?? null}, ${terms ? JSON.stringify(terms.entry) : null}::jsonb,
+         ${input.mcpTools ? JSON.stringify(input.mcpTools) : null}::jsonb, ${input.mcpTokenHash ?? null},
          CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
     `;
     }
     async findSessionByCapabilityHash(capabilityHash) {
         const rows = await this.db.$queryRaw `
       SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status", "registryTokenHash",
-             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry"
+             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash", "mcpCallCount"
       FROM "CodingProxySession" WHERE "capabilityHash" = ${capabilityHash}
     `;
         return rows[0] ? sessionFromRow(rows[0]) : null;
     }
+    async findSessionByMcpTokenHash(mcpTokenHash) {
+        const rows = await this.db.$queryRaw `
+      SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status", "registryTokenHash",
+             "budgetExhaustedAt", "upstreamFailure", "pricingVersion", "catalogEntry", "mcpTools", "mcpTokenHash", "mcpCallCount"
+      FROM "CodingProxySession" WHERE "mcpTokenHash" = ${mcpTokenHash}
+    `;
+        return rows[0] ? sessionFromRow(rows[0]) : undefined;
+    }
     async reserve(input) {
         return this.transaction(async (tx) => {
             const sessions = await tx.$queryRaw `
@@ -132,28 +168,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 "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 "held"
+            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 +227,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 +253,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 +275,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 +349,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 +426,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,7 @@
 import type { ModelPricing } from "../llm/pricing-core.js";
-import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyModelTerms, ProxyProtocol } from "./types.js";
+import { capabilityHash } from "./capability-hash.js";
+import type { McpToolPin } from "../../core/mcp-tools.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;
@@ -43,6 +45,10 @@ export interface CreateCodingProxySession {
     budgetUsd: number;
     /** The run's catalog entry recorded at dispatch; the session then prices and shapes requests from it. */
     terms?: ProxyModelTerms;
+    /** The run's pinned MCP tools (no URLs or secrets); only with mcpTokenHash, and only when there is one. */
+    mcpTools?: McpToolPin[];
+    /** SHA-256 (base64url) of the run's MCP token; the control plane mints and delivers the token itself. */
+    mcpTokenHash?: string;
 }
 export interface CreatedCodingProxySession {
     id: string;
@@ -64,8 +70,13 @@ 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 { capabilityHash };
 export declare class CodingProxy {
     private readonly ledger;
     private readonly credentials;
@@ -76,11 +87,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 +109,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;
 }