梯度 0: inputTokens 0 ~ 1000 → 价格 X
梯度 1: inputTokens 1000+   → 价格 Y

场景：模型梯度 0~1000 tokens → 价格 A；1000+ → 价格 B（更低）

Call 1: inputTokens = 500 → 应匹配梯度 0，价格 A
Call 2: inputTokens = 600 → 应匹配梯度 0，价格 A

正确总价：A * 500/1000 + A * 600/1000

错误做法：累加 1100 tokens → 匹配梯度 1，价格 B
错误总价：B * 1100/1000（价格偏低，用户少付钱）

// 问题：在 while 循环中累加 tokens
inputTokens += usage.inputTokens;
outputTokens += usage.outputTokens;

// 每次调用单独计算价格并推送（当 usagePush 存在时），但不记录进返回值
const agentUsage = formatModelChars2Points({ inputTokens: usage.inputTokens, ... });
usagePush?.([{ totalPoints: agentUsage.totalPoints, ... }]);

// 返回的是累加值，调用方再次用累加值计算价格 → 重复错误
return { inputTokens, outputTokens, ... };

// toolCallInputTokens = 所有轮次累加的 tokens
const { totalPoints: modelTotalPoints } = formatModelChars2Points({
  inputTokens: toolCallInputTokens,   // ❌ 累加值
  outputTokens: toolCallOutputTokens
});

// inputTokens = runAgentLoop 返回的累加值
const llmUsage = formatModelChars2Points({
  inputTokens,   // ❌ 累加值
  outputTokens
});

// 再生成时累加 tokens
usage.inputTokens += regenerateResponse.usage.inputTokens;
usage.outputTokens += regenerateResponse.usage.outputTokens;

// 用累加值计算
const { totalPoints } = formatModelChars2Points({
  inputTokens: usage.inputTokens,   // ❌ 累加值
  outputTokens: usage.outputTokens
});

// RunAgentResponse 类型新增字段
type RunAgentResponse = {
  ...
  llmTotalPoints: number;  // ← 新增
  inputTokens: number;     // 保留，用于展示
  outputTokens: number;    // 保留，用于展示
  ...
};

// 内部实现
let llmTotalPoints: number = 0;   // ← 新增

// while 循环内，每次 LLM 调用后：
const agentUsage = formatModelChars2Points({
  model: modelData.model,
  inputTokens: usage.inputTokens,   // 当次调用的 tokens
  outputTokens: usage.outputTokens
});
llmTotalPoints += agentUsage.totalPoints;   // ← 累加价格（不是 tokens）
usagePush?.([{ totalPoints: agentUsage.totalPoints, ... }]);

// return 新增
return {
  ...
  llmTotalPoints,
};

// ResponseType 新增
type ResponseType = {
  ...
  toolCallTotalPoints: number;  // ← 新增（替代用累加 tokens 重算的方式）
  toolCallInputTokens: number;  // 保留展示用
  toolCallOutputTokens: number; // 保留展示用
};

// runAgentLoop 返回后
const { inputTokens, outputTokens, llmTotalPoints, ... } = await runAgentLoop(...);

return {
  ...
  toolCallTotalPoints: llmTotalPoints,   // ← 透传
  toolCallInputTokens: inputTokens,
  toolCallOutputTokens: outputTokens,
};

// 修改前（❌）
const { totalPoints: modelTotalPoints, modelName } = formatModelChars2Points({
  model,
  inputTokens: toolCallInputTokens,
  outputTokens: toolCallOutputTokens
});

// 修改后（✅）
// modelName 直接从 toolModel.name 获取，无需再调用 formatModelChars2Points
const modelName = toolModel.name;
const modelTotalPoints = toolCallTotalPoints;   // 直接使用预计算值，不再重算

// runAgentLoop 返回 llmTotalPoints
const { inputTokens, outputTokens, llmTotalPoints, childrenUsages, ... } = await runAgentLoop(...);

// 修改前（❌）
const llmUsage = formatModelChars2Points({ model: agentModel, inputTokens, outputTokens });

// 修改后（✅）
const modelData = getLLMModel(agentModel);
const llmUsage = {
  modelName: modelData.name,
  totalPoints: llmTotalPoints   // 使用预计算值
};

let totalPoints = 0;

// 初始调用：
const initialResult = await createLLMResponse(...);
const initialUsage = formatModelChars2Points({
  model: modelData.model,
  inputTokens: initialResult.usage.inputTokens,   // 单次 tokens
  outputTokens: initialResult.usage.outputTokens
});
totalPoints += initialUsage.totalPoints;
usage.inputTokens += initialResult.usage.inputTokens;  // 累加 tokens 仅用于展示
usage.outputTokens += initialResult.usage.outputTokens;

// 再生成时：
const regenResult = await createLLMResponse(...);
const regenUsage = formatModelChars2Points({
  model: modelData.model,
  inputTokens: regenResult.usage.inputTokens,   // 单次 tokens
  outputTokens: regenResult.usage.outputTokens
});
totalPoints += regenUsage.totalPoints;
usage.inputTokens += regenResult.usage.inputTokens;
usage.outputTokens += regenResult.usage.outputTokens;

// 最终用 totalPoints（累加价格）