koishi-plugin-chatluna-usage 1.0.0

package/lib/index.cjs

@@ -0,0 +1,424 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatLunaUsage: () => ChatLunaUsage,
+  Config: () => Config,
+  apply: () => apply,
+  cleanupUsage: () => cleanupUsage,
+  default: () => index_default,
+  inject: () => inject,
+  name: () => name,
+  queryUsage: () => queryUsage
+});
+module.exports = __toCommonJS(index_exports);
+var import_koishi = require("koishi");
+var import_plugin_console = require("@koishijs/plugin-console");
+var import_path = require("path");
+var logger = new import_koishi.Logger("chatluna-usage");
+var ChatLunaUsage = class extends import_plugin_console.DataService {
+  constructor(ctx, config) {
+    super(ctx, "chatluna_usage", {
+      immediate: true
+    });
+    this.config = config;
+    ctx.database.extend(
+      "chatluna_usage",
+      {
+        id: "unsigned",
+        source: { type: "char", length: 128 },
+        callType: { type: "char", length: 20 },
+        platform: { type: "char", length: 128 },
+        chatPlatform: { type: "char", length: 128, nullable: true },
+        model: { type: "char", length: 255 },
+        usageMetadata: {
+          type: "json",
+          nullable: false,
+          initial: {
+            input_tokens: 0,
+            output_tokens: 0,
+            total_tokens: 0
+          }
+        },
+        estimated: "boolean",
+        success: "boolean",
+        createdAt: { type: "timestamp", nullable: false },
+        conversationId: { type: "char", length: 255, nullable: true },
+        requestId: { type: "char", length: 255, nullable: true },
+        userId: { type: "char", length: 255, nullable: true },
+        guildId: { type: "char", length: 255, nullable: true }
+      },
+      {
+        autoInc: true,
+        primary: "id",
+        indexes: ["createdAt", "source", "model", "guildId"]
+      }
+    );
+    ctx.on("chatluna/model-usage", async (usage) => {
+      try {
+        await ctx.database.create("chatluna_usage", {
+          source: usage.source,
+          callType: usage.callType,
+          platform: usage.platform,
+          chatPlatform: usage.context?.chatPlatform ?? null,
+          model: usage.model,
+          usageMetadata: usage.usageMetadata,
+          estimated: usage.estimated,
+          success: usage.success,
+          createdAt: usage.createdAt,
+          conversationId: usage.context?.conversationId ?? null,
+          requestId: usage.context?.requestId ?? null,
+          userId: usage.context?.userId ?? null,
+          guildId: usage.context?.guildId ?? null
+        });
+        if (config.webui) await this.refresh();
+      } catch (e) {
+        logger.error(e);
+      }
+    });
+    if (!config.webui) return;
+    ctx.inject(["console"], (ctx2) => {
+      ctx2.console.addListener(
+        "chatluna-usage/query",
+        async (input) => this.query(input)
+      );
+      ctx2.console.addListener(
+        "chatluna-usage/list",
+        async (input) => this.list(input)
+      );
+      ctx2.console.addListener(
+        "chatluna-usage/cleanup",
+        async (before) => {
+          await this.cleanup(before ? new Date(before) : void 0);
+          await this.refresh();
+          return { success: true };
+        }
+      );
+      ctx2.console.addEntry({
+        dev: (0, import_path.resolve)(__dirname, "../client/index.ts"),
+        prod: (0, import_path.resolve)(__dirname, "../dist")
+      });
+    });
+  }
+  static {
+    __name(this, "ChatLunaUsage");
+  }
+  async get() {
+    return await this.query();
+  }
+  async query(input = {}) {
+    const rows = await this.search(input);
+    const groupBy = input.groupBy ?? "model";
+    const sortBy = input.sortBy ?? "totalTokens";
+    const desc = input.desc ?? true;
+    const groups = /* @__PURE__ */ new Map();
+    const models = /* @__PURE__ */ new Map();
+    const sources = /* @__PURE__ */ new Map();
+    const timeline = /* @__PURE__ */ new Map();
+    const modelTimeline = /* @__PURE__ */ new Map();
+    const totals = {
+      key: "total",
+      label: "全部用量",
+      calls: 0,
+      successfulCalls: 0,
+      failedCalls: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      estimatedTokens: 0,
+      cachedTokens: 0,
+      reasoningTokens: 0,
+      successRate: 0
+    };
+    for (const row of rows) {
+      const key = this.groupKey(row, groupBy);
+      const item = groups.get(key) ?? {
+        key,
+        label: this.groupLabel(key, groupBy),
+        platform: groupBy === "model" ? row.platform : void 0,
+        calls: 0,
+        successfulCalls: 0,
+        failedCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        estimatedTokens: 0,
+        cachedTokens: 0,
+        reasoningTokens: 0,
+        successRate: 0
+      };
+      const model = models.get(row.model) ?? {
+        key: row.model,
+        label: row.model,
+        platform: row.platform,
+        calls: 0,
+        successfulCalls: 0,
+        failedCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        estimatedTokens: 0,
+        cachedTokens: 0,
+        reasoningTokens: 0,
+        successRate: 0
+      };
+      const source = sources.get(row.source) ?? {
+        key: row.source,
+        label: row.source,
+        calls: 0,
+        successfulCalls: 0,
+        failedCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        estimatedTokens: 0,
+        cachedTokens: 0,
+        reasoningTokens: 0,
+        successRate: 0
+      };
+      const date = this.dateKey(row.createdAt, input.period ?? "day");
+      const point = timeline.get(date) ?? {
+        date,
+        calls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        cachedTokens: 0,
+        reasoningTokens: 0
+      };
+      this.add(row, item);
+      this.add(row, model);
+      this.add(row, source);
+      this.add(row, totals);
+      point.calls += 1;
+      point.inputTokens += row.usageMetadata.input_tokens;
+      point.outputTokens += row.usageMetadata.output_tokens;
+      point.totalTokens += row.usageMetadata.total_tokens;
+      point.cachedTokens += (row.usageMetadata.input_token_details?.cache_read ?? 0) + (row.usageMetadata.input_token_details?.cache_creation ?? 0);
+      point.reasoningTokens += row.usageMetadata.output_token_details?.reasoning ?? 0;
+      if (!modelTimeline.has(row.model))
+        modelTimeline.set(row.model, /* @__PURE__ */ new Map());
+      modelTimeline.get(row.model).set(date, (modelTimeline.get(row.model).get(date) ?? 0) + 1);
+      groups.set(key, item);
+      models.set(row.model, model);
+      sources.set(row.source, source);
+      timeline.set(date, point);
+    }
+    this.finish(totals);
+    return {
+      query: this.withDefaults(input),
+      totals,
+      groups: [...groups.values()].map((row) => this.finish(row)).sort((a, b) => {
+        const diff = a[sortBy] - b[sortBy];
+        return desc ? -diff : diff;
+      }),
+      models: [...models.values()].map((row) => this.finish(row)).sort((a, b) => b.calls - a.calls),
+      sources: [...sources.values()].map((row) => this.finish(row)).sort((a, b) => b.calls - a.calls),
+      timeline: [...timeline.values()].sort(
+        (a, b) => a.date.localeCompare(b.date)
+      ),
+      modelTimeline: [...modelTimeline.entries()].map(
+        ([model, dates]) => ({
+          model,
+          points: [...dates.entries()].map(([date, calls]) => ({ date, calls })).sort((a, b) => a.date.localeCompare(b.date))
+        })
+      ),
+      list: this.pageRows(rows, input)
+    };
+  }
+  async list(input = {}) {
+    const rows = await this.search(input);
+    return this.pageRows(rows, input);
+  }
+  async cleanup(before) {
+    await this.ctx.database.remove(
+      "chatluna_usage",
+      before ? { createdAt: { $lt: before } } : {}
+    );
+  }
+  async search(input) {
+    const query = this.withDefaults(input);
+    const where = {
+      createdAt: { $gte: query.start, $lt: query.end }
+    };
+    if (query.source) where.source = query.source;
+    if (query.model) where.model = query.model;
+    if (query.platform) where.platform = query.platform;
+    if (query.callType) where.callType = query.callType;
+    if (query.success != null) where.success = query.success;
+    if (query.estimated != null) where.estimated = query.estimated;
+    const rows = await this.ctx.database.get(
+      "chatluna_usage",
+      where
+    );
+    if (!query.chatPlatform && !query.guildId && !query.userId && !query.keyword) {
+      return rows;
+    }
+    return rows.filter((row) => {
+      if (query.chatPlatform && !(row.chatPlatform ?? "").includes(query.chatPlatform)) {
+        return false;
+      }
+      if (query.guildId && !(row.guildId ?? "").includes(query.guildId)) {
+        return false;
+      }
+      if (query.userId && !(row.userId ?? "").includes(query.userId)) {
+        return false;
+      }
+      if (!query.keyword) return true;
+      return [
+        row.source,
+        row.callType,
+        row.platform,
+        row.chatPlatform,
+        row.model,
+        row.conversationId,
+        row.requestId,
+        row.userId,
+        row.guildId
+      ].filter(Boolean).some((value) => value.includes(query.keyword));
+    });
+  }
+  withDefaults(input) {
+    const period = input.period ?? "day";
+    const end = input.end ? new Date(input.end) : /* @__PURE__ */ new Date();
+    const start = input.start ? new Date(input.start) : period === "year" ? new Date(end.getFullYear() - 1, end.getMonth(), end.getDate()) : period === "month" ? new Date(end.getFullYear(), end.getMonth() - 11, 1) : new Date(+end - this.config.recentDays * import_koishi.Time.day);
+    return {
+      ...input,
+      period,
+      groupBy: input.groupBy ?? "model",
+      sortBy: input.sortBy ?? "totalTokens",
+      desc: input.desc ?? true,
+      page: input.page ?? 1,
+      pageSize: input.pageSize ?? this.config.pageSize,
+      listSortBy: input.listSortBy ?? "createdAt",
+      listDesc: input.listDesc ?? true,
+      start,
+      end
+    };
+  }
+  pageRows(rows, input) {
+    const query = this.withDefaults(input);
+    const sorted = rows.map((row) => ({
+      ...row,
+      inputTokens: row.usageMetadata.input_tokens,
+      outputTokens: row.usageMetadata.output_tokens,
+      totalTokens: row.usageMetadata.total_tokens,
+      estimated: row.estimated,
+      cachedTokens: (row.usageMetadata.input_token_details?.cache_read ?? 0) + (row.usageMetadata.input_token_details?.cache_creation ?? 0),
+      reasoningTokens: row.usageMetadata.output_token_details?.reasoning ?? 0
+    })).sort((a, b) => {
+      const left = a[query.listSortBy];
+      const right = b[query.listSortBy];
+      let diff;
+      if (left instanceof Date && right instanceof Date) {
+        diff = +left - +right;
+      } else if (typeof left === "string" && typeof right === "string") {
+        diff = left.localeCompare(right);
+      } else {
+        diff = Number(left) - Number(right);
+      }
+      return query.listDesc ? -diff : diff;
+    });
+    const start = (query.page - 1) * query.pageSize;
+    return {
+      total: sorted.length,
+      page: query.page,
+      pageSize: query.pageSize,
+      rows: sorted.slice(start, start + query.pageSize)
+    };
+  }
+  add(row, item) {
+    item.calls += 1;
+    if (row.success) item.successfulCalls += 1;
+    else item.failedCalls += 1;
+    item.inputTokens += row.usageMetadata.input_tokens;
+    item.outputTokens += row.usageMetadata.output_tokens;
+    item.totalTokens += row.usageMetadata.total_tokens;
+    item.cachedTokens += (row.usageMetadata.input_token_details?.cache_read ?? 0) + (row.usageMetadata.input_token_details?.cache_creation ?? 0);
+    item.reasoningTokens += row.usageMetadata.output_token_details?.reasoning ?? 0;
+    if (row.estimated)
+      item.estimatedTokens += row.usageMetadata.total_tokens;
+    if (!item.lastSeen || row.createdAt > item.lastSeen)
+      item.lastSeen = row.createdAt;
+  }
+  finish(item) {
+    item.successRate = item.calls ? item.successfulCalls / item.calls : 0;
+    return item;
+  }
+  groupKey(row, groupBy) {
+    if (groupBy === "guild") return row.guildId ?? "private";
+    if (groupBy === "chatPlatform") return row.chatPlatform ?? "unknown";
+    return row[groupBy];
+  }
+  groupLabel(key, groupBy) {
+    if (groupBy === "guild" && key === "private") return "私聊/未知群";
+    if (groupBy === "chatPlatform" && key === "unknown")
+      return "未知聊天平台";
+    return key;
+  }
+  dateKey(date, period) {
+    const y = date.getFullYear();
+    const m = String(date.getMonth() + 1).padStart(2, "0");
+    const d = String(date.getDate()).padStart(2, "0");
+    if (period === "year") return String(y);
+    if (period === "month") return `${y}-${m}`;
+    return `${y}-${m}-${d}`;
+  }
+};
+((ChatLunaUsage2) => {
+  ChatLunaUsage2.Config = import_koishi.Schema.object({
+    recentDays: import_koishi.Schema.natural().description("默认统计最近几天的数据。").default(30),
+    pageSize: import_koishi.Schema.natural().description("调用明细分页大小。").default(50),
+    webui: import_koishi.Schema.boolean().description("启用 Web UI 控制台用量面板。").default(true)
+  });
+  ChatLunaUsage2.inject = ["chatluna", "database"];
+})(ChatLunaUsage || (ChatLunaUsage = {}));
+var index_default = ChatLunaUsage;
+async function queryUsage(ctx, source) {
+  const result = await ctx.chatluna_usage.query({ groupBy: "source" });
+  if (!source) return result.groups;
+  return result.groups.filter((row) => row.key === source);
+}
+__name(queryUsage, "queryUsage");
+async function cleanupUsage(ctx, before) {
+  await ctx.chatluna_usage.cleanup(before);
+}
+__name(cleanupUsage, "cleanupUsage");
+function apply(ctx, config) {
+  ctx.plugin(ChatLunaUsage, config);
+}
+__name(apply, "apply");
+var Config = ChatLunaUsage.Config;
+var inject = {
+  required: ["chatluna", "database"],
+  optional: ["console"]
+};
+var name = "chatluna-usage";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatLunaUsage,
+  Config,
+  apply,
+  cleanupUsage,
+  inject,
+  name,
+  queryUsage
+});