627 lines
24 KiB
TypeScript
627 lines
24 KiB
TypeScript
import { quoteFromPriceRule, resolveBillingParameterPricing } from "@/lib/billing";
|
||
import {
|
||
getOrganizationWallet,
|
||
InsufficientBalanceError,
|
||
listBillingPriceRules,
|
||
listBillingLedgerEntries,
|
||
postWalletEntry
|
||
} from "@/lib/server/billing-store";
|
||
import { ensureDefaultBillingPriceRules } from "@/lib/server/billing-catalog";
|
||
import {
|
||
calculateSeedanceActualAmountFen,
|
||
estimateSeedanceAmountFen,
|
||
requestHasInputVideo,
|
||
requestInputVideoDurationSeconds,
|
||
seedanceTokenPriceFenPerMillion
|
||
} from "@/lib/server/seedance-billing";
|
||
import { getGenerationJob, updateGenerationJob } from "@/lib/server/data-store";
|
||
import type {
|
||
BillingAccountConfig,
|
||
BillingConditionValue,
|
||
BillingJobCharge,
|
||
BillingParameterSnapshot,
|
||
BillingPriceRule,
|
||
BillingQuantitySource,
|
||
BillingRuleConditions,
|
||
BillingScalar,
|
||
GenerationCapability,
|
||
GenerationJob,
|
||
GenerationProvider,
|
||
UsageContext
|
||
} from "@/lib/types";
|
||
|
||
export class BillingConfigurationError extends Error {
|
||
status = 503;
|
||
|
||
constructor(message: string) {
|
||
super(message);
|
||
this.name = "BillingConfigurationError";
|
||
}
|
||
}
|
||
|
||
export type BillingGenerationInput = {
|
||
provider: GenerationProvider;
|
||
capability: GenerationCapability;
|
||
reqKey: string;
|
||
requestPayload: Record<string, unknown>;
|
||
usageContext?: UsageContext;
|
||
externalClientId?: string;
|
||
allowUnboundOrganization?: boolean;
|
||
};
|
||
|
||
export async function quoteGenerationCharge(input: BillingGenerationInput): Promise<BillingJobCharge | undefined> {
|
||
if (!billingEnabled() || input.provider === "mock") return undefined;
|
||
const quotaExempt = isQuotaExemptUsageContext(input.usageContext);
|
||
if (!input.usageContext?.organizationId && !quotaExempt) {
|
||
if (input.externalClientId || input.usageContext?.source === "api") return undefined;
|
||
if (!input.allowUnboundOrganization) {
|
||
throw new BillingConfigurationError("当前账号未绑定组织，暂时无法提交计费生成任务。");
|
||
}
|
||
}
|
||
await ensureDefaultBillingPriceRules();
|
||
const rule = await findMatchingPriceRule(input);
|
||
if (!rule) {
|
||
throw new BillingConfigurationError(`尚未配置 ${input.provider} / ${input.capability} 的计费规则，请联系超级管理员。`);
|
||
}
|
||
const parameters = normalizeBillingParameters(input.requestPayload);
|
||
if (!resolveBillingParameterPricing(rule, parameters)) {
|
||
throw new BillingConfigurationError(`尚未配置 ${input.provider} / ${input.capability} 当前参数组合的标准价格，请联系超级管理员。`);
|
||
}
|
||
const quantity = quantityForRule(rule, parameters);
|
||
const quote: BillingJobCharge = {
|
||
...quoteFromPriceRule({
|
||
rule,
|
||
provider: input.provider,
|
||
capability: input.capability,
|
||
reqKey: input.reqKey,
|
||
quantity,
|
||
parameters,
|
||
conditions: effectiveBillingRuleConditions(rule)
|
||
}),
|
||
status: "pending",
|
||
quotaExempt: quotaExempt || undefined
|
||
};
|
||
if (input.provider !== "seedance" || input.reqKey !== "doubao-seedance-2-0-260128") {
|
||
return quote;
|
||
}
|
||
|
||
const inputVideo = requestHasInputVideo(input.requestPayload);
|
||
const estimatedAmountFen = estimateSeedanceAmountFen({
|
||
resolution: parameters.resolution,
|
||
aspectRatio: parameters.aspectRatio,
|
||
outputDurationSeconds: quantity,
|
||
inputVideo,
|
||
inputVideoDurationSeconds: requestInputVideoDurationSeconds(input.requestPayload),
|
||
markupMultiplier: quote.markupMultiplier
|
||
});
|
||
const reservedAmountFen = Math.max(quote.amountFen, estimatedAmountFen);
|
||
return {
|
||
...quote,
|
||
amountFen: reservedAmountFen,
|
||
reservedAmountFen,
|
||
settlementStatus: "pending"
|
||
};
|
||
}
|
||
|
||
export async function chargeGenerationJob(job: GenerationJob): Promise<GenerationJob> {
|
||
const billing = job.billing;
|
||
if (!billing || billing.status !== "pending") return job;
|
||
if (isQuotaExemptBilling(job)) {
|
||
return updateGenerationJob(job.id, {
|
||
billing: {
|
||
...billing,
|
||
quotaExempt: true,
|
||
status: "not_charged",
|
||
settlementStatus: job.provider === "seedance" ? "pending" : billing.settlementStatus
|
||
}
|
||
});
|
||
}
|
||
if (!job.usageContext?.organizationId) return job;
|
||
const reservedAmountFen = billing.reservedAmountFen ?? billing.amountFen;
|
||
const result = await postWalletEntry({
|
||
organizationId: job.usageContext.organizationId,
|
||
accountId: job.usageContext.accountId,
|
||
jobId: job.id,
|
||
kind: "charge",
|
||
deltaFen: -reservedAmountFen,
|
||
idempotencyKey: `job-charge:${job.id}`,
|
||
description: `${capabilityLabel(job.capability)} · ${job.reqKey}`,
|
||
metadata: {
|
||
quote: { ...billing, reservedAmountFen },
|
||
accountName: job.usageContext.displayName,
|
||
organizationName: job.usageContext.organizationName
|
||
}
|
||
});
|
||
return updateGenerationJob(job.id, {
|
||
billing: {
|
||
...billing,
|
||
reservedAmountFen,
|
||
status: "charged",
|
||
settlementStatus: job.provider === "seedance" ? "pending" : billing.settlementStatus,
|
||
ledgerEntryId: result.entry.id,
|
||
chargedAt: result.entry.createdAt
|
||
}
|
||
});
|
||
}
|
||
|
||
export async function refundGenerationCharge(jobOrId: GenerationJob | string, reason: string): Promise<GenerationJob | null> {
|
||
const job = typeof jobOrId === "string" ? await getGenerationJob(jobOrId) : jobOrId;
|
||
if (!job) return null;
|
||
if (!["failed", "expired", "cancelled"].includes(job.status)) return job;
|
||
const billing = job.billing;
|
||
if (!billing || isQuotaExemptBilling(job) || billing.status !== "charged" || !job.usageContext?.organizationId) return job;
|
||
const result = await postWalletEntry({
|
||
organizationId: job.usageContext.organizationId,
|
||
accountId: job.usageContext.accountId,
|
||
jobId: job.id,
|
||
kind: "refund",
|
||
deltaFen: billing.amountFen,
|
||
idempotencyKey: `job-refund:${job.id}`,
|
||
description: `${capabilityLabel(job.capability)}失败退款 · ${reason}`,
|
||
metadata: {
|
||
chargeLedgerEntryId: billing.ledgerEntryId,
|
||
reason,
|
||
quote: billing
|
||
}
|
||
});
|
||
return updateGenerationJob(job.id, {
|
||
billing: {
|
||
...billing,
|
||
status: "refunded",
|
||
refundLedgerEntryId: result.entry.id,
|
||
refundedAt: result.entry.createdAt,
|
||
refundReason: reason
|
||
}
|
||
});
|
||
}
|
||
|
||
export async function settleSeedanceGenerationCharge(
|
||
jobOrId: GenerationJob | string,
|
||
completionTokens?: number
|
||
): Promise<GenerationJob | null> {
|
||
const job = typeof jobOrId === "string" ? await getGenerationJob(jobOrId) : jobOrId;
|
||
if (!job) return null;
|
||
const billing = job.billing;
|
||
const quotaExempt = isQuotaExemptBilling(job);
|
||
const organizationId = job.usageContext?.organizationId;
|
||
const chargeReady = billing?.status === "charged" || quotaExempt && billing?.status === "not_charged";
|
||
if (job.provider !== "seedance" || !billing || !chargeReady || !quotaExempt && !organizationId) return job;
|
||
if (billing.settlementStatus === "settled" || billing.settlementStatus === "estimated") return job;
|
||
|
||
if (!Number.isFinite(completionTokens) || Number(completionTokens) <= 0) {
|
||
return updateGenerationJob(job.id, {
|
||
billing: {
|
||
...billing,
|
||
settlementStatus: "estimated",
|
||
settlementReason: "provider_usage_unavailable",
|
||
settledAt: new Date().toISOString()
|
||
}
|
||
});
|
||
}
|
||
|
||
const inputVideo = requestHasInputVideo(job.requestPayload);
|
||
const resolution = billing.parameters?.resolution;
|
||
const actualAmountFen = calculateSeedanceActualAmountFen({
|
||
resolution,
|
||
inputVideo,
|
||
completionTokens: Number(completionTokens),
|
||
markupMultiplier: billing.markupMultiplier
|
||
});
|
||
const deltaFen = actualAmountFen - billing.amountFen;
|
||
let settlementLedgerEntryId: string | undefined;
|
||
let settledAt = new Date().toISOString();
|
||
if (deltaFen !== 0 && !quotaExempt && organizationId) {
|
||
const settlement = await postWalletEntry({
|
||
organizationId,
|
||
accountId: job.usageContext?.accountId,
|
||
jobId: job.id,
|
||
kind: deltaFen > 0 ? "charge" : "refund",
|
||
deltaFen: -deltaFen,
|
||
idempotencyKey: `job-settlement:${job.id}`,
|
||
description: deltaFen > 0 ? `${capabilityLabel(job.capability)}实际用量补扣` : `${capabilityLabel(job.capability)}实际用量差额退回`,
|
||
metadata: {
|
||
operation: "seedance_actual_settlement",
|
||
reservedAmountFen: billing.reservedAmountFen ?? billing.amountFen,
|
||
chargedAmountFen: billing.amountFen,
|
||
actualAmountFen,
|
||
completionTokens: Math.floor(Number(completionTokens)),
|
||
inputVideo,
|
||
resolution: String(resolution || "720p")
|
||
}
|
||
});
|
||
settlementLedgerEntryId = settlement.entry.id;
|
||
settledAt = settlement.entry.createdAt;
|
||
}
|
||
|
||
return updateGenerationJob(job.id, {
|
||
billing: {
|
||
...billing,
|
||
amountFen: actualAmountFen,
|
||
settlementStatus: "settled",
|
||
settlementLedgerEntryId,
|
||
settledAt,
|
||
providerUsage: {
|
||
completionTokens: Math.floor(Number(completionTokens)),
|
||
resolution: String(resolution || "720p"),
|
||
inputVideo,
|
||
tokenPriceFenPerMillion: seedanceTokenPriceFenPerMillion(resolution, inputVideo)
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
export async function getOrganizationBillingSnapshot(organizationId: string) {
|
||
const wallet = await getOrganizationWallet(organizationId);
|
||
return {
|
||
wallet,
|
||
balanceFen: wallet.balanceFen,
|
||
balanceYuan: wallet.balanceFen / 100
|
||
};
|
||
}
|
||
|
||
export function getBillingAccountConfig(): BillingAccountConfig {
|
||
return {
|
||
accountName: optionalEnv("ZHINIAN_BILLING_ACCOUNT_NAME"),
|
||
bankName: optionalEnv("ZHINIAN_BILLING_ACCOUNT_BANK"),
|
||
accountNumber: optionalEnv("ZHINIAN_BILLING_ACCOUNT_NUMBER"),
|
||
contact: optionalEnv("ZHINIAN_BILLING_CONTACT")
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Direct organization top-up entry point for administrator actions and future
|
||
* payment-success callbacks. The caller must only invoke it after the payment
|
||
* provider has already confirmed the amount when self-service payments exist.
|
||
*/
|
||
export async function postOrganizationTopUp(input: {
|
||
organizationId: string;
|
||
amountFen: number;
|
||
idempotencyKey: string;
|
||
description?: string;
|
||
metadata?: Record<string, unknown>;
|
||
}) {
|
||
if (!Number.isFinite(input.amountFen) || input.amountFen <= 0) {
|
||
throw Object.assign(new Error("上账金额必须大于 0。"), { status: 400 });
|
||
}
|
||
return postWalletEntry({
|
||
organizationId: input.organizationId,
|
||
kind: "recharge",
|
||
deltaFen: Math.round(input.amountFen),
|
||
idempotencyKey: input.idempotencyKey,
|
||
description: input.description || "组织余额上账",
|
||
metadata: {
|
||
operation: "organization_top_up",
|
||
...input.metadata
|
||
}
|
||
});
|
||
}
|
||
|
||
export async function getBillingOverview(input: { organizationId: string; accountId: string }) {
|
||
const [wallet, ledger, personalLedger] = await Promise.all([
|
||
getOrganizationWallet(input.organizationId),
|
||
listBillingLedgerEntries({ organizationId: input.organizationId, limit: 500 }),
|
||
listBillingLedgerEntries({ organizationId: input.organizationId, accountId: input.accountId, limit: 500 })
|
||
]);
|
||
return {
|
||
wallet,
|
||
ledger,
|
||
billingAccount: getBillingAccountConfig(),
|
||
summary: summarizeLedger(ledger),
|
||
personal: summarizeLedger(personalLedger)
|
||
};
|
||
}
|
||
|
||
function summarizeLedger(entries: Array<{ kind: string; deltaFen: number }>) {
|
||
const rechargeFen = entries.filter((entry) => entry.kind === "recharge" || entry.kind === "adjustment" && entry.deltaFen > 0).reduce((sum, entry) => sum + Math.max(0, entry.deltaFen), 0);
|
||
const chargedFen = entries.filter((entry) => entry.kind === "charge").reduce((sum, entry) => sum + Math.max(0, -entry.deltaFen), 0);
|
||
const refundedFen = entries.filter((entry) => entry.kind === "refund").reduce((sum, entry) => sum + Math.max(0, entry.deltaFen), 0);
|
||
return { rechargeFen, chargedFen, refundedFen, netConsumedFen: Math.max(0, chargedFen - refundedFen) };
|
||
}
|
||
|
||
function billingEnabled(): boolean {
|
||
return process.env.ZHINIAN_BILLING_REQUIRED !== "0";
|
||
}
|
||
|
||
function isQuotaExemptUsageContext(usageContext?: UsageContext): boolean {
|
||
return usageContext?.source === "platform" && usageContext.role === "super_admin";
|
||
}
|
||
|
||
function isQuotaExemptBilling(job: GenerationJob): boolean {
|
||
return Boolean(job.billing?.quotaExempt || isQuotaExemptUsageContext(job.usageContext));
|
||
}
|
||
|
||
export async function findMatchingPriceRule(input: BillingGenerationInput): Promise<BillingPriceRule | null> {
|
||
const rules = await listBillingPriceRules({ includeDisabled: false });
|
||
return findMatchingBillingPriceRule(rules, input);
|
||
}
|
||
|
||
export function findMatchingBillingPriceRule(rules: BillingPriceRule[], input: Pick<BillingGenerationInput, "provider" | "capability" | "reqKey" | "requestPayload">): BillingPriceRule | null {
|
||
const parameters = normalizeBillingParameters(input.requestPayload);
|
||
const scoped = rules.filter((rule) => rule.provider === input.provider && rule.capability === input.capability);
|
||
const matches = scoped.flatMap((rule) => {
|
||
if (rule.reqKey && rule.reqKey !== input.reqKey) return [];
|
||
const conditions = effectiveBillingRuleConditions(rule);
|
||
if (!conditionsMatchParameters(conditions, parameters)) return [];
|
||
return [{
|
||
rule,
|
||
reqKeySpecificity: rule.reqKey ? 1 : 0,
|
||
conditionSpecificity: Object.keys(conditions).length,
|
||
priority: Number.isFinite(rule.priority) ? Number(rule.priority) : 0
|
||
}];
|
||
});
|
||
if (!matches.length) return null;
|
||
|
||
matches.sort((left, right) => right.reqKeySpecificity - left.reqKeySpecificity
|
||
|| right.conditionSpecificity - left.conditionSpecificity
|
||
|| right.priority - left.priority
|
||
|| left.rule.id.localeCompare(right.rule.id));
|
||
const winner = matches[0];
|
||
const ambiguous = matches.filter((item) => item !== winner
|
||
&& item.reqKeySpecificity === winner.reqKeySpecificity
|
||
&& item.conditionSpecificity === winner.conditionSpecificity
|
||
&& item.priority === winner.priority);
|
||
if (ambiguous.length) {
|
||
throw new BillingConfigurationError(`计费规则配置存在歧义：${[winner.rule.id, ...ambiguous.map((item) => item.rule.id)].join("、")}。请让条件更具体或调整优先级。`);
|
||
}
|
||
return winner.rule;
|
||
}
|
||
|
||
export function normalizeBillingParameters(requestPayload: Record<string, unknown>): BillingParameterSnapshot {
|
||
const settings = recordValue(requestPayload.settings);
|
||
const providerPayload = recordValue(requestPayload.providerPayload);
|
||
const input = recordValue(requestPayload.input);
|
||
const providerParameters = recordValue(providerPayload?.parameters);
|
||
const providerInput = recordValue(providerPayload?.input);
|
||
const inputSettings = recordValue(input?.settings);
|
||
const assembled = recordValue(requestPayload.assembled);
|
||
const parameters: BillingParameterSnapshot = {};
|
||
|
||
setParameter(parameters, "model", firstValue(providerPayload?.model, input?.model, settings?.model));
|
||
setParameter(parameters, "resolution", firstValue(
|
||
settings?.resolution,
|
||
providerParameters?.resolution,
|
||
providerPayload?.resolution,
|
||
inputSettings?.resolution,
|
||
input?.resolution
|
||
), normalizeTextParameter);
|
||
setParameter(parameters, "size", firstValue(
|
||
providerPayload?.size,
|
||
providerParameters?.size,
|
||
inputSettings?.size,
|
||
input?.size
|
||
), normalizeSizeParameter);
|
||
|
||
const width = numberParameter(firstValue(providerPayload?.width, input?.width));
|
||
const height = numberParameter(firstValue(providerPayload?.height, input?.height));
|
||
if (parameters.size === undefined && width !== undefined && height !== undefined) {
|
||
parameters.size = `${width}*${height}`;
|
||
}
|
||
const aspectRatio = firstValue(
|
||
settings?.ratio,
|
||
settings?.aspectRatio,
|
||
providerPayload?.ratio,
|
||
providerParameters?.ratio,
|
||
inputSettings?.ratio,
|
||
input?.ratio,
|
||
input?.aspectRatio
|
||
);
|
||
const normalizedAspectRatio = normalizeAspectRatioParameter(aspectRatio, width, height);
|
||
if (normalizedAspectRatio !== undefined) parameters.aspectRatio = normalizedAspectRatio;
|
||
|
||
setParameter(parameters, "quality", firstValue(
|
||
input?.quality,
|
||
settings?.quality,
|
||
providerPayload?.quality,
|
||
providerParameters?.quality
|
||
), normalizeTextParameter);
|
||
setParameter(parameters, "duration", firstValue(
|
||
settings?.duration,
|
||
providerParameters?.duration,
|
||
providerPayload?.duration,
|
||
inputSettings?.duration,
|
||
input?.duration
|
||
), numberParameter);
|
||
|
||
const imageCount = numberParameter(firstValue(
|
||
providerPayload?.n,
|
||
providerParameters?.n,
|
||
input?.n,
|
||
input?.imageCount
|
||
));
|
||
if (imageCount !== undefined && imageCount > 0) parameters.imageCount = Math.ceil(imageCount);
|
||
|
||
const referenceImageCount = countReferenceImages({ requestPayload, input, providerPayload, providerInput, assembled });
|
||
if (referenceImageCount > 0) parameters.referenceImageCount = referenceImageCount;
|
||
|
||
const inputVideo = countReferenceVideos({ input, assembled });
|
||
if (inputVideo > 0) parameters.inputVideo = true;
|
||
|
||
setParameter(parameters, "scale", firstValue(input?.scale, settings?.scale), numberParameter);
|
||
setParameter(parameters, "generateAudio", firstValue(
|
||
settings?.generate_audio,
|
||
settings?.generateAudio,
|
||
providerParameters?.generate_audio,
|
||
providerParameters?.generateAudio,
|
||
input?.generate_audio,
|
||
input?.generateAudio
|
||
), booleanParameter);
|
||
|
||
return parameters;
|
||
}
|
||
|
||
export function effectiveBillingRuleConditions(rule: BillingPriceRule): BillingRuleConditions {
|
||
const legacyConditions = parseLegacyVariantKey(rule.variantKey);
|
||
return { ...legacyConditions, ...(rule.conditions || {}) };
|
||
}
|
||
|
||
export function quantityForRule(rule: BillingPriceRule, parameters: BillingParameterSnapshot): number {
|
||
const source = rule.quantitySource || defaultQuantitySource(rule.unit);
|
||
if (source === "request") return 1;
|
||
if (source === "duration") {
|
||
const duration = Number(parameters.duration);
|
||
return Number.isFinite(duration) && duration > 0 ? Math.ceil(duration) : 1;
|
||
}
|
||
const imageCount = Number(parameters.imageCount);
|
||
return Number.isFinite(imageCount) && imageCount > 0 ? Math.ceil(imageCount) : 1;
|
||
}
|
||
|
||
function defaultQuantitySource(unit: BillingPriceRule["unit"]): BillingQuantitySource {
|
||
if (unit === "video_second") return "duration";
|
||
if (unit === "image") return "image_count";
|
||
return "request";
|
||
}
|
||
|
||
function conditionsMatchParameters(conditions: BillingRuleConditions, parameters: BillingParameterSnapshot): boolean {
|
||
return Object.entries(conditions).every(([key, condition]) => conditionMatchesValue(condition, parameters[key]));
|
||
}
|
||
|
||
function conditionMatchesValue(condition: BillingConditionValue, actual: BillingScalar | undefined): boolean {
|
||
if (actual === undefined) return false;
|
||
if (typeof condition === "object" && condition !== null && !Array.isArray(condition)) {
|
||
if (Array.isArray(condition.values) && !condition.values.some((value) => scalarEquals(value, actual))) return false;
|
||
const numericActual = Number(actual);
|
||
if (condition.min !== undefined && (!Number.isFinite(numericActual) || numericActual < condition.min)) return false;
|
||
if (condition.max !== undefined && (!Number.isFinite(numericActual) || numericActual > condition.max)) return false;
|
||
return true;
|
||
}
|
||
if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean") {
|
||
return scalarEquals(condition, actual);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function scalarEquals(left: BillingScalar, right: BillingScalar): boolean {
|
||
if (typeof left === "number" || typeof right === "number") return Number(left) === Number(right);
|
||
if (typeof left === "boolean" || typeof right === "boolean") return Boolean(left) === Boolean(right);
|
||
return normalizeTextParameter(left) === normalizeTextParameter(right);
|
||
}
|
||
|
||
function parseLegacyVariantKey(variantKey?: string): BillingRuleConditions {
|
||
if (!variantKey) return {};
|
||
const conditions: BillingRuleConditions = {};
|
||
for (const part of variantKey.split(/[;,]/)) {
|
||
const separator = part.indexOf("=");
|
||
if (separator <= 0) continue;
|
||
const key = part.slice(0, separator).trim();
|
||
const value = part.slice(separator + 1).trim();
|
||
if (!key || !value) continue;
|
||
if (["model", "resolution", "size", "aspectRatio", "ratio", "quality"].includes(key)) {
|
||
const normalized = normalizeTextParameter(value);
|
||
if (normalized !== undefined) conditions[key === "ratio" ? "aspectRatio" : key] = normalized;
|
||
continue;
|
||
}
|
||
if (["duration", "imageCount", "referenceImageCount", "scale"].includes(key)) {
|
||
const number = Number(value);
|
||
if (Number.isFinite(number)) conditions[key] = number;
|
||
}
|
||
}
|
||
return conditions;
|
||
}
|
||
|
||
function countReferenceImages(input: {
|
||
requestPayload: Record<string, unknown>;
|
||
input?: Record<string, unknown>;
|
||
providerPayload?: Record<string, unknown>;
|
||
providerInput?: Record<string, unknown>;
|
||
assembled?: Record<string, unknown>;
|
||
}): number {
|
||
const urls = [
|
||
...stringArray(input.input?.imageUrls),
|
||
...stringArray(input.providerPayload?.image_urls),
|
||
...stringArray(input.providerPayload?.imageUrls)
|
||
];
|
||
const materials = [
|
||
...(Array.isArray(input.input?.materials) ? input.input.materials : []),
|
||
...(Array.isArray(input.assembled?.materials) ? input.assembled.materials : [])
|
||
];
|
||
const materialImages = materials.filter((item) => {
|
||
const record = recordValue(item);
|
||
return record?.type === "image" || typeof record?.url === "string";
|
||
}).length;
|
||
const messages = Array.isArray(input.providerInput?.messages) ? input.providerInput.messages : [];
|
||
const messageImages = messages.reduce((count, message) => {
|
||
const content = recordValue(message)?.content;
|
||
return count + (Array.isArray(content) ? content.filter((item) => Boolean(recordValue(item)?.image)).length : 0);
|
||
}, 0);
|
||
return Math.max(urls.length, materialImages, messageImages);
|
||
}
|
||
|
||
function countReferenceVideos(input: { input?: Record<string, unknown>; assembled?: Record<string, unknown> }): number {
|
||
const materials = [
|
||
...(Array.isArray(input.input?.materials) ? input.input.materials : []),
|
||
...(Array.isArray(input.assembled?.materials) ? input.assembled.materials : [])
|
||
];
|
||
return materials.filter((item) => recordValue(item)?.type === "video").length;
|
||
}
|
||
|
||
function stringArray(value: unknown): string[] {
|
||
return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string" && item.trim().length > 0) : [];
|
||
}
|
||
|
||
function setParameter(
|
||
target: BillingParameterSnapshot,
|
||
key: string,
|
||
value: unknown,
|
||
normalize: (value: unknown) => BillingScalar | undefined = normalizeScalarParameter
|
||
) {
|
||
const normalized = normalize(value);
|
||
if (normalized !== undefined) target[key] = normalized;
|
||
}
|
||
|
||
function firstValue(...values: unknown[]): unknown {
|
||
return values.find((value) => value !== undefined && value !== null && value !== "");
|
||
}
|
||
|
||
function normalizeScalarParameter(value: unknown): BillingScalar | undefined {
|
||
if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
|
||
return undefined;
|
||
}
|
||
|
||
function normalizeTextParameter(value: unknown): string | undefined {
|
||
if (typeof value !== "string" && typeof value !== "number") return undefined;
|
||
const normalized = String(value).trim().toLowerCase().replace(/\s+/g, "");
|
||
return normalized || undefined;
|
||
}
|
||
|
||
function normalizeSizeParameter(value: unknown): string | undefined {
|
||
const normalized = normalizeTextParameter(value);
|
||
return normalized?.replace(/[×x]/g, "*");
|
||
}
|
||
|
||
function normalizeAspectRatioParameter(value: unknown, width?: number, height?: number): string | undefined {
|
||
const normalized = normalizeTextParameter(value);
|
||
if (normalized) return normalized;
|
||
if (width === undefined || height === undefined || height <= 0) return undefined;
|
||
const ratio = width / height;
|
||
const common = [[1, 1], [4, 3], [3, 2], [16, 9], [9, 16], [21, 9], [9, 21], [2, 3], [3, 4]] as const;
|
||
const match = common.find(([numerator, denominator]) => Math.abs(ratio - numerator / denominator) < 0.02);
|
||
return match ? `${match[0]}:${match[1]}` : ratio.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
|
||
}
|
||
|
||
function numberParameter(value: unknown): number | undefined {
|
||
const number = Number(value);
|
||
return Number.isFinite(number) ? number : undefined;
|
||
}
|
||
|
||
function booleanParameter(value: unknown): boolean | undefined {
|
||
if (typeof value === "boolean") return value;
|
||
if (value === "true" || value === "1") return true;
|
||
if (value === "false" || value === "0") return false;
|
||
return undefined;
|
||
}
|
||
|
||
function recordValue(value: unknown): Record<string, unknown> | undefined {
|
||
return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
|
||
}
|
||
|
||
function capabilityLabel(capability: GenerationCapability): string {
|
||
return capability === "video.generate" ? "视频生成" : "图片生成";
|
||
}
|
||
|
||
function optionalEnv(name: string): string | undefined {
|
||
const value = process.env[name]?.trim();
|
||
return value || undefined;
|
||
}
|
||
|
||
export { InsufficientBalanceError };
|