@wardby/cli 0.1.0

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

@@ -0,0 +1,103 @@
+function cloneSession(session) {
+    return { ...session, allowedModels: [...session.allowedModels], deadlineAt: new Date(session.deadlineAt) };
+}
+function cloneRequest(request) {
+    return {
+        ...request,
+        pricing: { ...request.pricing },
+        usage: request.usage ? { ...request.usage } : undefined,
+    };
+}
+/** Deterministic contract adapter. Sharing one instance simulates a proxy restart. */
+export class MemoryProxyLedger {
+    sessions = new Map();
+    sessionByCapability = new Map();
+    requests = new Map();
+    requestBySessionKey = new Map();
+    async createSession(input) {
+        if ([...this.sessions.values()].some((session) => session.runId === input.runId)) {
+            throw new Error("proxy_session_exists");
+        }
+        if (this.sessionByCapability.has(input.capabilityHash))
+            throw new Error("proxy_capability_collision");
+        const session = { ...input, allowedModels: [...input.allowedModels], status: "active" };
+        this.sessions.set(session.id, session);
+        this.sessionByCapability.set(session.capabilityHash, session.id);
+    }
+    async findSessionByCapabilityHash(capabilityHash) {
+        const id = this.sessionByCapability.get(capabilityHash);
+        const session = id ? this.sessions.get(id) : undefined;
+        return session ? cloneSession(session) : null;
+    }
+    async reserve(input) {
+        const session = this.sessions.get(input.sessionId);
+        if (!session || session.status === "cancelled")
+            return { outcome: "inactive", reason: "cancelled" };
+        if (input.now.getTime() >= session.deadlineAt.getTime())
+            return { outcome: "inactive", reason: "expired" };
+        const lookupKey = `${input.sessionId}\0${input.requestKey}`;
+        const existingId = this.requestBySessionKey.get(lookupKey);
+        if (existingId)
+            return { outcome: "duplicate", request: cloneRequest(this.requests.get(existingId)) };
+        let committedOrHeld = 0;
+        for (const request of this.requests.values()) {
+            if (request.sessionId !== input.sessionId)
+                continue;
+            if (request.status === "completed")
+                committedOrHeld += request.actualCostUsd;
+            if (request.status === "reserved" || request.status === "uncertain")
+                committedOrHeld += request.reservationUsd;
+        }
+        if (committedOrHeld + input.reservationUsd >= session.budgetUsd)
+            return { outcome: "budget_exhausted" };
+        const request = { ...input, pricing: { ...input.pricing }, status: "reserved" };
+        this.requests.set(request.id, request);
+        this.requestBySessionKey.set(lookupKey, request.id);
+        return { outcome: "reserved", request: cloneRequest(request) };
+    }
+    async complete(requestId, usage, actualCostUsd, upstreamStatus) {
+        const request = this.requiredRequest(requestId);
+        if (request.status === "completed") {
+            if (request.actualCostUsd !== actualCostUsd || JSON.stringify(request.usage) !== JSON.stringify(usage)) {
+                throw new Error("proxy_completion_conflict");
+            }
+            return cloneRequest(request);
+        }
+        if (request.status === "released")
+            throw new Error("proxy_request_released");
+        request.status = "completed";
+        request.actualCostUsd = actualCostUsd;
+        request.usage = { ...usage };
+        request.upstreamStatus = upstreamStatus;
+        return cloneRequest(request);
+    }
+    async release(requestId, upstreamStatus) {
+        const request = this.requiredRequest(requestId);
+        if (request.status === "completed" || request.status === "uncertain")
+            return;
+        request.status = "released";
+        request.upstreamStatus = upstreamStatus;
+    }
+    async markUncertain(requestId, upstreamStatus) {
+        const request = this.requiredRequest(requestId);
+        if (request.status !== "reserved")
+            return;
+        request.status = "uncertain";
+        request.upstreamStatus = upstreamStatus;
+    }
+    async cancelSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session)
+            session.status = "cancelled";
+    }
+    async getRequest(requestId) {
+        const request = this.requests.get(requestId);
+        return request ? cloneRequest(request) : null;
+    }
+    requiredRequest(requestId) {
+        const request = this.requests.get(requestId);
+        if (!request)
+            throw new Error("unknown_proxy_request");
+        return request;
+    }
+}

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

@@ -0,0 +1,20 @@
+import { type ModelPricing } from "../llm/pricing.js";
+import type { PricingSnapshot, ProxyUsage } from "./types.js";
+export declare function parseAuthoritativeUsage(value: unknown): ProxyUsage;
+export declare function parseAnthropicAuthoritativeUsage(value: unknown): ProxyUsage;
+export declare function actualCostUsd(usage: ProxyUsage, pricing: ModelPricing): number;
+export declare function estimateReservationUsd(bodyBytes: number, maxOutputTokens: number, pricing: ModelPricing): number;
+export declare function fingerprintRequest(body: string): string;
+export interface TerminalUsage {
+    terminal: boolean;
+    usage?: ProxyUsage;
+}
+export declare function terminalUsageFromSseFrame(frame: string): TerminalUsage;
+/** Accumulates Anthropic's split input/output usage until message_stop. */
+export declare class AnthropicSseUsageTracker {
+    private startUsage?;
+    private outputTokens?;
+    private stopped;
+    consume(frame: string): TerminalUsage;
+}
+export declare function pricingSnapshot(version: string, pricing: ModelPricing): PricingSnapshot;

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

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { computeCost } from "../llm/pricing.js";
+const MAX_SAFE_TOKENS = 2_000_000_000;
+function tokenCount(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > MAX_SAFE_TOKENS) {
+        throw new Error(`invalid_authoritative_usage:${name}`);
+    }
+    return value;
+}
+export function parseAuthoritativeUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid_authoritative_usage");
+    const usage = value;
+    const inputDetails = usage.input_tokens_details && typeof usage.input_tokens_details === "object"
+        ? usage.input_tokens_details
+        : {};
+    const outputDetails = usage.output_tokens_details && typeof usage.output_tokens_details === "object"
+        ? usage.output_tokens_details
+        : {};
+    const parsed = {
+        inputTokens: tokenCount(usage.input_tokens, "input_tokens"),
+        outputTokens: tokenCount(usage.output_tokens, "output_tokens"),
+        cachedInputTokens: tokenCount(inputDetails.cached_tokens ?? 0, "cached_tokens"),
+        cacheWriteTokens: tokenCount(inputDetails.cache_write_tokens ?? 0, "cache_write_tokens"),
+        reasoningTokens: tokenCount(outputDetails.reasoning_tokens ?? 0, "reasoning_tokens"),
+    };
+    if (parsed.cachedInputTokens > parsed.inputTokens || parsed.reasoningTokens > parsed.outputTokens) {
+        throw new Error("invalid_authoritative_usage:details_exceed_total");
+    }
+    return parsed;
+}
+export function parseAnthropicAuthoritativeUsage(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid_authoritative_usage");
+    const usage = value;
+    const cachedInputTokens = tokenCount(usage.cache_read_input_tokens ?? 0, "cache_read_input_tokens");
+    return {
+        inputTokens: tokenCount(usage.input_tokens, "input_tokens") + cachedInputTokens,
+        outputTokens: tokenCount(usage.output_tokens, "output_tokens"),
+        cachedInputTokens,
+        cacheWriteTokens: tokenCount(usage.cache_creation_input_tokens ?? 0, "cache_creation_input_tokens"),
+        reasoningTokens: 0,
+    };
+}
+export function actualCostUsd(usage, pricing) {
+    return computeCost(pricing, usage);
+}
+export function estimateReservationUsd(bodyBytes, maxOutputTokens, pricing) {
+    if (!Number.isSafeInteger(bodyBytes) || bodyBytes < 1)
+        throw new Error("invalid_request_size");
+    if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens < 1)
+        throw new Error("invalid_max_output_tokens");
+    const cacheWriteRate = pricing.cacheWritePerMTok ?? pricing.inputPerMTok;
+    return (bodyBytes * (pricing.inputPerMTok + cacheWriteRate) + maxOutputTokens * pricing.outputPerMTok) / 1_000_000;
+}
+export function fingerprintRequest(body) {
+    return createHash("sha256").update(body).digest("base64url");
+}
+export function terminalUsageFromSseFrame(frame) {
+    const data = frame
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data || data === "[DONE]")
+        return { terminal: false };
+    let event;
+    try {
+        event = JSON.parse(data);
+    }
+    catch {
+        throw new Error("invalid_upstream_sse");
+    }
+    if (!event || typeof event !== "object")
+        return { terminal: false };
+    const record = event;
+    if (record.type !== "response.completed" && record.type !== "response.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) };
+}
+function sseEvent(frame) {
+    const lines = frame.split("\n");
+    const name = lines
+        .find((line) => line.startsWith("event:"))
+        ?.slice(6)
+        .trim();
+    const data = lines
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data || data === "[DONE]")
+        return { name };
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch {
+        throw new Error("invalid_upstream_sse");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid_upstream_sse");
+    const record = value;
+    if (typeof record.type !== "string" || (name && name !== record.type))
+        throw new Error("invalid_upstream_sse");
+    return { name, value: record };
+}
+/** Accumulates Anthropic's split input/output usage until message_stop. */
+export class AnthropicSseUsageTracker {
+    startUsage;
+    outputTokens;
+    stopped = false;
+    consume(frame) {
+        const { value } = sseEvent(frame);
+        if (!value)
+            return { terminal: false };
+        switch (value.type) {
+            case "message_start": {
+                if (this.startUsage || !value.message || typeof value.message !== "object") {
+                    throw new Error("invalid_upstream_sse");
+                }
+                const usage = value.message.usage;
+                if (!usage || typeof usage !== "object" || Array.isArray(usage))
+                    throw new Error("invalid_upstream_sse");
+                const record = usage;
+                tokenCount(record.input_tokens, "input_tokens");
+                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");
+                return { terminal: false };
+            }
+            case "message_delta": {
+                const usage = value.usage;
+                if (!usage || typeof usage !== "object" || Array.isArray(usage))
+                    throw new Error("invalid_upstream_sse");
+                this.outputTokens = tokenCount(usage.output_tokens, "output_tokens");
+                return { terminal: false };
+            }
+            case "message_stop": {
+                if (this.stopped || !this.startUsage || this.outputTokens === undefined) {
+                    return { terminal: true };
+                }
+                this.stopped = true;
+                return {
+                    terminal: true,
+                    usage: parseAnthropicAuthoritativeUsage({ ...this.startUsage, output_tokens: this.outputTokens }),
+                };
+            }
+            default:
+                return { terminal: false };
+        }
+    }
+}
+export function pricingSnapshot(version, pricing) {
+    return { version, ...pricing };
+}

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

@@ -0,0 +1,15 @@
+import type { PrismaClient } from "@prisma/client";
+import type { CreateProxySessionInput, ProxyLedger, ProxyRequest, ProxySession, ProxyUsage, ReserveProxyRequestInput, ReserveProxyRequestResult } from "./types.js";
+export type PrismaProxyLedgerDb = Pick<PrismaClient, "$transaction" | "$queryRaw" | "$executeRaw">;
+export declare class PrismaProxyLedger implements ProxyLedger {
+    private readonly db;
+    constructor(db: PrismaProxyLedgerDb);
+    createSession(input: CreateProxySessionInput): Promise<void>;
+    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>;
+    cancelSession(sessionId: string): Promise<void>;
+    getRequest(requestId: string): Promise<ProxyRequest | null>;
+}

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

@@ -0,0 +1,213 @@
+function sessionFromRow(row) {
+    if (!Array.isArray(row.allowedModels) || !row.allowedModels.every((model) => typeof model === "string")) {
+        throw new Error("invalid_proxy_session_models");
+    }
+    if (row.protocol !== "openai-responses" && row.protocol !== "anthropic-messages") {
+        throw new Error("invalid_proxy_session_protocol");
+    }
+    return {
+        id: row.id,
+        runId: row.runId,
+        capabilityHash: row.capabilityHash,
+        credentialRef: row.credentialRef,
+        protocol: row.protocol,
+        allowedModels: row.allowedModels,
+        deadlineAt: row.deadlineAt,
+        budgetUsd: Number(row.budgetUsd),
+        status: row.status,
+    };
+}
+function requestFromRow(row) {
+    const pricing = row.pricingSnapshot;
+    const hasUsage = row.inputTokens !== null && row.outputTokens !== null;
+    return {
+        id: row.id,
+        sessionId: row.sessionId,
+        requestKey: row.requestKey,
+        requestFingerprint: row.requestFingerprint,
+        model: row.model,
+        status: row.status,
+        reservationUsd: Number(row.reservationUsd),
+        actualCostUsd: row.actualCostUsd === null ? undefined : Number(row.actualCostUsd),
+        pricing: { ...pricing, version: row.pricingVersion },
+        usage: hasUsage
+            ? {
+                inputTokens: row.inputTokens,
+                outputTokens: row.outputTokens,
+                cachedInputTokens: row.cachedInputTokens ?? 0,
+                cacheWriteTokens: row.cacheWriteTokens ?? 0,
+                reasoningTokens: row.reasoningTokens ?? 0,
+            }
+            : undefined,
+        upstreamStatus: row.upstreamStatus ?? undefined,
+    };
+}
+async function requestById(db, id) {
+    const rows = await db.$queryRaw `
+    SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
+           "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
+           "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
+           "reasoningTokens", "upstreamStatus"
+    FROM "CodingProxyRequest" WHERE "id" = ${id}
+  `;
+    return rows[0] ? requestFromRow(rows[0]) : null;
+}
+export class PrismaProxyLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createSession(input) {
+        const models = JSON.stringify(input.allowedModels);
+        await this.db.$executeRaw `
+      INSERT INTO "CodingProxySession"
+        ("id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt",
+         "budgetUsd", "status", "createdAt", "updatedAt")
+      VALUES
+        (${input.id}, ${input.runId}, ${input.capabilityHash}, ${input.credentialRef}, ${input.protocol}, ${models}::jsonb,
+         ${input.deadlineAt}, ${input.budgetUsd}, 'active', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    `;
+    }
+    async findSessionByCapabilityHash(capabilityHash) {
+        const rows = await this.db.$queryRaw `
+      SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status"
+      FROM "CodingProxySession" WHERE "capabilityHash" = ${capabilityHash}
+    `;
+        return rows[0] ? sessionFromRow(rows[0]) : null;
+    }
+    async reserve(input) {
+        return this.db.$transaction(async (tx) => {
+            const sessions = await tx.$queryRaw `
+          SELECT "id", "runId", "capabilityHash", "credentialRef", "protocol", "allowedModels", "deadlineAt", "budgetUsd", "status"
+          FROM "CodingProxySession" WHERE "id" = ${input.sessionId} FOR UPDATE
+        `;
+            const row = sessions[0];
+            if (!row || row.status !== "active")
+                return { outcome: "inactive", reason: "cancelled" };
+            if (input.now.getTime() >= row.deadlineAt.getTime())
+                return { outcome: "inactive", reason: "expired" };
+            const duplicate = await tx.$queryRaw `
+          SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
+                 "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
+                 "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
+                 "reasoningTokens", "upstreamStatus"
+          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
+              WHEN "status" = 'completed' THEN "actualCostUsd"
+              WHEN "status" IN ('reserved', 'uncertain') THEN "reservationUsd"
+              ELSE 0
+            END
+          ), 0) AS "held"
+          FROM "CodingProxyRequest" WHERE "sessionId" = ${input.sessionId}
+        `;
+            if (Number(totals[0]?.held ?? 0) + input.reservationUsd >= Number(row.budgetUsd)) {
+                return { outcome: "budget_exhausted" };
+            }
+            const pricing = JSON.stringify({
+                encoding: input.pricing.encoding,
+                inputPerMTok: input.pricing.inputPerMTok,
+                outputPerMTok: input.pricing.outputPerMTok,
+                cachedInputPerMTok: input.pricing.cachedInputPerMTok,
+                cacheWritePerMTok: input.pricing.cacheWritePerMTok,
+            });
+            await tx.$executeRaw `
+          INSERT INTO "CodingProxyRequest"
+            ("id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
+             "reservationUsd", "pricingVersion", "pricingSnapshot", "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)
+        `;
+            const request = await requestById(tx, input.id);
+            if (!request)
+                throw new Error("proxy_reservation_not_persisted");
+            return { outcome: "reserved", request };
+        });
+    }
+    async complete(requestId, usage, actualCostUsd, upstreamStatus) {
+        return this.db.$transaction(async (tx) => {
+            const initial = await requestById(tx, requestId);
+            if (!initial)
+                throw new Error("unknown_proxy_request");
+            await tx.$queryRaw `
+          SELECT "id" FROM "CodingProxySession" WHERE "id" = ${initial.sessionId} FOR UPDATE
+        `;
+            const locked = await tx.$queryRaw `
+          SELECT "id", "sessionId", "requestKey", "requestFingerprint", "model", "status",
+                 "reservationUsd", "actualCostUsd", "pricingVersion", "pricingSnapshot",
+                 "inputTokens", "outputTokens", "cachedInputTokens", "cacheWriteTokens",
+                 "reasoningTokens", "upstreamStatus"
+          FROM "CodingProxyRequest" WHERE "id" = ${requestId} FOR UPDATE
+        `;
+            const prior = locked[0] ? requestFromRow(locked[0]) : null;
+            if (!prior)
+                throw new Error("unknown_proxy_request");
+            if (prior.status === "released")
+                throw new Error("proxy_request_released");
+            if (prior.status === "completed") {
+                if (Math.abs((prior.actualCostUsd ?? -1) - actualCostUsd) > 1e-12 ||
+                    JSON.stringify(prior.usage) !== JSON.stringify(usage)) {
+                    throw new Error("proxy_completion_conflict");
+                }
+                return prior;
+            }
+            await tx.$executeRaw `
+          UPDATE "CodingProxyRequest"
+          SET "status" = 'completed', "actualCostUsd" = ${actualCostUsd},
+              "inputTokens" = ${usage.inputTokens}, "outputTokens" = ${usage.outputTokens},
+              "cachedInputTokens" = ${usage.cachedInputTokens}, "cacheWriteTokens" = ${usage.cacheWriteTokens},
+              "reasoningTokens" = ${usage.reasoningTokens}, "upstreamStatus" = ${upstreamStatus},
+              "completedAt" = CURRENT_TIMESTAMP, "updatedAt" = CURRENT_TIMESTAMP
+          WHERE "id" = ${requestId} AND "status" IN ('reserved', 'uncertain')
+        `;
+            await tx.$executeRaw `
+          UPDATE "Run" AS r
+          SET "tokensIn" = totals."tokensIn", "tokensOut" = totals."tokensOut", "costUsd" = totals."costUsd"
+          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"
+            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"
+        `;
+            const request = await requestById(tx, requestId);
+            if (!request)
+                throw new Error("proxy_completion_not_persisted");
+            return request;
+        });
+    }
+    async release(requestId, upstreamStatus) {
+        await this.db.$executeRaw `
+      UPDATE "CodingProxyRequest"
+      SET "status" = 'released', "upstreamStatus" = ${upstreamStatus}, "updatedAt" = CURRENT_TIMESTAMP
+      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 cancelSession(sessionId) {
+        await this.db.$executeRaw `
+      UPDATE "CodingProxySession" SET "status" = 'cancelled', "updatedAt" = CURRENT_TIMESTAMP
+      WHERE "id" = ${sessionId} AND "status" = 'active'
+    `;
+    }
+    getRequest(requestId) {
+        return requestById(this.db, requestId);
+    }
+}

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

@@ -0,0 +1,75 @@
+import { type ModelPricing } from "../llm/pricing.js";
+import type { CredentialResolver, ProxyAuditSink, ProxyLedger, ProxyProtocol } 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;
+export declare const CLAUDE_CODE_ANTHROPIC_BETAS: readonly ["claude-code-20250219", "context-management-2025-06-27", "effort-2025-11-24", "interleaved-thinking-2025-05-14", "mid-conversation-system-2026-04-07", "prompt-caching-scope-2026-01-05", "thinking-token-count-2026-05-13"];
+export declare class CodingProxyError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string);
+}
+export interface ProxyResponseSink {
+    start(status: number, headers: Record<string, string>): void;
+    write(chunk: Uint8Array): void | Promise<void>;
+    end(): void;
+    destroy(): void;
+}
+export interface ExecuteProxyRequest {
+    bearer: string;
+    protocol: ProxyProtocol;
+    rawBody: string;
+    requestKey?: string;
+    anthropicBeta?: string;
+}
+export interface CreateCodingProxySession {
+    runId: string;
+    credentialRef: string;
+    protocol: ProxyProtocol;
+    allowedModels: string[];
+    deadlineAt: Date;
+    budgetUsd: number;
+}
+export interface CreatedCodingProxySession {
+    id: string;
+    runId: string;
+    capability: string;
+    protocol: ProxyProtocol;
+    allowedModels: string[];
+    deadlineAt: Date;
+    budgetUsd: number;
+}
+export interface CodingProxyOptions {
+    ledger: ProxyLedger;
+    credentials: CredentialResolver;
+    upstreamUrl?: string;
+    anthropicUpstreamUrl?: string;
+    upstreamAllowedHosts?: string[];
+    fetch?: typeof globalThis.fetch;
+    now?: () => Date;
+    audit?: ProxyAuditSink;
+    pricing?: (model: string, protocol: ProxyProtocol) => ModelPricing;
+    pricingVersion?: string;
+}
+export declare class CodingProxy {
+    private readonly ledger;
+    private readonly credentials;
+    private readonly upstreamUrls;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly audit;
+    private readonly getPricing;
+    private readonly priceVersion;
+    private readonly activeRequests;
+    constructor(options: CodingProxyOptions);
+    createSession(input: CreateCodingProxySession): Promise<CreatedCodingProxySession>;
+    cancelSession(sessionId: string): Promise<void>;
+    execute(input: ExecuteProxyRequest, sink: ProxyResponseSink): Promise<void>;
+    private authenticate;
+    private trackActive;
+    private handleDuplicate;
+    private complete;
+    private forwardJson;
+    private forwardStream;
+    private markUncertain;
+}