Function fetchMinimaxUsage

packages/arctic/src/provider/usage.ts:442–486

(input: {
    provider: Provider.Info
    sessionID?: string
    timePeriod?: TimePeriod
  })

  }

  async function fetchMinimaxUsage(input: {
    provider: Provider.Info
    sessionID?: string
    timePeriod?: TimePeriod
  }): Promise<Omit<Record, "providerID" | "providerName" | "fetchedAt">> {
    const sessionData = await fetchSessionUsage(input)

    let limitSummary:
      | {
          planType?: string
          allowed?: boolean
          limitReached?: boolean
          limits?: { primary?: RateLimitWindowSummary }
        }
      | undefined
    let limitError: string | undefined

    const auth = await Auth.get(input.provider.id)
    if (auth?.type === "api" && auth.groupId) {
      const apiKey = auth.key || input.provider.key || input.provider.options?.apiKey
      if (apiKey) {
        limitSummary = await fetchMinimaxUsageLimits(auth.groupId, apiKey).catch((error) => {
          limitError = error instanceof Error ? error.message : String(error)
          return undefined
        })
      }
    }

    const record: Omit<Record, "providerID" | "providerName" | "fetchedAt"> = {
      ...sessionData,
    }

    if (limitSummary) {
      record.planType = limitSummary.planType
      record.allowed = limitSummary.allowed
      record.limitReached = limitSummary.limitReached
      record.limits = limitSummary.limits
    }

    if (limitError) {
      record.error = limitError
    }

    return record
  }

  async function fetchMinimaxUsageLimits(groupId: string, apiKey: string): Promise<{
    planType?: string