Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { CANCEL_RATE } from '@librechat/data-schemas';
import type { TCustomConfig, TTransactionsConfig } from 'librechat-data-provider';
import type { TransactionData } from '@librechat/data-schemas';
import type { EndpointTokenConfig } from '~/types/tokens';
type TokenType = 'prompt' | 'completion';
interface GetMultiplierParams {
valueKey?: string;
tokenType?: TokenType;
model?: string;
endpointTokenConfig?: EndpointTokenConfig;
inputTokenCount?: number;
}
interface GetCacheMultiplierParams {
/** `write1h` is Anthropic's 1-hour cache write; `write` is the 5-minute rate */
cacheType: 'write' | 'read' | 'write1h';
model?: string;
endpointTokenConfig?: EndpointTokenConfig;
inputTokenCount?: number;
}
export interface PricingFns {
getMultiplier: (params: GetMultiplierParams) => number;
getCacheMultiplier: (params: GetCacheMultiplierParams) => number | null;
}
interface BaseTxData {
user: string;
model?: string;
context: string;
messageId?: string;
conversationId: string;
endpointTokenConfig?: EndpointTokenConfig;
balance?: Partial<TCustomConfig['balance']> | null;
transactions?: Partial<TTransactionsConfig>;
}
interface StandardTxData extends BaseTxData {
tokenType: TokenType;
rawAmount: number;
inputTokenCount?: number;
valueKey?: string;
}
interface StructuredTxData extends BaseTxData {
tokenType: TokenType;
inputTokens?: number;
writeTokens?: number;
/** Subset of `writeTokens` written to the 1-hour cache */
write1hTokens?: number;
readTokens?: number;
inputTokenCount?: number;
rawAmount?: number;
}
export interface PreparedEntry {
doc: TransactionData;
tokenValue: number;
balance?: Partial<TCustomConfig['balance']> | null;
}
export interface TokenUsage {
promptTokens?: number;
completionTokens?: number;
}
export interface StructuredPromptTokens {
input?: number;
write?: number;
/** Subset of `write` written to the 1-hour cache, billed at its own rate */
write1h?: number;
read?: number;
}
export interface StructuredTokenUsage {
promptTokens?: StructuredPromptTokens;
completionTokens?: number;
}
export interface TxMetadata {
user: string;
model?: string;
context: string;
messageId?: string;
conversationId: string;
balance?: Partial<TCustomConfig['balance']> | null;
transactions?: Partial<TTransactionsConfig>;
endpointTokenConfig?: EndpointTokenConfig;
}
export interface BulkWriteDeps {
insertMany: (docs: TransactionData[]) => Promise<unknown>;
updateBalance: (params: { user: string; incrementValue: number }) => Promise<unknown>;
}
function calculateTokenValue(
txData: StandardTxData,
pricing: PricingFns,
): { tokenValue: number; rate: number } {
const { tokenType, model, endpointTokenConfig, inputTokenCount, rawAmount, valueKey } = txData;
const multiplier = Math.abs(
pricing.getMultiplier({ valueKey, tokenType, model, endpointTokenConfig, inputTokenCount }),
);
let rate = multiplier;
let tokenValue = rawAmount * multiplier;
if (txData.context === 'incomplete' && tokenType === 'completion') {
tokenValue = Math.ceil(tokenValue * CANCEL_RATE);
rate *= CANCEL_RATE;
}
return { tokenValue, rate };
}
function calculateStructuredTokenValue(
txData: StructuredTxData,
pricing: PricingFns,
): { tokenValue: number; rate: number; rawAmount: number; rateDetail?: Record<string, number> } {
const { tokenType, model, endpointTokenConfig, inputTokenCount } = txData;
if (!tokenType) {
return { tokenValue: txData.rawAmount ?? 0, rate: 0, rawAmount: txData.rawAmount ?? 0 };
}
if (tokenType === 'prompt') {
const inputMultiplier = pricing.getMultiplier({
tokenType: 'prompt',
model,
endpointTokenConfig,
inputTokenCount,
});
const writeMultiplier =
pricing.getCacheMultiplier({
cacheType: 'write',
model,
endpointTokenConfig,
inputTokenCount,
}) ?? inputMultiplier;
const readMultiplier =
pricing.getCacheMultiplier({
cacheType: 'read',
model,
endpointTokenConfig,
inputTokenCount,
}) ?? inputMultiplier;
const inputAbs = Math.abs(txData.inputTokens ?? 0);
const writeAbs = Math.abs(txData.writeTokens ?? 0);
const write1hAbs = Math.min(Math.abs(txData.write1hTokens ?? 0), writeAbs);
const readAbs = Math.abs(txData.readTokens ?? 0);
const totalPromptTokens = inputAbs + writeAbs + readAbs;
const write1hMultiplier =
write1hAbs > 0
? (pricing.getCacheMultiplier({
cacheType: 'write1h',
model,
endpointTokenConfig,
inputTokenCount,
}) ?? writeMultiplier)
: writeMultiplier;
const promptValue =
inputAbs * Math.abs(inputMultiplier) +
(writeAbs - write1hAbs) * Math.abs(writeMultiplier) +
write1hAbs * Math.abs(write1hMultiplier) +
readAbs * Math.abs(readMultiplier);
const rate =
totalPromptTokens > 0 ? promptValue / totalPromptTokens : Math.abs(inputMultiplier);
const tokenValue = -(
inputAbs * inputMultiplier +
(writeAbs - write1hAbs) * writeMultiplier +
write1hAbs * write1hMultiplier +
readAbs * readMultiplier
);
return {
tokenValue,
rate,
rawAmount: -totalPromptTokens,
rateDetail: {
input: inputMultiplier,
write: writeMultiplier,
read: readMultiplier,
...(write1hAbs > 0 && { write1h: write1hMultiplier }),
},
};
}
const multiplier = pricing.getMultiplier({
tokenType,
model,
endpointTokenConfig,
inputTokenCount,
});
const rawAmount = -Math.abs(txData.rawAmount ?? 0);
let rate = Math.abs(multiplier);
let tokenValue = rawAmount * multiplier;
if (txData.context === 'incomplete' && tokenType === 'completion') {
tokenValue = Math.ceil(tokenValue * CANCEL_RATE);
rate *= CANCEL_RATE;
}
return { tokenValue, rate, rawAmount };
}
function prepareStandardTx(
_txData: StandardTxData & {
balance?: Partial<TCustomConfig['balance']> | null;
transactions?: Partial<TTransactionsConfig>;
},
pricing: PricingFns,
): PreparedEntry | null {
const { balance, transactions, ...txData } = _txData;
if (txData.rawAmount != null && isNaN(txData.rawAmount)) {
return null;
}
if (transactions?.enabled === false) {
return null;
}
const { tokenValue, rate } = calculateTokenValue(txData, pricing);
return {
doc: { ...txData, tokenValue, rate },
tokenValue,
balance,
};
}
function prepareStructuredTx(
_txData: StructuredTxData & {
balance?: Partial<TCustomConfig['balance']> | null;
transactions?: Partial<TTransactionsConfig>;
},
pricing: PricingFns,
): PreparedEntry | null {
const { balance, transactions, ...txData } = _txData;
if (transactions?.enabled === false) {
return null;
}
const { tokenValue, rate, rawAmount, rateDetail } = calculateStructuredTokenValue(
txData,
pricing,
);
return {
doc: {
...txData,
tokenValue,
rate,
rawAmount,
...(rateDetail && { rateDetail }),
},
tokenValue,
balance,
};
}
export function prepareTokenSpend(
txData: TxMetadata,
tokenUsage: TokenUsage,
pricing: PricingFns,
): PreparedEntry[] {
const { promptTokens, completionTokens } = tokenUsage;
const results: PreparedEntry[] = [];
const normalizedPromptTokens = Math.max(promptTokens ?? 0, 0);
if (promptTokens !== undefined) {
const entry = prepareStandardTx(
{
...txData,
tokenType: 'prompt',
rawAmount: promptTokens === 0 ? 0 : -normalizedPromptTokens,
inputTokenCount: normalizedPromptTokens,
},
pricing,
);
if (entry) {
results.push(entry);
}
}
if (completionTokens !== undefined) {
const entry = prepareStandardTx(
{
...txData,
tokenType: 'completion',
rawAmount: completionTokens === 0 ? 0 : -Math.max(completionTokens, 0),
inputTokenCount: normalizedPromptTokens,
},
pricing,
);
if (entry) {
results.push(entry);
}
}
return results;
}
export function prepareStructuredTokenSpend(
txData: TxMetadata,
tokenUsage: StructuredTokenUsage,
pricing: PricingFns,
): PreparedEntry[] {
const { promptTokens, completionTokens } = tokenUsage;
const results: PreparedEntry[] = [];
if (promptTokens) {
const input = Math.max(promptTokens.input ?? 0, 0);
const write = Math.max(promptTokens.write ?? 0, 0);
const write1h = Math.min(Math.max(promptTokens.write1h ?? 0, 0), write);
const read = Math.max(promptTokens.read ?? 0, 0);
const totalInputTokens = input + write + read;
const entry = prepareStructuredTx(
{
...txData,
tokenType: 'prompt',
inputTokens: -input,
writeTokens: -write,
...(write1h > 0 && { write1hTokens: -write1h }),
readTokens: -read,
inputTokenCount: totalInputTokens,
},
pricing,
);
if (entry) {
results.push(entry);
}
}
if (completionTokens) {
const totalInputTokens = promptTokens
? Math.max(promptTokens.input ?? 0, 0) +
Math.max(promptTokens.write ?? 0, 0) +
Math.max(promptTokens.read ?? 0, 0)
: undefined;
const entry = prepareStandardTx(
{
...txData,
tokenType: 'completion',
rawAmount: -Math.max(completionTokens, 0),
inputTokenCount: totalInputTokens,
},
pricing,
);
if (entry) {
results.push(entry);
}
}
return results;
}
export async function bulkWriteTransactions(
{ user, docs }: { user: string; docs: PreparedEntry[] },
dbOps: BulkWriteDeps,
): Promise<void> {
if (!docs.length) {
return;
}
let totalTokenValue = 0;
let balanceEnabled = false;
const plainDocs = docs.map(({ doc, tokenValue, balance }) => {
if (balance?.enabled) {
balanceEnabled = true;
totalTokenValue += tokenValue;
}
return doc;
});
/**
* Ledger first, then balance (same order as `createTransaction`): a failed insert
* must never leave a debit without its transaction records.
*/
await dbOps.insertMany(plainDocs);
if (balanceEnabled) {
await dbOps.updateBalance({ user, incrementValue: totalTokenValue });
}
}