@cortexkit/anthropic-auth-core 1.22.0 → 2.0.0

package/dist/cachekeep.js

@@ -1,578 +0,0 @@
-import { signRequestBody } from './cch.js';
-import { orderClaudeCodeBody } from './claude-code.js';
-import { dumpDirectRequest, dumpResponseArtifact } from './dump.js';
-import { logger } from './logger.js';
-export const CLAUDE_CACHE_KEEP_COMMAND_NAME = 'claude-cachekeep';
-export const CACHE_KEEP_TTL_MS = 60 * 60_000;
-export const CACHE_KEEP_PREWARM_LEAD_MS = 5 * 60_000;
-export const CACHE_KEEP_TICK_MS = 60_000;
-export const CACHE_KEEP_EXTENDED_TTL_BETA = 'extended-cache-ttl-2025-04-11';
-export const CACHE_KEEP_MAX_TARGETS = 32;
-export const CACHE_KEEP_MAX_BODY_BYTES = 16 * 1024 * 1024;
-export const CACHE_KEEP_PREWARM_TIMEOUT_MS = 30_000;
-export const CACHE_KEEP_RETRY_BASE_MS = 60_000;
-export const CACHE_KEEP_RETRY_MAX_MS = 15 * 60_000;
-export const CACHE_KEEP_RETRY_JITTER_MAX_MS = 30_000;
-const STATUS_TITLE = '## Claude Cache Keep Status';
-const ENABLED_TITLE = '## Claude Cache Keep Enabled';
-const DISABLED_TITLE = '## Claude Cache Keep Disabled';
-const USAGE_TITLE = '## Claude Cache Keep Usage';
-const USAGE = 'Usage: `/claude-cachekeep`, `/claude-cachekeep always`, `/claude-cachekeep off`, or `/claude-cachekeep HH-HH`.';
-function padHour(hour) {
-    return String(hour).padStart(2, '0');
-}
-export function parseCacheKeepCommandAction(input) {
-    const trimmed = input.trim();
-    if (!trimmed)
-        return { type: 'status' };
-    if (trimmed === 'off')
-        return { type: 'disable' };
-    if (trimmed === 'always')
-        return { type: 'always' };
-    if (trimmed === 'subagents on')
-        return { type: 'subagents', enabled: true };
-    if (trimmed === 'subagents off')
-        return { type: 'subagents', enabled: false };
-    const match = /^(\d{1,2})-(\d{1,2})$/.exec(trimmed);
-    if (!match)
-        return { type: 'usage' };
-    const startHour = Number(match[1]);
-    const endHour = Number(match[2]);
-    if (!Number.isInteger(startHour) ||
-        !Number.isInteger(endHour) ||
-        startHour < 0 ||
-        startHour > 23 ||
-        endHour < 0 ||
-        endHour > 23 ||
-        startHour === endHour) {
-        return { type: 'usage' };
-    }
-    return { type: 'window', startHour, endHour };
-}
-export function getCacheKeepWindow(storage) {
-    const startHour = Number(storage?.cacheKeep?.startHour);
-    const endHour = Number(storage?.cacheKeep?.endHour);
-    if (!Number.isInteger(startHour) ||
-        !Number.isInteger(endHour) ||
-        startHour < 0 ||
-        startHour > 23 ||
-        endHour < 0 ||
-        endHour > 23 ||
-        startHour === endHour) {
-        return undefined;
-    }
-    return { startHour, endHour };
-}
-export function isCacheKeepAlways(storage) {
-    return (storage?.cacheKeep?.enabled === true && storage.cacheKeep.always === true);
-}
-export function isCacheKeepPersistentlyEnabled(storage) {
-    return (storage?.cacheKeep?.enabled === true &&
-        (isCacheKeepAlways(storage) || !!getCacheKeepWindow(storage)));
-}
-export function isCacheKeepHybridActive(storage) {
-    return (isCacheKeepPersistentlyEnabled(storage) &&
-        storage?.claudeCache?.enabled === true &&
-        storage.claudeCache.mode === 'hybrid');
-}
-export function isWithinCacheKeepWindow(window, now = new Date()) {
-    if (!window)
-        return false;
-    const hour = now.getHours();
-    if (window.startHour < window.endHour) {
-        return hour >= window.startHour && hour < window.endHour;
-    }
-    return hour >= window.startHour || hour < window.endHour;
-}
-export function isCacheKeepActiveNow(storage, now = new Date()) {
-    if (storage?.cacheKeep?.enabled !== true)
-        return false;
-    return (isCacheKeepAlways(storage) ||
-        isWithinCacheKeepWindow(getCacheKeepWindow(storage), now));
-}
-export function localDayKey(now = new Date()) {
-    return `${now.getFullYear()}-${padHour(now.getMonth() + 1)}-${padHour(now.getDate())}`;
-}
-function localWindowKey(window, now = new Date()) {
-    if (window &&
-        window.startHour > window.endHour &&
-        now.getHours() < window.endHour) {
-        const previous = new Date(now);
-        previous.setDate(previous.getDate() - 1);
-        return localDayKey(previous);
-    }
-    return localDayKey(now);
-}
-function cacheKeepPeriodKey(storage, window, now = new Date()) {
-    return isCacheKeepAlways(storage) ? 'always' : localWindowKey(window, now);
-}
-export function buildCacheKeepStatusSummary(status) {
-    const schedule = status.always
-        ? 'always (while this process is running)'
-        : status.window
-            ? `${padHour(status.window.startHour)}-${padHour(status.window.endHour)}`
-            : 'not configured';
-    const lines = [
-        `Cache keep: ${status.enabled ? 'enabled' : 'disabled'}`,
-        `Schedule: ${schedule}`,
-        'Mode requirement: `/claude-cache mode hybrid` must be active.',
-    ];
-    if (typeof status.hybridActive === 'boolean') {
-        lines.push(`Hybrid active: ${status.hybridActive ? 'yes' : 'no'}`);
-    }
-    if (typeof status.trackedSessions === 'number') {
-        lines.push(`Tracked sessions: ${status.trackedSessions}`);
-    }
-    if (status.trackedSessionDetails?.length) {
-        lines.push('Sessions:');
-        for (const session of status.trackedSessionDetails) {
-            lines.push(`- ${session.id}`);
-        }
-    }
-    if (status.nextPrewarmAt) {
-        lines.push(`Next prewarm: ${new Date(status.nextPrewarmAt).toLocaleString()}`);
-    }
-    return lines.join('\n');
-}
-export function executeCacheKeepCommand(input) {
-    const action = parseCacheKeepCommandAction(input.argumentsText);
-    const status = {
-        enabled: input.enabled ?? false,
-        always: input.always,
-        window: input.window,
-        trackedSessions: input.trackedSessions,
-        trackedSessionDetails: input.trackedSessionDetails,
-        nextPrewarmAt: input.nextPrewarmAt,
-        hybridActive: input.hybridActive,
-    };
-    if (action.type === 'status') {
-        return [STATUS_TITLE, '', buildCacheKeepStatusSummary(status)].join('\n');
-    }
-    if (action.type === 'disable') {
-        return [
-            DISABLED_TITLE,
-            '',
-            buildCacheKeepStatusSummary({ ...status, enabled: false }),
-        ].join('\n');
-    }
-    if (action.type === 'always') {
-        return [
-            ENABLED_TITLE,
-            '',
-            buildCacheKeepStatusSummary({
-                ...status,
-                enabled: true,
-                always: true,
-                window: undefined,
-            }),
-        ].join('\n');
-    }
-    if (action.type === 'window') {
-        return [
-            ENABLED_TITLE,
-            '',
-            buildCacheKeepStatusSummary({
-                ...status,
-                enabled: true,
-                always: false,
-                window: { startHour: action.startHour, endHour: action.endHour },
-            }),
-        ].join('\n');
-    }
-    if (action.type === 'subagents') {
-        return [
-            STATUS_TITLE,
-            '',
-            buildCacheKeepStatusSummary(status),
-            '',
-            `Subagent tracking: ${action.enabled ? 'enabled' : 'disabled'}`,
-        ].join('\n');
-    }
-    return [USAGE_TITLE, '', USAGE, '', buildCacheKeepStatusSummary(status)].join('\n');
-}
-function hasExplicitCacheControl(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    if (Array.isArray(value))
-        return value.some(hasExplicitCacheControl);
-    const record = value;
-    const cacheControl = record.cache_control;
-    if (cacheControl &&
-        typeof cacheControl === 'object' &&
-        cacheControl.type === 'ephemeral') {
-        return true;
-    }
-    return Object.values(record).some(hasExplicitCacheControl);
-}
-export async function buildCacheKeepPrewarmBody(bodyText) {
-    let body;
-    try {
-        body = JSON.parse(bodyText);
-    }
-    catch {
-        return { ok: false, reason: 'body is not valid JSON' };
-    }
-    if (!hasExplicitCacheControl(body)) {
-        return { ok: false, reason: 'body has no explicit cache breakpoints' };
-    }
-    const warm = structuredClone(body);
-    warm.max_tokens = 0;
-    delete warm.stream;
-    const thinking = warm.thinking;
-    if (thinking?.type === 'enabled')
-        delete warm.thinking;
-    const outputConfig = warm.output_config;
-    if (outputConfig?.format)
-        delete warm.output_config;
-    const toolChoice = warm.tool_choice;
-    if (toolChoice?.type === 'tool' || toolChoice?.type === 'any') {
-        delete warm.tool_choice;
-    }
-    const signedBodyText = await signRequestBody(JSON.stringify(orderClaudeCodeBody(warm)));
-    return { ok: true, bodyText: signedBodyText };
-}
-function cacheKeepRetryDelayMs(targetId, failureCount) {
-    const exponential = Math.min(CACHE_KEEP_RETRY_MAX_MS, CACHE_KEEP_RETRY_BASE_MS * 2 ** Math.min(Math.max(failureCount - 1, 0), 8));
-    let hash = 2_166_136_261;
-    for (const character of `${targetId}:${failureCount}`) {
-        hash ^= character.charCodeAt(0);
-        hash = Math.imul(hash, 16_777_619);
-    }
-    const jitter = (hash >>> 0) %
-        (Math.min(CACHE_KEEP_RETRY_JITTER_MAX_MS, exponential / 4) + 1);
-    return exponential + jitter;
-}
-export class CacheKeepManager {
-    options;
-    targets = new Map();
-    timer = null;
-    tickPromise = null;
-    constructor(options) {
-        this.options = options;
-    }
-    start() {
-        if (this.timer)
-            return;
-        logger.debug('cachekeep', 'started');
-        this.timer = (this.options.setIntervalImpl ?? globalThis.setInterval)(() => {
-            void this.tick().catch((error) => {
-                logger.warn('cachekeep', 'tick failed', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }, CACHE_KEEP_TICK_MS);
-        if ('unref' in this.timer)
-            this.timer.unref();
-    }
-    stop() {
-        if (!this.timer)
-            return;
-        logger.debug('cachekeep', 'stopped');
-        const clearIntervalImpl = this.options.clearIntervalImpl ?? globalThis.clearInterval;
-        clearIntervalImpl(this.timer);
-        this.timer = null;
-    }
-    stats(window, now = this.options.now?.() ?? Date.now(), always = false) {
-        const today = always ? 'always' : localWindowKey(window, new Date(now));
-        const targets = [...this.targets.values()].filter((target) => target.dayKey === today);
-        const nextPrewarmAt = targets.length
-            ? Math.min(...targets.map((target) => target.nextPrewarmAt))
-            : undefined;
-        return { trackedSessions: targets.length, nextPrewarmAt };
-    }
-    trackedSessions() {
-        return [...this.targets.values()]
-            .map((target) => ({
-            id: target.id,
-            cacheExpiresAt: target.cacheExpiresAt,
-            nextPrewarmAt: target.nextPrewarmAt,
-        }))
-            .sort((left, right) => left.id.localeCompare(right.id));
-    }
-    trackedOAuthRoute(sessionId) {
-        const target = this.targets.get(sessionId);
-        return target ? { oauthAccountId: target.oauthAccountId } : undefined;
-    }
-    trackedCount() {
-        return this.targets.size;
-    }
-    publishTrackedSessions() {
-        const callback = this.options.onTrackedSessionsChanged;
-        if (!callback)
-            return;
-        try {
-            void Promise.resolve(callback(this.trackedSessions())).catch((error) => {
-                logger.warn('cachekeep', 'failed to publish tracked sessions', {
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
-        catch (error) {
-            logger.warn('cachekeep', 'failed to publish tracked sessions', {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    totalBodyBytes() {
-        return [...this.targets.values()].reduce((sum, target) => sum + target.bodyText.length, 0);
-    }
-    evictOldestTarget() {
-        const oldest = this.targets.keys().next().value;
-        if (oldest !== undefined)
-            this.targets.delete(oldest);
-    }
-    pruneTargets(now, today) {
-        for (const [id, target] of this.targets) {
-            if (today && target.dayKey !== today) {
-                this.targets.delete(id);
-                continue;
-            }
-            if (now >= target.cacheExpiresAt)
-                this.targets.delete(id);
-        }
-        while (this.targets.size > CACHE_KEEP_MAX_TARGETS)
-            this.evictOldestTarget();
-        while (this.totalBodyBytes() > CACHE_KEEP_MAX_BODY_BYTES) {
-            const before = this.targets.size;
-            this.evictOldestTarget();
-            if (this.targets.size === before)
-                break;
-        }
-    }
-    track(input) {
-        if (!input.sessionId)
-            return { tracked: false, reason: 'missing session id' };
-        if (!isCacheKeepPersistentlyEnabled(input.storage)) {
-            return { tracked: false, reason: 'cachekeep disabled' };
-        }
-        if (input.cacheMode !== 'hybrid') {
-            return { tracked: false, reason: 'cache mode is not hybrid' };
-        }
-        if (input.bodyText.length > CACHE_KEEP_MAX_BODY_BYTES) {
-            return { tracked: false, reason: 'body exceeds cachekeep memory budget' };
-        }
-        const now = this.options.now?.() ?? Date.now();
-        const window = getCacheKeepWindow(input.storage);
-        if (!isCacheKeepActiveNow(input.storage, new Date(now))) {
-            return { tracked: false, reason: 'outside configured schedule' };
-        }
-        const today = cacheKeepPeriodKey(input.storage, window, new Date(now));
-        this.pruneTargets(now, today);
-        if (this.targets.has(input.sessionId))
-            this.targets.delete(input.sessionId);
-        const headers = {};
-        input.headers.forEach((value, key) => {
-            headers[key] = value;
-        });
-        this.targets.set(input.sessionId, {
-            id: input.sessionId,
-            url: input.url,
-            headers,
-            bodyText: input.bodyText,
-            cacheExpiresAt: now + CACHE_KEEP_TTL_MS,
-            nextPrewarmAt: now + CACHE_KEEP_TTL_MS - CACHE_KEEP_PREWARM_LEAD_MS,
-            consecutiveFailures: 0,
-            dayKey: today,
-            oauthAccountId: input.oauthAccountId,
-            isSubagent: input.isSubagent ?? false,
-        });
-        this.pruneTargets(now, today);
-        this.publishTrackedSessions();
-        this.start();
-        return { tracked: true };
-    }
-    async prewarmNow(input) {
-        const headers = {};
-        input.headers.forEach((value, key) => {
-            headers[key] = value;
-        });
-        const target = {
-            id: input.sessionId,
-            url: input.url,
-            headers,
-            bodyText: input.bodyText,
-            cacheExpiresAt: this.options.now?.() ?? Date.now(),
-            nextPrewarmAt: this.options.now?.() ?? Date.now(),
-            consecutiveFailures: 0,
-            dayKey: '',
-            oauthAccountId: input.oauthAccountId,
-            isSubagent: input.isSubagent ?? false,
-        };
-        return this.sendPrewarm(target);
-    }
-    tick() {
-        if (this.tickPromise)
-            return this.tickPromise;
-        let run;
-        run = this.runTick().finally(() => {
-            if (this.tickPromise === run)
-                this.tickPromise = null;
-        });
-        this.tickPromise = run;
-        return run;
-    }
-    async runTick() {
-        const storage = await this.options.loadStorage();
-        const window = getCacheKeepWindow(storage);
-        const now = this.options.now?.() ?? Date.now();
-        const today = cacheKeepPeriodKey(storage, window, new Date(now));
-        if (isCacheKeepAlways(storage)) {
-            for (const target of this.targets.values())
-                target.dayKey = 'always';
-        }
-        this.pruneTargets(now, today);
-        if (!this.targets.size) {
-            this.publishTrackedSessions();
-            this.stop();
-            return;
-        }
-        if (!isCacheKeepHybridActive(storage)) {
-            this.publishTrackedSessions();
-            return;
-        }
-        if (!isCacheKeepActiveNow(storage, new Date(now))) {
-            this.publishTrackedSessions();
-            return;
-        }
-        logger.debug('cachekeep', 'fired', { targets: this.targets.size });
-        for (const target of this.targets.values()) {
-            if (target.nextPrewarmAt > now)
-                continue;
-            try {
-                await this.prewarm(target, now);
-            }
-            catch (error) {
-                logger.warn('cachekeep', 'prewarm failed', {
-                    session: target.id,
-                    reason: error instanceof Error ? error.message : String(error),
-                });
-                target.consecutiveFailures += 1;
-                target.nextPrewarmAt =
-                    now + cacheKeepRetryDelayMs(target.id, target.consecutiveFailures);
-            }
-        }
-        this.publishTrackedSessions();
-    }
-    async sendPrewarm(target) {
-        let bodyText = target.bodyText;
-        if (this.options.prepareBody) {
-            try {
-                bodyText = await this.options.prepareBody(bodyText, target);
-            }
-            catch (error) {
-                logger.warn('cachekeep', 'prepare body failed', {
-                    session: target.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        const preparedTarget = { ...target, bodyText };
-        const prewarm = await buildCacheKeepPrewarmBody(bodyText);
-        if (!prewarm.ok)
-            return prewarm;
-        const fetchImpl = this.options.fetchImpl ?? fetch;
-        const prewarmTarget = { ...preparedTarget, bodyText: prewarm.bodyText };
-        const headers = this.options.prepareHeaders
-            ? await this.options.prepareHeaders(new Headers(target.headers), prewarmTarget)
-            : new Headers(target.headers);
-        headers.delete('content-length');
-        headers.delete('transfer-encoding');
-        let response;
-        try {
-            response = await fetchImpl(target.url, {
-                method: 'POST',
-                headers,
-                body: prewarm.bodyText,
-                signal: AbortSignal.timeout(this.options.prewarmTimeoutMs ?? CACHE_KEEP_PREWARM_TIMEOUT_MS),
-            });
-        }
-        catch (error) {
-            return {
-                ok: false,
-                reason: error instanceof Error ? error.message : String(error),
-                transient: true,
-            };
-        }
-        const receivedAt = this.options.now?.() ?? Date.now();
-        const raw = await response.text().catch(() => '');
-        let data = null;
-        try {
-            data = raw ? JSON.parse(raw) : null;
-        }
-        catch { }
-        try {
-            await this.options.onResponse?.({
-                target,
-                bodyText: prewarm.bodyText,
-                status: response.status,
-                data,
-                receivedAt,
-            });
-        }
-        catch { }
-        try {
-            const dumpHandle = await dumpDirectRequest({
-                affinity: target.id,
-                route: 'cachekeep',
-                status: response.status,
-                bodyText: prewarm.bodyText,
-                url: target.url,
-                method: 'POST',
-                headers,
-                tag: 'cachekeep',
-            });
-            await dumpResponseArtifact(dumpHandle, {
-                status: response.status,
-                message: data,
-            });
-        }
-        catch (error) {
-            logger.debug('cachekeep', 'dump failed', {
-                session: target.id,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        if (!response.ok) {
-            return {
-                ok: false,
-                reason: raw || `HTTP ${response.status}`,
-                status: response.status,
-            };
-        }
-        const objectData = data && typeof data === 'object' && !Array.isArray(data)
-            ? data
-            : null;
-        const usage = objectData?.usage;
-        return { ok: true, ...(usage && { usage }) };
-    }
-    async prewarm(target, now) {
-        const result = await this.sendPrewarm(target);
-        if (!result.ok) {
-            if (result.status == null && !result.transient) {
-                logger.debug('cachekeep', 'prewarm skipped', {
-                    session: target.id,
-                    reason: result.reason,
-                });
-                this.targets.delete(target.id);
-            }
-            else {
-                logger.warn('cachekeep', 'prewarm failed', {
-                    session: target.id,
-                    status: result.status,
-                    reason: result.reason,
-                });
-                target.consecutiveFailures += 1;
-                target.nextPrewarmAt =
-                    now + cacheKeepRetryDelayMs(target.id, target.consecutiveFailures);
-            }
-            return;
-        }
-        target.cacheExpiresAt = now + CACHE_KEEP_TTL_MS;
-        target.nextPrewarmAt = target.cacheExpiresAt - CACHE_KEEP_PREWARM_LEAD_MS;
-        target.consecutiveFailures = 0;
-        logger.debug('cachekeep', 'prewarm succeeded', {
-            session: target.id,
-            ...(result.usage && { usage: result.usage }),
-        });
-    }
-}

package/dist/cch.js

@@ -1,127 +0,0 @@
-import { createHash } from 'node:crypto';
-import xxhashInit from 'xxhash-wasm';
-import { CCH_POSITIONS, CCH_SALT, CLAUDE_CODE_VERSION } from './constants.js';
-const CCH_SEED = 0x4d659218e32a3268n;
-const CCH_PLACEHOLDER = 'cch=00000;';
-export const CCH_PATTERN = /\bcch=([0-9a-f]{5});/;
-const BILLING_HEADER_CCH_PATTERN = /("system":\[\{"type":"text","text":"x-anthropic-billing-header: cc_version=[^;"]+; cc_entrypoint=[^;"]+; )cch=([0-9a-f]{5});/;
-const BILLING_HEADER_CCH_PLACEHOLDER_PATTERN = /("system":\[\{"type":"text","text":"x-anthropic-billing-header: cc_version=[^;"]+; cc_entrypoint=[^;"]+; )cch=00000;/;
-let xxhashPromise = null;
-let xxhash64Raw = null;
-async function ensureXxhash() {
-    if (xxhash64Raw)
-        return;
-    xxhashPromise ??= (async () => {
-        const hasher = await xxhashInit();
-        xxhash64Raw = hasher.h64Raw;
-    })();
-    await xxhashPromise;
-}
-/**
- * Extract the visible prompt from the first user message. Claude Code prepends
- * reminder blocks and derives its version suffix from the final text block.
- */
-export function extractFirstUserMessageText(messages) {
-    const userMsg = messages.find((message) => message.role === 'user');
-    if (!userMsg)
-        return '';
-    const { content } = userMsg;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        const textBlocks = content.filter((block) => block.type === 'text');
-        const commandBlock = textBlocks.find((block) => block.text?.includes('<command-name>'));
-        if (commandBlock?.text) {
-            return commandBlock.text.slice(commandBlock.text.indexOf('<command-name>'));
-        }
-        const visibleBlock = textBlocks.findLast((block) => typeof block.text === 'string' && block.text.length > 0);
-        if (visibleBlock?.text)
-            return visibleBlock.text;
-    }
-    return '';
-}
-export class ClaudeCodeFirstUserTextTracker {
-    limit;
-    #values = new Map();
-    constructor(limit = 1_000) {
-        this.limit = limit;
-    }
-    resolve(sessionId, messages, pin = true) {
-        const existing = this.#values.get(sessionId);
-        if (existing !== undefined) {
-            this.#values.delete(sessionId);
-            this.#values.set(sessionId, existing);
-            return existing;
-        }
-        const value = extractFirstUserMessageText(messages);
-        if (pin) {
-            if (!this.#values.has(sessionId) && this.#values.size >= this.limit) {
-                const oldest = this.#values.keys().next().value;
-                if (oldest !== undefined)
-                    this.#values.delete(oldest);
-            }
-            this.#values.set(sessionId, value);
-        }
-        return value;
-    }
-    has(sessionId) {
-        return this.#values.has(sessionId);
-    }
-    clear() {
-        this.#values.clear();
-    }
-}
-/**
- * Compute Claude Code's cch token over the final serialized request body.
- *
- * Real Claude Code signs the full body bytes with xxHash64 using a fixed seed,
- * masks to 20 bits, and writes that value into the billing-header placeholder.
- */
-export async function computeCCH(bodyBytes) {
-    await ensureXxhash();
-    const hash = xxhash64Raw?.(bodyBytes, CCH_SEED) ?? 0n;
-    return (hash & 0xfffffn).toString(16).padStart(5, '0');
-}
-export async function computeXxhash64Hex(value) {
-    await ensureXxhash();
-    const hash = xxhash64Raw?.(new TextEncoder().encode(value), 0n) ?? 0n;
-    return hash.toString(16).padStart(16, '0').slice(0, 16);
-}
-export function resetBillingHeaderCCH(bodyString) {
-    return bodyString.replace(BILLING_HEADER_CCH_PATTERN, `$1${CCH_PLACEHOLDER}`);
-}
-export function extractBillingHeaderCCH(bodyString) {
-    return BILLING_HEADER_CCH_PATTERN.exec(bodyString)?.[2] ?? null;
-}
-export async function signRequestBody(bodyString) {
-    if (!BILLING_HEADER_CCH_PATTERN.test(bodyString))
-        return bodyString;
-    const unsignedBodyString = resetBillingHeaderCCH(bodyString);
-    const canonicalBody = JSON.parse(unsignedBodyString);
-    if ('model' in canonicalBody)
-        canonicalBody.model = '';
-    delete canonicalBody.max_tokens;
-    const token = await computeCCH(new TextEncoder().encode(JSON.stringify(canonicalBody)));
-    return unsignedBodyString.replace(BILLING_HEADER_CCH_PLACEHOLDER_PATTERN, `$1cch=${token};`);
-}
-/**
- * Compute Claude Code's 3-character suffix for cc_version.
- */
-export function computeCcVersionSuffix(firstUserText, version = CLAUDE_CODE_VERSION) {
-    const sampledText = CCH_POSITIONS.map((position) => firstUserText[position] ?? '0').join('');
-    return createHash('sha256')
-        .update(`${CCH_SALT}${sampledText}${version}`)
-        .digest('hex')
-        .slice(0, 3);
-}
-/**
- * Build the billing header with a cch placeholder.
- * signRequestBody() must run after final request serialization to replace it.
- */
-export function buildBillingHeaderValue(messages, version = CLAUDE_CODE_VERSION, entrypoint, pinnedFirstUserText) {
-    const suffix = computeCcVersionSuffix(pinnedFirstUserText ?? extractFirstUserMessageText(messages), version);
-    return ('x-anthropic-billing-header: ' +
-        `cc_version=${version}.${suffix}; ` +
-        `cc_entrypoint=${entrypoint}; ` +
-        'cch=00000;');
-}