@wardby/cli 0.2.1 → 0.4.0

package/dist/mcp/webhooks/ingress.js

@@ -9,7 +9,7 @@ function extractCodingTask(req) {
     const parsed = CodingTaskOverrideSchema.safeParse(req.body.task);
     return parsed.success ? parsed.data : undefined;
 }
-export async function handleWebhookIngress(webhookId, req, db, executor) {
+export async function handleWebhookIngress(webhookId, req, db, executor, issueTrackers) {
     const secret = extractSecret(req);
     if (!secret) {
         return { status: 401, body: { error: "invalid_secret", error_description: "No webhook secret presented." } };
@@ -18,11 +18,18 @@ export async function handleWebhookIngress(webhookId, req, db, executor) {
     if (req.body.task !== undefined && codingTask === undefined) {
         return { status: 400, body: { error: "invalid_task" } };
     }
-    const result = await resolveWebhookRun(webhookId, secret, db, executor, codingTask);
+    // `wardbyIssue`, not `issue`: forwarded third-party payloads (GitHub, Jira)
+    // carry their own top-level `issue` object, which is not ours to read.
+    const result = await resolveWebhookRun(webhookId, secret, db, executor, codingTask, {
+        issue: req.body.wardbyIssue,
+        issueTrackers,
+    });
     if (result.ok) {
         return { status: 202, body: { runId: result.runId } };
     }
     switch (result.reason) {
+        case "invalid_issue":
+            return { status: 400, body: { error: "invalid_issue", error_description: result.message } };
         case "not_found":
             return { status: 404, body: { error: "not_found" } };
         case "invalid_secret":

package/dist/providers/auth/delegating.d.ts

@@ -13,7 +13,25 @@ export interface DelegatingAuthConfig {
     issuer?: string;
     audience?: string;
     jwksUri?: string;
+    /**
+     * AUTH_ROLE_CLAIM: the access-token claim carrying the IdP's roles/groups —
+     * an exact top-level claim name first (e.g. Auth0's namespaced
+     * `https://wardby.example/roles`, Okta `groups`, FusionAuth `roles`), else
+     * a dotted path into nested objects (Keycloak `realm_access.roles`).
+     */
+    roleClaim?: string;
+    /**
+     * AUTH_ROLE_MAP: comma-separated `idpValue=wardbyRole` pairs, e.g.
+     * `wardby-admin=admin,wardby-packages=package-approver,wardby-services=service-manager`.
+     */
+    roleMap?: string;
 }
+/**
+ * Parses AUTH_ROLE_MAP. Whitespace around entries and around `=` is ignored;
+ * an unknown wardby role, or a malformed or empty entry, is a startup error.
+ * The LAST `=` splits an entry (wardby role names never contain one).
+ */
+export declare function parseRoleMap(value: string): Map<string, string[]>;
 /**
  * Every spelling of the configured audience a token may legitimately carry.
  *
@@ -35,6 +53,7 @@ export declare class DelegatingAuthProvider implements AuthProvider {
     private readonly config;
     private readonly audiences;
     private readonly jwks;
+    private readonly roleMap?;
     constructor(config: DelegatingAuthConfig, jwks?: JWTVerifyGetKey);
     verifyBearer(token: string): Promise<VerifiedToken>;
     profile(idToken: string): Promise<AuthProfile>;

package/dist/providers/auth/delegating.js

@@ -10,6 +10,63 @@
 import { createRemoteJWKSet, jwtVerify, errors as joseErrors } from "jose";
 import { AudienceError, NotSupportedError } from "./types.js";
 import { requireSubject } from "./subject.js";
+import { ROLE_NAMES, isRoleName } from "../../mcp/auth/resource-server.js";
+/**
+ * Parses AUTH_ROLE_MAP. Whitespace around entries and around `=` is ignored;
+ * an unknown wardby role, or a malformed or empty entry, is a startup error.
+ * The LAST `=` splits an entry (wardby role names never contain one).
+ */
+export function parseRoleMap(value) {
+    const map = new Map();
+    const entries = value.split(",").map((e) => e.trim());
+    if (entries.every((e) => !e))
+        throw new Error("AUTH_ROLE_MAP is empty.");
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        const at = entry.lastIndexOf("=");
+        const idpValue = at > 0 ? entry.slice(0, at).trim() : "";
+        const role = at > 0 ? entry.slice(at + 1).trim() : "";
+        if (!idpValue || !role)
+            throw new Error(`AUTH_ROLE_MAP entry "${entry}" must look like idpValue=wardbyRole.`);
+        if (!isRoleName(role))
+            throw new Error(`AUTH_ROLE_MAP maps "${idpValue}" to unknown role "${role}" (known: ${ROLE_NAMES.join(", ")}).`);
+        map.set(idpValue, [...new Set([...(map.get(idpValue) ?? []), role])]);
+    }
+    return map;
+}
+/**
+ * Resolves `claim` in a verified payload: an exact top-level name wins (claim
+ * names may themselves contain dots and slashes), otherwise a dotted path.
+ */
+function resolveClaim(payload, claim) {
+    if (Object.prototype.hasOwnProperty.call(payload, claim))
+        return payload[claim];
+    if (!claim.includes("."))
+        return undefined;
+    let value = payload;
+    for (const part of claim.split(".")) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            return undefined;
+        if (!Object.prototype.hasOwnProperty.call(value, part))
+            return undefined;
+        value = value[part];
+    }
+    return value;
+}
+/**
+ * Maps a resolved claim (a string, or an array of strings) through the role
+ * map; unmapped values are ignored, and any other shape yields no roles.
+ */
+function rolesFromClaim(value, map) {
+    const values = typeof value === "string" ? [value] : Array.isArray(value) ? value : [];
+    const roles = new Set();
+    for (const v of values)
+        if (typeof v === "string")
+            for (const r of map.get(v) ?? [])
+                roles.add(r);
+    return [...roles];
+}
 /**
  * Every spelling of the configured audience a token may legitimately carry.
  *
@@ -53,9 +110,16 @@ export class DelegatingAuthProvider {
     config;
     audiences;
     jwks;
+    roleMap;
     constructor(config, jwks) {
         if (!config.issuer || !config.audience)
             throw new Error("AUTH_ISSUER and AUTH_AUDIENCE are required.");
+        // Half a configuration would silently give everyone no roles while
+        // looking configured — refuse to start instead.
+        if ((config.roleClaim !== undefined || config.roleMap !== undefined) && (!config.roleClaim || !config.roleMap))
+            throw new Error("AUTH_ROLE_CLAIM and AUTH_ROLE_MAP must be set together (or both left unset).");
+        if (config.roleMap)
+            this.roleMap = parseRoleMap(config.roleMap);
         this.config = config;
         this.audiences = audienceCandidates(config.audience);
         if (jwks) {
@@ -80,6 +144,13 @@ export class DelegatingAuthProvider {
                 email: typeof payload.email === "string" ? payload.email : undefined,
                 roles: Array.isArray(payload.roles) ? payload.roles.map(String) : [],
                 scopes: scopesFromClaim(payload.scope ?? payload.scp),
+                // Read from the bearer token validated above for this issuer and
+                // audience (signature, expiry too); the IdP should mint that audience
+                // only into access tokens. Unconfigured, every caller has no roles
+                // and privileged operations are refused.
+                wardbyRoles: this.config.roleClaim && this.roleMap
+                    ? rolesFromClaim(resolveClaim(payload, this.config.roleClaim), this.roleMap)
+                    : [],
             };
         }
         catch (err) {

package/dist/providers/auth/index.d.ts

@@ -8,4 +8,6 @@ import type { AuthProviderKind, AuthConfig } from "../../config/providers.js";
 import type { AuthProvider } from "./types.js";
 export { DelegatingAuthProvider } from "./delegating.js";
 export { SelfHostedAuthProvider } from "./self-hosted.js";
+/** Configuration that is valid but almost certainly not what the operator meant. */
+export declare function authConfigWarnings(kind: AuthProviderKind, config: AuthConfig): string[];
 export declare function buildAuthProvider(kind: AuthProviderKind, config: AuthConfig, db: PrismaClient): AuthProvider;

package/dist/providers/auth/index.js

@@ -1,8 +1,19 @@
 import { DelegatingAuthProvider } from "./delegating.js";
 import { SelfHostedAuthProvider } from "./self-hosted.js";
+import { logger } from "../../core/logger.js";
 export { DelegatingAuthProvider } from "./delegating.js";
 export { SelfHostedAuthProvider } from "./self-hosted.js";
+/** Configuration that is valid but almost certainly not what the operator meant. */
+export function authConfigWarnings(kind, config) {
+    const warnings = [];
+    if (kind === "self-hosted" && (config.roleClaim || config.roleMap))
+        warnings.push("AUTH_ROLE_CLAIM / AUTH_ROLE_MAP are set but ignored with AUTH_PROVIDER=self-hosted: self-hosted roles " +
+            "come from the database (`wardby auth user grant --subject <s> --role <role>`).");
+    return warnings;
+}
 export function buildAuthProvider(kind, config, db) {
+    for (const warning of authConfigWarnings(kind, config))
+        logger.warn({ module: "auth" }, warning);
     if (kind === "self-hosted") {
         if (!config.audience || !config.signingKey || !config.credentialHashKey) {
             throw new Error("AUTH_AUDIENCE, AUTH_SIGNING_KEY, and AUTH_CREDENTIAL_HASH_KEY are required.");

package/dist/providers/auth/self-hosted.d.ts

@@ -4,6 +4,13 @@ import { Credentials } from "../../mcp/auth/self-hosted/credentials.js";
 import { Sessions } from "../../mcp/auth/self-hosted/session.js";
 import type { AuthorizeParams, RegisterClientParams, SelfHostedAuthConfig, TokenParams, TokenResult } from "./authorization-server.js";
 export type { AuthorizeParams, RegisterClientParams, SelfHostedAuthConfig, TokenParams, TokenResult, } from "./authorization-server.js";
+/**
+ * Whether `requested` is one of a client's registered redirect URIs. A native
+ * app's loopback redirect may differ from its registration only in port: it
+ * listens on whatever port the OS hands it (RFC 8252 §7.3). Everything else —
+ * scheme, host, path, query — must match exactly, with no userinfo or fragment.
+ */
+export declare function redirectMatches(registered: readonly string[], requested: string): boolean;
 export declare class SelfHostedAuthProvider implements AuthProvider {
     readonly db: PrismaClient;
     readonly credentials: Credentials;
@@ -39,18 +46,19 @@ export declare class SelfHostedAuthProvider implements AuthProvider {
                 clientId: string;
             };
         } & {
-            id: string;
             createdAt: Date;
+            id: string;
             state: string | null;
+            clientId: string;
             expiresAt: Date;
             resource: string;
-            clientId: string;
             consumedAt: Date | null;
             redirectUri: string;
             codeChallenge: string;
             requestedScope: string;
         };
         challenge: string;
+        scopes: string[];
     }>;
     consent(sessionToken: string, interactionId: string, challenge: string, approve: boolean): Promise<string>;
     handleToken(params: TokenParams): Promise<TokenResult>;

package/dist/providers/auth/self-hosted.js

@@ -3,17 +3,53 @@ import { SignJWT, jwtVerify } from "jose";
 import { z } from "zod";
 import { NotSupportedError } from "./types.js";
 import { requireSubject } from "./subject.js";
-import { SCOPES_SUPPORTED } from "../../mcp/auth/resource-server.js";
+import { SCOPES_SUPPORTED, limitScope } from "../../mcp/auth/resource-server.js";
 import { canonicalUrl } from "../../mcp/transport/http-limits.js";
 import { Credentials, DAY, decodeKey, lockUser } from "../../mcp/auth/self-hosted/credentials.js";
 import { Sessions } from "../../mcp/auth/self-hosted/session.js";
+const LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+/**
+ * Whether `requested` is one of a client's registered redirect URIs. A native
+ * app's loopback redirect may differ from its registration only in port: it
+ * listens on whatever port the OS hands it (RFC 8252 §7.3). Everything else —
+ * scheme, host, path, query — must match exactly, with no userinfo or fragment.
+ */
+export function redirectMatches(registered, requested) {
+    if (registered.includes(requested))
+        return true;
+    let want;
+    try {
+        want = new URL(requested);
+    }
+    catch {
+        return false;
+    }
+    if (want.protocol !== "http:" || !LOOPBACK_HOSTS.includes(want.hostname))
+        return false;
+    return registered.some((value) => {
+        try {
+            const have = new URL(value);
+            return (have.protocol === "http:" &&
+                have.hostname === want.hostname &&
+                have.pathname === want.pathname &&
+                have.search === want.search &&
+                !want.username &&
+                !want.password &&
+                !requested.includes("#") // URL.hash is "" for a bare "#"
+            );
+        }
+        catch {
+            return false;
+        }
+    });
+}
 function validRedirect(value) {
     try {
         const u = new URL(value);
         return (!value.includes("#") &&
             !u.username &&
             !u.password &&
-            (u.protocol === "https:" || (u.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname))));
+            (u.protocol === "https:" || (u.protocol === "http:" && LOOPBACK_HOSTS.includes(u.hostname))));
     }
     catch {
         return false;
@@ -104,9 +140,10 @@ export class SelfHostedAuthProvider {
             throw new Error("Invalid resource.");
         const client = await this.db.oAuthClient.findUnique({ where: { clientId: p.clientId } });
         const metadata = client?.metadata;
-        if (!metadata?.redirect_uris?.includes(p.redirectUri) || !metadata.grant_types?.includes("authorization_code"))
+        if (!redirectMatches(metadata?.redirect_uris ?? [], p.redirectUri) ||
+            !metadata?.grant_types?.includes("authorization_code"))
             throw new Error("Invalid client or redirect.");
-        const scope = [...new Set(p.scope.split(/\s+/).filter((s) => SCOPES_SUPPORTED.includes(s)))].join(" ");
+        const scope = limitScope(p.scope, SCOPES_SUPPORTED);
         const request = await this.db.oAuthAuthorizationRequest.create({
             data: {
                 clientId: p.clientId,
@@ -129,7 +166,10 @@ export class SelfHostedAuthProvider {
         if (!interaction || interaction.consumedAt || interaction.expiresAt.getTime() <= Date.now())
             throw new Error("Invalid interaction.");
         const challenge = await this.sessions.challenge("consent", session.sessionId, interactionId);
-        return { interaction, challenge };
+        // Exactly what approving issues: the stored (supported-only) request.
+        // It's fixed when the interaction is created, so what the page shows
+        // can't drift from what consent() puts on the code.
+        return { interaction, challenge, scopes: interaction.requestedScope.split(" ").filter(Boolean) };
     }
     async consent(sessionToken, interactionId, challenge, approve) {
         const first = await this.sessions.get(sessionToken);
@@ -339,7 +379,16 @@ export class SelfHostedAuthProvider {
             family.clientId !== payload.client_id ||
             payload.scope !== family.scope)
             throw new Error("Invalid token.");
-        return { subject, scopes: family.scope.split(/\s+/).filter(Boolean), roles: [] };
+        // Roles are read from the database on every request (no caching), so a
+        // grant or revocation applies to live tokens immediately. Scopes stay
+        // exactly what the user consented to; roles decide whether the
+        // privileged ones are honoured (resource-server.ts requireScope).
+        return {
+            subject,
+            scopes: family.scope.split(/\s+/).filter(Boolean),
+            roles: [],
+            wardbyRoles: family.user.roles ?? [],
+        };
     }
     async cleanup() {
         const now = new Date();

package/dist/providers/auth/types.d.ts

@@ -32,6 +32,12 @@ export interface VerifiedToken {
     scopes: string[];
     email?: string;
     roles?: string[];
+    /**
+     * wardby roles (not the IdP's raw `roles`), decided by the provider at
+     * verification time: self-hosted reads AuthUser.roles live; delegating
+     * maps the configured signed claim through AUTH_ROLE_MAP. Absent = none.
+     */
+    wardbyRoles?: string[];
 }
 export interface AuthTokens {
     idToken: string;

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

@@ -1,4 +1,4 @@
-import type { CreateProxySessionInput, ProxyLedger, ProxyRequest, ProxySession, ProxyUsage, ReserveProxyRequestInput, ReserveProxyRequestResult } from "./types.js";
+import { type CreateProxySessionInput, type ProxyLedger, 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 sessions;
@@ -12,6 +12,9 @@ export declare class MemoryProxyLedger implements ProxyLedger {
     release(requestId: string, upstreamStatus: number): Promise<void>;
     markUncertain(requestId: string, upstreamStatus?: number): Promise<void>;
     cancelSession(sessionId: string): Promise<void>;
+    budgetExhausted(sessionId: string): Promise<boolean>;
+    recordUpstreamFailure(sessionId: string, code: string): Promise<void>;
+    upstreamFailure(sessionId: string): Promise<string | null>;
     getRequest(requestId: string): Promise<ProxyRequest | null>;
     private requiredRequest;
 }

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

@@ -1,5 +1,15 @@
+import { normalizeProxyModelTerms, } from "./types.js";
 function cloneSession(session) {
-    return { ...session, allowedModels: [...session.allowedModels], deadlineAt: new Date(session.deadlineAt) };
+    return {
+        ...session,
+        allowedModels: [...session.allowedModels],
+        deadlineAt: new Date(session.deadlineAt),
+        budgetExhaustedAt: session.budgetExhaustedAt ? new Date(session.budgetExhaustedAt) : null,
+        upstreamFailure: session.upstreamFailure ?? null,
+        terms: session.terms
+            ? { version: session.terms.version, entry: { ...session.terms.entry, efforts: [...session.terms.entry.efforts] } }
+            : null,
+    };
 }
 function cloneRequest(request) {
     return {
@@ -20,7 +30,12 @@ export class MemoryProxyLedger {
         }
         if (this.sessionByCapability.has(input.capabilityHash))
             throw new Error("proxy_capability_collision");
-        const session = { ...input, allowedModels: [...input.allowedModels], status: "active" };
+        const session = {
+            ...input,
+            allowedModels: [...input.allowedModels],
+            status: "active",
+            terms: input.terms ? normalizeProxyModelTerms(input.terms) : null,
+        };
         this.sessions.set(session.id, session);
         this.sessionByCapability.set(session.capabilityHash, session.id);
     }
@@ -48,8 +63,10 @@ export class MemoryProxyLedger {
             if (request.status === "reserved" || request.status === "uncertain")
                 committedOrHeld += request.reservationUsd;
         }
-        if (committedOrHeld + input.reservationUsd >= session.budgetUsd)
+        if (committedOrHeld + input.reservationUsd >= session.budgetUsd) {
+            session.budgetExhaustedAt ??= new Date(input.now);
             return { outcome: "budget_exhausted" };
+        }
         const request = { ...input, pricing: { ...input.pricing }, status: "reserved" };
         this.requests.set(request.id, request);
         this.requestBySessionKey.set(lookupKey, request.id);
@@ -90,6 +107,17 @@ export class MemoryProxyLedger {
         if (session)
             session.status = "cancelled";
     }
+    async budgetExhausted(sessionId) {
+        return Boolean(this.sessions.get(sessionId)?.budgetExhaustedAt);
+    }
+    async recordUpstreamFailure(sessionId, code) {
+        const session = this.sessions.get(sessionId);
+        if (session)
+            session.upstreamFailure ??= code;
+    }
+    async upstreamFailure(sessionId) {
+        return this.sessions.get(sessionId)?.upstreamFailure ?? null;
+    }
     async getRequest(requestId) {
         const request = this.requests.get(requestId);
         return request ? cloneRequest(request) : null;

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

@@ -1,4 +1,4 @@
-import { type ModelPricing } from "../llm/pricing.js";
+import { type ModelPricing } from "../llm/pricing-core.js";
 import type { PricingSnapshot, ProxyUsage } from "./types.js";
 export declare function parseAuthoritativeUsage(value: unknown): ProxyUsage;
 export declare function parseAnthropicAuthoritativeUsage(value: unknown): ProxyUsage;
@@ -8,8 +8,12 @@ export declare function fingerprintRequest(body: string): string;
 export interface TerminalUsage {
     terminal: boolean;
     usage?: ProxyUsage;
+    /** Set when the upstream ended the response as failed or incomplete: its error code. */
+    failure?: string;
 }
 export declare function terminalUsageFromSseFrame(frame: string): TerminalUsage;
+/** The safe error code in an upstream error body (a stream event or a rejected response's JSON), if any. */
+export declare function safeUpstreamErrorCode(record: Record<string, unknown>): string | undefined;
 /** Accumulates Anthropic's split input/output usage until message_stop. */
 export declare class AnthropicSseUsageTracker {
     private startUsage?;
@@ -17,4 +21,5 @@ export declare class AnthropicSseUsageTracker {
     private stopped;
     consume(frame: string): TerminalUsage;
 }
+/** 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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { computeCost } from "../llm/pricing.js";
+import { computeCost } from "../llm/pricing-core.js";
 const MAX_SAFE_TOKENS = 2_000_000_000;
 function tokenCount(value, name) {
     if (!Number.isSafeInteger(value) || value < 0 || value > MAX_SAFE_TOKENS) {
@@ -74,13 +74,36 @@ export function terminalUsageFromSseFrame(frame) {
     if (!event || typeof event !== "object")
         return { terminal: false };
     const record = event;
-    if (record.type !== "response.completed" && record.type !== "response.failed")
+    // A stream-level error event (quota, rate limit, server error) ends the response with no usage.
+    if (record.type === "error")
+        return { terminal: true, failure: upstreamErrorCode(record) };
+    const failed = record.type === "response.failed" || record.type === "response.incomplete";
+    if (record.type !== "response.completed" && !failed)
         return { terminal: false };
     const response = record.response;
     if (!response || typeof response !== "object")
         throw new Error("invalid_upstream_terminal_event");
     const usage = response.usage;
-    return { terminal: true, usage: usage == null ? undefined : parseAuthoritativeUsage(usage) };
+    return {
+        terminal: true,
+        usage: usage == null ? undefined : parseAuthoritativeUsage(usage),
+        ...(failed ? { failure: upstreamErrorCode(response) } : {}),
+    };
+}
+const SAFE_ERROR_CODE = /^[A-Za-z0-9_.-]{1,64}$/;
+/** The upstream's own error code, never its message: codes are fixed identifiers, messages can echo input. */
+function upstreamErrorCode(record) {
+    return safeUpstreamErrorCode(record) ?? "unknown";
+}
+/** The safe error code in an upstream error body (a stream event or a rejected response's JSON), if any. */
+export function safeUpstreamErrorCode(record) {
+    const nested = (key) => {
+        const value = record[key];
+        return value && typeof value === "object" ? value : undefined;
+    };
+    const candidates = [nested("error")?.code, nested("error")?.type, nested("incomplete_details")?.reason, record.code];
+    const code = candidates.find((value) => typeof value === "string" && SAFE_ERROR_CODE.test(value));
+    return typeof code === "string" ? code : undefined;
 }
 function sseEvent(frame) {
     const lines = frame.split("\n");
@@ -118,6 +141,9 @@ export class AnthropicSseUsageTracker {
         if (!value)
             return { terminal: false };
         switch (value.type) {
+            // A stream-level error event (quota, rate limit, server error) ends the response with no usage.
+            case "error":
+                return { terminal: true, failure: upstreamErrorCode(value) };
             case "message_start": {
                 if (this.startUsage || !value.message || typeof value.message !== "object") {
                     throw new Error("invalid_upstream_sse");
@@ -156,6 +182,17 @@ export class AnthropicSseUsageTracker {
         }
     }
 }
+/** 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) {
-    return { version, ...pricing };
+    const snapshot = {
+        version,
+        encoding: pricing.encoding,
+        inputPerMTok: pricing.inputPerMTok,
+        outputPerMTok: pricing.outputPerMTok,
+    };
+    if (pricing.cachedInputPerMTok !== undefined)
+        snapshot.cachedInputPerMTok = pricing.cachedInputPerMTok;
+    if (pricing.cacheWritePerMTok !== undefined)
+        snapshot.cacheWritePerMTok = pricing.cacheWritePerMTok;
+    return snapshot;
 }

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

@@ -1,9 +1,23 @@
 import type { PrismaClient } from "#prisma";
 import type { CreateProxySessionInput, ProxyLedger, 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
+ *  gets more room than the default; its pool is also kept apart from the
+ *  package registry's (coding-proxy/main.ts). */
+export declare const LEDGER_TRANSACTION_MAX_WAIT_MS = 5000;
+/** How long a ledger transaction may run once started (Prisma's default is
+ *  5 s). Each is a handful of small queries, but a proxy busy with package
+ *  installs (the registry's dependency walk parses large npm documents on the
+ *  same event loop) can stall between them; a live lockfile install expired
+ *  one ("A commit cannot be executed on an expired transaction") and failed
+ *  the model request. The row lock it holds is per session, so a longer
+ *  window only delays that run's own next request. */
+export declare const LEDGER_TRANSACTION_TIMEOUT_MS = 20000;
 export declare class PrismaProxyLedger implements ProxyLedger {
     private readonly db;
     constructor(db: PrismaProxyLedgerDb);
+    private transaction;
     createSession(input: CreateProxySessionInput): Promise<void>;
     findSessionByCapabilityHash(capabilityHash: string): Promise<ProxySession | null>;
     reserve(input: ReserveProxyRequestInput): Promise<ReserveProxyRequestResult>;
@@ -11,5 +25,8 @@ export declare class PrismaProxyLedger implements ProxyLedger {
     release(requestId: string, upstreamStatus: number): Promise<void>;
     markUncertain(requestId: string, upstreamStatus?: number): Promise<void>;
     cancelSession(sessionId: string): Promise<void>;
+    budgetExhausted(sessionId: string): Promise<boolean>;
+    recordUpstreamFailure(sessionId: string, code: string): Promise<void>;
+    upstreamFailure(sessionId: string): Promise<string | null>;
     getRequest(requestId: string): Promise<ProxyRequest | null>;
 }