@wardby/cli 0.6.0 → 0.8.0

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

@@ -0,0 +1,86 @@
+/**
+ * A model request's hold: what the proxy reserves against the run's budget before forwarding it.
+ * After a mostly cached reply in the same conversation, the part of the prompt the previous reply
+ * read from (or wrote to) the cache is priced at the cache-read rate; everything else, including
+ * what the body grew by (one token per byte), at the input + cache-write rates. Capped at the
+ * ceiling, today's worst case (the whole body as uncached input), which a reply may never exceed.
+ */
+import { createHash } from "node:crypto";
+import { estimateReservationUsd } from "./metering.js";
+/**
+ * Anthropic's prompt cache lives 5 minutes from when a request is processed, not from when its reply
+ * finishes: a previous request sent longer ago than this says nothing about the cache.
+ */
+export const CACHE_WINDOW_MS = 5 * 60_000;
+export const MIN_CACHED_SHARE = 0.5;
+function withoutCacheControl(value) {
+    if (Array.isArray(value))
+        return value.map(withoutCacheControl);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== "cache_control")
+        .map(([key, inner]) => [key, withoutCacheControl(inner)]));
+}
+/**
+ * What identifies one conversation within a run (Claude Code runs several: the main one and its
+ * sub-agents). Anthropic: the first message without cache markers (the system prompt carries a
+ * per-version billing line). OpenAI: prompt_cache_key, else instructions + the first input item.
+ */
+export function conversationKey(protocol, body) {
+    let basis;
+    if (protocol === "anthropic-messages") {
+        const messages = body.messages;
+        if (!Array.isArray(messages) || messages.length === 0)
+            return null;
+        // Claude Code's first message can carry the date, so a conversation crossing midnight starts a
+        // new key (its next request falls back to the worst case once).
+        basis = ["anthropic", withoutCacheControl(messages[0])];
+    }
+    else if (typeof body.prompt_cache_key === "string" && body.prompt_cache_key) {
+        basis = ["openai-key", body.prompt_cache_key];
+    }
+    else {
+        const input = body.input;
+        const first = typeof input === "string" ? input : Array.isArray(input) ? input[0] : undefined;
+        if (first === undefined)
+            return null;
+        basis = ["openai-first", body.instructions ?? null, first];
+    }
+    return createHash("sha256").update(JSON.stringify(basis)).digest("base64url");
+}
+export function estimateHold(input) {
+    const ceilingUsd = estimateReservationUsd(input.bodyBytes, input.maxOutputTokens, input.pricing);
+    const full = (fallback) => ({ holdUsd: ceilingUsd, ceilingUsd, basis: "full", fallback });
+    const previous = input.previous;
+    if (!previous)
+        return full("no_previous");
+    if (previous.model !== input.model)
+        return full("model_changed");
+    if (previous.costEstimated)
+        return full("previous_estimated");
+    if (previous.status !== "completed" || !previous.usage)
+        return full("previous_not_completed");
+    if (previous.requestBytes === null)
+        return full("no_request_bytes");
+    if (input.now.getTime() - previous.startedAt.getTime() > CACHE_WINDOW_MS)
+        return full("cache_expired");
+    if (input.bodyBytes < previous.requestBytes)
+        return full("body_shrank");
+    const usage = previous.usage;
+    const prevPrompt = usage.inputTokens + usage.cacheWriteTokens;
+    const cachedTokens = input.protocol === "anthropic-messages"
+        ? usage.cachedInputTokens + usage.cacheWriteTokens
+        : usage.cachedInputTokens;
+    if (prevPrompt <= 0 || cachedTokens < prevPrompt * MIN_CACHED_SHARE)
+        return full("low_cache_share");
+    const uncachedTokens = prevPrompt + (input.bodyBytes - previous.requestBytes) - cachedTokens;
+    const { pricing } = input;
+    const cacheReadRate = pricing.cachedInputPerMTok ?? pricing.inputPerMTok;
+    const cacheWriteRate = pricing.cacheWritePerMTok ?? pricing.inputPerMTok;
+    const holdUsd = (cachedTokens * cacheReadRate +
+        uncachedTokens * (pricing.inputPerMTok + cacheWriteRate) +
+        input.maxOutputTokens * pricing.outputPerMTok) /
+        1_000_000;
+    return { holdUsd: Math.min(holdUsd, ceilingUsd), ceilingUsd, basis: "cached", cachedTokens, uncachedTokens };
+}

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

@@ -0,0 +1,70 @@
+import { type ModelPricing } from "../llm/pricing-core.js";
+import type { PreviousReply, ProxyUsage } from "./types.js";
+export interface InterruptedFacts {
+    /** Anthropic message_start usage already read (inputTokens includes cache reads, not writes). */
+    readUsage?: {
+        inputTokens: number;
+        cachedInputTokens: number;
+        cacheWriteTokens: number;
+    };
+    /** Output tokens the upstream reported so far (Anthropic message_delta), if any. */
+    reportedOutputTokens?: number;
+    /** message_start's output count: a placeholder (usually 1), so only a floor, never the count. */
+    outputFloorTokens?: number;
+    /** A stream that failed before its response started: the provider generated no output. */
+    beforeResponse?: boolean;
+    /** UTF-8 bytes of output relayed to the client before the break: text, tool input, thinking. */
+    relayedOutputBytes: number;
+    /** The input of the request's own prompt, from its conversation's previous reply (previousInput). */
+    previous?: ProxyUsage;
+    /** UTF-8 bytes of the request body the proxy forwarded, when known. */
+    bodyBytes?: number;
+    /** Median outputTokens of the session's completed replies for the same model, if any. */
+    medianOutputTokens?: number;
+    /** The request's hold and the output tokens it reserved for. */
+    reservationUsd: number;
+    maxOutputTokens: number;
+    /** The request's worst case (its ceiling); the estimate never exceeds it. Defaults to the hold. */
+    ceilingUsd?: number;
+}
+export interface InterruptedEstimate {
+    usage: ProxyUsage;
+    costUsd: number;
+}
+/** Output tokens for relayed text: ceil(bytes / 3), a deliberately high count. */
+export declare function relayedOutputTokens(bytes: number): number;
+/**
+ * Prompt tokens for request-body bytes in a settled estimate: ceil(bytes / 3), the same high count
+ * as the native gateway's byte estimate. Coding-agent bodies are mostly code, JSON and English,
+ * which tokenize at about 3.5 to 4.5 bytes a token, so a token per 3 bytes stays above the real
+ * count. Text that tokenizes tighter is mostly multi-byte UTF-8 (3 bytes a character, rarely more
+ * than a token each), and base64 images are billed by size, not bytes, so both still lean high.
+ * The hold itself still counts a token per byte (hold.ts): this is only the settled estimate.
+ */
+export declare function bodyInputTokens(bytes: number): number;
+/**
+ * The input of a cut request from its conversation's previous reply: that reply's prompt and cache
+ * split, plus the body's growth since (bodyInputTokens) as uncached input (uncachedInput).
+ * Undefined when that reply can't stand for this prompt, as for the hold (hold.ts): another model,
+ * estimated or unfinished, an unknown or larger body, or a cache that had expired by the time the
+ * request was reserved. The estimate then prices the whole body as uncached input.
+ */
+export declare function previousInput(input: {
+    model: string;
+    bodyBytes: number | undefined;
+    previous: PreviousReply | null;
+    pricing: ModelPricing;
+    /** When the request was reserved: the hold's own clock. */
+    now: Date;
+}): ProxyUsage | undefined;
+/**
+ * The best known cost of a reply that broke before its final usage (spec PR 1
+ * › 1b): usage already read, else the input from its conversation's previous
+ * reply (previousInput), else the whole body as uncached input
+ * (bodyInputTokens), else (body size unknown) the input part of the hold; plus
+ * the output seen so far. With no output seen, the model's median completed
+ * reply, or none while there is no completed reply (a deliberate rule: one cut
+ * must not book a whole reserved reply). A stream that failed before its
+ * response started generated none. Never more than the request's worst case.
+ */
+export declare function estimateInterrupted(facts: InterruptedFacts, pricing: ModelPricing): InterruptedEstimate;

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

@@ -0,0 +1,104 @@
+import { computeCost } from "../llm/pricing-core.js";
+import { CACHE_WINDOW_MS } from "./hold.js";
+/** Output tokens for relayed text: ceil(bytes / 3), a deliberately high count. */
+export function relayedOutputTokens(bytes) {
+    return bytes > 0 ? Math.ceil(bytes / 3) : 0;
+}
+/**
+ * Prompt tokens for request-body bytes in a settled estimate: ceil(bytes / 3), the same high count
+ * as the native gateway's byte estimate. Coding-agent bodies are mostly code, JSON and English,
+ * which tokenize at about 3.5 to 4.5 bytes a token, so a token per 3 bytes stays above the real
+ * count. Text that tokenizes tighter is mostly multi-byte UTF-8 (3 bytes a character, rarely more
+ * than a token each), and base64 images are billed by size, not bytes, so both still lean high.
+ * The hold itself still counts a token per byte (hold.ts): this is only the settled estimate.
+ */
+export function bodyInputTokens(bytes) {
+    return bytes > 0 ? Math.ceil(bytes / 3) : 0;
+}
+/**
+ * New prompt tokens as usage, at the higher of the model's fresh-input and cache-write rates: the
+ * provider may write them to its cache (Claude Code marks the latest message; OpenAI GPT-5.6 and
+ * later bill cache writes above input), or bill them as input.
+ */
+function uncachedInput(tokens, pricing) {
+    const written = (pricing.cacheWritePerMTok ?? pricing.inputPerMTok) > pricing.inputPerMTok;
+    return { inputTokens: written ? 0 : tokens, cacheWriteTokens: written ? tokens : 0 };
+}
+/**
+ * The input of a cut request from its conversation's previous reply: that reply's prompt and cache
+ * split, plus the body's growth since (bodyInputTokens) as uncached input (uncachedInput).
+ * Undefined when that reply can't stand for this prompt, as for the hold (hold.ts): another model,
+ * estimated or unfinished, an unknown or larger body, or a cache that had expired by the time the
+ * request was reserved. The estimate then prices the whole body as uncached input.
+ */
+export function previousInput(input) {
+    const { previous, bodyBytes } = input;
+    if (!previous || previous.model !== input.model || previous.costEstimated)
+        return undefined;
+    if (previous.status !== "completed" || !previous.usage)
+        return undefined;
+    if (bodyBytes === undefined || previous.requestBytes === null || bodyBytes < previous.requestBytes)
+        return undefined;
+    if (input.now.getTime() - previous.startedAt.getTime() > CACHE_WINDOW_MS)
+        return undefined;
+    const growth = uncachedInput(bodyInputTokens(bodyBytes - previous.requestBytes), input.pricing);
+    const usage = previous.usage;
+    return {
+        inputTokens: usage.inputTokens + growth.inputTokens,
+        cachedInputTokens: usage.cachedInputTokens,
+        cacheWriteTokens: usage.cacheWriteTokens + growth.cacheWriteTokens,
+        outputTokens: 0,
+        reasoningTokens: 0,
+    };
+}
+/**
+ * The best known cost of a reply that broke before its final usage (spec PR 1
+ * › 1b): usage already read, else the input from its conversation's previous
+ * reply (previousInput), else the whole body as uncached input
+ * (bodyInputTokens), else (body size unknown) the input part of the hold; plus
+ * the output seen so far. With no output seen, the model's median completed
+ * reply, or none while there is no completed reply (a deliberate rule: one cut
+ * must not book a whole reserved reply). A stream that failed before its
+ * response started generated none. Never more than the request's worst case.
+ */
+export function estimateInterrupted(facts, pricing) {
+    const relayed = relayedOutputTokens(facts.relayedOutputBytes);
+    const output = relayed > 0 || facts.beforeResponse ? relayed : (facts.medianOutputTokens ?? 0);
+    const clamp = (cost) => Math.max(0, Math.min(cost, facts.ceilingUsd ?? facts.reservationUsd));
+    if (facts.readUsage) {
+        const usage = {
+            ...facts.readUsage,
+            outputTokens: facts.reportedOutputTokens ?? Math.max(facts.outputFloorTokens ?? 0, output),
+            reasoningTokens: 0,
+        };
+        return { usage, costUsd: clamp(computeCost(pricing, usage)) };
+    }
+    if (facts.previous) {
+        const usage = {
+            inputTokens: facts.previous.inputTokens,
+            cachedInputTokens: facts.previous.cachedInputTokens,
+            cacheWriteTokens: facts.previous.cacheWriteTokens,
+            outputTokens: output,
+            reasoningTokens: 0,
+        };
+        return { usage, costUsd: clamp(computeCost(pricing, usage)) };
+    }
+    if (facts.bodyBytes !== undefined) {
+        const usage = {
+            ...uncachedInput(bodyInputTokens(facts.bodyBytes), pricing),
+            cachedInputTokens: 0,
+            outputTokens: output,
+            reasoningTokens: 0,
+        };
+        return { usage, costUsd: clamp(computeCost(pricing, usage)) };
+    }
+    const usage = {
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        cacheWriteTokens: 0,
+        outputTokens: output,
+        reasoningTokens: 0,
+    };
+    const inputPart = facts.reservationUsd - (facts.maxOutputTokens * pricing.outputPerMTok) / 1_000_000;
+    return { usage, costUsd: clamp(inputPart + (usage.outputTokens * pricing.outputPerMTok) / 1_000_000) };
+}

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

@@ -0,0 +1,34 @@
+/**
+ * The coding proxy's /mcp route (remote MCP servers, phase 2): the worker's MCP server URL. It
+ * checks the run's MCP token (`rmt_…`, WARDBY_MCP_TOKEN in the worker) against the proxy session,
+ * then forwards the JSON-RPC body unchanged, with the same Authorization, to the native gateway's
+ * /coding-mcp route (WARDBY_MCP_GATEWAY_URL), which checks the token again and runs the call. The
+ * proxy never sees an MCP server URL or secret; the gateway redacts results before they get here.
+ *
+ * Secrets: the token is only hashed and forwarded, never logged or echoed. The route's log line
+ * carries the session id, a sanitized JSON-RPC method, the status and a fixed reason code only:
+ * never the body, the token or an error's text. Every body this route writes is fixed text or the
+ * gateway's answer, unchanged.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ProxyLedger } from "./types.js";
+export declare const MCP_ROUTE_PATH = "/mcp";
+/** The longest a forwarded call may take, when the session's deadline is later. */
+export declare const MCP_FORWARD_MAX_MS: number;
+export declare const MCP_UNAVAILABLE_MESSAGE = "MCP tools aren't available on this server.";
+/**
+ * A JSON-RPC method as the log may carry it: its first 64 characters when they are letters, `/`
+ * and `_` only, else "other". Anything that starts like an MCP token is "other" too.
+ */
+export declare function mcpLogMethod(value: unknown): string;
+export interface McpRouteOptions {
+    ledger: Pick<ProxyLedger, "findSessionByMcpTokenHash">;
+    /** The native gateway's base URL; without one, /mcp answers 503 mcp_unavailable. */
+    gatewayUrl: string | undefined;
+    fetchImpl?: typeof fetch;
+    now?: () => Date;
+    log?: {
+        info(fields: Record<string, unknown>, message: string): void;
+    };
+}
+export declare function createMcpRoute(options: McpRouteOptions): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/providers/coding-proxy/mcp-route.js

@@ -0,0 +1,166 @@
+import { isMcpToken, mcpTokenHash, MCP_TOKEN_REQUIRED_MESSAGE } from "../../coding/mcp-token.js";
+import { logger } from "../../core/logger.js";
+import { HTTP_LIMITS, HttpBoundaryError, readBodyBytes } from "../../mcp/transport/http-limits.js";
+export const MCP_ROUTE_PATH = "/mcp";
+/** The gateway's route this one forwards to. */
+const GATEWAY_PATH = "/coding-mcp";
+/** The longest a forwarded call may take, when the session's deadline is later. */
+export const MCP_FORWARD_MAX_MS = 5 * 60_000;
+/** The largest gateway answer relayed (a tool result is text the model reads; same as a model request). */
+const MAX_GATEWAY_RESPONSE_BYTES = 8 * 1024 * 1024;
+export const MCP_UNAVAILABLE_MESSAGE = "MCP tools aren't available on this server.";
+const MCP_UNREACHABLE_MESSAGE = "MCP tools can't be reached right now.";
+const LOG_METHOD = /^[A-Za-z/_]+$/;
+/**
+ * A JSON-RPC method as the log may carry it: its first 64 characters when they are letters, `/`
+ * and `_` only, else "other". Anything that starts like an MCP token is "other" too.
+ */
+export function mcpLogMethod(value) {
+    if (typeof value !== "string")
+        return "other";
+    const method = value.slice(0, 64);
+    return LOG_METHOD.test(method) && !method.includes("rmt_") ? method : "other";
+}
+function methodOf(body) {
+    try {
+        const message = JSON.parse(body.toString("utf8"));
+        return mcpLogMethod(message?.method);
+    }
+    catch {
+        return "other";
+    }
+}
+class GatewayError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+const JSON_HEADERS = { "content-type": "application/json", "cache-control": "no-store" };
+const rpcError = (code, message) => JSON.stringify({ jsonrpc: "2.0", id: null, error: { code, message } });
+async function readGatewayBody(response) {
+    const chunks = [];
+    let size = 0;
+    if (!response.body)
+        return Buffer.alloc(0);
+    for await (const chunk of response.body) {
+        size += chunk.byteLength;
+        if (size > MAX_GATEWAY_RESPONSE_BYTES) {
+            void response.body.cancel().catch(() => undefined);
+            throw new GatewayError("gateway_response_too_large");
+        }
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks, size);
+}
+export function createMcpRoute(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const now = options.now ?? (() => new Date());
+    const log = options.log ?? logger.child({ module: "coding-proxy" });
+    const gatewayUrl = options.gatewayUrl?.replace(/\/+$/, "");
+    return async (req, res) => {
+        const startedAt = performance.now();
+        const seen = {};
+        /** Refused before the body was read: close the connection rather than read what is still coming. */
+        const closeIfBodyUnread = () => {
+            if (!req.complete && !res.headersSent)
+                res.setHeader("connection", "close");
+        };
+        const send = (status, body, headers = JSON_HEADERS) => {
+            res.writeHead(status, headers).end(body);
+        };
+        try {
+            if (req.method !== "POST") {
+                closeIfBodyUnread();
+                res.setHeader("allow", "POST");
+                if (req.method === "HEAD")
+                    res.writeHead(405, JSON_HEADERS).end();
+                else
+                    send(405, rpcError(-32600, "Use POST."));
+                return;
+            }
+            if (!gatewayUrl) {
+                closeIfBodyUnread();
+                send(503, JSON.stringify({ error: "mcp_unavailable", message: MCP_UNAVAILABLE_MESSAGE }));
+                return;
+            }
+            const token = /^Bearer (\S+)$/.exec(req.headers.authorization ?? "")?.[1];
+            const session = isMcpToken(token)
+                ? await options.ledger.findSessionByMcpTokenHash(mcpTokenHash(token))
+                : undefined;
+            const at = now().getTime();
+            if (!session || session.status !== "active" || at >= session.deadlineAt.getTime()) {
+                // No WWW-Authenticate: a client must not start OAuth discovery against this route.
+                closeIfBodyUnread();
+                send(401, rpcError(-32001, MCP_TOKEN_REQUIRED_MESSAGE));
+                return;
+            }
+            seen.sessionId = session.id;
+            if (req.headers["content-type"]?.split(";", 1)[0].trim().toLowerCase() !== "application/json") {
+                closeIfBodyUnread();
+                send(415, rpcError(-32600, "Send one JSON-RPC message as application/json."));
+                return;
+            }
+            let body;
+            try {
+                body = await readBodyBytes(req, HTTP_LIMITS.json, AbortSignal.timeout(HTTP_LIMITS.requestMs));
+            }
+            catch (error) {
+                closeIfBodyUnread();
+                send(error instanceof HttpBoundaryError ? error.status : 400, rpcError(-32600, "The request body could not be read."));
+                return;
+            }
+            seen.method = methodOf(body);
+            // The call may take as long as it needs, up to the run's deadline or MCP_FORWARD_MAX_MS. The
+            // server's requestTimeout covers receiving the request only, which is over by now.
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(new GatewayError("gateway_timeout")), Math.min(MCP_FORWARD_MAX_MS, session.deadlineAt.getTime() - at));
+            const clientGone = () => {
+                if (!res.writableFinished)
+                    controller.abort(new GatewayError("client_disconnected"));
+            };
+            res.once("close", clientGone);
+            try {
+                const upstream = await fetchImpl(`${gatewayUrl}${GATEWAY_PATH}`, {
+                    method: "POST",
+                    headers: { authorization: req.headers.authorization, "content-type": "application/json" },
+                    body: new Uint8Array(body),
+                    redirect: "error",
+                    signal: controller.signal,
+                });
+                const answer = await readGatewayBody(upstream);
+                send(upstream.status, answer, {
+                    "content-type": upstream.headers.get("content-type") ?? "application/json",
+                    "cache-control": "no-store",
+                });
+            }
+            catch (error) {
+                const reason = controller.signal.reason instanceof GatewayError ? controller.signal.reason.reason : undefined;
+                throw error instanceof GatewayError ? error : new GatewayError(reason ?? "gateway_unreachable");
+            }
+            finally {
+                clearTimeout(timer);
+                res.off("close", clientGone);
+            }
+        }
+        catch (error) {
+            // Nothing of the error's text leaves or is logged: only a fixed reason code.
+            seen.reason = error instanceof GatewayError ? error.reason : "gateway_unreachable";
+            if (!res.headersSent)
+                send(502, JSON.stringify({ error: "mcp_unavailable", message: MCP_UNREACHABLE_MESSAGE }));
+            else
+                res.destroy();
+        }
+        finally {
+            log.info({
+                event: "mcp.request",
+                ...(seen.sessionId ? { sessionId: seen.sessionId } : {}),
+                ...(seen.method ? { method: seen.method } : {}),
+                status: res.statusCode,
+                ...(seen.reason ? { reason: seen.reason } : {}),
+                durationMs: Math.round(performance.now() - startedAt),
+            }, "coding proxy mcp request");
+        }
+    };
+}

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

@@ -1,18 +1,33 @@
-import { type CreateProxySessionInput, type ProxyLedger, type ProxyRequest, type ProxySession, type ProxyUsage, type ReserveProxyRequestInput, type ReserveProxyRequestResult } from "./types.js";
+import { type PreviousReply, type CreateProxySessionInput, type ProxyLedger, type ProxyRefusalRecord, type ProxyRequest, type ProxySession, type ProxyUsage, type ReserveProxyRequestInput, type ReserveProxyRequestResult } from "./types.js";
 /** Deterministic contract adapter. Sharing one instance simulates a proxy restart. */
 export declare class MemoryProxyLedger implements ProxyLedger {
+    private readonly options;
     private readonly sessions;
     private readonly sessionByCapability;
+    private readonly sessionByMcpToken;
     private readonly requests;
     private readonly requestBySessionKey;
+    private readonly startedAt;
+    constructor(options?: {
+        now?: () => Date;
+    });
     createSession(input: CreateProxySessionInput): Promise<void>;
+    findSessionByMcpTokenHash(mcpTokenHash: string): Promise<ProxySession | undefined>;
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
     complete(requestId: string, usage: ProxyUsage, actualCostUsd: number, upstreamStatus: number): Promise<ProxyRequest>;
     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>;