Upload 197 files

.env

@@ -0,0 +1,60 @@
+#基础部分
+#设置一个你自己的访问密码
+PASSWORD=123
+#配置时区
+TZ=Asia/Shanghai
+
+#ai studio部分
+
+#将key1,key2,key3等替换为你真正拥有的gemini api key
+GEMINI_API_KEYS=key1,key2,key3
+
+#是否启用存储
+ENABLE_STORAGE=true
+
+#存储路径
+STORAGE_DIR=./hajimi
+
+#每分钟最大请求数
+MAX_REQUESTS_PER_MINUTE=30
+
+#每天每个 IP 最大请求数
+MAX_REQUESTS_PER_DAY_PER_IP=600
+
+#是否启用假流式传输
+FAKE_STREAMING=true
+
+#单api 24小时最大使用次数
+API_KEY_DAILY_LIMIT=100
+
+#空响应重试次数
+MAX_EMPTY_RESPONSES=5
+
+#是否启用伪装信息
+RANDOM_STRING=true
+
+#伪装信息长度
+RANDOM_STRING_LENGTH=5
+
+#默认的并发请求数
+CONCURRENT_REQUESTS=1
+
+#当请求失败时增加的并发请求数
+INCREASE_CONCURRENT_ON_FAILURE=0
+
+允许的最大并发请求数
+MAX_CONCURRENT_REQUESTS=3
+
+#是否启用联网模式(联网模式有严格的审核)
+SEARCH_MODE=false
+
+#联网模式提示词(用英文单引号包裹提示词)
+SEARCH_PROMPT='（使用搜索工具联网搜索，需要在content中结合搜索内容）'
+
+#vertex部分（如果您不需要vertex或不知道vertex是什么，无需配置这些内容）
+
+#是否启用vertex
+ENABLE_VERTEX=false
+
+#vertex ai 凭证
+GOOGLE_CREDENTIALS_JSON=''

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+wiki/img/claw/1.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/claw/3.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/files.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/settings.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/spaces.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/vertex/index.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/windows/添加key.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/windows/主页-安装包位置.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/zeabur/6.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/zeabur/7.png filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,53 @@
+name: "问题反馈"
+description: Bug report
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢您花时间填写此错误报告，请**务必确认您的issue不是重复的且不是因为您的操作或版本问题**
+
+  - type: checkboxes
+    attributes:
+      label: Please make sure of the following things
+      description: |
+        您必须勾选以下所有内容，否则您的issue可能会被直接关闭。
+      options:
+        - label: |
+            我已经阅读了[错误自查](./wiki/error.md)。
+        - label: |
+            我确定没有重复的issue或讨论。
+        - label: |
+            我确定是`Hajimi`自身的问题，而不是酒馆等三方件的原因。
+        - label: |
+            我确定这个问题在最新版本中没有被修复。
+
+  - type: input
+    id: version
+    attributes:
+      label: hajimi版本
+      description: |
+        您使用的是哪个版本的程序？请不要使用`latest`作为答案。
+      placeholder: v0.x.x
+    validations:
+      required: true
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: 问题描述
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: 复现方法
+      description: |
+        请提供能复现此问题的方法以方便开发者定问题，请知悉如果不提供它你的issue可能会被直接关闭。
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / 日志
+      description: |
+        请复制粘贴错误日志，或者截图

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,32 @@
+name: "功能请求"
+description: Feature request
+labels: [enhancement]
+body:
+  - type: checkboxes
+    attributes:
+      label: 请确认以下事项
+      description: 您可以选择多项，甚至全部。
+      options:
+        - label: 我已阅读了[更新日志](./update.md)。
+        - label: 我确定没有重复的议题或讨论。
+        - label: 我确定此功能尚未实现。
+        - label: 我确定这是一个合理且普遍的需求。
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: 功能描述
+    validations:
+      required: true
+  - type: textarea
+    id: suggested-solution
+    attributes:
+      label: 建议的解决方案
+      description: |
+        实现此需求的解决思路。
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: 附加信息
+      description: |
+        关于此功能请求的任何其他上下文或截图，或者您觉得有帮助的信息。
+        相关的任何其他上下文或截图，或者你觉得有帮助的信息

.github/workflows/issues-duplicate.yml

@@ -0,0 +1,25 @@
+name: Issue Duplicate
+
+on:
+  issues:
+    types: [labeled]
+
+jobs:
+  create-comment:
+    runs-on: ubuntu-latest
+    if: github.event.label.name == 'duplicate'
+    steps:
+      - name: Create comment
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: 'create-comment'
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.issue.number }}
+          body: |
+            Hello @${{ github.event.issue.user.login }}, your issue is a duplicate and will be closed.
+            你好 @${{ github.event.issue.user.login }}，你的issue是重复的，将被关闭。
+      - name: Close issue
+        uses: actions-cool/issues-helper@v3
+        with:
+          actions: 'close-issue'
+          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/main.yml

@@ -0,0 +1,48 @@
+name: GHCR CI
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - name: lowercase repository name
+      run: echo "IMAGE_NAME=${GITHUB_REPOSITORY@L}" >> ${GITHUB_ENV}
+
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Read version from file
+      id: version
+      run: echo "VERSION=$(cat version.txt | grep version= | cut -d= -f2)" >> $GITHUB_OUTPUT
+
+    - name: Log in to the GitHub Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ghcr.io
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v6
+      with:
+        context: .
+        push: true
+        tags: |
+          ghcr.io/${{ env.IMAGE_NAME }}:latest
+          ghcr.io/${{ env.IMAGE_NAME }}:${{ steps.version.outputs.VERSION }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        platforms: |
+          linux/amd64
+          linux/arm64

.gitignore

@@ -0,0 +1 @@
+__pycache__/

.python-version

@@ -0,0 +1 @@
+3.12

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install uv
+RUN uv pip install --system --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,407 @@
+Attribution-NonCommercial 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-NonCommercial 4.0 International Public
+License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial 4.0 International Public License ("Public
+License"). To the extent this Public License may be interpreted as a
+contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You
+such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and
+conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  j. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  k. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  l. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -1,10 +1,123 @@
----
-title: Fufeigemini
-emoji: ⚡
-colorFrom: pink
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🚀 HAJIMI Gemini API Proxy
+
+- 这是一个基于 FastAPI 构建的 Gemini API 代理，旨在提供一个简单、安全且可配置的方式来访问 Google 的 Gemini 模型。适用于在 Hugging Face Spaces 上部署，并支持openai api格式的工具集成。
+
+## 管理前端一键部署模板
+[![Use EdgeOne Pages to deploy](https://cdnstatic.tencentcs.com/edgeone/pages/deploy.svg)](https://edgeone.ai/pages/new?repository-url=https%3A%2F%2Fgithub.com%2Fwyeeeee%2Fhajimi&root-directory=.%2Fpage&output-directory=..%2Fapp%2Ftemplates%2Fassets&install-command=npm%20install&build-command=npm%20run%20build)
+
+# 本项目基于CC BY-NC 4.0许可开源，需遵守以下规则
+- 您必须给出适当的署名，提供指向本协议的链接，并指明是否（对原作）作了修改。您可以以任何合理方式进行，但不得以任何方式暗示许可方认可您或您的使用。
+- 您不得将本作品用于商业目的，包括但不限于任何形式的商业倒卖、SaaS、API 付费接口、二次销售、打包出售、收费分发或其他直接或间接盈利行为。
+
+### 如需商业授权，请联系原作者获得书面许可。违者将承担相应法律责任。
+
+### 感谢[@warming-afternoon](https://github.com/warming-afternoon)，[@任梓樂](https://github.com/rzline)在技术上的大力支持
+
+###  错误自查
+
+遇到问题请先查看以下的 **错误自查** 文档，确保已尝试按照其上的指示进行了相应的排查与处理。
+
+- [错误自查](./wiki/error.md)
+###  使用文档
+- [huggingface 部署的使用文档（复活？！）（推荐，免费，手机电脑均可使用）](./wiki/huggingface2.md)
+
+- [Claw Cloud部署的使用文档（推荐，免费，手机电脑均可使用）](./wiki/claw.md) 感谢[@IDeposit](https://github.com/IDeposit)编写
+
+- [termux部署的使用文档（手机使用）](./wiki/Termux.md) 感谢[@天命不又](https://github.com/tmby)编写
+
+- [windows 本地部署的使用文档](./wiki/windows.md)
+
+- ~~[zeabur部署的使用文档(需付费)](./wiki/zeabur.md) 感谢**墨舞ink**编写~~（已过时且暂时无人更新，欢迎提交pull requests）
+
+- [vertex模式的使用文档](./wiki/vertex.md)
+
+###  更新日志
+* v1.0.1
+   * 新增`清除失效密钥`功能
+   * 新增`输出有效秘钥`功能
+
+## ✨ 主要功能：
+
+### 🔑 API 密钥轮询和管理
+
+### 📑 模型列表接口
+
+### 💬 聊天补全接口：
+
+*   提供 `/v1/chat/completions` 接口，支持流式和非流式响应，支持函数调用，与 OpenAI API 格式兼容。
+*   支持的输入内容: 文本、文件、图像
+*   自动将 OpenAI 格式的请求转换为 Gemini 格式。
+
+### 🔒 密码保护（可选）：
+
+*   通过 `PASSWORD` 环境变量设置密码。
+*   提供默认密码 `"123"`。
+
+### 🧩 服务兼容
+
+*   提供的接口与 OpenAI API 格式兼容,便于接入各种服务
+
+### ⚙️ 功能配置
+
+* 方式 1 : 通过网页前端进行配置
+* 方式 2 : 根据 [配置文档](./app/config/settings.py) 中的注释说明，修改对应的变量
+
+## ⚠️ 注意事项：
+
+*   **强烈建议在生产环境中设置 `PASSWORD` 环境变量，并使用强密码。**
+*   根据你的使用情况调整速率限制相关的环境变量。
+*   确保你的 Gemini API 密钥具有足够的配额。
+
+
+## 💡 特色功能：
+
+### 🎭 假流式传输
+
+*   **作用：** 解决部分网络环境下客户端通过非流式请求 Gemini 时可能遇到的断连问题。**默认开启**。
+
+*   **原理简述：** 当客户端请求流式响应时，本代理会每隔一段时间向客户端发出一个空信息以维持连接，同时在后台向 Gemini 发起一个完整的、非流式的请求。等 Gemini 返回完整响应后，再一次性将响应发回给客户端。
+
+*   **注意：** 如果想使用真的流式请求，请**关闭**该功能
+
+### ⚡ 并发与缓存
+
+*   **作用：** 允许您为用户的单次提问同时向 Gemini 发送多个请求，并将额外的成功响应缓存起来，用于后续重新生成回复。
+
+*   **注意：** 此功能**默认关闭** 。只有当您将并发数设置为 2 或以上时，缓存才会生效。缓存匹配要求提问的上下文与被缓存的问题**完全一致**（包括标点符号）。此外，该模式目前仅支持非流式及假流式传输
+    
+    **Q: 新版本增加的并发缓存功能会增加 gemini 配额的使用量吗？**
+   
+    **A: 不会**。因为默认情况下该功能是关闭的。只有当你主动将并发数 `CONCURRENT_REQUESTS` 设置为大于 1 的数值时，才会实际发起并发请求，这才会消耗更多配额。
+   
+    **Q: 如何使用并发缓存功能？**
+   
+    **A:** 修改并发请求数，使其等于你想在一次用户提��中同时向 Gemini 发送的请求数量（例如设置为 `3`）。
+    
+    这样设置后，如果一次并发请求中收到了多个成功的响应，除了第一个返回给用户外，其他的就会被缓存起来。
+
+### 🎭 伪装信息
+
+*   **作用：** 在发送给 Gemini 的消息中添加一段随机生成的、无意义的字符串，用于“伪装”请求，可能有助于防止被识别为自动化程序。**默认开启**。
+
+*   **注意：** 如果使用非 SillyTavern 的其余客户端 (例如 cherryStudio )，请**关闭**该功能
+
+### 🌐 联网模式
+
+*   **作用：** 让 Gemini 模型能够利用搜索工具进行联网搜索，以回答需要最新信息或超出其知识库范围的问题。
+
+*   **如何使用：**
+
+    在客户端请求时，选择模型名称带有 `-search` 后缀的模型（例如 `gemini-2.5-pro-search`，具体可用模型请通过 `/v1/models` 接口查询）。
+
+
+### 🚦 速率限制和防滥用：
+
+*   通过环境变量自定义限制：
+    *   `MAX_REQUESTS_PER_MINUTE`：每分钟最大请求数（默认 30）。
+    *   `MAX_REQUESTS_PER_DAY_PER_IP`：每天每个 IP 最大请求数（默认 600）。
+*   超过速率限制时返回 429 错误。
+
+# 赞助商
+[![edgeone logo](https://edgeone.ai/_next/static/media/headLogo.daeb48ad.png?auto=format&fit=max&w=384)](https://edgeone.ai)
+CDN acceleration and security protection for this project are sponsored by Tencent EdgeOne.
+本项目的CDN加速及安全防护由腾讯EdgeOne赞助支持。

app/api/__init__.py

@@ -0,0 +1,9 @@
+from app.api.routes import router, init_router
+from app.api.dashboard import dashboard_router, init_dashboard_router
+
+__all__ = [
+    'router',
+    'init_router',
+    'dashboard_router',
+    'init_dashboard_router'
+]

app/api/dashboard.py

@@ -0,0 +1,830 @@
+from fastapi import APIRouter, HTTPException, Depends
+from datetime import datetime, timedelta
+import time
+import asyncio
+import random
+import threading
+from app.utils import (
+    log_manager,
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    clean_expired_stats
+)
+import app.config.settings as settings
+import app.vertex.config as app_config
+from app.services import GeminiClient
+from app.utils.auth import verify_web_password
+from app.utils.maintenance import api_call_stats_clean
+from app.utils.logging import log, vertex_log_manager
+from app.config.persistence import save_settings
+from app.utils.stats import api_stats_manager
+from typing import List
+import json
+
+# Import necessary components for Google Credentials JSON update
+from app.vertex.credentials_manager import CredentialManager, parse_multiple_json_credentials
+
+# 引入重新初始化vertex的函数
+from app.vertex.vertex_ai_init import init_vertex_ai as re_init_vertex_ai_function, reset_global_fallback_client
+
+# 创建路由器
+dashboard_router = APIRouter(prefix="/api", tags=["dashboard"])
+
+# 全局变量引用，将在init_dashboard_router中设置
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+credential_manager = None  # 添加全局credential_manager变量
+
+# 用于存储API密钥检测的进度信息
+api_key_test_progress = {
+    "is_running": False,
+    "completed": 0,
+    "total": 0,
+    "valid": 0,
+    "invalid": 0,
+    "is_completed": False
+}
+
+def init_dashboard_router(
+    key_mgr,
+    cache_mgr,
+    active_req_mgr,
+    cred_mgr=None  # 添加credential_manager参数
+):
+    """初始化仪表盘路由器"""
+    global key_manager, response_cache_manager, active_requests_manager, credential_manager
+    key_manager = key_mgr
+    response_cache_manager = cache_mgr
+    active_requests_manager = active_req_mgr
+    credential_manager = cred_mgr  # 保存credential_manager
+    return dashboard_router
+
+async def run_blocking_init_vertex():
+    """Helper to run the init_vertex_ai function with the current credential_manager."""
+    try:
+        if credential_manager is None:
+            # 如果credential_manager为None，记录警告并创建一个新的实例
+            log('warning', "Credential Manager不存在，将创建一个新的实例用于初始化")
+            temp_credential_manager = CredentialManager()
+            credentials_count = temp_credential_manager.get_total_credentials()
+            log('info', f"临时Credential Manager已创建，包含{credentials_count}个凭证")
+            
+            # 传递临时创建的credential_manager实例
+            success = await re_init_vertex_ai_function(credential_manager=temp_credential_manager)
+        else:
+            # 记录当前有多少凭证可用
+            credentials_count = credential_manager.get_total_credentials()
+            log('info', f"使用现有Credential Manager进行初始化，当前有{credentials_count}个凭证")
+            
+            # 传递当前的credential_manager实例
+            success = await re_init_vertex_ai_function(credential_manager=credential_manager)
+        
+        if success:
+            log('info', "异步重新执行 init_vertex_ai 成功，以响应 Google Credentials JSON 的更新。")
+        else:
+            log('warning', "异步重新执行 init_vertex_ai 失败或未完成，在 Google Credentials JSON 更新后。")
+    except Exception as e:
+        log('error', f"执行 run_blocking_init_vertex 时出错: {e}")
+
+@dashboard_router.get("/dashboard-data")
+async def get_dashboard_data():
+    """获取仪表盘数据的API端点，用于动态刷新"""
+    # 先清理过期数据，确保统计数据是最新的
+    await api_stats_manager.maybe_cleanup()
+    await response_cache_manager.clean_expired()  # 使用管理器清理缓存
+    active_requests_manager.clean_completed()  # 使用管理器清理活跃请求
+    
+    # 获取当前统计数据
+    now = datetime.now()
+    
+    # 使用新的统计系统获取调用数据
+    last_24h_calls = api_stats_manager.get_calls_last_24h()
+    hourly_calls = api_stats_manager.get_calls_last_hour(now)
+    minute_calls = api_stats_manager.get_calls_last_minute(now)
+    
+    # 获取时间序列数据
+    time_series_data, tokens_time_series = api_stats_manager.get_time_series_data(30, now)
+    
+    # 获取API密钥使用统计
+    api_key_stats = api_stats_manager.get_api_key_stats(key_manager.api_keys)
+    
+    # 根据ENABLE_VERTEX设置决定返回哪种日志
+    if settings.ENABLE_VERTEX:
+        recent_logs = vertex_log_manager.get_recent_logs(500)  # 获取最近500条Vertex日志
+    else:
+        recent_logs = log_manager.get_recent_logs(500)  # 获取最近500条普通日志
+    
+    # 获取缓存统计
+    total_cache = response_cache_manager.cur_cache_num
+    
+    # 获取活跃请求统计
+    active_count = len(active_requests_manager.active_requests)
+    active_done = sum(1 for task in active_requests_manager.active_requests.values() if task.done())
+    active_pending = active_count - active_done
+
+    # 获取凭证数量
+    credentials_count = 0
+    if credential_manager is not None:
+        credentials_count = credential_manager.get_total_credentials()
+    
+    # 返回JSON格式的数据
+    return {
+        "key_count": len(key_manager.api_keys),
+        "model_count": len(GeminiClient.AVAILABLE_MODELS),
+        "retry_count": settings.MAX_RETRY_NUM,
+        "credentials_count": credentials_count,  # 添加凭证数量
+        "last_24h_calls": last_24h_calls,
+        "hourly_calls": hourly_calls,
+        "minute_calls": minute_calls,
+        "calls_time_series": time_series_data,      # 添加API调用时间序列
+        "tokens_time_series": tokens_time_series,   # 添加Token使用时间序列
+        "current_time": datetime.now().strftime('%H:%M:%S'),
+        "logs": recent_logs,
+        "api_key_stats": api_key_stats,
+        # 添加配置信息
+        "max_requests_per_minute": settings.MAX_REQUESTS_PER_MINUTE,
+        "max_requests_per_day_per_ip": settings.MAX_REQUESTS_PER_DAY_PER_IP,
+        # 添加版本信息
+        "local_version": settings.version["local_version"],
+        "remote_version": settings.version["remote_version"],
+        "has_update": settings.version["has_update"],
+        # 添加流式响应配置
+        "fake_streaming": settings.FAKE_STREAMING,
+        "fake_streaming_interval": settings.FAKE_STREAMING_INTERVAL,
+        # 添加随机字符串配置
+        "random_string": settings.RANDOM_STRING,
+        "random_string_length": settings.RANDOM_STRING_LENGTH,
+        # 添加联网搜索配置
+        "search_mode": settings.search["search_mode"],
+        "search_prompt": settings.search["search_prompt"],
+        # 添加缓存信息
+        "cache_entries": total_cache,
+        "cache_expiry_time": settings.CACHE_EXPIRY_TIME,
+        "max_cache_entries": settings.MAX_CACHE_ENTRIES,
+        # 添加活跃请求池信息
+        "active_count": active_count,
+        "active_done": active_done,
+        "active_pending": active_pending,
+        # 添加并发请求配置
+        "concurrent_requests": settings.CONCURRENT_REQUESTS,
+        "increase_concurrent_on_failure": settings.INCREASE_CONCURRENT_ON_FAILURE,
+        "max_concurrent_requests": settings.MAX_CONCURRENT_REQUESTS,
+        # 启用vertex
+        "enable_vertex": settings.ENABLE_VERTEX,
+        # 添加Vertex Express配置
+        "enable_vertex_express": settings.ENABLE_VERTEX_EXPRESS,
+        "vertex_express_api_key": bool(settings.VERTEX_EXPRESS_API_KEY),  # 只返回是否设置的状态
+        "google_credentials_json": bool(settings.GOOGLE_CREDENTIALS_JSON),  # 只返回是否设置的状态
+        # 添加最大重试次数
+        "max_retry_num": settings.MAX_RETRY_NUM,
+        # 添加空响应重试次数限制
+        "max_empty_responses": settings.MAX_EMPTY_RESPONSES,
+    }
+
+@dashboard_router.post("/reset-stats")
+async def reset_stats(password_data: dict):
+    """
+    重置API调用统计数据
+    
+    Args:
+        password_data (dict): 包含密码的字典
+        
+    Returns:
+        dict: 操作结果
+    """
+    try:
+        if not isinstance(password_data, dict):
+            raise HTTPException(status_code=422, detail="请求体格式错误：应为JSON对象")
+            
+        password = password_data.get("password")
+        if not password:
+            raise HTTPException(status_code=400, detail="缺少密码参数")
+            
+        if not isinstance(password, str):
+            raise HTTPException(status_code=422, detail="密码参数类型错误：应为字符串")
+            
+        if not verify_web_password(password):
+            raise HTTPException(status_code=401, detail="密码错误")
+        
+        # 调用重置函数
+        await api_stats_manager.reset()
+        
+        return {"status": "success", "message": "API调用统计数据已重置"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"重置失败：{str(e)}")
+
+@dashboard_router.post("/update-config")
+async def update_config(config_data: dict):
+    """
+    更新配置项
+    
+    Args:
+        config_data (dict): 包含配置项和密码的字典
+        
+    Returns:
+        dict: 操作结果
+    """
+    try:
+        if not isinstance(config_data, dict):
+            raise HTTPException(status_code=422, detail="请求体格式错误：应为JSON对象")
+            
+        password = config_data.get("password")
+        if not password:
+            raise HTTPException(status_code=400, detail="缺少密码参数")
+            
+        if not isinstance(password, str):
+            raise HTTPException(status_code=422, detail="密码参数类型错误：应为字符串")
+            
+        if not verify_web_password(password):
+            raise HTTPException(status_code=401, detail="密码错误")
+        
+        # 获取要更新的配置项
+        config_key = config_data.get("key")
+        config_value = config_data.get("value")
+        
+        if not config_key:
+            raise HTTPException(status_code=400, detail="缺少配置项键名")
+            
+        # 根据配置项类型进行类型转换和验证
+        if config_key == "max_requests_per_minute":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("每分钟请求限制必须大于0")
+                settings.MAX_REQUESTS_PER_MINUTE = value
+                log('info', f"每分钟请求限制已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "max_requests_per_day_per_ip":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("每IP每日请求限制必须大于0")
+                settings.MAX_REQUESTS_PER_DAY_PER_IP = value
+                log('info', f"每IP每日请求限制已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "fake_streaming":
+            if not isinstance(config_value, bool):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为布尔值")
+            settings.FAKE_STREAMING = config_value
+            log('info', f"假流式请求已更新为：{config_value}")
+            
+            # 同步更新vertex配置中的假流式设置
+            try:
+                import app.vertex.config as vertex_config
+                vertex_config.FAKE_STREAMING_ENABLED = config_value  # 直接更新全局变量
+                vertex_config.update_config('FAKE_STREAMING', config_value)  # 同时调用更新函数
+                log('info', f"已同步更新Vertex中的假流式设置为：{config_value}")
+            except Exception as e:
+                log('warning', f"更新Vertex假流式设置时出错: {str(e)}")
+            
+        elif config_key == "enable_vertex_express":
+            if not isinstance(config_value, bool):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为布尔值")
+            settings.ENABLE_VERTEX_EXPRESS = config_value
+            log('info', f"Vertex Express已更新为：{config_value}")
+            
+        elif config_key == "vertex_express_api_key":
+            if not isinstance(config_value, str):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为字符串")
+            
+            # 检查是否为空字符串或"true"，如果是，则不更新
+            if not config_value or config_value.lower() == "true":
+                log('info', f"Vertex Express API Key未更新，因为值为空或为'true'")
+            else:
+                settings.VERTEX_EXPRESS_API_KEY = config_value
+                # 更新app_config中的API密钥列表
+                app_config.VERTEX_EXPRESS_API_KEY_VAL = [key.strip() for key in config_value.split(',') if key.strip()]
+                log('info', f"Vertex Express API Key已更新，共{len(app_config.VERTEX_EXPRESS_API_KEY_VAL)}个有效密钥")
+                
+                # 尝试刷新模型配置
+                try:
+                    from app.vertex.model_loader import refresh_models_config_cache
+                    refresh_success = await refresh_models_config_cache()
+                    if refresh_success:
+                        log('info', "更新Express API Key后成功刷新模型配置")
+                    else:
+                        log('warning', "更新Express API Key后刷新模型配置失败，将使用默认模型或现有缓存")
+                except Exception as e:
+                    log('warning', f"尝试刷新模型配置时出错: {str(e)}")
+            
+        elif config_key == "fake_streaming_interval":
+            try:
+                value = float(config_value)
+                if value <= 0:
+                    raise ValueError("假流式间隔必须大于0")
+                settings.FAKE_STREAMING_INTERVAL = value
+                log('info', f"假流式间隔已更新为：{value}")
+                
+                # 同步更新vertex配置中的假流式间隔设置
+                try:
+                    import app.vertex.config as vertex_config
+                    vertex_config.update_config('FAKE_STREAMING_INTERVAL', value)
+                    log('info', f"已同步更新Vertex中的假流式间隔设置为：{value}")
+                except Exception as e:
+                    log('warning', f"更新Vertex假流式间隔设置时出错: {str(e)}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "random_string":
+            if not isinstance(config_value, bool):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为布尔值")
+            settings.RANDOM_STRING = config_value
+            log('info', f"随机字符串已更新为：{config_value}")
+        elif config_key == "random_string_length":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("随机字符串长度必须大于0")
+                settings.RANDOM_STRING_LENGTH = value
+                log('info', f"随机字符串长度已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "search_mode":
+            if not isinstance(config_value, bool):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为布尔值")
+            settings.search["search_mode"] = config_value
+            log('info', f"联网搜索模式已更新为：{config_value}")
+            
+            # 在切换search_mode时，重新获取一次可用模型列表
+            try:
+                # 重置密钥栈以确保随机性
+                key_manager._reset_key_stack()
+                # 获取一个随机API密钥
+                for key in key_manager.api_keys:
+                    log('info', f"使用API密钥 {key[:8]}... 刷新可用模型列表")
+                    # 使用随机密钥获取可用模型
+                    all_models = await GeminiClient.list_available_models(key)
+                    GeminiClient.AVAILABLE_MODELS = [model.replace("models/", "") for model in all_models]
+                    if len(GeminiClient.AVAILABLE_MODELS) > 0:
+                        log('info', f"可用模型列表已更新，当前模型数量：{len(GeminiClient.AVAILABLE_MODELS)}")
+                        break
+                else:
+                    log('warning', f"没有可用的API密钥，无法刷新可用模型列表")
+            except Exception as e:
+                log('warning', f"刷新可用模型列表时发生错误: {str(e)}")
+                
+        elif config_key == "concurrent_requests":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("并发请求数必须大于0")
+                settings.CONCURRENT_REQUESTS = value
+                log('info', f"并发请求数已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "increase_concurrent_on_failure":
+            try:
+                value = int(config_value)
+                if value < 0:
+                    raise ValueError("失败时增加的并发数不能为负数")
+                settings.INCREASE_CONCURRENT_ON_FAILURE = value
+                log('info', f"失败时增加的并发数已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "max_concurrent_requests":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("最大并发请求数必须大于0")
+                settings.MAX_CONCURRENT_REQUESTS = value
+                log('info', f"最大并发请求数已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "enable_vertex":
+            if not isinstance(config_value, bool):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为布尔值")
+            settings.ENABLE_VERTEX = config_value
+            log('info', f"Vertex AI 已更新为：{config_value}")
+
+        elif config_key == "google_credentials_json":
+            if not isinstance(config_value, str): # Allow empty string to clear
+                raise HTTPException(status_code=422, detail="参数类型错误：Google Credentials JSON 应为字符串")
+
+            # 检查是否为空字符串或"true"，如果是，则不更新
+            if not config_value or config_value.lower() == "true":
+                log('info', f"Google Credentials JSON未更新，因为值为空或为'true'")
+                save_settings() # 仍然保存其他可能的设置更改
+                return {"status": "success", "message": f"配置项 {config_key} 未更新，值为空或为'true'"}
+
+            # Validate JSON structure if not empty
+            if config_value:
+                try:
+                    # Attempt to parse as single or multiple JSONs
+                    # parse_multiple_json_credentials logs errors if parsing fails but returns list.
+                    temp_parsed = parse_multiple_json_credentials(config_value)
+                    # If parse_multiple_json_credentials returns an empty list for a non-empty string,
+                    # it means it didn't find any valid top-level JSON objects as per its logic.
+                    # We can do an additional check for a single valid JSON object.
+                    if not temp_parsed: # and config_value.strip(): # ensure non-empty string before json.loads
+                        try:
+                            # This is a stricter check. If parse_multiple_json_credentials, which is more lenient,
+                            # failed to find anything, and this also fails, then it's likely malformed.
+                            json.loads(config_value) # Try parsing as a single JSON object
+                            # If this succeeds, it implies the string IS a valid single JSON,
+                            # but not in the multi-JSON format parse_multiple_json_credentials might be looking for initially.
+                            # parse_multiple_json_credentials will be called again later and should handle it.
+                        except json.JSONDecodeError:
+                            # This specific error means it's not even a valid single JSON.
+                            raise HTTPException(status_code=422, detail="Google Credentials JSON 格式无效。它既不是有效的单个JSON对象，也不是逗号分隔的多个JSON对象。")
+                except HTTPException: # Re-raise if it's already an HTTPException from inner check
+                    raise
+                except Exception as e: # Catch any other error during this pre-check
+                    # This might catch errors if parse_multiple_json_credentials itself had an unexpected issue
+                    # not related to JSONDecodeError but still an error.
+                    raise HTTPException(status_code=422, detail=f"Google Credentials JSON 预检查失败: {str(e)}")
+
+            settings.GOOGLE_CREDENTIALS_JSON = config_value
+            log('info', "Google Credentials JSON 设置已更新 (内容未记录)。")
+
+            # Reset global fallback client first
+            reset_global_fallback_client()
+
+            # Clear previously loaded JSON string credentials from manager
+            if credential_manager is not None:
+                cleared_count = credential_manager.clear_json_string_credentials()
+                log('info', f"从 CredentialManager 中清除了 {cleared_count} 个先前由 JSON 字符串加载的凭据。")
+
+                if config_value: # If new JSON string is provided
+                    parsed_json_objects = parse_multiple_json_credentials(config_value)
+                    if parsed_json_objects:
+                        loaded_count = credential_manager.load_credentials_from_json_list(parsed_json_objects)
+                        if loaded_count > 0:
+                            log('info', f"从更新的 Google Credentials JSON 中加载了 {loaded_count} 个凭据到 CredentialManager。")
+                        else:
+                            log('warning', "尝试加载Google Credentials JSON凭据失败，没有凭据被成功加载。")
+                    else:
+                        # 尝试作为单个JSON对象加载
+                        try:
+                            single_cred = json.loads(config_value)
+                            if credential_manager.add_credential_from_json(single_cred):
+                                log('info', "作为单个JSON对象成功加载了一个凭据。")
+                            else:
+                                log('warning', "作为单个JSON对象加载凭据失败。")
+                        except json.JSONDecodeError:
+                            log('warning', "Google Credentials JSON无法作为JSON对象解析。")
+                        except Exception as e:
+                            log('warning', f"尝试加载单个JSON凭据时出错: {str(e)}")
+                else:
+                    log('info', "Google Credentials JSON 已被清空。CredentialManager 中来自 JSON 字符串的凭据已被移除。")
+                
+                # 检查凭证是否存在
+                if credential_manager.get_total_credentials() == 0:
+                    log('warning', "警告：当前没有可用的凭证。Vertex AI功能可能无法正常工作。")
+            else:
+                log('warning', "CredentialManager未初始化，无法加载Google Credentials JSON。")
+            
+            # Save all settings changes
+            save_settings() # Moved save_settings here to ensure it's called for this key
+
+            # Trigger re-initialization of Vertex AI (which can re-init the global client)
+            try:
+                # 检查credential_manager是否可用
+                if credential_manager is None:
+                    log('warning', "重新初始化Vertex AI时发现credential_manager为None")
+                else:
+                    log('info', f"开始重新初始化Vertex AI，当前凭证数: {credential_manager.get_total_credentials()}")
+                
+                # 调用run_blocking_init_vertex
+                await run_blocking_init_vertex()
+                log('info', "Vertex AI服务重新初始化完成")
+                
+                # 显式刷新模型配置缓存
+                from app.vertex.model_loader import refresh_models_config_cache
+                refresh_success = await refresh_models_config_cache()
+                if refresh_success:
+                    log('info', "成功刷新模型配置缓存")
+                else:
+                    log('warning', "刷新模型配置缓存失败，将使用默认模型或现有缓存")
+            except Exception as e:
+                log('error', f"重新初始化Vertex AI服务时出错: {str(e)}")
+        
+        elif config_key == "max_retry_num":
+            try:
+                value = int(config_value)
+                if value <= 0:
+                    raise ValueError("最大重试次数必须大于0")
+                settings.MAX_RETRY_NUM = value
+                log('info', f"最大重试次数已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+                
+        elif config_key == "search_prompt":
+            if not isinstance(config_value, str):
+                raise HTTPException(status_code=422, detail="参数类型错误：应为字符串")
+            settings.search["search_prompt"] = config_value
+            log('info', f"联网搜索提示已更新为：{config_value}")
+        
+        elif config_key == "gemini_api_keys":
+            if not isinstance(config_value, str):
+                raise HTTPException(status_code=422, detail="参数类型错误：API密钥应为逗号分隔的字符串")
+            
+            # 分割并清理API密钥
+            new_keys = [key.strip() for key in config_value.split(',') if key.strip()]
+            if not new_keys:
+                raise HTTPException(status_code=400, detail="未提供有效的API密钥")
+            
+            # 添加到现有的API密钥字符串中
+            current_keys = settings.GEMINI_API_KEYS.split(',') if settings.GEMINI_API_KEYS else []
+            current_keys = [key.strip() for key in current_keys if key.strip()]
+            
+            # 合并新旧密钥并去重
+            all_keys = list(set(current_keys + new_keys))
+            settings.GEMINI_API_KEYS = ','.join(all_keys)
+            
+            # 计算新添加的密钥数量
+            added_key_count = 0
+            for key in new_keys:
+                if key not in key_manager.api_keys:
+                    key_manager.api_keys.append(key)
+                    added_key_count += 1
+            
+            # 重置密钥栈
+            key_manager._reset_key_stack()
+            
+            # 如果可用模型为空，尝试获取模型列表
+            if not GeminiClient.AVAILABLE_MODELS:
+                try:
+                    # 使用新添加的密钥之一尝试获取可用模型
+                    for key in new_keys:
+                        log('info', f"使用新添加的API密钥 {key[:8]}... 获取可用模型列表")
+                        all_models = await GeminiClient.list_available_models(key)
+                        GeminiClient.AVAILABLE_MODELS = [model.replace("models/", "") for model in all_models]
+                        if GeminiClient.AVAILABLE_MODELS:
+                            log('info', f"成功获取可用模型列表，共 {len(GeminiClient.AVAILABLE_MODELS)} 个模型")
+                            break
+                except Exception as e:
+                    log('warning', f"获取可用模型列表时发生错误: {str(e)}")
+            
+            log('info', f"已添加 {added_key_count} 个新API密钥，当前共有 {len(key_manager.api_keys)} 个")
+                
+        elif config_key == "max_empty_responses":
+            try:
+                value = int(config_value)
+                if value < 0: # 通常至少为0或1，根据实际需求调整
+                    raise ValueError("空响应重试次数不能为负数")
+                settings.MAX_EMPTY_RESPONSES = value
+                log('info', f"空响应重试次数已更新为：{value}")
+            except ValueError as e:
+                raise HTTPException(status_code=422, detail=f"参数类型错误：{str(e)}")
+        
+        else:
+            raise HTTPException(status_code=400, detail=f"不支持的配置项：{config_key}")
+        save_settings()
+        return {"status": "success", "message": f"配置项 {config_key} 已更新"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"更新失败：{str(e)}")
+
+@dashboard_router.post("/test-api-keys")
+async def test_api_keys(password_data: dict):
+    """
+    测试所有API密��的有效性
+    
+    Args:
+        password_data (dict): 包含密码的字典
+        
+    Returns:
+        dict: 操作结果
+    """
+    try:
+        if not isinstance(password_data, dict):
+            raise HTTPException(status_code=422, detail="请求体格式错误：应为JSON对象")
+            
+        password = password_data.get("password")
+        if not password:
+            raise HTTPException(status_code=400, detail="缺少密码参数")
+            
+        if not isinstance(password, str):
+            raise HTTPException(status_code=422, detail="密码参数类型错误：应为字符串")
+            
+        if not verify_web_password(password):
+            raise HTTPException(status_code=401, detail="密码错误")
+        
+        # 检查是否已经有测试在运行
+        if api_key_test_progress["is_running"]:
+            raise HTTPException(status_code=409, detail="已有API密钥检测正在进行中")
+        
+        # 获取有效密钥列表
+        valid_keys = key_manager.api_keys.copy()
+        
+        # 启动异步测试
+        threading.Thread(
+            target=start_api_key_test_in_thread, 
+            args=(valid_keys,), 
+            daemon=True
+        ).start()
+        
+        return {"status": "success", "message": "API密钥检测已启动，将同时检测有效密钥和无效密钥"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"启动API密钥检测失败：{str(e)}")
+
+@dashboard_router.get("/test-api-keys/progress")
+async def get_test_api_keys_progress():
+    """
+    获取API密钥检测进度
+    
+    Returns:
+        dict: 进度信息
+    """
+    return api_key_test_progress
+
+def check_api_key_in_thread(key):
+    """在线程中检查单个API密钥的有效性"""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        is_valid = loop.run_until_complete(test_api_key(key))
+        if is_valid:
+            log('info', f"API密钥 {key[:8]}... 有效")
+            return key, True
+        else:
+            log('warning', f"API密钥 {key[:8]}... 无效")
+            return key, False
+    finally:
+        loop.close()
+
+async def test_api_key(key):
+    """测试单个API密钥是否有效"""
+    try:
+        # 尝试列出可用模型来检查API密钥是否有效
+        all_models = await GeminiClient.list_available_models(key)
+        return len(all_models) > 0
+    except Exception as e:
+        log('error', f"测试API密钥 {key[:8]}... 时出错: {str(e)}")
+        return False
+
+def start_api_key_test_in_thread(keys):
+    """在线程中启动API密钥检测过程"""
+    # 重置进度信息
+    api_key_test_progress.update({
+        "is_running": True,
+        "completed": 0,
+        "total": 0,  # 稍后会更新
+        "valid": 0,
+        "invalid": 0,
+        "is_completed": False
+    })
+    
+    try:
+        # 获取所有需要检测的密钥（包括当前GEMINI_API_KEYS和INVALID_API_KEYS）
+        current_keys = keys
+        
+        # 获取当前无效密钥
+        invalid_api_keys = settings.INVALID_API_KEYS.split(',') if settings.INVALID_API_KEYS else []
+        invalid_api_keys = [key.strip() for key in invalid_api_keys if key.strip()]
+        
+        # 合并所有需要测试的密钥，去重
+        all_keys_to_test = list(set(current_keys + invalid_api_keys))
+        
+        # 更新总数
+        api_key_test_progress["total"] = len(all_keys_to_test)
+        
+        # 创建有效和无效密钥列表
+        valid_keys = []
+        invalid_keys = []
+        
+        # 检查每个密钥
+        for key in all_keys_to_test:
+            # 检查密钥
+            _, is_valid = check_api_key_in_thread(key)
+            
+            # 更新进度
+            api_key_test_progress["completed"] += 1
+            
+            # 将密钥添加到相应列表
+            if is_valid:
+                valid_keys.append(key)
+                api_key_test_progress["valid"] += 1
+            else:
+                invalid_keys.append(key)
+                api_key_test_progress["invalid"] += 1
+        
+        # 更新全局密钥列表
+        key_manager.api_keys = valid_keys
+        
+        # 更新设置中的有效和无效密钥
+        settings.GEMINI_API_KEYS = ','.join(valid_keys)
+        settings.INVALID_API_KEYS = ','.join(invalid_keys)
+        
+        # 保存设置
+        save_settings()
+        
+        # 重置密钥栈
+        key_manager._reset_key_stack()
+        
+        log('info', f"API密钥检测完成。有效密钥: {len(valid_keys)}，无效密钥: {len(invalid_keys)}")
+    except Exception as e:
+        log('error', f"API密钥检测过程中发生错误: {str(e)}")
+    finally:
+        # 标记检测完成
+        api_key_test_progress.update({
+            "is_running": False,
+            "is_completed": True
+        })
+
+@dashboard_router.post("/clear-invalid-api-keys")
+async def clear_invalid_api_keys(password_data: dict):
+    """
+    清除所有失效的API密钥
+    
+    Args:
+        password_data (dict): 包含密码的字典
+        
+    Returns:
+        dict: 操作结果
+    """
+    try:
+        if not isinstance(password_data, dict):
+            raise HTTPException(status_code=422, detail="请求体格式错误：应为JSON对象")
+            
+        password = password_data.get("password")
+        if not password:
+            raise HTTPException(status_code=400, detail="缺少密码参数")
+            
+        if not isinstance(password, str):
+            raise HTTPException(status_code=422, detail="密码参数类型错误：应为字符串")
+            
+        if not verify_web_password(password):
+            raise HTTPException(status_code=401, detail="密码错误")
+        
+        # 获取当前无效密钥数量
+        current_invalid_keys = settings.INVALID_API_KEYS.split(',') if settings.INVALID_API_KEYS else []
+        current_invalid_keys = [key.strip() for key in current_invalid_keys if key.strip()]
+        invalid_count = len(current_invalid_keys)
+        
+        if invalid_count == 0:
+            return {"status": "success", "message": "没有失效的API密钥需要清除"}
+        
+        # 清除无效密钥
+        settings.INVALID_API_KEYS = ""
+        save_settings()
+        
+        log('info', f"已清除 {invalid_count} 个失效的API密钥")
+        
+        return {
+            "status": "success", 
+            "message": f"已成功清除 {invalid_count} 个失效的API密钥"
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"清除失效API密钥失败：{str(e)}")
+
+@dashboard_router.post("/export-valid-api-keys")
+async def export_valid_api_keys(password_data: dict):
+    """
+    输出所有有效的API密钥
+    
+    Args:
+        password_data (dict): 包含密码的字典
+        
+    Returns:
+        dict: 操作结果，包含有效密钥列表
+    """
+    try:
+        if not isinstance(password_data, dict):
+            raise HTTPException(status_code=422, detail="请求体格式错误：应为JSON对象")
+            
+        password = password_data.get("password")
+        if not password:
+            raise HTTPException(status_code=400, detail="缺少密码参数")
+            
+        if not isinstance(password, str):
+            raise HTTPException(status_code=422, detail="密码参数类型错误：应为字符串")
+            
+        if not verify_web_password(password):
+            raise HTTPException(status_code=401, detail="密码错误")
+        
+        # 获取当前有效密钥
+        valid_keys = key_manager.api_keys.copy()
+        
+        if not valid_keys:
+            return {"status": "success", "message": "当前没有有效的API密钥", "keys": []}
+        
+        # 直接返回完整的密钥列表
+        log('info', f"用户导出了 {len(valid_keys)} 个有效API密钥")
+        
+        return {
+            "status": "success", 
+            "message": f"成功获取 {len(valid_keys)} 个有效API密钥",
+            "keys": valid_keys,
+            "count": len(valid_keys)
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取有效API密钥失败：{str(e)}")

app/api/nonstream_handlers.py

@@ -0,0 +1,577 @@
+import asyncio
+from fastapi import HTTPException, Request
+from fastapi.responses import StreamingResponse, Response
+from app.models.schemas import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import update_api_call_stats
+from app.utils.error_handling import handle_gemini_error
+from app.utils.logging import log
+import app.config.settings as settings
+from typing import Literal
+from app.utils.response import gemini_from_text, openAI_from_Gemini, openAI_from_text
+from app.utils.stats import get_api_key_usage
+
+
+# 非流式请求处理函数
+async def process_nonstream_request(
+    chat_request: ChatCompletionRequest,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str
+):
+    """处理非流式API请求"""
+    gemini_client = GeminiClient(current_api_key)
+    # 创建调用 Gemini API 的主任务
+    gemini_task = asyncio.create_task(
+        gemini_client.complete_chat(
+            chat_request,
+            contents,
+            safety_settings_g2 if 'gemini-2.5' in chat_request.model else safety_settings,
+            system_instruction
+        )
+    )
+    # 使用 shield 保护任务不被外部轻易取消
+    shielded_gemini_task = asyncio.shield(gemini_task)
+
+    try:
+        # 等待受保护的 API 调用任务完成
+        response_content = await shielded_gemini_task
+        response_content.set_model(chat_request.model)
+        
+        # 检查响应内容是否为空
+        if not response_content or (not response_content.text and not response_content.function_call):
+            log('warning', f"API密钥 {current_api_key[:8]}... 返回空响应",
+                extra={'key': current_api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+            return "empty"
+        
+        # 缓存响应结果
+        await response_cache_manager.store(cache_key, response_content)
+        # 更新 API 调用统计
+        await update_api_call_stats(settings.api_call_stats, endpoint=current_api_key, model=chat_request.model,token=response_content.total_token_count)
+        
+        return "success"
+
+    except Exception as e:
+        # 处理 API 调用过程中可能发生的任何异常
+        handle_gemini_error(e, current_api_key) 
+        return "error"
+
+
+# 带保活功能的非流式请求处理函数
+async def process_nonstream_request_with_keepalive(
+    chat_request: ChatCompletionRequest,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str,
+    keepalive_interval: float = 30.0  # 保活间隔，默认30秒
+):
+    """处理非流式API请求，带TCP保活功能"""
+    gemini_client = GeminiClient(current_api_key)
+    
+    # 创建调用 Gemini API 的主任务
+    gemini_task = asyncio.create_task(
+        gemini_client.complete_chat(
+            chat_request,
+            contents,
+            safety_settings_g2 if 'gemini-2.5' in chat_request.model else safety_settings,
+            system_instruction
+        )
+    )
+    
+    # 创建保活任务
+    keepalive_task = asyncio.create_task(
+        send_keepalive_messages(keepalive_interval)
+    )
+    
+    try:
+        # 等待Gemini任务完成
+        response_content = await gemini_task
+        
+        # 取消保活任务
+        keepalive_task.cancel()
+        
+        response_content.set_model(chat_request.model)
+        
+        # 检查响应内容是否为空
+        if not response_content or (not response_content.text and not response_content.function_call):
+            log('warning', f"API密钥 {current_api_key[:8]}... 返回空响应",
+                extra={'key': current_api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+            return "empty"
+        
+        # 缓存响应结果
+        await response_cache_manager.store(cache_key, response_content)
+        # 更新 API 调用统计
+        await update_api_call_stats(settings.api_call_stats, endpoint=current_api_key, model=chat_request.model,token=response_content.total_token_count)
+        
+        return "success"
+
+    except Exception as e:
+        # 取消保活任务
+        keepalive_task.cancel()
+        # 处理 API 调用过程中可能发生的任何异常
+        handle_gemini_error(e, current_api_key) 
+        return "error"
+
+
+# 简化的保活功能 - 在等待期间发送换行符
+async def process_nonstream_request_with_simple_keepalive(
+    chat_request: ChatCompletionRequest,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str,
+    keepalive_interval: float = 30.0  # 保活间隔，默认30秒
+):
+    """处理非流式API请求，带简化TCP保活功能"""
+    gemini_client = GeminiClient(current_api_key)
+    
+    # 创建调用 Gemini API 的��任务
+    gemini_task = asyncio.create_task(
+        gemini_client.complete_chat(
+            chat_request,
+            contents,
+            safety_settings_g2 if 'gemini-2.5' in chat_request.model else safety_settings,
+            system_instruction
+        )
+    )
+    
+    # 创建保活任务
+    keepalive_task = asyncio.create_task(
+        send_keepalive_messages(keepalive_interval)
+    )
+    
+    try:
+        # 等待Gemini任务完成
+        response_content = await gemini_task
+        
+        # 取消保活任务
+        keepalive_task.cancel()
+        
+        response_content.set_model(chat_request.model)
+        
+        # 检查响应内容是否为空
+        if not response_content or (not response_content.text and not response_content.function_call):
+            log('warning', f"API密钥 {current_api_key[:8]}... 返回空响应",
+                extra={'key': current_api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+            return "empty"
+        
+        # 缓存响应结果
+        await response_cache_manager.store(cache_key, response_content)
+        # 更新 API 调用统计
+        await update_api_call_stats(settings.api_call_stats, endpoint=current_api_key, model=chat_request.model,token=response_content.total_token_count)
+        
+        return "success"
+
+    except Exception as e:
+        # 取消保活任务
+        keepalive_task.cancel()
+        # 处理 API 调用过程中可能发生的任何异常
+        handle_gemini_error(e, current_api_key) 
+        return "error"
+
+
+async def send_keepalive_messages(interval: float):
+    """发送保活消息的任务"""
+    try:
+        while True:
+            await asyncio.sleep(interval)
+            # 发送换行符作为保活消息
+            # 注意：在非流式响应中，我们无法直接发送数据到客户端
+    except asyncio.CancelledError:
+        # 任务被取消时正常退出
+        pass
+    except Exception as e:
+        log('error', f"保活任务出错: {str(e)}", 
+            extra={'request_type': 'non-stream', 'keepalive': True})
+
+
+# 处理 route 中发起请求的函数
+async def process_request(
+    chat_request,
+    key_manager,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str
+):
+    """处理非流式请求"""
+    global current_api_key
+
+    format_type = getattr(chat_request, 'format_type', None)
+    if format_type and (format_type == "gemini"):
+        is_gemini = True
+        contents, system_instruction = None,None
+    else:
+        is_gemini = False
+        # 转换消息格式
+        contents, system_instruction = GeminiClient.convert_messages(GeminiClient, chat_request.messages,model=chat_request.model)
+
+    # 设置初始并发数
+    current_concurrent = settings.CONCURRENT_REQUESTS
+    max_retry_num = settings.MAX_RETRY_NUM
+    
+    # 当前请求次数
+    current_try_num = 0
+    
+    # 空响应计数
+    empty_response_count = 0
+    
+    # 尝试使用不同API密钥，直到达到最大重试次数或空响应限制
+    while (current_try_num < max_retry_num) and (empty_response_count < settings.MAX_EMPTY_RESPONSES):
+        # 获取当前批次的密钥数量
+        batch_num = min(max_retry_num - current_try_num, current_concurrent)
+        
+        # 获取当前批次的密钥
+        valid_keys = []
+        checked_keys = set()  # 用于记录已检查过的密钥
+        all_keys_checked = False  # 标记是否已检查所有密钥
+        
+        # 尝试获取足够数量的有效密钥
+        while len(valid_keys) < batch_num:
+            api_key = await key_manager.get_available_key()
+            if not api_key:
+                break
+                
+            # 如果这个密钥已经检查过，说明已经检查了所有密钥
+            if api_key in checked_keys:
+                all_keys_checked = True
+                break
+            
+            checked_keys.add(api_key)
+            # 获取API密钥的调用次数
+            usage = await get_api_key_usage(settings.api_call_stats, api_key)
+            # 如果调用次数小于限制，则添加到有效密钥列表
+            if usage < settings.API_KEY_DAILY_LIMIT:
+                valid_keys.append(api_key)
+            else:
+                log('warning', f"API密钥 {api_key[:8]}... 已达到每日调用限制 ({usage}/{settings.API_KEY_DAILY_LIMIT})",
+                    extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+        
+        # 如果已经检查了所有密钥且没有找到有效密钥，则重置密钥栈
+        if all_keys_checked and not valid_keys:
+            log('warning', "所有API密钥已达到每日调用限制，重置密钥栈",
+                extra={'request_type': 'non-stream', 'model': chat_request.model})
+            key_manager._reset_key_stack()
+            # 重置后重新获取一个密钥
+            api_key = await key_manager.get_available_key()
+            if api_key:
+                valid_keys = [api_key]
+        
+        # 如果没有获取到任何有效密钥，跳出循环
+        if not valid_keys:
+            break
+            
+        # 更新当前尝试次数
+        current_try_num += len(valid_keys)
+        
+        # 创建并发任务
+        tasks = []
+        tasks_map = {}
+        for api_key in valid_keys:
+            # 记录当前尝试的密钥信息
+            log('info', f"非流式请求开始，使用密钥: {api_key[:8]}...", 
+                extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+            
+            # 创建任务 - 根据配置决定是否使用保活功能
+            if settings.NONSTREAM_KEEPALIVE_ENABLED:
+                task = asyncio.create_task(
+                    process_nonstream_request_with_simple_keepalive(
+                        chat_request,
+                        contents,
+                        system_instruction,
+                        api_key,
+                        response_cache_manager,
+                        safety_settings,
+                        safety_settings_g2,
+                        cache_key,
+                        settings.NONSTREAM_KEEPALIVE_INTERVAL
+                    )
+                )
+            else:
+                task = asyncio.create_task(
+                    process_nonstream_request(
+                        chat_request,
+                        contents,
+                        system_instruction,
+                        api_key,
+                        response_cache_manager,
+                        safety_settings,
+                        safety_settings_g2,
+                        cache_key
+                    )
+                )
+            tasks.append((api_key, task))
+            tasks_map[task] = api_key
+        
+        # 等待所有任务完成或找到成功响应
+        success = False
+        while tasks and not success:
+            # 短时间等待任务完成
+            done, pending = await asyncio.wait(
+                [task for _, task in tasks],
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            # 检查已完成的任务是否成功
+            for task in done:
+                api_key = tasks_map[task]
+                try:
+                    status = task.result()                    
+                    # 如果有成功响应内容
+                    if status == "success" :  
+                        success = True
+                        log('info', f"非流式请求成功", 
+                            extra={'key': api_key[:8],'request_type': 'non-stream', 'model': chat_request.model})
+                        cached_response, cache_hit = await  response_cache_manager.get_and_remove(cache_key)
+                        if is_gemini :
+                            return cached_response.data
+                        else:
+                            return openAI_from_Gemini(cached_response,stream=False)
+                    elif status == "empty":
+                        # 增加空响应计数
+                        empty_response_count += 1
+                        log('warning', f"空响应计数: {empty_response_count}/{settings.MAX_EMPTY_RESPONSES}",
+                            extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+                
+                except Exception as e:
+                    handle_gemini_error(e, api_key)
+                
+                # 更新任务列表，移除已完成的任务
+                tasks = [(k, t) for k, t in tasks if not t.done()]
+                
+        # 如果当前批次没有成功响应，并且还有密钥可用，则继续尝试
+        if not success and valid_keys:
+            # 增加并发数，但不超过最大并发数
+            current_concurrent = min(current_concurrent + settings.INCREASE_CONCURRENT_ON_FAILURE, settings.MAX_CONCURRENT_REQUESTS)
+            log('info', f"所有并发请求失败或返回空响应，增加并发数至: {current_concurrent}", 
+                extra={'request_type': 'non-stream', 'model': chat_request.model})
+        
+        # 如果空响应次数达到限制，跳出循环，并返回酒馆正常响应(包含错误信息)
+        if empty_response_count >= settings.MAX_EMPTY_RESPONSES:
+            log('warning', f"空响应次数达到限制 ({empty_response_count}/{settings.MAX_EMPTY_RESPONSES})，停止轮询",
+                extra={'request_type': 'non-stream', 'model': chat_request.model})
+            
+            if is_gemini :
+                return gemini_from_text(content="空响应次数达到上限\n请修改输入提示词",finish_reason="STOP",stream=False)
+            else:
+                return openAI_from_text(model=chat_request.model,content="空响应次数达到上限\n请修改输入提示词",finish_reason="stop",stream=False)
+    
+    # 如果所有尝试都失败
+    log('error', "API key 替换失败，所有API key���已尝试，请重新配置或稍后重试", extra={'request_type': 'switch_key'})
+    
+    if is_gemini:
+        return gemini_from_text(content="所有API密钥均请求失败\n具体错误请查看轮询日志",finish_reason="STOP",stream=False)
+    else:
+        return openAI_from_text(model=chat_request.model,content="所有API密钥均请求失败\n具体错误请查看轮询日志",finish_reason="stop",stream=False)
+
+    # raise HTTPException(status_code=500, detail=f"API key 替换失败，所有API key都已尝试，请重新配置或稍后重试")
+
+
+# 处理带保活的非流式请求（使用流式响应）
+async def process_nonstream_with_keepalive_stream(
+    chat_request,
+    key_manager,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str,
+    is_gemini: bool
+):
+    """处理带保活的非流式请求，使用流式响应发送保活消息但最终返回非流式格式"""
+    from fastapi.responses import StreamingResponse
+    import json
+    
+    async def keepalive_stream_generator():
+        """生成带保活的流式响应"""
+        try:
+            # 转换消息格式
+            format_type = getattr(chat_request, 'format_type', None)
+            if format_type and (format_type == "gemini"):
+                contents, system_instruction = None, None
+            else:
+                contents, system_instruction = GeminiClient.convert_messages(GeminiClient, chat_request.messages, model=chat_request.model)
+
+            # 设置初始并发数
+            current_concurrent = settings.CONCURRENT_REQUESTS
+            max_retry_num = settings.MAX_RETRY_NUM
+            
+            # 当前请求次数
+            current_try_num = 0
+            
+            # 空响应计数
+            empty_response_count = 0
+            
+            # 尝试使用不同API密钥，直到达到最大重试次数或空响应限制
+            while (current_try_num < max_retry_num) and (empty_response_count < settings.MAX_EMPTY_RESPONSES):
+                # 获取当前批次的密钥数量
+                batch_num = min(max_retry_num - current_try_num, current_concurrent)
+                
+                # 获取当前批次的密钥
+                valid_keys = []
+                checked_keys = set()  # 用于记录已检查过的密钥
+                all_keys_checked = False  # 标记是否已检查所有密钥
+                
+                # 尝试获取足够数量的有效密钥
+                while len(valid_keys) < batch_num:
+                    api_key = await key_manager.get_available_key()
+                    if not api_key:
+                        break
+                        
+                    # 如果这个密钥已经检查过，说明已经检查了所有密钥
+                    if api_key in checked_keys:
+                        all_keys_checked = True
+                        break
+                    
+                    checked_keys.add(api_key)
+                    # 获取API密钥的调用次数
+                    usage = await get_api_key_usage(settings.api_call_stats, api_key)
+                    # 如果调用次数小于限制，则添加到有效密钥列表
+                    if usage < settings.API_KEY_DAILY_LIMIT:
+                        valid_keys.append(api_key)
+                    else:
+                        log('warning', f"API密钥 {api_key[:8]}... 已达到每日调用限制 ({usage}/{settings.API_KEY_DAILY_LIMIT})",
+                            extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+                
+                # 如果已经检查了所有密钥且没有找到有效密钥，则重置密钥栈
+                if all_keys_checked and not valid_keys:
+                    log('warning', "所有API密钥已达到每日调用限制，重置密钥栈",
+                        extra={'request_type': 'non-stream', 'model': chat_request.model})
+                    key_manager._reset_key_stack()
+                    # 重置后重新获取一个密钥
+                    api_key = await key_manager.get_available_key()
+                    if api_key:
+                        valid_keys = [api_key]
+                
+                # 如果没有获取到任何有效密钥，跳出循环
+                if not valid_keys:
+                    break
+                    
+                # 更新当前尝试次数
+                current_try_num += len(valid_keys)
+                
+                # 创建并发任务
+                tasks = []
+                tasks_map = {}
+                for api_key in valid_keys:
+                    # 记录当前尝试的密钥信息
+                    log('info', f"非流式请求开始，使用密钥: {api_key[:8]}...", 
+                        extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+                    
+                    # 创建任务
+                    task = asyncio.create_task(
+                        process_nonstream_request(
+                            chat_request,
+                            contents,
+                            system_instruction,
+                            api_key,
+                            response_cache_manager,
+                            safety_settings,
+                            safety_settings_g2,
+                            cache_key
+                        )
+                    )
+                    tasks.append((api_key, task))
+                    tasks_map[task] = api_key
+                
+                # 等待所有任务完成或找到成功响应
+                success = False
+                keepalive_counter = 0
+                while tasks and not success:
+                    # 短时间等待任务完成
+                    done, pending = await asyncio.wait(
+                        [task for _, task in tasks],
+                        timeout=settings.NONSTREAM_KEEPALIVE_INTERVAL,
+                        return_when=asyncio.FIRST_COMPLETED
+                    )
+                    
+                    # 如果没有任务完成，发送保活消息
+                    if not done:
+                        keepalive_counter += 1
+                        
+                        # 发送简单的换行符作为保活消息
+                        yield "\n"
+                        continue
+                    
+                    # 检查已完成的任务是否成功
+                    for task in done:
+                        api_key = tasks_map[task]
+                        try:
+                            status = task.result()                    
+                            # 如果有成功响应内容
+                            if status == "success" :  
+                                success = True
+                                log('info', f"非流式请求成功", 
+                                    extra={'key': api_key[:8],'request_type': 'non-stream', 'model': chat_request.model})
+                                cached_response, cache_hit = await response_cache_manager.get_and_remove(cache_key)
+                                
+                                # 发送最终的非流式响应
+                                if is_gemini:
+                                    final_response = cached_response.data
+                                else:
+                                    final_response = openAI_from_Gemini(cached_response, stream=False)
+                                
+                                # 将非流式响应作为字符串发送
+                                yield json.dumps(final_response, ensure_ascii=False)
+                                return
+                            elif status == "empty":
+                                # 增加空响应计数
+                                empty_response_count += 1
+                                log('warning', f"空响应计数: {empty_response_count}/{settings.MAX_EMPTY_RESPONSES}",
+                                    extra={'key': api_key[:8], 'request_type': 'non-stream', 'model': chat_request.model})
+                        
+                        except Exception as e:
+                            handle_gemini_error(e, api_key)
+                        
+                        # 更新任务列表，移除已完成的任务
+                        tasks = [(k, t) for k, t in tasks if not t.done()]
+                        
+                # 如果当前批次没有成功响应，并且还有密钥可用，则继续尝试
+                if not success and valid_keys:
+                    # 增加并发数，但不超过最大并发数
+                    current_concurrent = min(current_concurrent + settings.INCREASE_CONCURRENT_ON_FAILURE, settings.MAX_CONCURRENT_REQUESTS)
+                    log('info', f"所有并发请求失败或返回空响应，增加并发数至: {current_concurrent}", 
+                        extra={'request_type': 'non-stream', 'model': chat_request.model})
+                
+                # 如果空响应次数达到限制，跳出循环，并返回酒馆正常响应(包含错误信息)
+                if empty_response_count >= settings.MAX_EMPTY_RESPONSES:
+                    log('warning', f"空响应次数达到限制 ({empty_response_count}/{settings.MAX_EMPTY_RESPONSES})，停止轮询",
+                        extra={'request_type': 'non-stream', 'model': chat_request.model})
+                    
+                    if is_gemini :
+                        error_response = gemini_from_text(content="空响应次数达到上限\n请修改输入提示词", finish_reason="STOP", stream=False)
+                    else:
+                        error_response = openAI_from_text(model=chat_request.model, content="空响应次数达到上限\n请修改输入提示词", finish_reason="stop", stream=False)
+                    
+                    yield json.dumps(error_response, ensure_ascii=False)
+                    return
+            
+            # 如果所有尝试都失败
+            log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'request_type': 'switch_key'})
+            
+            if is_gemini:
+                error_response = gemini_from_text(content="所有API密钥均请求失败\n具体错误请查看轮询日志", finish_reason="STOP", stream=False)
+            else:
+                error_response = openAI_from_text(model=chat_request.model, content="所有API密钥均请求失败\n具体错误请查看轮询日志", finish_reason="stop", stream=False)
+            
+            yield json.dumps(error_response, ensure_ascii=False)
+                
+        except Exception as e:
+            log('error', f"保活流式处理出错: {str(e)}", 
+                extra={'request_type': 'non-stream', 'keepalive': True})
+            raise
+    
+    # 返回流式响应，但使用application/json媒体类型
+    return StreamingResponse(
+        keepalive_stream_generator(),
+        media_type="application/json"
+    )

app/api/routes.py

@@ -0,0 +1,336 @@
+import json
+from typing import Optional, Union
+from fastapi import APIRouter, Body, HTTPException, Path, Query, Request, Depends, status, Header
+from fastapi.responses import StreamingResponse
+from app.services import GeminiClient
+from app.utils import protect_from_abuse,generate_cache_key,openAI_from_text,log
+from app.utils.response import openAI_from_Gemini
+from app.utils.auth import custom_verify_password
+from .stream_handlers import process_stream_request
+from .nonstream_handlers import process_request, process_nonstream_with_keepalive_stream
+from app.models.schemas import ChatCompletionRequest, ChatCompletionResponse, ModelList, AIRequest, ChatRequestGemini
+import app.config.settings as settings
+import asyncio
+from app.vertex.routes import chat_api, models_api
+from app.vertex.models import OpenAIRequest, OpenAIMessage
+
+# 创建路由器
+router = APIRouter()
+
+# 全局变量引用 - 这些将在main.py中初始化并传递给路由
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+safety_settings = None
+safety_settings_g2 = None
+current_api_key = None
+FAKE_STREAMING = None
+FAKE_STREAMING_INTERVAL = None
+PASSWORD = None
+MAX_REQUESTS_PER_MINUTE = None
+MAX_REQUESTS_PER_DAY_PER_IP = None
+
+# 初始化路由器的函数
+def init_router(
+    _key_manager,
+    _response_cache_manager,
+    _active_requests_manager,
+    _safety_settings,
+    _safety_settings_g2,
+    _current_api_key,
+    _fake_streaming,
+    _fake_streaming_interval,
+    _password,
+    _max_requests_per_minute,
+    _max_requests_per_day_per_ip
+):
+    global key_manager, response_cache_manager, active_requests_manager
+    global safety_settings, safety_settings_g2, current_api_key
+    global FAKE_STREAMING, FAKE_STREAMING_INTERVAL
+    global PASSWORD, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP
+    
+    key_manager = _key_manager
+    response_cache_manager = _response_cache_manager
+    active_requests_manager = _active_requests_manager
+    safety_settings = _safety_settings
+    safety_settings_g2 = _safety_settings_g2
+    current_api_key = _current_api_key
+    FAKE_STREAMING = _fake_streaming
+    FAKE_STREAMING_INTERVAL = _fake_streaming_interval
+    PASSWORD = _password
+    MAX_REQUESTS_PER_MINUTE = _max_requests_per_minute
+    MAX_REQUESTS_PER_DAY_PER_IP = _max_requests_per_day_per_ip
+
+async def verify_user_agent(request: Request):
+    if not settings.WHITELIST_USER_AGENT:
+        return
+    if request.headers.get("User-Agent") not in settings.WHITELIST_USER_AGENT:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not allowed client")
+
+# todo : 添加 gemini 支持(流式返回)
+async def get_cache(cache_key,is_stream: bool,is_gemini=False):
+    # 检查缓存是否存在，如果存在，返回缓存
+    cached_response, cache_hit = await response_cache_manager.get_and_remove(cache_key)
+    
+    if cache_hit and cached_response:
+        log('info', f"缓存命中: {cache_key[:8]}...", 
+            extra={'request_type': 'non-stream', 'model': cached_response.model})
+        
+        if is_gemini:
+            if is_stream:
+                data = f"data: {json.dumps(cached_response.data, ensure_ascii=False)}\n\n"
+                return StreamingResponse(data, media_type="text/event-stream")
+            else:
+                return cached_response.data
+            
+        
+        if is_stream:
+            chunk = openAI_from_Gemini(cached_response,stream=True)
+            return StreamingResponse(chunk, media_type="text/event-stream")
+        else: 
+            return openAI_from_Gemini(cached_response,stream=False)
+
+    return None
+
+@router.get("/aistudio/models",response_model=ModelList)
+async def aistudio_list_models(_ = Depends(custom_verify_password),
+                               _2 = Depends(verify_user_agent)):
+    if settings.WHITELIST_MODELS:
+        filtered_models = [model for model in GeminiClient.AVAILABLE_MODELS if model in settings.WHITELIST_MODELS]
+    else:
+        filtered_models = [model for model in GeminiClient.AVAILABLE_MODELS if model not in settings.BLOCKED_MODELS]
+    return ModelList(data=[{"id": model, "object": "model", "created": 1678888888, "owned_by": "organization-owner"} for model in filtered_models])
+
+@router.get("/vertex/models",response_model=ModelList)
+async def vertex_list_models(request: Request, 
+                             _ = Depends(custom_verify_password),
+                             _2 = Depends(verify_user_agent)):
+    # 使用vertex/routes/models_api的实现
+    return await models_api.list_models(request, current_api_key)
+
+# API路由
+@router.get("/v1/models",response_model=ModelList)
+@router.get("/models",response_model=ModelList)
+async def list_models(request: Request,
+                      _ = Depends(custom_verify_password),
+                      _2 = Depends(verify_user_agent)):
+    if settings.ENABLE_VERTEX:
+        return await vertex_list_models(request, _, _2)
+    return await aistudio_list_models(_, _2)
+
+@router.post("/aistudio/chat/completions", response_model=ChatCompletionResponse)
+async def aistudio_chat_completions(
+    request: Union[ChatCompletionRequest, AIRequest],
+    http_request: Request,
+    _ = Depends(custom_verify_password),
+    _2 = Depends(verify_user_agent),
+):
+    format_type = getattr(request, 'format_type', None)
+    if format_type and (format_type == "gemini"):
+        is_gemini = True
+    else:
+        is_gemini = False
+    
+    # 生成缓存键 - 用于匹配请求内容对应缓存
+    if settings.PRECISE_CACHE:
+        cache_key = generate_cache_key(request, is_gemini = is_gemini)
+    else:    
+        cache_key = generate_cache_key(request, last_n_messages = settings.CALCULATE_CACHE_ENTRIES,is_gemini = is_gemini)
+    
+    # 请求前基本检查
+    await protect_from_abuse(
+        http_request, 
+        settings.MAX_REQUESTS_PER_MINUTE, 
+        settings.MAX_REQUESTS_PER_DAY_PER_IP)
+    
+    if request.model not in GeminiClient.AVAILABLE_MODELS:
+        log('error', "无效的模型", 
+            extra={'model': request.model, 'status_code': 400})
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="无效的模型")
+    
+    
+    # 记录请求缓存键信息
+    log('info', f"请求缓存键: {cache_key[:8]}...", 
+        extra={'request_type': 'non-stream', 'model': request.model})
+    
+    # 检查缓存是否存在，如果存在，返回缓存
+    cached_response = await get_cache(cache_key, is_stream = request.stream,is_gemini=is_gemini)
+    if cached_response :
+        return cached_response
+    
+    if not settings.PUBLIC_MODE:
+        # 构建包含缓存键的活跃请求池键
+        pool_key = f"{cache_key}"
+        
+        # 查找所有使用相同缓存键的活跃任务
+        active_task = active_requests_manager.get(pool_key)
+        if active_task and not active_task.done():
+            log('info', f"发现相同请求的进行中任务", 
+                extra={'request_type': 'stream' if request.stream else "non-stream", 'model': request.model})
+            
+            # 等待已有任务完成
+            try:
+                # 设置超时，避免无限等待
+                await asyncio.wait_for(active_task, timeout=240)
+                
+                # 使用任务结果
+                if active_task.done() and not active_task.cancelled():
+                    
+                    result = active_task.result()
+                    active_requests_manager.remove(pool_key)
+                    if result:
+                        return result
+            
+            except (asyncio.TimeoutError, asyncio.CancelledError) as e:
+                # 任务超时或被取消的情况下，记录日志然后让代码继续执行
+                error_type = "超时" if isinstance(e, asyncio.TimeoutError) else "被取消"
+                log('warning', f"等待已有任务{error_type}: {pool_key}", 
+                    extra={'request_type': 'non-stream', 'model': request.model})
+                
+                # 从活跃请求池移除该任务
+                if active_task.done() or active_task.cancelled():
+                    active_requests_manager.remove(pool_key)
+                    log('info', f"已从活跃请求池移除{error_type}任务: {pool_key}", 
+                        extra={'request_type': 'non-stream'})
+    
+        
+    if request.stream:
+        # 流式请求处理任务
+        process_task = asyncio.create_task(
+            process_stream_request(
+                chat_request = request, 
+                key_manager=key_manager,
+                response_cache_manager = response_cache_manager,
+                safety_settings = safety_settings,
+                safety_settings_g2 = safety_settings_g2,
+                cache_key = cache_key
+            )
+        )
+    
+    else:
+        # 检查是否启用非流式保活功能
+        if settings.NONSTREAM_KEEPALIVE_ENABLED:
+            # 使用带保活功能的非流式请求处理
+            process_task = asyncio.create_task(
+                process_nonstream_with_keepalive_stream(
+                    chat_request = request,
+                    key_manager = key_manager,
+                    response_cache_manager = response_cache_manager,
+                    safety_settings = safety_settings,
+                    safety_settings_g2 = safety_settings_g2,
+                    cache_key = cache_key,
+                    is_gemini = is_gemini
+                )
+            )
+        else:
+            # 创建非流式请求处理任务
+            process_task = asyncio.create_task(
+                process_request(
+                    chat_request = request,
+                    key_manager = key_manager,
+                    response_cache_manager = response_cache_manager,
+                    safety_settings = safety_settings,
+                    safety_settings_g2 = safety_settings_g2,
+                    cache_key = cache_key
+                )
+            )
+
+    if not settings.PUBLIC_MODE:
+        # 将任务添加到活跃请求池
+        active_requests_manager.add(pool_key, process_task)
+    
+    # 等待任务完成
+    try:
+        response = await process_task
+        if not settings.PUBLIC_MODE:
+            active_requests_manager.remove(pool_key)
+        
+        return response
+    except Exception as e:
+        if not settings.PUBLIC_MODE:
+            # 如果任务失败，从活跃请求池中移除
+            active_requests_manager.remove(pool_key)
+        
+        # 检查是否已有缓存的结果（可能是由另一个任务创建的）
+        cached_response = await get_cache(cache_key, is_stream = request.stream,is_gemini=is_gemini)
+        if cached_response :
+            return cached_response
+        
+        # 发送错误信息给客户端
+        raise HTTPException(status_code=500, detail=f" hajimi 服务器内部处理时发生错误\n具体原因:{e}")
+
+@router.post("/vertex/chat/completions", response_model=ChatCompletionResponse)
+async def vertex_chat_completions(
+    request: ChatCompletionRequest, 
+    http_request: Request,
+    _dp = Depends(custom_verify_password),
+    _du = Depends(verify_user_agent),
+    ):
+    # 使用vertex/routes/chat_api的实现
+    
+    # 转换消息格式
+    openai_messages = []
+    for message in request.messages:
+        openai_messages.append(OpenAIMessage(
+            role=message.get('role', ''),
+            content=message.get('content', '')
+        ))
+    
+    # 转换请求格式
+    vertex_request = OpenAIRequest(
+        model=request.model,
+        messages=openai_messages,
+        temperature=request.temperature,
+        max_tokens=request.max_tokens,
+        top_p=request.top_p,
+        top_k=request.top_k,
+        stream=request.stream,
+        stop=request.stop,
+        presence_penalty=request.presence_penalty,
+        frequency_penalty=request.frequency_penalty,
+        seed=getattr(request, 'seed', None),
+        logprobs=getattr(request, 'logprobs', None),
+        response_logprobs=getattr(request, 'response_logprobs', None),
+        n=request.n
+    )
+    
+    # 调用vertex/routes/chat_api的实现
+    return await chat_api.chat_completions(http_request, vertex_request, current_api_key)
+
+@router.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+@router.post("/chat/completions", response_model=ChatCompletionResponse)
+async def chat_completions(
+    request: ChatCompletionRequest,
+    http_request: Request,
+    _dp = Depends(custom_verify_password),
+    _du = Depends(verify_user_agent),
+):
+    """处理API请求的主函数，根据需要处理流式或非流式请求"""
+    if settings.ENABLE_VERTEX:
+        return await vertex_chat_completions(request, http_request, _dp, _du)
+    return await aistudio_chat_completions(request, http_request, _dp, _du)
+
+@router.post("/gemini/{api_version:str}/models/{model_and_responseType:path}")
+async def gemini_chat_completions(
+    request: Request,
+    model_and_responseType: str = Path(...),
+    key: Optional[str] = Query(None),
+    alt: Optional[str] = Query(None, description=" sse 或 None"),
+    payload: ChatRequestGemini = Body(...),
+    _dp = Depends(custom_verify_password),
+    _du = Depends(verify_user_agent),
+):
+    # 提取路径参数
+    is_stream = False
+    try:
+        model_name, action_type = model_and_responseType.split(":", 1)
+        if action_type == "streamGenerateContent":
+            is_stream = True
+        
+    except ValueError:
+        raise HTTPException(status_code=400, detail="无效的请求路径")
+    
+    geminiRequest = AIRequest(payload=payload,model=model_name,stream=is_stream,format_type='gemini')
+    return await aistudio_chat_completions(geminiRequest, request, _dp, _du)
+        

app/api/stream_handlers.py

@@ -0,0 +1,374 @@
+import asyncio
+import json
+from fastapi.responses import StreamingResponse
+from app.models.schemas import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import handle_gemini_error, update_api_call_stats,log,openAI_from_text
+from app.utils.response import openAI_from_Gemini,gemini_from_text
+from app.utils.stats import get_api_key_usage
+import app.config.settings as settings
+
+async def stream_response_generator(
+    chat_request,
+    key_manager,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str
+):
+    format_type = getattr(chat_request, 'format_type', None)
+    if format_type and (format_type == "gemini"):
+        is_gemini = True
+        contents, system_instruction = None,None
+    else:
+        is_gemini = False
+        # 转换消息格式
+        contents, system_instruction = GeminiClient.convert_messages(GeminiClient, chat_request.messages,model=chat_request.model)
+    # 设置初始并发数
+    current_concurrent = settings.CONCURRENT_REQUESTS
+    max_retry_num = settings.MAX_RETRY_NUM
+    
+    # 当前请求次数
+    current_try_num = 0
+    
+    # 空响应计数
+    empty_response_count = 0
+    
+    # (假流式) 尝试使用不同API密钥，直到达到最大重试次数或空响应限制
+    while (settings.FAKE_STREAMING and (current_try_num < max_retry_num) and (empty_response_count < settings.MAX_EMPTY_RESPONSES)):
+        # 获取当前批次的密钥数量
+        batch_num = min(max_retry_num - current_try_num, current_concurrent)
+        
+        # 获取当前批次的密钥
+        valid_keys = []
+        checked_keys = set()  # 用于记录已检查过的密钥
+        all_keys_checked = False  # 标记是否已检查所有密钥
+        
+        # 尝试获取足够数量的有效密钥
+        while len(valid_keys) < batch_num:
+            api_key = await key_manager.get_available_key()
+            if not api_key:
+                break
+                
+            # 如果这个密钥已经检查过，说明已经检查了所有密钥
+            if api_key in checked_keys:
+                all_keys_checked = True
+                break
+            
+            checked_keys.add(api_key)
+            # 获取API密钥的调用次数
+            usage = await get_api_key_usage(settings.api_call_stats, api_key)
+            # 如果调用次数小于限制，则添加到有效密钥列表
+            if usage < settings.API_KEY_DAILY_LIMIT:
+                valid_keys.append(api_key)
+            else:
+                log('warning', f"API密钥 {api_key[:8]}... 已达到每日调用限制 ({usage}/{settings.API_KEY_DAILY_LIMIT})",
+                    extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+        
+        # 如果已经检查了所有密钥且没有找到有效密钥，则重置密钥栈
+        if all_keys_checked and not valid_keys:
+            log('warning', "所有API密钥已达到每日调用限制，重置密钥栈",
+                extra={'request_type': 'stream', 'model': chat_request.model})
+            key_manager._reset_key_stack()
+            # 重置后重新获取一个密钥
+            api_key = await key_manager.get_available_key()
+            if api_key:
+                valid_keys = [api_key]
+        
+        # 如果没有获取到任何有效密钥，跳出循环
+        if not valid_keys:
+            break
+            
+        # 更新当前尝试次数
+        current_try_num += len(valid_keys)
+        
+        # 创建并发任务
+        tasks = []
+        tasks_map = {}
+        for api_key in valid_keys:
+            # 假流式模式的处理逻辑
+            log('info', f"假流式请求开始，使用密钥: {api_key[:8]}...",
+                extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+            
+            task = asyncio.create_task(
+                handle_fake_streaming(
+                    api_key, 
+                    chat_request, 
+                    contents, 
+                    response_cache_manager,
+                    system_instruction, 
+                    safety_settings, 
+                    safety_settings_g2,
+                    cache_key
+                )
+            )
+            
+            tasks.append((api_key, task))
+            tasks_map[task] = api_key
+        
+        # 等待所有任务完成或找到成功响应
+        success = False
+        while tasks and not success:
+            # 等待任务完成
+            done, pending = await asyncio.wait(
+                [task for _, task in tasks],
+                timeout=settings.FAKE_STREAMING_INTERVAL,
+                return_when=asyncio.FIRST_COMPLETED
+            )
+            
+            # 如果没有任务完成，发送保活消息
+            if not done :
+                if is_gemini:
+                    yield gemini_from_text(content='',stream=True)
+                else:
+                    yield openAI_from_text(model=chat_request.model,content='',stream=True)
+                continue
+            
+            # 检查已完成的任务是否成功
+            for task in done:
+                api_key = tasks_map[task]
+                if not task.cancelled():
+                    try:
+                        status = task.result()
+                        # 如果有成功响应内容
+                        if status == "success" :  
+                            success = True
+                            log('info', f"假流式请求成功", 
+                                extra={'key': api_key[:8],'request_type': "fake-stream", 'model': chat_request.model})
+                            cached_response, cache_hit = await response_cache_manager.get_and_remove(cache_key)
+                            if cache_hit and cached_response: 
+                                if is_gemini :
+                                    json_payload = json.dumps(cached_response.data, ensure_ascii=False)
+                                    data_to_yield = f"data: {json_payload}\n\n"
+                                    yield data_to_yield
+                                else:
+                                    yield openAI_from_Gemini(cached_response,stream=True)
+                            else:
+                                success = False
+                            break
+                        elif status == "empty":
+                            # 增加空响应计数
+                            empty_response_count += 1
+                            log('warning', f"空响应计数: {empty_response_count}/{settings.MAX_EMPTY_RESPONSES}",
+                                extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                        
+                    except Exception as e:
+                        error_detail = handle_gemini_error(e, api_key)
+                        log('error', f"请求失败: {error_detail}",
+                            extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+
+            # 如果找到成功的响应，跳出循环
+            if success:
+                return
+            
+            # 如果空响应次数达到限制，跳出循环
+            if empty_response_count >= settings.MAX_EMPTY_RESPONSES:
+                log('warning', f"空响应次数达到限制 ({empty_response_count}/{settings.MAX_EMPTY_RESPONSES})，停止轮询",
+                    extra={'request_type': 'fake-stream', 'model': chat_request.model})
+                if is_gemini :
+                    yield gemini_from_text(content="空响应次数达到上限\n请修改输入提示词",finish_reason="STOP",stream=True)
+                else:
+                    yield openAI_from_text(model=chat_request.model,content="空响应次数达到上限\n请修改输入提示词",finish_reason="stop",stream=True)
+                
+                return
+            
+            # 更新任务列表，移除已完成的任务
+            tasks = [(k, t) for k, t in tasks if not t.done()]
+        
+        # 如果所有请求都失败，增加并发数并继续尝试
+        if not success and valid_keys:
+            # 增加并发数，但不超过最大并发数
+            current_concurrent = min(current_concurrent + settings.INCREASE_CONCURRENT_ON_FAILURE, settings.MAX_CONCURRENT_REQUESTS)
+            log('info', f"所有假流式请求失败，增加并发数至: {current_concurrent}", 
+                extra={'request_type': 'stream', 'model': chat_request.model})
+
+    # (真流式) 尝试使用不同API密钥，直到达到最大重试次数或空响应限制
+    while (not settings.FAKE_STREAMING and (current_try_num < max_retry_num) and (empty_response_count < settings.MAX_EMPTY_RESPONSES)):
+        # 获取当前批次的密钥
+        valid_keys = []
+        checked_keys = set()  # 用于记录已检查过的密钥
+        all_keys_checked = False  # 标记是否已检查所有密钥
+        
+        # 尝试获取一个有效密钥
+        while len(valid_keys) < 1:
+            api_key = await key_manager.get_available_key()
+            if not api_key:
+                break
+                
+            # 如果这个密钥已经检查过，说明已经检查了所有密钥
+            if api_key in checked_keys:
+                all_keys_checked = True
+                break
+            
+            checked_keys.add(api_key)
+            # 获取API密钥的调用次数
+            usage = await get_api_key_usage(settings.api_call_stats, api_key)
+            # 如果调用次数小于限制，则添加到有效密钥列表
+            if usage < settings.API_KEY_DAILY_LIMIT:
+                valid_keys.append(api_key)
+            else:
+                log('warning', f"API密钥 {api_key[:8]}... 已达到每日调用限制 ({usage}/{settings.API_KEY_DAILY_LIMIT})",
+                    extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+        
+        # 如果已经检查了所有密钥且没有找到有效密钥，则重置密钥栈
+        if all_keys_checked and not valid_keys:
+            log('warning', "所有API密钥已达到每日调用限制，重置密钥栈",
+                extra={'request_type': 'stream', 'model': chat_request.model})
+            key_manager._reset_key_stack()
+            # 重置后重新获取一个密钥
+            api_key = await key_manager.get_available_key()
+            if api_key:
+                valid_keys = [api_key]
+        
+        # 如果没有获取到任何有效密钥，跳出循环
+        if not valid_keys:
+            break
+            
+        # 更新当前尝试次数
+        current_try_num += 1
+        
+        # 获取密钥
+        api_key = valid_keys[0]
+        
+        success = False
+        try:            
+            client = GeminiClient(api_key)
+            
+            # 获取流式响应
+            stream_generator = client.stream_chat(
+                chat_request,
+                contents,
+                safety_settings_g2 if 'gemini-2.5' in chat_request.model else safety_settings,
+                system_instruction
+            )
+            token=0
+            # 处理流式响应
+            async for chunk in stream_generator:
+                if chunk :
+                    
+                    if chunk.total_token_count:
+                        token = int(chunk.total_token_count)
+                    success = True
+                    
+                    if is_gemini:
+                        json_payload = json.dumps(chunk.data, ensure_ascii=False)
+                        data = f"data: {json_payload}\n\n"
+                    else:
+                        data = openAI_from_Gemini(chunk,stream=True)
+                    
+                    # log('info', f"流式响应发送数据: {data}")
+                    yield data
+                    
+                else:
+                    log('warning', f"流式请求返回空响应，空响应计数: {empty_response_count}/{settings.MAX_EMPTY_RESPONSES}",
+                        extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                    # 增加空响应计数
+                    empty_response_count += 1
+                    await update_api_call_stats(
+                        settings.api_call_stats, 
+                        endpoint=api_key, 
+                        model=chat_request.model,
+                        token=token
+                    )
+                    break
+        
+        except Exception as e:
+            error_detail = handle_gemini_error(e, api_key)
+            log('error', f"流式响应: API密钥 {api_key[:8]}... 请求失败: {error_detail}",
+                extra={'key': api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+        finally: 
+            # 如果成功获取相应，更新API调用统计
+            if success:
+                await update_api_call_stats(
+                    settings.api_call_stats, 
+                    endpoint=api_key, 
+                    model=chat_request.model,
+                    token=token
+                )
+                return
+            
+            # 如果空响应次数达到限制，跳出循环
+            if empty_response_count >= settings.MAX_EMPTY_RESPONSES:
+                
+                log('warning', f"空响应次数达到限制 ({empty_response_count}/{settings.MAX_EMPTY_RESPONSES})，停止轮询",
+                    extra={'request_type': 'stream', 'model': chat_request.model})
+                
+                if is_gemini:
+                    yield gemini_from_text(content="空响应次数达到上限\n请修改输入提示词",finish_reason="STOP",stream=True)
+                else:
+                    yield openAI_from_text(model=chat_request.model,content="空响应次数达到上限\n请修改输入提示词",finish_reason="stop",stream=True)
+                
+                return
+    
+    # 所有API密钥都尝试失败的处理
+    log('error', "所有 API 密钥均请求失败，请稍后重试",
+        extra={'key': 'ALL', 'request_type': 'stream', 'model': chat_request.model})
+    
+    if is_gemini:
+        yield gemini_from_text(content="所有API密钥均请求失败\n具体错误请查看轮询日志",finish_reason="STOP",stream=True)
+    else:
+        yield openAI_from_text(model=chat_request.model,content="所有API密钥均请求失败\n具体错误请查看轮询日志",finish_reason="stop")
+
+# 处理假流式模式
+async def handle_fake_streaming(api_key,chat_request, contents, response_cache_manager,system_instruction, safety_settings, safety_settings_g2, cache_key):
+    
+    # 使用非流式请求内容
+    gemini_client = GeminiClient(api_key)
+    
+    gemini_task = asyncio.create_task(
+        gemini_client.complete_chat( 
+            chat_request,
+            contents,
+            safety_settings_g2 if 'gemini-2.5' in chat_request.model else safety_settings,
+            system_instruction
+        )
+    )
+    gemini_task = asyncio.shield(gemini_task)
+    
+    try:
+        # 获取响应内容
+        response_content = await gemini_task
+        response_content.set_model(chat_request.model)
+        log('info', f"假流式成功获取响应，进行缓存",
+            extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+
+        # 更新API调用统计
+        await update_api_call_stats(settings.api_call_stats, endpoint=api_key, model=chat_request.model,token=response_content.total_token_count)
+        
+        # 检查响应内容是否为空
+        if not response_content or (not response_content.text and not response_content.function_call):
+            log('warning', f"请求返回空响应",
+                extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})        
+            return "empty"
+
+        # 缓存
+        await response_cache_manager.store(cache_key, response_content)
+        return "success"
+    
+    except Exception as e:
+        handle_gemini_error(e, api_key)
+        # log('error', f"假流式模式: API密钥 {api_key[:8]}... 请求失败: {error_detail}",
+        #     extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+        return "error"
+        
+
+
+# 流式请求处理函数
+async def process_stream_request(
+    chat_request: ChatCompletionRequest,
+    key_manager,
+    response_cache_manager,
+    safety_settings,
+    safety_settings_g2,
+    cache_key: str
+) -> StreamingResponse:
+    """处理流式API请求"""
+    
+    return StreamingResponse(stream_response_generator(
+                chat_request,
+                key_manager,
+                response_cache_manager,
+                safety_settings,
+                safety_settings_g2,
+                cache_key
+            ), media_type="text/event-stream")

app/config/__init__.py

@@ -0,0 +1,4 @@
+# 配置模块初始化文件
+import app.config.settings as settings
+from app.config.safety import *
+from app.config.persistence import save_settings, load_settings

app/config/persistence.py

@@ -0,0 +1,165 @@
+import json
+import os
+import inspect
+import pathlib
+from app.config import settings
+from app.utils.logging import log
+
+# 定义不应该被保存或加载的配置项
+EXCLUDED_SETTINGS = [
+    "STORAGE_DIR", 
+    "ENABLE_STORAGE", 
+    "BASE_DIR", 
+    "PASSWORD", 
+    "WEB_PASSWORD", 
+    "WHITELIST_MODELS", 
+    "BLOCKED_MODELS", 
+    "DEFAULT_BLOCKED_MODELS", 
+    "PUBLIC_MODE", 
+    "DASHBOARD_URL",
+    "version"
+]
+
+def save_settings():
+    """
+    将settings中所有的从os.environ.get获取的配置保存到JSON文件中，
+    但排除特定的配置项
+    """
+    if settings.ENABLE_STORAGE:
+        # 确保存储目录存在
+        storage_dir = pathlib.Path(settings.STORAGE_DIR)
+        storage_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 设置JSON文件路径
+        settings_file = storage_dir / "settings.json"
+        
+        # 获取settings模块中的所有变量
+        settings_dict = {}
+        for name, value in inspect.getmembers(settings):
+            # 跳过内置和私有变量，以及函数/模块/类，以及排除列表中的配置项
+            if (not name.startswith('_') and 
+                not inspect.isfunction(value) and 
+                not inspect.ismodule(value) and 
+                not inspect.isclass(value) and
+                name not in EXCLUDED_SETTINGS):
+                
+                # 尝试将可序列化的值添加到字典中
+                try:
+                    json.dumps({name: value})  # 测试是否可序列化
+                    settings_dict[name] = value
+                except (TypeError, OverflowError):
+                    # 如果不可序列化，则跳过
+                    continue
+        log('info', f"保存设置到JSON文件: {settings_file}")
+        
+        # 保存到JSON文件
+        with open(settings_file, 'w', encoding='utf-8') as f:
+            json.dump(settings_dict, f, ensure_ascii=False, indent=4)
+        
+        return settings_file
+
+def load_settings():
+    """
+    从JSON文件中加载设置并更新settings模块，
+    排除特定的配置项，并合并GEMINI_API_KEYS
+    """
+    if settings.ENABLE_STORAGE:
+        # 设置JSON文件路径
+        storage_dir = pathlib.Path(settings.STORAGE_DIR)
+        settings_file = storage_dir / "settings.json"
+        
+        # 如果文件不存在，则返回
+        if not settings_file.exists():
+            return False
+        
+        # 从JSON文件中加载设置
+        try:
+            with open(settings_file, 'r', encoding='utf-8') as f:
+                loaded_settings = json.load(f)
+            
+            # 保存当前环境变量中的GEMINI_API_KEYS
+            current_api_keys = []
+            if hasattr(settings, 'GEMINI_API_KEYS') and settings.GEMINI_API_KEYS:
+                current_api_keys = settings.GEMINI_API_KEYS.split(',')
+                current_api_keys = [key.strip() for key in current_api_keys if key.strip()]
+            
+            # 保存当前环境变量中的GOOGLE_CREDENTIALS_JSON和VERTEX_EXPRESS_API_KEY
+            current_google_credentials_json = settings.GOOGLE_CREDENTIALS_JSON if hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') else ""
+            current_vertex_express_api_key = settings.VERTEX_EXPRESS_API_KEY if hasattr(settings, 'VERTEX_EXPRESS_API_KEY') else ""
+            
+            # 更新settings模块中的变量，但排除特定配置项
+            for name, value in loaded_settings.items():
+                if hasattr(settings, name) and name not in EXCLUDED_SETTINGS:
+                    # 特殊处理GEMINI_API_KEYS，进行合并去重
+                    if name == "GEMINI_API_KEYS":
+                        loaded_api_keys = value.split(',') if value else []
+                        loaded_api_keys = [key.strip() for key in loaded_api_keys if key.strip()]
+                        all_keys = list(set(current_api_keys + loaded_api_keys))
+                        setattr(settings, name, ','.join(all_keys))
+                    # 特殊处理GOOGLE_CREDENTIALS_JSON，如果当前环境变量中有值，则优先使用环境变量中的值
+                    elif name == "GOOGLE_CREDENTIALS_JSON":
+                        # 检查当前值是否为空（None、空字符串、只有空白字符，或者是"''"这样的空引号）
+                        is_empty = (not current_google_credentials_json or 
+                                   not current_google_credentials_json.strip() or 
+                                   current_google_credentials_json.strip() in ['""', "''"])
+                        log('debug', f"is_empty检查结果: {is_empty}")
+                        if is_empty:
+                            log('debug', f"当前GOOGLE_CREDENTIALS_JSON为空，将使用持久化的值")
+                            setattr(settings, name, value)
+                            # 更新环境变量，确保其他模块能够访问到
+                            if value:  # 只有当value不为空���才设置环境变量
+                                os.environ["GOOGLE_CREDENTIALS_JSON"] = value
+                                log('info', f"从持久化存储加载了GOOGLE_CREDENTIALS_JSON配置")
+                            else:
+                                log('warning', f"持久化的GOOGLE_CREDENTIALS_JSON值为空")
+                        else:
+                            log('debug', f"当前GOOGLE_CREDENTIALS_JSON不为空，保持现有值")
+                    # 特殊处理VERTEX_EXPRESS_API_KEY，如果当前环境变量中有值，则优先使用环境变量中的值
+                    elif name == "VERTEX_EXPRESS_API_KEY":
+                        # 检查当前值是否为空（None、空字符串或只有空白字符）
+                        if not current_vertex_express_api_key or not current_vertex_express_api_key.strip():
+                            setattr(settings, name, value)
+                            # 更新环境变量，确保其他模块能够访问到
+                            if value:  # 只有当value不为空时才设置环境变量
+                                os.environ["VERTEX_EXPRESS_API_KEY"] = value
+                                log('info', f"从持久化存储加载了VERTEX_EXPRESS_API_KEY配置")
+                    else:
+                        setattr(settings, name, value)
+            
+            # 在加载完设置后，检查是否需要刷新模型配置
+            try:
+                # 如果加载了Google Credentials JSON或Vertex Express API Key，需要刷新模型配置
+                if (hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') and settings.GOOGLE_CREDENTIALS_JSON) or \
+                   (hasattr(settings, 'VERTEX_EXPRESS_API_KEY') and settings.VERTEX_EXPRESS_API_KEY):
+                    log('info', "检测到Google Credentials JSON或Vertex Express API Key，准备更新配置")
+                    
+                    # 更新配置
+                    import app.vertex.config as app_config
+                    
+                    # 重新加载vertex配置
+                    app_config.reload_config()
+                    
+                    # 更新app_config中的GOOGLE_CREDENTIALS_JSON
+                    if hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') and settings.GOOGLE_CREDENTIALS_JSON:
+                        app_config.GOOGLE_CREDENTIALS_JSON = settings.GOOGLE_CREDENTIALS_JSON
+                        # 同时更新环境变量，确保其他模块能够访问到
+                        os.environ["GOOGLE_CREDENTIALS_JSON"] = settings.GOOGLE_CREDENTIALS_JSON
+                        log('info', "已更新app_config和环境变量中的GOOGLE_CREDENTIALS_JSON")
+                    
+                    # 更新app_config中的VERTEX_EXPRESS_API_KEY_VAL
+                    if hasattr(settings, 'VERTEX_EXPRESS_API_KEY') and settings.VERTEX_EXPRESS_API_KEY:
+                        app_config.VERTEX_EXPRESS_API_KEY_VAL = [key.strip() for key in settings.VERTEX_EXPRESS_API_KEY.split(',') if key.strip()]
+                        # 同时更新环境变量
+                        os.environ["VERTEX_EXPRESS_API_KEY"] = settings.VERTEX_EXPRESS_API_KEY
+                        log('info', f"已更新app_config和环境变量中的VERTEX_EXPRESS_API_KEY_VAL，共{len(app_config.VERTEX_EXPRESS_API_KEY_VAL)}个有效密钥")
+                    
+                    log('info', "配置更新完成，Vertex AI将在下次请求时重新初始化")
+                    
+            except Exception as e:
+                log('error', f"更新配置时出错: {str(e)}")
+            
+            log('info', f"加载设置成功")
+            return True
+        except Exception as e:
+            log('error', f"加载设置时出错: {e}")
+            return False 

app/config/safety.py

@@ -0,0 +1,49 @@
+# 安全设置配置
+
+# Gemini 1.0 安全设置
+SAFETY_SETTINGS = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'BLOCK_NONE'
+    }
+]
+
+# Gemini 2.0 安全设置
+SAFETY_SETTINGS_G2 = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'OFF'
+    }
+]

app/config/settings.py

@@ -0,0 +1,125 @@
+import os
+import pathlib
+import logging
+from datetime import datetime, timedelta
+import asyncio 
+
+# ---------- 以下是基础配置信息 ----------
+
+# 调用本项目时使用的密码
+PASSWORD = os.environ.get("PASSWORD", "123").strip('"') 
+
+# 网页配置密码，设置后，在网页修改配置时使用 WEB_PASSWORD 而不是上面的 PASSWORD
+WEB_PASSWORD = os.environ.get("WEB_PASSWORD", PASSWORD).strip('"') 
+
+# API密钥
+GEMINI_API_KEYS = os.environ.get("GEMINI_API_KEYS", "")
+
+# 假流式是否开启
+FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
+
+# 配置持久化存储目录
+STORAGE_DIR = os.environ.get("STORAGE_DIR", "/hajimi/settings/")
+ENABLE_STORAGE = os.environ.get("ENABLE_STORAGE", "false").lower() in ["true", "1", "yes"]
+
+# 并发请求配置
+CONCURRENT_REQUESTS = int(os.environ.get("CONCURRENT_REQUESTS", "1"))  # 默认并发请求数
+INCREASE_CONCURRENT_ON_FAILURE = int(os.environ.get("INCREASE_CONCURRENT_ON_FAILURE", "0"))  # 失败时增加的并发数
+MAX_CONCURRENT_REQUESTS = int(os.environ.get("MAX_CONCURRENT_REQUESTS", "3"))  # 最大并发请求数
+
+# 缓存配置
+CACHE_EXPIRY_TIME = int(os.environ.get("CACHE_EXPIRY_TIME", "21600"))  # 默认缓存 6 小时 (21600 秒)
+MAX_CACHE_ENTRIES = int(os.environ.get("MAX_CACHE_ENTRIES", "500"))  # 默认最多缓存500条响应
+CALCULATE_CACHE_ENTRIES = int(os.environ.get("CALCULATE_CACHE_ENTRIES", "6"))  # 默认取最后 6 条消息算缓存键
+PRECISE_CACHE = os.environ.get("PRECISE_CACHE", "false").lower() in ["true", "1", "yes"] #是否取所有消息来算缓存键
+
+# 是否启用 Vertex AI
+ENABLE_VERTEX = os.environ.get("ENABLE_VERTEX", "false").lower() in ["true", "1", "yes"]
+GOOGLE_CREDENTIALS_JSON = os.environ.get("GOOGLE_CREDENTIALS_JSON", "")
+
+# 是否启用快速模式 Vertex
+ENABLE_VERTEX_EXPRESS = os.environ.get("ENABLE_VERTEX_EXPRESS", "false").lower() in ["true", "1", "yes"]
+VERTEX_EXPRESS_API_KEY = os.environ.get("VERTEX_EXPRESS_API_KEY", "")
+
+# 联网搜索配置
+search={
+    "search_mode":os.environ.get("SEARCH_MODE", "false").lower() in ["true", "1", "yes"],
+    "search_prompt":os.environ.get("SEARCH_PROMPT", "（使用搜索工具联网搜索，需要在content中结合搜索内容）").strip('"')
+}
+
+#随机字符串
+RANDOM_STRING = os.environ.get("RANDOM_STRING", "true").lower() in ["true", "1", "yes"]
+RANDOM_STRING_LENGTH = int(os.environ.get("RANDOM_STRING_LENGTH", "5"))
+
+# 空响应重试次数限制
+MAX_EMPTY_RESPONSES = int(os.environ.get("MAX_EMPTY_RESPONSES", "5"))  # 默认最多允许5次空响应
+
+# ---------- 以下是其他配置信息 ----------
+
+# 访问限制
+MAX_RETRY_NUM = int(os.environ.get("MAX_RETRY_NUM", "15")) # 请求时的最大总轮询 key 数
+MAX_REQUESTS_PER_MINUTE = int(os.environ.get("MAX_REQUESTS_PER_MINUTE", "30")) 
+MAX_REQUESTS_PER_DAY_PER_IP = int(os.environ.get("MAX_REQUESTS_PER_DAY_PER_IP", "600"))
+
+# API密钥使用限制
+API_KEY_DAILY_LIMIT = int(os.environ.get("API_KEY_DAILY_LIMIT", "100"))# 默认每个API密钥每24小时可使用100次
+
+# 模型屏蔽黑名单，格式应为逗号分隔的模型名称集合
+BLOCKED_MODELS = { model.strip() for model in os.environ.get("BLOCKED_MODELS", "").split(",") if model.strip() }
+
+#公益站模式
+PUBLIC_MODE = os.environ.get("PUBLIC_MODE", "false").lower() in ["true", "1", "yes"]
+#前端地址
+DASHBOARD_URL = os.environ.get("DASHBOARD_URL", "")
+
+# 模型屏蔽白名单
+WHITELIST_MODELS = { x.strip() for x in os.environ.get("WHITELIST_MODELS", "").split(",") if x.strip() }
+# 白名单User-Agent
+WHITELIST_USER_AGENT = { x.strip().lower() for x in os.environ.get("WHITELIST_USER_AGENT", "").split(",") if x.strip() }
+
+# 跨域配置
+# 允许的源列表，逗号分隔，例如 "http://localhost:3000,https://example.com"
+ALLOWED_ORIGINS_STR = os.environ.get("ALLOWED_ORIGINS", "")
+ALLOWED_ORIGINS = [origin.strip() for origin in ALLOWED_ORIGINS_STR.split(",") if origin.strip()]
+
+# ---------- 运行时全局信息，无需修改 ----------
+
+# 基础目录设置
+BASE_DIR = pathlib.Path(__file__).parent.parent
+
+# 失效的API密钥
+INVALID_API_KEYS = os.environ.get("INVALID_API_KEYS", "")
+
+version={
+    "local_version":"0.0.0",
+    "remote_version":"0.0.0",
+    "has_update":False
+}
+
+# API调用统计
+# 这个对象保留为空结构以保持向后兼容性
+# 实际统计数据已迁移到 app/utils/stats.py 中的 ApiStatsManager 类
+api_call_stats = {
+    'calls': []  # 兼容旧版代码结构
+}
+
+# 用于保护 api_call_stats 并发访问的锁
+stats_lock = asyncio.Lock() 
+
+# 日志配置
+logging.getLogger("uvicorn").disabled = True
+logging.getLogger("uvicorn.access").disabled = True
+
+
+# ---------- 以下配置信息已废弃 ----------
+
+# 假流式请求的空内容返回间隔（秒）
+FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
+# 假流式响应的每个块大小
+FAKE_STREAMING_CHUNK_SIZE = int(os.environ.get("FAKE_STREAMING_CHUNK_SIZE", "10"))
+# ���流式响应的每个块之间的延迟（秒）
+FAKE_STREAMING_DELAY_PER_CHUNK = float(os.environ.get("FAKE_STREAMING_DELAY_PER_CHUNK", "0.1"))
+
+# 非流式请求TCP保活配置
+NONSTREAM_KEEPALIVE_ENABLED = os.environ.get("NONSTREAM_KEEPALIVE_ENABLED", "true").lower() in ["true", "1", "yes"]
+NONSTREAM_KEEPALIVE_INTERVAL = float(os.environ.get("NONSTREAM_KEEPALIVE_INTERVAL", "5.0"))

app/main.py

@@ -0,0 +1,260 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.middleware.cors import CORSMiddleware
+from app.models.schemas import ErrorResponse
+from app.services import GeminiClient
+from app.utils import (
+    APIKeyManager, 
+    test_api_key, 
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    check_version,
+    schedule_cache_cleanup,
+    handle_exception,
+    log
+)
+from app.config.persistence import save_settings, load_settings
+from app.api import router, init_router, dashboard_router, init_dashboard_router
+from app.vertex.vertex_ai_init import init_vertex_ai
+from app.vertex.credentials_manager import CredentialManager
+import app.config.settings as settings
+from app.config.safety import SAFETY_SETTINGS, SAFETY_SETTINGS_G2
+import asyncio
+import sys
+import pathlib
+import os
+# 设置模板目录
+BASE_DIR = pathlib.Path(__file__).parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+app = FastAPI(limit="50M")
+
+# --------------- CORS 中间件 ---------------
+# 如果 ALLOWED_ORIGINS 为空列表，则不允许任何跨域请求
+if settings.ALLOWED_ORIGINS:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.ALLOWED_ORIGINS,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+# --------------- 全局实例 ---------------
+load_settings()
+# 初始化API密钥管理器
+key_manager = APIKeyManager()
+
+# 创建全局缓存字典，将作为缓存管理器的内部存储
+response_cache = {}
+
+# 初始化缓存管理器，使用全局字典作为存储
+response_cache_manager = ResponseCacheManager(
+    expiry_time=settings.CACHE_EXPIRY_TIME,
+    max_entries=settings.MAX_CACHE_ENTRIES,
+    cache_dict=response_cache
+)
+
+# 活跃请求池 - 将作为活跃请求管理器的内部存储
+active_requests_pool = {}
+
+# 初始化活跃请求管理器
+active_requests_manager = ActiveRequestsManager(requests_pool=active_requests_pool)
+
+SKIP_CHECK_API_KEY = os.environ.get("SKIP_CHECK_API_KEY", "").lower() == "true"
+
+# --------------- 工具函数 ---------------
+# @app.middleware("http")
+# async def log_requests(request: Request, call_next):
+#     """
+#     DEBUG用，接收并打印请求内容
+#     """
+#     log('info', f"接收到请求: {request.method} {request.url}")
+#     try:
+#         body = await request.json()
+#         log('info', f"请求体: {body}")
+#     except Exception:
+#         log('info', "请求体不是 JSON 格式或者为空")
+    
+#     response = await call_next(request)
+#     return response
+
+async def check_remaining_keys_async(keys_to_check: list, initial_invalid_keys: list):
+    """
+    在后台异步检查剩余的 API 密钥。
+    """
+    local_invalid_keys = []
+    found_valid_keys =False
+
+    log('info', f" 开始在后台检查剩余 API Key 是否有效")
+    for key in keys_to_check:
+        is_valid = await test_api_key(key)
+        if is_valid:
+            if key not in key_manager.api_keys: # 避免重复添加
+                key_manager.api_keys.append(key)
+                found_valid_keys = True
+            # log('info', f"API Key {key[:8]}... 有效")
+        else:
+            local_invalid_keys.append(key)
+            log('warning', f" API Key {key[:8]}... 无效")
+        
+        await asyncio.sleep(0.05) # 短暂休眠，避免请求过于密集
+
+    if found_valid_keys:
+        key_manager._reset_key_stack() # 如果找到新的有效key，重置栈
+
+    # 合并所有无效密钥 (初始无效 + 后台检查出的无效)
+    combined_invalid_keys = list(set(initial_invalid_keys + local_invalid_keys))
+
+    # 获取当前设置中的无效密钥
+    current_invalid_keys_str = settings.INVALID_API_KEYS or ""
+    current_invalid_keys_set = set(k.strip() for k in current_invalid_keys_str.split(',') if k.strip())
+
+    # 更新无效密钥集合
+    new_invalid_keys_set = current_invalid_keys_set.union(set(combined_invalid_keys))
+
+    # 只有当无效密钥列表发生变化时才保存
+    if new_invalid_keys_set != current_invalid_keys_set:
+        settings.INVALID_API_KEYS = ','.join(sorted(list(new_invalid_keys_set)))
+        save_settings()
+
+    log('info', f"密钥检查任务完成。当前总可用密钥数量: {len(key_manager.api_keys)}")
+
+# 设置全局异常处理
+sys.excepthook = handle_exception
+
+# --------------- 事件处理 ---------------
+
+@app.on_event("startup")
+async def startup_event():
+    
+    # 首先加载持久化设置，确保所有配置都是最新的
+    load_settings()
+    
+    
+    # 重新加载vertex配置，确保获取到最新的持久化设置
+    import app.vertex.config as vertex_config
+    vertex_config.reload_config()
+    
+    
+    # 初始化CredentialManager
+    credential_manager_instance = CredentialManager()
+    # 添加到应用程序状态
+    app.state.credential_manager = credential_manager_instance
+    
+    # 初始化Vertex AI服务
+    await init_vertex_ai(credential_manager=credential_manager_instance)
+    schedule_cache_cleanup(response_cache_manager, active_requests_manager)
+    # 检查版本
+    await check_version()
+    
+    # 密钥检查 
+    initial_keys = key_manager.api_keys.copy()
+    key_manager.api_keys = [] # 清空，等待检查结果
+    first_valid_key = None
+    initial_invalid_keys = []
+    keys_to_check_later = []
+
+    # 阻塞式查找第一个有效密钥
+    for index, key in enumerate(initial_keys):
+        is_valid = await test_api_key(key)
+        if is_valid:
+            log('info', f"找到第一个有效密钥: {key[:8]}...")
+            first_valid_key = key
+            key_manager.api_keys.append(key) # 添加到管理器
+            key_manager._reset_key_stack()
+            # 将剩余的key放入后台检查列表
+            keys_to_check_later = initial_keys[index + 1:]
+            break # 找到即停止
+        else:
+            log('warning', f"密钥 {key[:8]}... 无效")
+            initial_invalid_keys.append(key)
+    
+    if not first_valid_key:
+        log('error', "启动时未能找到任何有效 API 密钥！")
+        keys_to_check_later = [] # 没有有效key，无需后台检查
+    else:
+        # 使用第一个有效密钥加载模型
+        try:
+            all_models = await GeminiClient.list_available_models(first_valid_key)
+            GeminiClient.AVAILABLE_MODELS = [model.replace("models/", "") for model in all_models]
+            log('info', f"使用密钥 {first_valid_key[:8]}... 加载可用模型成功")
+        except Exception as e:
+            log('warning', f"使用密钥 {first_valid_key[:8]}... 加载可用模型失败",extra={'error_message': str(e)})
+
+    if not SKIP_CHECK_API_KEY:
+        # 创建后台任务检查剩余密钥
+        if keys_to_check_later:
+            asyncio.create_task(check_remaining_keys_async(keys_to_check_later, initial_invalid_keys))
+        else:
+            # 如果没有需要后台检查的key，也要处理初始无效key
+            current_invalid_keys_str = settings.INVALID_API_KEYS or ""
+            current_invalid_keys_set = set(k.strip() for k in current_invalid_keys_str.split(',') if k.strip())
+            new_invalid_keys_set = current_invalid_keys_set.union(set(initial_invalid_keys))
+            if new_invalid_keys_set != current_invalid_keys_set:
+                 settings.INVALID_API_KEYS = ','.join(sorted(list(new_invalid_keys_set)))
+                 save_settings()
+                 log('info', f"更新初始无效密钥列表完成，总无效密钥数: {len(new_invalid_keys_set)}")
+
+    else: # 跳过检查
+        log('info',"跳过 API 密钥检查")
+        key_manager.api_keys.extend(keys_to_check_later)
+        key_manager._reset_key_stack()
+
+    # 初始化路由器
+    init_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager,
+        SAFETY_SETTINGS,
+        SAFETY_SETTINGS_G2,
+        first_valid_key,
+        settings.FAKE_STREAMING,
+        settings.FAKE_STREAMING_INTERVAL,
+        settings.PASSWORD,
+        settings.MAX_REQUESTS_PER_MINUTE,
+        settings.MAX_REQUESTS_PER_DAY_PER_IP
+    )
+        
+    # 初始化仪表盘路由器
+    init_dashboard_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager,
+        credential_manager_instance
+    )
+
+# --------------- 异常处理 ---------------
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    from app.utils import translate_error
+    error_message = translate_error(str(exc))
+    extra_log_unhandled_exception = {'status_code': 500, 'error_message': error_message}
+    log('error', f"Unhandled exception: {error_message}", extra=extra_log_unhandled_exception)
+    return JSONResponse(status_code=500, content=ErrorResponse(message=str(exc), type="internal_error").dict())
+
+# --------------- 路由 ---------------
+
+app.include_router(router)
+app.include_router(dashboard_router)
+
+# 挂载静态文件目录
+app.mount("/assets", StaticFiles(directory="app/templates/assets"), name="assets")
+
+# 设置根路由路径
+dashboard_path = f"/{settings.DASHBOARD_URL}" if settings.DASHBOARD_URL else "/"
+
+@app.get(dashboard_path, response_class=HTMLResponse)
+async def root(request: Request):
+    """
+    根路由 - 返回静态 HTML 文件
+    """
+    base_url = str(request.base_url).replace("http", "https")
+    api_url = f"{base_url}v1" if base_url.endswith("/") else f"{base_url}/v1"
+    # 直接返回 index.html 文件
+    return templates.TemplateResponse(
+        "index.html", {"request": request, "api_url": api_url}
+    )

app/models/schemas.py

@@ -0,0 +1,68 @@
+from typing import List, Dict, Optional, Union, Literal, Any
+from pydantic import BaseModel, Field
+
+# openAI 请求
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Dict[str, Any]]
+    temperature: float = 0.7
+    top_p: Optional[float] = None
+    top_k: Optional[float] = None
+    n: int = 1
+    stream: bool = False
+    stop: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+    seed: Optional[int] = None
+    logprobs: Optional[int] = None
+    response_logprobs: Optional[bool] = None
+    thinking_budget: Optional[int] = None
+    reasoning_effort : Optional[str] = None
+    # 函数调用
+    tools: Optional[List[Dict[str, Any]]] = None
+    tool_choice: Optional[Union[Literal["none", "auto"], Dict[str, Any]]] = "auto"
+
+# gemini 请求
+class ChatRequestGemini(BaseModel):
+    contents: List[Dict[str, Any]]
+    system_instruction: Optional[Dict[str, Any]]= None
+    systemInstruction: Optional[Dict[str, Any]]= None
+    safetySettings: Optional[List[Dict[str, Any]]] = None
+    generationConfig: Optional[Dict[str, Any]] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+
+# AI模型请求包装
+class AIRequest(BaseModel):
+    payload: Optional[ChatRequestGemini] = None
+    model: Optional[str] = None
+    stream: bool = False
+    format_type: Optional[str] = "gemini"
+
+class Usage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion"]
+    created: int
+    model: str
+    choices: List[Any]
+    usage: Usage = Field(default_factory=Usage)
+
+class ErrorResponse(BaseModel):
+    message: str
+    type: str
+    param: Optional[str] = None
+    code: Optional[str] = None
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Dict[str, Any]]
+
+class ChatResponseGemini(BaseModel):
+    candidates: Optional[List[Any]] = None
+    promptFeedback: Optional[Any] = None
+    usageMetadata: Optional[Dict[str, int]] = None

app/services/OpenAI.py

@@ -0,0 +1,107 @@
+import json
+import os
+import asyncio
+from app.models.schemas import ChatCompletionRequest
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+import httpx
+import logging
+import secrets
+import string
+from app.utils import format_log_message
+import app.config.settings as settings
+
+from app.utils.logging import log
+
+def generate_secure_random_string(length):
+    all_characters = string.ascii_letters + string.digits
+    secure_random_string = ''.join(secrets.choice(all_characters) for _ in range(length))
+    return secure_random_string
+
+@dataclass
+class GeneratedText:
+    text: str
+    finish_reason: Optional[str] = None
+
+class OpenAIClient:
+
+    AVAILABLE_MODELS = []
+    EXTRA_MODELS = os.environ.get("EXTRA_MODELS", "").split(",")
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def filter_data_by_whitelist(data, allowed_keys):
+        """
+        根据白名单过滤字典。
+        Args:
+            data (dict): 原始的 Python 字典 (代表 JSON 对象)。
+            allowed_keys (list or set): 包含允许保留的键名的列表或集合。
+                                        使用集合 (set) 进行查找通常更快。
+        Returns:
+            dict: 只包含白名单中键的新字典。
+        """
+        # 使用集合(set)可以提高查找效率，特别是当白名单很大时
+        allowed_keys_set = set(allowed_keys)
+        # 使用字典推导式创建过滤后的新字典
+        filtered_data = {key: value for key, value in data.items() if key in allowed_keys_set}
+        return filtered_data
+    
+    # 真流式处理
+    async def stream_chat(self, request: ChatCompletionRequest):
+        whitelist = ["model", "messages", "temperature", "max_tokens","stream","tools","reasoning_effort","top_k","presence_penalty"]
+        
+        data = self.filter_data_by_whitelist(request, whitelist)
+
+        
+        if settings.search["search_mode"] and data.model.endswith("-search"):
+            log('INFO', "开启联网搜索模式", extra={'key': self.api_key[:8], 'model':request.model})
+            data.setdefault("tools", []).append({"google_search": {}})
+                
+        data.model = data.model.removesuffix("-search")
+                
+        # 真流式请求处理逻辑
+        extra_log = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model}
+        log('INFO', "流式请求开始", extra=extra_log)
+
+        
+        url = f"https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        
+        async with httpx.AsyncClient() as client:
+            async with client.stream("POST", url, headers=headers, json=data, timeout=600) as response:
+                buffer = b"" # 用于累积可能不完整的 JSON 数据
+                try:
+                    async for line in response.aiter_lines():
+                        if not line.strip(): # 跳过空行 (SSE 消息分隔符)
+                            continue
+                        if line.startswith("data: "):
+                            line = line[len("data: "):].strip() # 去除 "data: " 前缀
+                        
+                        # 检查是否是结束标志，如果是，结束循环
+                        if line == "[DONE]":
+                            break 
+                        
+                        buffer += line.encode('utf-8')
+                        try:
+                            # 尝试解析整个缓冲区
+                            data = json.loads(buffer.decode('utf-8'))
+                            # 解析成功，清空缓冲区
+                            buffer = b"" 
+                            
+                            yield data
+
+                        except json.JSONDecodeError:
+                            # JSON 不完整，继续累积到 buffer
+                            continue 
+                        except Exception as e:
+                            log('ERROR', f"流式处理期间发生错误", 
+                                extra={'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model})
+                            raise e
+                except Exception as e:
+                    raise e
+                finally:
+                    log('info', "流式请求结束")

app/services/__init__.py

@@ -0,0 +1,9 @@
+from app.services.gemini import GeminiClient, GeminiResponseWrapper, GeneratedText
+from app.services.OpenAI import OpenAIClient
+
+__all__ = [
+    'GeminiClient',
+    'OpenAIClient',
+    'GeminiResponseWrapper',
+    'GeneratedText'
+]

app/services/gemini.py

@@ -0,0 +1,472 @@
+import json
+import os
+import httpx 
+from app.models.schemas import ChatCompletionRequest
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+import httpx
+import secrets
+import string
+import app.config.settings as settings
+
+from app.utils.logging import log
+
+def generate_secure_random_string(length):
+    all_characters = string.ascii_letters + string.digits
+    secure_random_string = ''.join(secrets.choice(all_characters) for _ in range(length))
+    return secure_random_string
+
+@dataclass
+class GeneratedText:
+    text: str
+    finish_reason: Optional[str] = None
+
+
+class GeminiResponseWrapper:
+    def __init__(self, data: Dict[Any, Any]):  
+        self._data = data
+        self._text = self._extract_text()
+        self._finish_reason = self._extract_finish_reason()
+        self._prompt_token_count = self._extract_prompt_token_count()
+        self._candidates_token_count = self._extract_candidates_token_count()
+        self._total_token_count = self._extract_total_token_count()
+        self._thoughts = self._extract_thoughts()
+        self._function_call = self._extract_function_call()
+        self._json_dumps = json.dumps(self._data, indent=4, ensure_ascii=False)
+        self._model = "gemini"
+
+    def _extract_thoughts(self) -> Optional[str]:
+        try:
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' in part:
+                    return part['text']
+            return ""
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_text(self) -> str:
+        try:
+            text=""
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' not in part and 'text' in part:
+                    text += part['text']
+            return text
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_function_call(self) -> Optional[Dict[str, Any]]:
+        try:
+            parts = self._data.get('candidates', [{}])[0].get('content', {}).get('parts', [])
+            # 使用列表推导式查找所有包含 'functionCall' 的 part，并提取其值
+            function_calls = [
+                part['functionCall']
+                for part in parts
+                if isinstance(part, dict) and 'functionCall' in part 
+            ]
+            # 如果列表不为空，则返回列表；否则返回 None
+            return function_calls if function_calls else None
+        except (KeyError, IndexError, TypeError):
+            return None
+
+    def _extract_finish_reason(self) -> Optional[str]:
+        try:
+            return self._data['candidates'][0].get('finishReason')
+        except (KeyError, IndexError):
+            return None
+
+    def _extract_prompt_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('promptTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_candidates_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('candidatesTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_total_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('totalTokenCount')
+        except (KeyError):
+            return None
+
+    def set_model(self,model) -> Optional[str]:
+        self._model = model
+
+    @property
+    def data(self) -> Dict[Any, Any]:
+        return self._data
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def finish_reason(self) -> Optional[str]:
+        return self._finish_reason
+
+    @property
+    def prompt_token_count(self) -> Optional[int]:
+        return self._prompt_token_count
+
+    @property
+    def candidates_token_count(self) -> Optional[int]:
+        return self._candidates_token_count
+
+    @property
+    def total_token_count(self) -> Optional[int]:
+        return self._total_token_count
+
+    @property
+    def thoughts(self) -> Optional[str]:
+        return self._thoughts
+
+    @property
+    def json_dumps(self) -> str:
+        return self._json_dumps
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    @property
+    def function_call(self) -> Optional[Dict[str, Any]]:
+        return self._function_call
+
+
+class GeminiClient:
+
+    AVAILABLE_MODELS = []
+    extra_models_str = os.environ.get("EXTRA_MODELS", "")
+    EXTRA_MODELS = [model.strip() for model in extra_models_str.split(",") if model.strip()]
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    # 请求参数处理
+    def _convert_request_data(self, request, contents, safety_settings, system_instruction):
+
+        model = request.model
+        format_type = getattr(request, 'format_type', None)
+        if format_type and (format_type == "gemini"):
+            api_version = "v1alpha" if "think" in request.model else "v1beta"
+            if request.payload:
+                # 将 Pydantic 模型转换为字典, 假设 Pydantic V2+
+                data = request.payload.model_dump(exclude_none=True)
+            # # 注入搜索提示
+            # if settings.search["search_mode"] and request.model and request.model.endswith("-search"):
+            #     data.insert(len(data)-2,{'role': 'user', 'parts': [{'text':settings.search["search_prompt"]}]})
+            
+            # # 注入随机字符串
+            # if settings.RANDOM_STRING:
+            #     data.insert(1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(settings.RANDOM_STRING_LENGTH)}]})
+            #     data.insert(len(data)-1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(settings.RANDOM_STRING_LENGTH)}]})
+            #     log('INFO', "伪装消息成功")
+            
+        else:
+            api_version, data = self._convert_openAI_request(request, contents, safety_settings, system_instruction)
+
+        # 联网模式
+        if settings.search["search_mode"] and request.model.endswith("-search"):
+            log('INFO', "开启联网搜索模式", extra={'key': self.api_key[:8], 'model':request.model})
+            
+            data.setdefault("tools", []).append({"google_search": {}})
+            model= request.model.removesuffix("-search")
+        
+        return api_version, model, data
+
+    
+    def _convert_openAI_request(self, request: ChatCompletionRequest, contents, safety_settings, system_instruction):
+        
+        config_params = {
+            "temperature": request.temperature,
+            "maxOutputTokens": request.max_tokens,
+            "topP": request.top_p,
+            "topK": request.top_k,
+            "stopSequences": request.stop if isinstance(request.stop, list) else [request.stop] if request.stop is not None else None,
+            "candidateCount": request.n,
+        }
+        if request.thinking_budget:
+            config_params["thinkingConfig"] = {
+                "thinkingBudget": request.thinking_budget
+            }
+        generationConfig = {k: v for k, v in config_params.items() if v is not None}
+        
+        api_version = "v1alpha" if "think" in request.model else "v1beta"
+        
+        data = {
+            "contents": contents,
+            "generationConfig": generationConfig,
+            "safetySettings": safety_settings,
+        }
+
+        # --- 函数调用处理 ---
+        # 1. 添加 tools (函数声明)
+        function_declarations = []
+        if request.tools:
+            # 显式提取 Gemini API 所需的字段，避免包含 'id' 等无效字段
+            function_declarations = []
+            for tool in request.tools:
+                if tool.get("type") == "function":
+                    func_def = tool.get("function")
+                    if func_def:
+                        # 只包含 Gemini API 接受的字段
+                        declaration = {
+                            "name": func_def.get("name"),
+                            "description": func_def.get("description"),
+                        }
+                        # 获取 parameters 并移除可能存在的 $schema 字段
+                        parameters = func_def.get("parameters")
+                        if isinstance(parameters, dict) and "$schema" in parameters:
+                            parameters = parameters.copy() 
+                            del parameters["$schema"]
+                        if parameters is not None:
+                            declaration["parameters"] = parameters
+
+                        # 移除值为 None 的键，以保持 payload 清洁
+                        declaration = {k: v for k, v in declaration.items() if v is not None}
+                        if declaration.get("name"): # 确保 name 存在
+                            function_declarations.append(declaration)
+
+        if function_declarations:
+            data["tools"] = [{"function_declarations": function_declarations}]
+
+        # 2. 添加 tool_config (基于 tool_choice)
+        tool_config = None 
+        if request.tool_choice:
+            choice = request.tool_choice
+            mode = None
+            allowed_functions = None
+            if isinstance(choice, str):
+                if choice == "none":
+                    mode = "NONE"
+                elif choice == "auto":
+                    mode = "AUTO"
+            elif isinstance(choice, dict) and choice.get("type") == "function":
+                func_name = choice.get("function", {}).get("name")
+                if func_name:
+                    mode = "ANY" # 'ANY' 模式用于强制调用特定函数
+                    allowed_functions = [func_name]
+            
+            # 如果成功解析出有效的 mode，构建 tool_config
+            if mode:
+                config = {"mode": mode}
+                if allowed_functions:
+                    config["allowed_function_names"] = allowed_functions
+                tool_config = {"function_calling_config": config}
+        
+        # 3. 添加 tool_config 到 data
+        if tool_config:
+            data["tool_config"] = tool_config
+
+        if system_instruction:
+            data["system_instruction"] = system_instruction    
+        
+        return api_version, data
+    
+
+    # 流式请求
+    async def stream_chat(self, request, contents, safety_settings, system_instruction):
+        # 真流式请求处理逻辑
+        extra_log = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model}
+        log('INFO', "流式请求开始", extra=extra_log)
+        
+        api_version, model, data = self._convert_request_data(request, contents, safety_settings, system_instruction)
+        
+        
+        url = f"https://generativelanguage.googleapis.com/{api_version}/models/{model}:streamGenerateContent?key={self.api_key}&alt=sse"
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        async with httpx.AsyncClient() as client:
+            async with client.stream("POST", url, headers=headers, json=data, timeout=600) as response:
+                response.raise_for_status()
+                buffer = b"" # 用于累积可能不完整的 JSON 数据
+                try:
+                    async for line in response.aiter_lines():
+                        if not line.strip(): # 跳过空行 (SSE 消息分隔符)
+                            continue
+                        if line.startswith("data: "):
+                            line = line[len("data: "):].strip() # 去除 "data: " 前缀
+                        
+                        # 检查是否是结束标志，如果是，结束循环
+                        if line == "[DONE]":
+                            break 
+                        
+                        buffer += line.encode('utf-8')
+                        try:
+                            # 尝试解析整个缓冲区
+                            data = json.loads(buffer.decode('utf-8'))
+                            # 解析成功，清空缓冲区
+                            buffer = b"" 
+                            yield GeminiResponseWrapper(data)
+
+                        except json.JSONDecodeError:
+                            # JSON 不完整，继续累积到 buffer
+                            continue 
+                        except Exception as e:
+                            log('ERROR', f"流式处理期间发生错误", 
+                                extra={'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model})
+                            raise e
+                except Exception as e:
+                    raise e
+                finally:
+                    log('info', "流式请求结束")
+
+    # 非流式处理
+    async def complete_chat(self, request, contents, safety_settings, system_instruction):
+
+        api_version, model, data = self._convert_request_data(request, contents, safety_settings, system_instruction)
+        
+        url = f"https://generativelanguage.googleapis.com/{api_version}/models/{model}:generateContent?key={self.api_key}"
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(url, headers=headers, json=data, timeout=600) 
+                response.raise_for_status() # 检查 HTTP 错误状态
+            
+            return GeminiResponseWrapper(response.json())
+        except Exception as e:
+            raise
+
+    # OpenAI 格式请求转换为 gemini 格式请求
+    def convert_messages(self, messages, use_system_prompt=False, model=None):
+        gemini_history = []
+        errors = []
+        
+        system_instruction_text = ""
+        system_instruction_parts = [] # 用于收集系统指令文本
+        
+        # 处理系统指令 
+        if use_system_prompt:
+            # 遍历消息列表，查找开头的连续 system 消息
+            for i, message in enumerate(messages):
+                # 必须是 system 角色且内容是字符串
+                if message.get('role') == 'system' and isinstance(message.get('content'), str):
+                    system_instruction_parts.append(message.get('content'))
+                else:
+                    break # 遇到第一个非 system 或内容非字符串的消息就停止
+        
+        # 将收集到的系统指令合并为一个字符串
+        system_instruction_text = "\n".join(system_instruction_parts)
+        system_instruction = {"parts": [{"text": system_instruction_text}]} if system_instruction_text else None
+        
+        # 转换主要消息
+        
+        for i, message in enumerate(messages):
+            role = message.get('role')
+            content = message.get('content')
+            if isinstance(content, str):
+
+                if role == 'tool':
+                    role_to_use = 'function'
+                    tool_call_id = message.get('tool_call_id')
+
+                    prefix = "call_"
+                    if tool_call_id.startswith(prefix):
+                        # 假设 tool_call_id = f"call_{function_name}" (response.py中的处理)
+                        function_name = tool_call_id[len(prefix):]
+                    else:
+                        continue
+
+                    function_response_part = {
+                        "functionResponse": {
+                            "name": function_name,
+                            "response": {"content": content}
+                        }
+                    }
+                    
+                    gemini_history.append({"role": role_to_use, "parts": [function_response_part]})
+                    
+                    continue
+                elif role in ['user', 'system']:
+                    role_to_use = 'user'
+                elif role == 'assistant':
+                    role_to_use = 'model'
+                    
+                else:
+                    errors.append(f"Invalid role: {role}")
+                    continue
+
+                # Gemini 的一个重要规则：连续的同角色消息需要合并
+                # 如果 gemini_history 已有内容，并且最后一条消息的角色和当前要添加的角色相同
+                if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                    gemini_history[-1]['parts'].append({"text": content})
+                else:
+                    gemini_history.append({"role": role_to_use, "parts": [{"text": content}]})
+            elif isinstance(content, list):
+                parts = []
+                for item in content:
+                    if item.get('type') == 'text':
+                        parts.append({"text": item.get('text')})
+                    elif item.get('type') == 'image_url':
+                        image_data = item.get('image_url', {}).get('url', '')
+                        if image_data.startswith('data:image/'):
+                            try:
+                                mime_type, base64_data = image_data.split(';')[0].split(':')[1], image_data.split(',')[1]
+                                parts.append({
+                                    "inline_data": {
+                                        "mime_type": mime_type,
+                                        "data": base64_data
+                                    }
+                                })
+                            except (IndexError, ValueError):
+                                errors.append(
+                                    f"Invalid data URI for image: {image_data}")
+                        else:
+                            errors.append(
+                                f"Invalid image URL format for item: {item}")
+
+                if parts:
+                    if role in ['user', 'system']:
+                        role_to_use = 'user'
+                    elif role == 'assistant':
+                        role_to_use = 'model'
+                    else:
+                        errors.append(f"Invalid role: {role}")
+                        continue
+                    
+                    if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                        gemini_history[-1]['parts'].extend(parts)
+                    else:
+                        gemini_history.append(
+                            {"role": role_to_use, "parts": parts})
+        if errors:
+            return errors
+        
+        # --- 后处理 ---
+        
+        # 注入搜索提示
+        if settings.search["search_mode"] and model and model.endswith("-search"):
+            gemini_history.insert(len(gemini_history)-2,{'role': 'user', 'parts': [{'text':settings.search["search_prompt"]}]})
+        
+        # 注入随机字符串
+        if settings.RANDOM_STRING:
+            gemini_history.insert(1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(settings.RANDOM_STRING_LENGTH)}]})
+            gemini_history.insert(len(gemini_history)-1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(settings.RANDOM_STRING_LENGTH)}]})
+            log('INFO', "伪装消息成功")
+        
+        return gemini_history, system_instruction
+
+    @staticmethod
+    async def list_available_models(api_key) -> list:
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(
+            api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            models = []
+            for model in data.get("models", []):
+                models.append(model["name"])
+                if model["name"].startswith("models/gemini-2") and settings.search["search_mode"]:
+                    models.append(model["name"] + "-search")
+            models.extend(GeminiClient.EXTRA_MODELS)
+                
+            return models

app/templates/__init__.py

@@ -0,0 +1 @@
+# Templates package initialization

app/templates/assets/9a4f356975f1a7b8b7bad9e93c1becba.css

@@ -0,0 +1 @@
+:root{--vt-c-white: #ffffff;--vt-c-white-soft: #f8f8f8;--vt-c-white-mute: #f2f2f2;--vt-c-black: #181818;--vt-c-black-soft: #222222;--vt-c-black-mute: #282828;--vt-c-indigo: #2c3e50;--vt-c-divider-light-1: rgba(60, 60, 60, .29);--vt-c-divider-light-2: rgba(60, 60, 60, .12);--vt-c-divider-dark-1: rgba(84, 84, 84, .65);--vt-c-divider-dark-2: rgba(84, 84, 84, .48);--vt-c-text-light-1: var(--vt-c-indigo);--vt-c-text-light-2: rgba(60, 60, 60, .66);--vt-c-text-dark-1: var(--vt-c-white);--vt-c-text-dark-2: rgba(235, 235, 235, .64)}:root{--color-background: var(--vt-c-white);--color-background-soft: var(--vt-c-white-soft);--color-background-mute: var(--vt-c-white-mute);--color-border: var(--vt-c-divider-light-2);--color-border-hover: var(--vt-c-divider-light-1);--color-heading: var(--vt-c-text-light-1);--color-text: var(--vt-c-text-light-1);--section-gap: 160px;--card-background: #ffffff;--card-border: #e0e0e0;--button-primary: #4f46e5;--button-primary-hover: #4338ca;--button-secondary: #f3f4f6;--button-secondary-hover: #e5e7eb;--button-secondary-text: #4b5563;--button-text: #ffffff;--stats-item-bg: #f8f9fa;--log-entry-bg: #f8f9fa;--log-entry-border: #e9ecef;--toggle-bg: #ccc;--toggle-active: #4f46e5;--gradient-primary: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);--gradient-secondary: linear-gradient(135deg, #3b82f6 0%, #2dd4bf 100%);--gradient-success: linear-gradient(135deg, #10b981 0%, #059669 100%);--gradient-warning: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);--gradient-danger: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);--gradient-info: linear-gradient(135deg, #3b82f6 0%, #2563eb 100%);--shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, .05);--shadow-md: 0 4px 6px -1px rgba(0, 0, 0, .1), 0 2px 4px -1px rgba(0, 0, 0, .06);--shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, .1), 0 4px 6px -2px rgba(0, 0, 0, .05);--shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, .1), 0 10px 10px -5px rgba(0, 0, 0, .04);--radius-sm: .25rem;--radius-md: .375rem;--radius-lg: .5rem;--radius-xl: .75rem;--radius-2xl: 1rem;--radius-full: 9999px;--transition-fast: .15s;--transition-normal: .3s;--transition-slow: .5s}.dark-mode{--color-background: var(--vt-c-black);--color-background-soft: var(--vt-c-black-soft);--color-background-mute: var(--vt-c-black-mute);--color-border: var(--vt-c-divider-dark-2);--color-border-hover: var(--vt-c-divider-dark-1);--color-heading: var(--vt-c-text-dark-1);--color-text: rgba(255, 255, 255, .85);--card-background: #1a1a1a;--card-border: #2a2a2a;--button-primary: #8b5cf6;--button-primary-hover: #7c3aed;--button-secondary: #2a2a2a;--button-secondary-hover: #3a3a3a;--button-secondary-text: #f1f5f9;--button-text: #ffffff;--stats-item-bg: #151515;--log-entry-bg: #151515;--log-entry-border: #2a2a2a;--toggle-bg: #3a3a3a;--toggle-active: #8b5cf6;--gradient-primary: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%);--gradient-secondary: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);--gradient-success: linear-gradient(135deg, #10b981 0%, #047857 100%);--gradient-warning: linear-gradient(135deg, #f59e0b 0%, #b45309 100%);--gradient-danger: linear-gradient(135deg, #ef4444 0%, #b91c1c 100%);--gradient-info: linear-gradient(135deg, #3b82f6 0%, #1e40af 100%);--shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, .3);--shadow-md: 0 4px 6px -1px rgba(0, 0, 0, .4), 0 2px 4px -1px rgba(0, 0, 0, .2);--shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, .4), 0 4px 6px -2px rgba(0, 0, 0, .2);--shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, .4), 0 10px 10px -5px rgba(0, 0, 0, .2)}@media (prefers-color-scheme: dark){:root:not(.dark-mode):not(.light-mode){--color-background: var(--vt-c-black);--color-background-soft: var(--vt-c-black-soft);--color-background-mute: var(--vt-c-black-mute);--color-border: var(--vt-c-divider-dark-2);--color-border-hover: var(--vt-c-divider-dark-1);--color-heading: var(--vt-c-text-dark-1);--color-text: rgba(255, 255, 255, .85);--card-background: #1a1a1a;--card-border: #2a2a2a;--button-primary: #8b5cf6;--button-primary-hover: #7c3aed;--button-secondary: #2a2a2a;--button-secondary-hover: #3a3a3a;--button-secondary-text: #f1f5f9;--button-text: #ffffff;--stats-item-bg: #151515;--log-entry-bg: #151515;--log-entry-border: #2a2a2a;--toggle-bg: #3a3a3a;--toggle-active: #8b5cf6;--gradient-primary: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%);--gradient-secondary: linear-gradient(135deg, #3b82f6 0%, #1d4ed8 100%);--gradient-success: linear-gradient(135deg, #10b981 0%, #047857 100%);--gradient-warning: linear-gradient(135deg, #f59e0b 0%, #b45309 100%);--gradient-danger: linear-gradient(135deg, #ef4444 0%, #b91c1c 100%);--gradient-info: linear-gradient(135deg, #3b82f6 0%, #1e40af 100%);--shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, .3);--shadow-md: 0 4px 6px -1px rgba(0, 0, 0, .4), 0 2px 4px -1px rgba(0, 0, 0, .2);--shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, .4), 0 4px 6px -2px rgba(0, 0, 0, .2);--shadow-xl: 0 20px 25px -5px rgba(0, 0, 0, .4), 0 10px 10px -5px rgba(0, 0, 0, .2)}}*,*:before,*:after{box-sizing:border-box;margin:0;font-weight:400}body{min-height:100vh;color:var(--color-text);background:var(--color-background);transition:color .5s,background-color .5s;line-height:1.6;font-family:Inter,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;font-size:15px;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}#app{max-width:1280px;margin:0 auto;padding:1rem;font-weight:400}a,.green{text-decoration:none;color:#00bd7e;transition:.4s;padding:3px}@media (hover: hover){a:hover{background-color:#00bd7e33}}body{margin:0;padding:0}.stats-grid[data-v-8b643ea6]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}@media (max-width: 768px){.stats-grid[data-v-8b643ea6]{gap:6px}}.stat-card[data-v-8b643ea6]{background-color:var(--stats-item-bg);padding:15px;border-radius:var(--radius-lg);text-align:center;box-shadow:var(--shadow-sm);transition:all .3s ease;position:relative;overflow:hidden;border:1px solid var(--card-border)}.stat-card[data-v-8b643ea6]:before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-secondary);opacity:0;transition:opacity .3s ease}.stat-card[data-v-8b643ea6]:hover:before{opacity:1}.stat-card[data-v-8b643ea6]:hover{transform:translateY(-5px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.stat-value[data-v-8b643ea6]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;margin-bottom:5px}.stat-label[data-v-8b643ea6]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;opacity:.8}@media (max-width: 768px){.stat-card[data-v-8b643ea6]{padding:8px 5px}.stat-value[data-v-8b643ea6]{font-size:16px}.stat-label[data-v-8b643ea6]{font-size:11px;margin-top:3px}}@media (max-width: 480px){.stat-card[data-v-8b643ea6]{padding:6px 3px}.stat-value[data-v-8b643ea6]{font-size:14px}.stat-label[data-v-8b643ea6]{font-size:10px;margin-top:2px}}.api-calls-chart-container[data-v-d9262b8e]{margin:20px 0;border-radius:var(--radius-lg);background-color:var(--stats-item-bg);padding:15px;box-shadow:var(--shadow-sm);border:1px solid var(--card-border);transition:all .3s ease}.api-calls-chart-container[data-v-d9262b8e]:hover{box-shadow:var(--shadow-md);border-color:var(--button-primary);transform:translateY(-3px)}.chart-title[data-v-d9262b8e]{margin-top:0;margin-bottom:15px;color:var(--color-heading);font-weight:600;text-align:center}.chart-container[data-v-d9262b8e]{width:100%;height:350px}@media (max-width: 768px){.chart-container[data-v-d9262b8e]{height:300px}}@media (max-width: 480px){.chart-container[data-v-d9262b8e]{height:250px}}.api-key-stats-container[data-v-a6a7d43b]{margin-top:20px}.header-section[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:center;margin-bottom:15px}.header-buttons[data-v-a6a7d43b]{display:flex;gap:10px}.add-api-key-button[data-v-a6a7d43b]{display:flex;align-items:center;gap:8px;background-color:var(--button-primary);color:#fff;border:none;border-radius:var(--radius-md);padding:8px 16px;font-size:14px;font-weight:500;cursor:pointer;transition:all .3s ease;box-shadow:var(--shadow-sm)}.add-api-key-button svg[data-v-a6a7d43b]{transition:transform .3s ease;stroke:#fff}.add-api-key-button[data-v-a6a7d43b]:hover{background-color:var(--button-primary-hover);transform:translateY(-2px);box-shadow:var(--shadow-md)}.add-api-key-button:hover svg[data-v-a6a7d43b]{transform:rotate(90deg);stroke:#fff}.test-api-key-button[data-v-a6a7d43b]{display:flex;align-items:center;gap:8px;background-color:var(--button-secondary);color:var(--button-secondary-text);border:1px solid var(--color-border);border-radius:var(--radius-md);padding:8px 16px;font-size:14px;font-weight:500;cursor:pointer;transition:all .3s ease;box-shadow:var(--shadow-sm)}.test-api-key-button svg[data-v-a6a7d43b]{transition:transform .3s ease;stroke:var(--button-secondary-text)}.test-api-key-button[data-v-a6a7d43b]:hover{background-color:var(--button-secondary-hover);transform:translateY(-2px);box-shadow:var(--shadow-md)}.test-api-key-button:hover svg[data-v-a6a7d43b]{transform:rotate(15deg)}.clear-invalid-keys-button[data-v-a6a7d43b]{display:flex;align-items:center;gap:8px;background-color:var(--button-danger, #dc3545);color:#fff;border:none;border-radius:var(--radius-md);padding:8px 16px;font-size:14px;font-weight:500;cursor:pointer;transition:all .3s ease;box-shadow:var(--shadow-sm)}.clear-invalid-keys-button svg[data-v-a6a7d43b]{transition:transform .3s ease;stroke:#fff}.clear-invalid-keys-button[data-v-a6a7d43b]:hover{background-color:var(--button-danger-hover, #c82333);transform:translateY(-2px);box-shadow:var(--shadow-md)}.clear-invalid-keys-button:hover svg[data-v-a6a7d43b]{transform:scale(1.1)}.export-valid-keys-button[data-v-a6a7d43b]{display:flex;align-items:center;gap:8px;background-color:var(--button-success, #28a745);color:#fff;border:none;border-radius:var(--radius-md);padding:8px 16px;font-size:14px;font-weight:500;cursor:pointer;transition:all .3s ease;box-shadow:var(--shadow-sm)}.export-valid-keys-button svg[data-v-a6a7d43b]{transition:transform .3s ease;stroke:#fff}.export-valid-keys-button[data-v-a6a7d43b]:hover{background-color:var(--button-success-hover, #218838);transform:translateY(-2px);box-shadow:var(--shadow-md)}.export-valid-keys-button:hover svg[data-v-a6a7d43b]{transform:translateY(-1px)}.api-key-test-form[data-v-a6a7d43b],.clear-invalid-keys-form[data-v-a6a7d43b],.export-valid-keys-form[data-v-a6a7d43b]{background-color:var(--color-background-mute);border-radius:var(--radius-lg);padding:20px;margin-bottom:20px;border:1px solid var(--card-border);box-shadow:var(--shadow-md)}.exported-keys-container[data-v-a6a7d43b]{margin-top:15px}.exported-keys-header[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px}.exported-keys-header h5[data-v-a6a7d43b]{font-size:14px;font-weight:600;color:var(--color-heading);margin:0}.copy-all-button[data-v-a6a7d43b]{display:flex;align-items:center;gap:6px;background-color:var(--button-primary);color:#fff;border:none;border-radius:var(--radius-sm);padding:6px 12px;font-size:12px;font-weight:500;cursor:pointer;transition:all .3s ease}.copy-all-button[data-v-a6a7d43b]:hover{background-color:var(--button-primary-hover);transform:translateY(-1px)}.copy-all-button svg[data-v-a6a7d43b]{stroke:#fff}.exported-keys-list[data-v-a6a7d43b]{max-height:300px;overflow-y:auto;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background)}.exported-key-item[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:center;padding:10px 12px;border-bottom:1px solid var(--color-border);transition:background-color .2s ease}.exported-key-item[data-v-a6a7d43b]:last-child{border-bottom:none}.exported-key-item[data-v-a6a7d43b]:hover{background-color:var(--color-background-mute)}.key-text[data-v-a6a7d43b]{font-family:Courier New,monospace;font-size:13px;color:var(--color-text);word-break:break-all;flex:1;margin-right:10px}.copy-key-button[data-v-a6a7d43b]{display:flex;align-items:center;justify-content:center;background-color:transparent;color:var(--color-text-muted);border:1px solid var(--color-border);border-radius:var(--radius-sm);padding:4px;cursor:pointer;transition:all .2s ease;min-width:28px;height:28px}.copy-key-button[data-v-a6a7d43b]:hover{background-color:var(--button-primary);color:#fff;border-color:var(--button-primary)}.copy-key-button svg[data-v-a6a7d43b]{stroke:currentColor}.form-title[data-v-a6a7d43b]{margin-bottom:15px}.form-title h4[data-v-a6a7d43b]{font-size:16px;font-weight:600;color:var(--color-heading);margin-bottom:8px}.form-description[data-v-a6a7d43b]{font-size:14px;color:var(--color-text);line-height:1.5;opacity:.8}.testing-progress[data-v-a6a7d43b]{margin:15px 0}.progress-bar-container[data-v-a6a7d43b]{height:10px;background-color:var(--color-background-soft);border-radius:var(--radius-full);overflow:hidden;margin-bottom:10px}.progress-bar-fill[data-v-a6a7d43b]{height:100%;background:var(--gradient-primary);border-radius:var(--radius-full);transition:width .3s ease;position:relative}.progress-bar-fill[data-v-a6a7d43b]:after{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.2),transparent);transform:translate(-100%);animation:progressShine-a6a7d43b 2s infinite}.progress-text[data-v-a6a7d43b]{font-size:14px;text-align:center;color:var(--color-heading)}.slide-enter-active[data-v-a6a7d43b],.slide-leave-active[data-v-a6a7d43b]{transition:all .3s ease;max-height:500px;opacity:1;overflow:hidden}.slide-enter-from[data-v-a6a7d43b],.slide-leave-to[data-v-a6a7d43b]{max-height:0;opacity:0;padding:0;margin:0;overflow:hidden}.stats-grid[data-v-a6a7d43b]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}.stat-card[data-v-a6a7d43b]{background-color:var(--stats-item-bg);padding:15px;border-radius:var(--radius-lg);text-align:center;box-shadow:var(--shadow-sm);transition:all .3s ease;position:relative;overflow:hidden;border:1px solid var(--card-border)}.stat-card[data-v-a6a7d43b]:before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-secondary);opacity:0;transition:opacity .3s ease}.stat-card[data-v-a6a7d43b]:hover:before{opacity:1}.stat-card[data-v-a6a7d43b]:hover{transform:translateY(-5px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.stat-value[data-v-a6a7d43b]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;margin-bottom:5px}.stat-label[data-v-a6a7d43b]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;opacity:.8}.stats-summary[data-v-a6a7d43b]{display:flex;justify-content:space-between;margin-bottom:20px;background-color:var(--color-background-mute);border-radius:var(--radius-lg);padding:15px;border:1px solid var(--card-border)}.summary-item[data-v-a6a7d43b]{display:flex;flex-direction:column;align-items:center;flex:1}.summary-label[data-v-a6a7d43b]{font-size:12px;color:var(--color-text);opacity:.8;margin-bottom:5px}.summary-value[data-v-a6a7d43b]{font-size:18px;font-weight:600;color:var(--button-primary)}.api-key-stats-list[data-v-a6a7d43b]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px}.api-key-item[data-v-a6a7d43b]{background-color:var(--stats-item-bg);border-radius:var(--radius-lg);padding:15px;box-shadow:var(--shadow-sm);transition:all .3s ease;position:relative;overflow:hidden;border:1px solid var(--card-border)}.api-key-item[data-v-a6a7d43b]:before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-info);opacity:0;transition:opacity .3s ease}.api-key-item[data-v-a6a7d43b]:hover:before{opacity:1}.api-key-item[data-v-a6a7d43b]:hover{transform:translateY(-3px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.api-key-header[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px}.api-key-name[data-v-a6a7d43b]{font-weight:700;color:var(--color-heading);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:50%;transition:all .3s ease}.api-key-usage[data-v-a6a7d43b]{display:flex;align-items:center;gap:10px;white-space:nowrap}.api-key-count[data-v-a6a7d43b]{font-weight:700;color:var(--button-primary);transition:all .3s ease}.progress-container[data-v-a6a7d43b]{width:100%;height:10px;background-color:var(--color-background-soft);border-radius:var(--radius-full);overflow:hidden;transition:all .3s ease;margin:10px 0}.progress-bar[data-v-a6a7d43b]{height:100%;border-radius:var(--radius-full);transition:width .5s ease,background-color .3s;position:relative;overflow:hidden}.progress-bar[data-v-a6a7d43b]:after{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.2),transparent);transform:translate(-100%);animation:progressShine-a6a7d43b 2s infinite}@keyframes progressShine-a6a7d43b{0%{transform:translate(-100%)}to{transform:translate(100%)}}.progress-bar.low[data-v-a6a7d43b]{background:var(--gradient-success)}.progress-bar.medium[data-v-a6a7d43b]{background:var(--gradient-warning)}.progress-bar.high[data-v-a6a7d43b]{background:var(--gradient-danger)}.model-stats-container[data-v-a6a7d43b]{margin-top:10px;border-top:1px dashed var(--color-border);padding-top:10px;transition:all .3s ease}.model-stats-header[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:center;cursor:pointer;-webkit-user-select:none;user-select:none;margin-bottom:8px;color:var(--color-heading);font-size:14px;transition:all .3s ease;padding:5px 8px;border-radius:var(--radius-md)}.model-stats-header[data-v-a6a7d43b]:hover{background-color:var(--color-background-mute)}.model-stats-title[data-v-a6a7d43b]{font-weight:600}.model-stats-list[data-v-a6a7d43b]{display:flex;flex-direction:column;gap:8px}.model-stat-item[data-v-a6a7d43b]{display:flex;justify-content:space-between;align-items:flex-start;padding:10px;background-color:var(--color-background-mute);border-radius:var(--radius-md);font-size:13px;transition:all .3s ease;border:1px solid transparent}.model-stat-item[data-v-a6a7d43b]:hover{transform:translate(5px);box-shadow:var(--shadow-sm);border-color:var(--button-primary)}.model-info[data-v-a6a7d43b]{display:flex;flex-direction:column;gap:4px;width:100%}.model-name[data-v-a6a7d43b]{font-weight:500;color:var(--color-heading);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:100%;transition:all .3s ease}.model-count[data-v-a6a7d43b]{display:flex;align-items:center;gap:8px;color:var(--button-primary);font-weight:600;transition:all .3s ease}.model-usage-text[data-v-a6a7d43b]{color:var(--color-text);font-weight:400;font-size:12px;transition:all .3s ease;opacity:.8}.model-tokens[data-v-a6a7d43b]{font-size:12px;color:var(--color-text);opacity:.8;transition:all .3s ease}.view-more-models[data-v-a6a7d43b]{text-align:center;color:var(--button-primary);font-size:12px;cursor:pointer;padding:8px;margin-top:5px;border-radius:var(--radius-md);background-color:#4f46e50d;transition:all .3s ease;border:1px dashed var(--button-primary)}.view-more-models[data-v-a6a7d43b]:hover{background-color:#4f46e51a;transform:translateY(-2px);box-shadow:var(--shadow-sm)}.section-title[data-v-a6a7d43b]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;transition:all .3s ease;position:relative;font-weight:600;margin:0}.section-title[data-v-a6a7d43b]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.fold-header[data-v-a6a7d43b]{cursor:pointer;-webkit-user-select:none;user-select:none;display:flex;justify-content:space-between;align-items:center;transition:all .3s ease;border-radius:var(--radius-md);padding:8px 12px;background-color:var(--color-background-mute);margin-bottom:0;margin-right:10px;flex:1}.fold-header[data-v-a6a7d43b]:hover{background-color:var(--color-background-soft);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.fold-icon[data-v-a6a7d43b]{display:inline-flex;align-items:center;justify-content:center;transition:transform .3s ease}.fold-icon.rotated[data-v-a6a7d43b]{transform:rotate(180deg)}.fold-content[data-v-a6a7d43b]{overflow:hidden}.fold-enter-active[data-v-a6a7d43b],.fold-leave-active[data-v-a6a7d43b]{transition:all .3s ease;max-height:1000px;opacity:1;overflow:hidden}.fold-enter-from[data-v-a6a7d43b],.fold-leave-to[data-v-a6a7d43b]{max-height:0;opacity:0;overflow:hidden}.total-tokens[data-v-a6a7d43b]{margin-top:6px;padding:8px 12px;background-color:var(--color-background-mute);border-radius:var(--radius-md);display:flex;align-items:center;gap:6px;transition:all .3s ease;border:1px solid var(--card-border)}.total-tokens[data-v-a6a7d43b]:hover{background-color:var(--color-background-soft);transform:translateY(-2px);box-shadow:var(--shadow-sm);border-color:var(--button-primary)}.total-tokens-label[data-v-a6a7d43b]{font-size:11px;color:var(--color-text);opacity:.8;white-space:nowrap;transition:all .3s ease}.total-tokens-value[data-v-a6a7d43b]{font-size:13px;font-weight:600;color:var(--button-primary);transition:all .3s ease}.pagination[data-v-a6a7d43b]{display:flex;justify-content:center;align-items:center;margin-top:20px;gap:15px}.pagination-button[data-v-a6a7d43b]{background-color:var(--button-secondary);color:var(--button-secondary-text);border:none;border-radius:var(--radius-md);padding:8px 16px;cursor:pointer;transition:all .3s ease;font-weight:500}.pagination-button[data-v-a6a7d43b]:hover:not(:disabled){background-color:var(--button-secondary-hover);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.pagination-button[data-v-a6a7d43b]:disabled{opacity:.5;cursor:not-allowed}.pagination-info[data-v-a6a7d43b]{font-size:14px;color:var(--color-text)}@media (max-width: 768px){.header-section[data-v-a6a7d43b]{flex-direction:column;align-items:flex-start;gap:15px}.header-buttons[data-v-a6a7d43b]{display:grid;grid-template-columns:repeat(2,1fr);gap:8px;width:100%}.add-api-key-button[data-v-a6a7d43b],.test-api-key-button[data-v-a6a7d43b],.clear-invalid-keys-button[data-v-a6a7d43b],.export-valid-keys-button[data-v-a6a7d43b]{padding:8px 12px;font-size:12px;justify-content:center;min-height:36px;gap:6px}.add-api-key-button svg[data-v-a6a7d43b],.test-api-key-button svg[data-v-a6a7d43b],.clear-invalid-keys-button svg[data-v-a6a7d43b],.export-valid-keys-button svg[data-v-a6a7d43b]{width:14px;height:14px;flex-shrink:0}.api-key-stats-list[data-v-a6a7d43b]{grid-template-columns:1fr}.api-key-item[data-v-a6a7d43b]{padding:10px}.api-key-name[data-v-a6a7d43b]{font-size:13px;max-width:100%;color:var(--button-primary)}.api-key-usage[data-v-a6a7d43b]{font-size:12px;gap:5px}.model-stats-container[data-v-a6a7d43b]{margin-top:10px}.model-info[data-v-a6a7d43b]{gap:3px}.total-tokens-label[data-v-a6a7d43b]{color:var(--color-heading);opacity:.9}.api-key-test-form[data-v-a6a7d43b],.clear-invalid-keys-form[data-v-a6a7d43b],.export-valid-keys-form[data-v-a6a7d43b]{padding:15px}.form-title h4[data-v-a6a7d43b]{font-size:14px}.form-description[data-v-a6a7d43b],.progress-text[data-v-a6a7d43b]{font-size:12px}.exported-keys-list[data-v-a6a7d43b]{max-height:250px}.exported-key-item[data-v-a6a7d43b]{padding:8px 10px}.key-text[data-v-a6a7d43b]{font-size:12px}.copy-key-button[data-v-a6a7d43b]{min-width:24px;height:24px;padding:3px}.copy-all-button[data-v-a6a7d43b]{padding:5px 10px;font-size:11px}}@media (max-width: 480px){.header-buttons[data-v-a6a7d43b]{grid-template-columns:1fr;gap:6px}.add-api-key-button[data-v-a6a7d43b],.test-api-key-button[data-v-a6a7d43b],.clear-invalid-keys-button[data-v-a6a7d43b],.export-valid-keys-button[data-v-a6a7d43b]{padding:10px 12px;font-size:13px;min-height:40px;gap:8px}.add-api-key-button svg[data-v-a6a7d43b],.test-api-key-button svg[data-v-a6a7d43b],.clear-invalid-keys-button svg[data-v-a6a7d43b],.export-valid-keys-button svg[data-v-a6a7d43b]{width:16px;height:16px;flex-shrink:0}.api-key-test-form[data-v-a6a7d43b],.clear-invalid-keys-form[data-v-a6a7d43b],.export-valid-keys-form[data-v-a6a7d43b]{padding:12px;margin-bottom:15px}.form-title h4[data-v-a6a7d43b]{font-size:15px}.form-description[data-v-a6a7d43b]{font-size:13px}.form-actions[data-v-a6a7d43b]{flex-direction:column;gap:8px}.submit-api-key[data-v-a6a7d43b],.cancel-api-key[data-v-a6a7d43b]{width:100%;padding:10px;font-size:14px}.exported-keys-header[data-v-a6a7d43b]{flex-direction:column;align-items:flex-start;gap:8px}.copy-all-button[data-v-a6a7d43b]{align-self:flex-end}}@media (max-width: 360px){.header-buttons[data-v-a6a7d43b]{gap:4px}.add-api-key-button[data-v-a6a7d43b],.test-api-key-button[data-v-a6a7d43b],.clear-invalid-keys-button[data-v-a6a7d43b],.export-valid-keys-button[data-v-a6a7d43b]{padding:8px 10px;font-size:12px;min-height:36px;gap:6px}.add-api-key-button svg[data-v-a6a7d43b],.test-api-key-button svg[data-v-a6a7d43b],.clear-invalid-keys-button svg[data-v-a6a7d43b],.export-valid-keys-button svg[data-v-a6a7d43b]{width:14px;height:14px}.api-key-test-form[data-v-a6a7d43b],.clear-invalid-keys-form[data-v-a6a7d43b],.export-valid-keys-form[data-v-a6a7d43b]{padding:10px}.form-title h4[data-v-a6a7d43b]{font-size:14px}.form-description[data-v-a6a7d43b]{font-size:12px}.submit-api-key[data-v-a6a7d43b],.cancel-api-key[data-v-a6a7d43b]{padding:8px;font-size:13px}}@media (max-width: 992px){.api-key-stats-list[data-v-a6a7d43b]{grid-template-columns:repeat(2,1fr)}}@media (max-width: 576px){.api-key-stats-list[data-v-a6a7d43b]{grid-template-columns:1fr}}.api-key-input-form[data-v-a6a7d43b]{background-color:var(--color-background-mute);border-radius:var(--radius-lg);padding:20px;margin-bottom:20px;border:1px solid var(--card-border);box-shadow:var(--shadow-md)}.form-group[data-v-a6a7d43b]{margin-bottom:15px}.form-group label[data-v-a6a7d43b]{display:block;margin-bottom:8px;font-size:14px;font-weight:500;color:var(--color-heading)}.api-key-textarea[data-v-a6a7d43b]{width:100%;padding:10px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-family:inherit;font-size:14px;resize:vertical;transition:all .3s ease}.api-key-textarea[data-v-a6a7d43b]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e51a}.api-key-password[data-v-a6a7d43b]{width:100%;padding:10px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-family:inherit;font-size:14px;transition:all .3s ease}.api-key-password[data-v-a6a7d43b]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e51a}.api-key-error[data-v-a6a7d43b]{color:var(--color-danger);font-size:14px;margin-bottom:15px;padding:10px;background-color:#ef44441a;border-radius:var(--radius-md);border-left:3px solid var(--color-danger)}.api-key-success[data-v-a6a7d43b]{color:var(--color-success);font-size:14px;margin-bottom:15px;padding:10px;background-color:#22c55e1a;border-radius:var(--radius-md);border-left:3px solid var(--color-success)}.form-actions[data-v-a6a7d43b]{display:flex;gap:10px}.submit-api-key[data-v-a6a7d43b]{padding:8px 20px;background-color:var(--button-primary);color:#fff;border:none;border-radius:var(--radius-md);font-weight:500;cursor:pointer;transition:all .3s ease}.submit-api-key[data-v-a6a7d43b]:hover:not(:disabled){background-color:var(--button-primary-hover);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.submit-api-key[data-v-a6a7d43b]:disabled{opacity:.5;cursor:not-allowed}.cancel-api-key[data-v-a6a7d43b]{padding:8px 20px;background-color:var(--button-secondary);color:var(--button-secondary-text);border:none;border-radius:var(--radius-md);font-weight:500;cursor:pointer;transition:all .3s ease}.cancel-api-key[data-v-a6a7d43b]:hover:not(:disabled){background-color:var(--button-secondary-hover);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.cancel-api-key[data-v-a6a7d43b]:disabled{opacity:.5;cursor:not-allowed}.info-box[data-v-257ff3a7]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:var(--radius-xl);padding:20px;margin-bottom:20px;box-shadow:var(--shadow-md);transition:all .3s ease;position:relative;overflow:hidden}.info-box[data-v-257ff3a7]:before{content:"";position:absolute;top:0;left:0;width:4px;height:100%;background:var(--gradient-success);opacity:.8}@media (max-width: 768px){.info-box[data-v-257ff3a7]{margin-bottom:12px;padding:15px 10px;border-radius:var(--radius-lg)}}@media (max-width: 480px){.info-box[data-v-257ff3a7]{margin-bottom:8px;padding:12px 8px;border-radius:var(--radius-md)}}.section-header[data-v-257ff3a7]{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px;position:relative}.status-container[data-v-257ff3a7]{display:flex;align-items:center;justify-content:center;position:absolute;left:50%;transform:translate(-50%)}.reset-button[data-v-257ff3a7]{display:flex;align-items:center;gap:5px;background-color:var(--button-secondary);color:var(--button-secondary-text);border:none;border-radius:var(--radius-md);padding:8px 12px;font-size:14px;cursor:pointer;transition:all .3s ease;position:relative;overflow:hidden;box-shadow:var(--shadow-sm);height:100%;z-index:1}.reset-button[data-v-257ff3a7]:before{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.1),transparent);transform:translate(-100%);transition:transform .6s ease}.reset-button[data-v-257ff3a7]:hover:before{transform:translate(100%)}.reset-button[data-v-257ff3a7]:hover{background-color:var(--button-secondary-hover);transform:translateY(-2px);box-shadow:var(--shadow-md)}.reset-button svg[data-v-257ff3a7]{transition:transform .3s}.reset-button:hover svg[data-v-257ff3a7]{transform:rotate(180deg)}.dialog-overlay[data-v-257ff3a7]{position:fixed;top:0;left:0;right:0;bottom:0;background-color:#00000080;display:flex;justify-content:center;align-items:flex-start;z-index:1000;padding-top:20px;-webkit-backdrop-filter:blur(5px);backdrop-filter:blur(5px)}.dialog[data-v-257ff3a7]{background-color:var(--card-background);border-radius:var(--radius-xl);padding:20px;width:90%;max-width:400px;box-shadow:var(--shadow-xl);margin-top:20px;position:relative;overflow:hidden;animation:dialogAppear-257ff3a7 .3s ease forwards}@keyframes dialogAppear-257ff3a7{0%{opacity:0;transform:translateY(-20px) scale(.95)}to{opacity:1;transform:translateY(0) scale(1)}}.dialog[data-v-257ff3a7]:before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-primary)}.dialog h3[data-v-257ff3a7]{margin-top:0;margin-bottom:10px;color:var(--color-heading);font-size:1.2rem;font-weight:600}.dialog p[data-v-257ff3a7]{margin-bottom:15px;color:var(--color-text);font-size:14px;line-height:1.5}.dialog input[data-v-257ff3a7]{width:100%;padding:12px 16px;border:1px solid var(--color-border);border-radius:var(--radius-md);margin-bottom:15px;background-color:var(--color-background);color:var(--color-text);transition:all .3s ease;font-size:14px}.dialog input[data-v-257ff3a7]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 3px #4f46e533}.error-message[data-v-257ff3a7]{color:#ef4444;margin-bottom:15px;font-size:14px;padding:8px 12px;background-color:#ef44441a;border-radius:var(--radius-md);border-left:3px solid #ef4444}.dialog-buttons[data-v-257ff3a7]{display:flex;justify-content:flex-end;gap:10px}.cancel-button[data-v-257ff3a7]{background-color:var(--button-secondary);color:var(--button-secondary-text);border:none;border-radius:var(--radius-md);padding:10px 18px;cursor:pointer;transition:all .3s ease;font-weight:500}.cancel-button[data-v-257ff3a7]:hover{background-color:var(--button-secondary-hover);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.confirm-button[data-v-257ff3a7]{background:var(--gradient-primary);color:#fff;border:none;border-radius:var(--radius-md);padding:10px 18px;cursor:pointer;transition:all .3s ease;font-weight:500;box-shadow:var(--shadow-sm)}.confirm-button[data-v-257ff3a7]:hover:not(:disabled){transform:translateY(-2px);box-shadow:var(--shadow-md)}.confirm-button[data-v-257ff3a7]:disabled{opacity:.7;cursor:not-allowed;transform:none;box-shadow:none}.status[data-v-257ff3a7]{color:#10b981;font-weight:700;font-size:16px;padding:8px 12px;background-color:#10b9811a;border-radius:var(--radius-md);border-left:none;transition:all .3s ease;animation:pulse-257ff3a7 2s infinite;margin:0;white-space:nowrap}@keyframes pulse-257ff3a7{0%{box-shadow:0 0 #10b98166}70%{box-shadow:0 0 0 10px #10b98100}to{box-shadow:0 0 #10b98100}}.section-title[data-v-257ff3a7]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;transition:all .3s ease;position:relative;font-weight:600;margin:0}.section-title[data-v-257ff3a7]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.vertex-notice[data-v-257ff3a7]{background-color:var(--color-background-soft);border-radius:var(--radius-lg);padding:16px;margin:20px 0;display:flex;gap:16px;align-items:flex-start;border:1px solid var(--color-border);transition:all .3s ease;position:relative;overflow:hidden}.vertex-notice[data-v-257ff3a7]:before{content:"";position:absolute;top:0;left:0;width:4px;height:100%;background:var(--gradient-info);opacity:.8}.vertex-notice[data-v-257ff3a7]:hover{transform:translateY(-3px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.notice-icon[data-v-257ff3a7]{font-size:24px;background-color:var(--color-background-mute);padding:8px;border-radius:50%;display:flex;align-items:center;justify-content:center;min-width:40px;height:40px;transition:all .3s ease;box-shadow:var(--shadow-sm)}.notice-content[data-v-257ff3a7]{flex:1}.notice-title[data-v-257ff3a7]{color:var(--color-heading);font-size:16px;font-weight:600;margin:0 0 8px;transition:all .3s ease}.notice-text[data-v-257ff3a7]{color:var(--color-text);font-size:14px;line-height:1.5;margin:0;transition:all .3s ease}@media (max-width: 768px){.vertex-notice[data-v-257ff3a7]{padding:12px;gap:12px}.notice-icon[data-v-257ff3a7]{font-size:20px;min-width:32px;height:32px;padding:6px}.notice-title[data-v-257ff3a7]{font-size:14px;margin-bottom:6px}.notice-text[data-v-257ff3a7]{font-size:12px}.status[data-v-257ff3a7]{font-size:14px;padding:6px 10px}.reset-button[data-v-257ff3a7]{font-size:12px;padding:6px 10px}}@media (max-width: 480px){.status[data-v-257ff3a7]{font-size:12px;padding:4px 8px}.reset-button[data-v-257ff3a7]{font-size:11px;padding:4px 8px}.section-header[data-v-257ff3a7]{flex-direction:row;align-items:center;justify-content:space-between;gap:8px;position:relative;padding-top:0}.section-title[data-v-257ff3a7]{font-size:14px;margin-right:auto}.status-container[data-v-257ff3a7]{position:static;transform:none;margin:0}.reset-button[data-v-257ff3a7]{align-self:center}}.section-title[data-v-bf7ce7b9]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-bf7ce7b9]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.basic-config[data-v-bf7ce7b9]{margin-bottom:25px}.config-form[data-v-bf7ce7b9]{background-color:var(--stats-item-bg);border-radius:var(--radius-lg);padding:20px;box-shadow:var(--shadow-sm);border:1px solid var(--card-border)}.config-row[data-v-bf7ce7b9]{display:flex;gap:15px;margin-bottom:15px;flex-wrap:wrap}.config-group[data-v-bf7ce7b9]{flex:1;min-width:120px}.config-label[data-v-bf7ce7b9]{display:block;font-size:14px;margin-bottom:5px;color:var(--color-text);font-weight:500}.config-input[data-v-bf7ce7b9]{width:100%;padding:8px 12px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.config-input[data-v-bf7ce7b9]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e533}@media (max-width: 768px){.config-row[data-v-bf7ce7b9]{gap:10px}.config-group[data-v-bf7ce7b9]{min-width:100px}}@media (max-width: 480px){.config-row[data-v-bf7ce7b9]{flex-direction:column;gap:10px}.config-group[data-v-bf7ce7b9]{width:100%}.config-form[data-v-bf7ce7b9]{padding:15px}}.section-title[data-v-dc697ea9]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-dc697ea9]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.features-config[data-v-dc697ea9]{margin-bottom:25px}.config-form[data-v-dc697ea9]{background-color:var(--stats-item-bg);border-radius:var(--radius-lg);padding:20px;box-shadow:var(--shadow-sm);border:1px solid var(--card-border)}.config-row[data-v-dc697ea9]{display:flex;gap:15px;margin-bottom:15px;flex-wrap:wrap}.config-group[data-v-dc697ea9]{flex:1;min-width:120px}.full-width[data-v-dc697ea9]{flex-basis:100%}.config-label[data-v-dc697ea9]{display:block;font-size:14px;margin-bottom:5px;color:var(--color-text);font-weight:500}.config-input[data-v-dc697ea9]{width:100%;padding:8px 12px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.config-input[data-v-dc697ea9]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e533}.toggle-wrapper[data-v-dc697ea9]{position:relative}.toggle[data-v-dc697ea9]{position:absolute;opacity:0;width:0;height:0}.toggle-label[data-v-dc697ea9]{display:flex;align-items:center;cursor:pointer;-webkit-user-select:none;user-select:none}.toggle-label[data-v-dc697ea9]:before{content:"";display:inline-block;width:36px;height:20px;background-color:var(--color-border);border-radius:10px;margin-right:8px;position:relative;transition:all .3s ease}.toggle-label[data-v-dc697ea9]:after{content:"";position:absolute;left:3px;width:14px;height:14px;background-color:#fff;border-radius:50%;transition:all .3s ease}.toggle:checked+.toggle-label[data-v-dc697ea9]:before{background-color:var(--button-primary)}.toggle:checked+.toggle-label[data-v-dc697ea9]:after{left:19px}.toggle-text[data-v-dc697ea9]{font-size:14px;color:var(--color-text)}@media (max-width: 768px){.config-row[data-v-dc697ea9]{gap:10px}.config-group[data-v-dc697ea9]{min-width:100px}}@media (max-width: 480px){.config-row[data-v-dc697ea9]{flex-direction:column;gap:10px}.config-group[data-v-dc697ea9]{width:100%}.config-form[data-v-dc697ea9]{padding:15px}}.section-title[data-v-e1a72b08]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-e1a72b08]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.stats-grid[data-v-e1a72b08]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}@media (max-width: 768px){.stats-grid[data-v-e1a72b08]{gap:8px}}.stat-card[data-v-e1a72b08]{background-color:var(--stats-item-bg);padding:10px 15px;border-radius:var(--radius-lg);text-align:center;box-shadow:var(--shadow-sm);transition:all .3s ease;position:relative;overflow:hidden;border:1px solid var(--card-border)}.stat-card[data-v-e1a72b08]:before{content:"";position:absolute;top:0;left:0;width:100%;height:3px;background:var(--gradient-secondary);opacity:0;transition:opacity .3s ease}.stat-card[data-v-e1a72b08]:hover{transform:translateY(-3px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.stat-card[data-v-e1a72b08]:hover:before{opacity:1}.stat-value[data-v-e1a72b08]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;margin-bottom:5px;position:relative;display:inline-block}.stat-label[data-v-e1a72b08]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;opacity:.8}.stat-card:hover .stat-label[data-v-e1a72b08]{opacity:1;color:var(--color-heading)}.update-status-container[data-v-e1a72b08]{display:flex;align-items:center;justify-content:center;min-height:40px;width:100%}.update-status[data-v-e1a72b08]{display:flex;align-items:center;justify-content:center;gap:8px;padding:8px 12px;border-radius:var(--radius-lg);transition:all .3s ease;width:100%;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.update-status .status-icon[data-v-e1a72b08]{font-size:1.2em;display:inline-flex;align-items:center;justify-content:center;flex-shrink:0}.update-status .status-text[data-v-e1a72b08]{font-size:1em;font-weight:600;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.update-status .status-icon.update-needed[data-v-e1a72b08],.update-status .status-text.update-needed[data-v-e1a72b08]{color:#ef4444}.update-status .status-icon.up-to-date[data-v-e1a72b08],.update-status .status-text.up-to-date[data-v-e1a72b08]{color:#10b981}.project-link-container[data-v-e1a72b08]{display:flex;justify-content:center;align-items:center;padding:15px;margin-top:20px;transition:all .3s ease}.project-link[data-v-e1a72b08]{display:flex;align-items:center;gap:10px;color:var(--button-primary);text-decoration:none;font-size:14px;padding:10px 18px;border-radius:var(--radius-full);background-color:var(--stats-item-bg);transition:all .3s ease;box-shadow:var(--shadow-sm);border:1px solid var(--card-border);position:relative;overflow:hidden}.project-link[data-v-e1a72b08]:before{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.1),transparent);transform:translate(-100%);transition:transform .6s ease}.project-link[data-v-e1a72b08]:hover{transform:translateY(-3px);box-shadow:var(--shadow-md);background-color:var(--color-background-mute);border-color:var(--button-primary)}.project-link[data-v-e1a72b08]:hover:before{transform:translate(100%)}.github-icon[data-v-e1a72b08]{font-size:18px;opacity:.8;transition:all .3s ease}.project-link:hover .github-icon[data-v-e1a72b08]{opacity:1;transform:scale(1.2) rotate(10deg)}.project-text[data-v-e1a72b08]{font-weight:500;position:relative}.project-text[data-v-e1a72b08]:after{content:"";position:absolute;bottom:-2px;left:0;width:0;height:1px;background:var(--gradient-primary);transition:width .3s ease}.project-link:hover .project-text[data-v-e1a72b08]:after{width:100%}@media (max-width: 768px){.stat-card[data-v-e1a72b08]{padding:8px}.stat-value[data-v-e1a72b08]{font-size:16px}.stat-label[data-v-e1a72b08]{font-size:12px;margin-top:2px}.update-status[data-v-e1a72b08]{padding:6px 10px}.update-status .status-icon[data-v-e1a72b08]{font-size:1.1em}.update-status .status-text[data-v-e1a72b08]{font-size:.9em}.project-link[data-v-e1a72b08]{font-size:12px;padding:8px 14px}.github-icon[data-v-e1a72b08]{font-size:16px}}@media (max-width: 480px){.stat-card[data-v-e1a72b08]{padding:6px}.stat-value[data-v-e1a72b08]{font-size:14px}.stat-label[data-v-e1a72b08]{font-size:11px;margin-top:1px}.update-status[data-v-e1a72b08]{padding:4px 8px}.update-status .status-icon[data-v-e1a72b08]{font-size:1em}.update-status .status-text[data-v-e1a72b08]{font-size:.85em}.project-link[data-v-e1a72b08]{font-size:11px;padding:6px 12px}.github-icon[data-v-e1a72b08]{font-size:14px}}.section-title[data-v-87fa5cbc]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-87fa5cbc]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.vertex-config[data-v-87fa5cbc]{margin-bottom:25px}.config-form[data-v-87fa5cbc]{background-color:var(--stats-item-bg);border-radius:var(--radius-lg);padding:20px;box-shadow:var(--shadow-sm);border:1px solid var(--card-border)}.config-row[data-v-87fa5cbc]{display:flex;gap:15px;margin-bottom:15px;flex-wrap:wrap}.config-group[data-v-87fa5cbc]{flex:1;min-width:120px}.full-width[data-v-87fa5cbc]{flex-basis:100%}.config-label[data-v-87fa5cbc]{display:block;font-size:14px;margin-bottom:5px;color:var(--color-text);font-weight:500}.config-input[data-v-87fa5cbc]{width:100%;padding:8px 12px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.config-input[data-v-87fa5cbc]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e533}.text-area[data-v-87fa5cbc]{resize:vertical;min-height:80px;font-family:inherit;line-height:1.5}.toggle-wrapper[data-v-87fa5cbc]{position:relative}.toggle[data-v-87fa5cbc]{position:absolute;opacity:0;width:0;height:0}.toggle-label[data-v-87fa5cbc]{display:flex;align-items:center;cursor:pointer;-webkit-user-select:none;user-select:none}.toggle-label[data-v-87fa5cbc]:before{content:"";display:inline-block;width:36px;height:20px;background-color:var(--color-border);border-radius:10px;margin-right:8px;position:relative;transition:all .3s ease}.toggle-label[data-v-87fa5cbc]:after{content:"";position:absolute;left:3px;width:14px;height:14px;background-color:#fff;border-radius:50%;transition:all .3s ease}.toggle:checked+.toggle-label[data-v-87fa5cbc]:before{background-color:var(--button-primary)}.toggle:checked+.toggle-label[data-v-87fa5cbc]:after{left:19px}.toggle-text[data-v-87fa5cbc]{font-size:14px;color:var(--color-text)}.save-section[data-v-87fa5cbc]{display:flex;gap:10px;margin-top:20px;align-items:center}.password-input[data-v-87fa5cbc]{flex:1}.save-button[data-v-87fa5cbc]{padding:8px 16px;background:var(--button-primary);color:#fff;border:none;border-radius:var(--radius-md);cursor:pointer;font-weight:500;transition:all .3s ease}.save-button[data-v-87fa5cbc]:hover{background:var(--button-primary-hover);transform:translateY(-2px)}.save-button[data-v-87fa5cbc]:disabled{opacity:.7;cursor:not-allowed;transform:none}.error-message[data-v-87fa5cbc]{color:var(--color-error);margin-top:10px;font-size:14px;padding:8px;background-color:var(--color-error-bg);border-radius:var(--radius-md)}.success-message[data-v-87fa5cbc]{color:var(--color-success);margin-top:10px;font-size:14px;padding:8px;background-color:var(--color-success-bg);border-radius:var(--radius-md)}@media (max-width: 768px){.config-row[data-v-87fa5cbc]{gap:10px}.config-group[data-v-87fa5cbc]{min-width:100px}.save-section[data-v-87fa5cbc]{flex-direction:column}.password-input[data-v-87fa5cbc]{width:100%;margin-bottom:10px}.save-button[data-v-87fa5cbc]{width:100%}}@media (max-width: 480px){.config-row[data-v-87fa5cbc]{flex-direction:column;gap:10px}.config-group[data-v-87fa5cbc]{width:100%}.config-form[data-v-87fa5cbc]{padding:15px}}.info-box[data-v-d8cf8b0b]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:var(--radius-xl);padding:20px;margin-bottom:20px;box-shadow:var(--shadow-md);transition:all .3s ease;position:relative;overflow:hidden}.info-box[data-v-d8cf8b0b]:before{content:"";position:absolute;top:0;left:0;width:4px;height:100%;background:var(--gradient-primary);opacity:.8}@media (max-width: 768px){.info-box[data-v-d8cf8b0b]{margin-bottom:12px;padding:15px 10px;border-radius:var(--radius-lg)}}@media (max-width: 480px){.info-box[data-v-d8cf8b0b]{margin-bottom:8px;padding:12px 8px;border-radius:var(--radius-md)}}.section-title[data-v-d8cf8b0b]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-d8cf8b0b]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}.stats-grid[data-v-d8cf8b0b]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}@media (max-width: 768px){.stats-grid[data-v-d8cf8b0b]{gap:8px}}.stat-card[data-v-d8cf8b0b]{background-color:var(--stats-item-bg);padding:10px 15px;border-radius:var(--radius-lg);text-align:center;box-shadow:var(--shadow-sm);transition:all .3s ease;position:relative;overflow:hidden;border:1px solid var(--card-border)}.stat-card[data-v-d8cf8b0b]:before{content:"";position:absolute;top:0;left:0;width:100%;height:3px;background:var(--gradient-secondary);opacity:0;transition:opacity .3s ease}.stat-card[data-v-d8cf8b0b]:hover{transform:translateY(-3px);box-shadow:var(--shadow-md);border-color:var(--button-primary)}.stat-card[data-v-d8cf8b0b]:hover:before{opacity:1}.stat-value[data-v-d8cf8b0b]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;margin-bottom:5px;position:relative;display:inline-block}.stat-label[data-v-d8cf8b0b]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:all .3s ease;opacity:.8}.stat-card:hover .stat-label[data-v-d8cf8b0b]{opacity:1;color:var(--color-heading)}.edit-btn[data-v-d8cf8b0b]{position:absolute;top:5px;right:5px;background:none;border:none;color:var(--color-text-muted);cursor:pointer;opacity:.5;transition:all .3s ease;padding:4px;border-radius:var(--radius-md);display:flex;align-items:center;justify-content:center;z-index:2}.edit-btn[data-v-d8cf8b0b]:hover{opacity:1;transform:scale(1.1) rotate(15deg);background-color:var(--color-background-mute);color:var(--button-primary)}.edit-dialog[data-v-d8cf8b0b]{position:fixed;top:0;left:0;right:0;bottom:0;background-color:#00000080;display:flex;align-items:center;justify-content:center;z-index:1000;-webkit-backdrop-filter:blur(5px);backdrop-filter:blur(5px)}.edit-dialog-content[data-v-d8cf8b0b]{background-color:var(--card-background);border-radius:var(--radius-xl);padding:25px;width:90%;max-width:400px;box-shadow:var(--shadow-xl);position:relative;overflow:hidden;animation:dialogAppear-d8cf8b0b .3s cubic-bezier(.34,1.56,.64,1)}@keyframes dialogAppear-d8cf8b0b{0%{opacity:0;transform:scale(.9) translateY(20px)}to{opacity:1;transform:scale(1) translateY(0)}}.edit-dialog-content[data-v-d8cf8b0b]:before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-primary)}.edit-dialog-content h3[data-v-d8cf8b0b]{margin-top:0;margin-bottom:15px;color:var(--color-heading);font-size:1.3rem;position:relative;padding-bottom:10px}.edit-dialog-content h3[data-v-d8cf8b0b]:after{content:"";position:absolute;bottom:0;left:0;width:40px;height:2px;background:var(--gradient-primary)}.edit-field[data-v-d8cf8b0b]{margin-bottom:20px}.edit-field label[data-v-d8cf8b0b]{display:block;margin-bottom:8px;color:var(--color-text);font-size:14px;line-height:1.5}.edit-input[data-v-d8cf8b0b]{width:100%;padding:12px 16px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.edit-input[data-v-d8cf8b0b]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 3px #4f46e533}.text-area[data-v-d8cf8b0b]{resize:vertical;min-height:80px;font-family:inherit;line-height:1.5}.boolean-selector[data-v-d8cf8b0b]{display:flex;gap:15px;margin-top:12px}.boolean-option[data-v-d8cf8b0b]{display:flex;align-items:center;gap:8px;cursor:pointer;padding:8px 12px;border-radius:var(--radius-md);background-color:var(--stats-item-bg);transition:all .3s ease;border:1px solid var(--color-border)}.boolean-option[data-v-d8cf8b0b]:hover{background-color:var(--color-background-mute);transform:translateY(-2px)}.boolean-option input[type=radio][data-v-d8cf8b0b]{accent-color:var(--button-primary)}.password-field[data-v-d8cf8b0b]{margin-top:15px;position:relative}.password-field label[data-v-d8cf8b0b]{margin-bottom:8px;display:block}.edit-error[data-v-d8cf8b0b]{color:#ef4444;font-size:12px;margin-top:8px;padding-left:5px;display:flex;align-items:center;gap:5px}.edit-error[data-v-d8cf8b0b]:before{content:"⚠️";font-size:14px}.edit-actions[data-v-d8cf8b0b]{display:flex;justify-content:flex-end;gap:10px;margin-top:20px}.cancel-btn[data-v-d8cf8b0b],.save-btn[data-v-d8cf8b0b]{padding:10px 18px;border-radius:var(--radius-md);font-size:14px;cursor:pointer;transition:all .3s ease;font-weight:500}.cancel-btn[data-v-d8cf8b0b]{background-color:var(--button-secondary);border:1px solid var(--color-border);color:var(--button-secondary-text)}.save-btn[data-v-d8cf8b0b]{background:var(--gradient-primary);border:none;color:#fff;box-shadow:var(--shadow-sm)}.cancel-btn[data-v-d8cf8b0b]:hover{background-color:var(--button-secondary-hover);transform:translateY(-2px)}.save-btn[data-v-d8cf8b0b]:hover{transform:translateY(-2px);box-shadow:var(--shadow-md)}.tooltip[data-v-d8cf8b0b]{position:fixed;background-color:#000c;color:#fff;padding:8px 12px;border-radius:var(--radius-md);font-size:12px;max-width:250px;z-index:1000;pointer-events:none;transform:translate(-50%,-100%);margin-top:-10px;box-shadow:var(--shadow-lg);-webkit-backdrop-filter:blur(5px);backdrop-filter:blur(5px);border:1px solid rgba(255,255,255,.1);animation:tooltipAppear-d8cf8b0b .2s ease}@keyframes tooltipAppear-d8cf8b0b{0%{opacity:0;transform:translate(-50%,-90%)}to{opacity:1;transform:translate(-50%,-100%)}}@media (max-width: 768px){.stat-card[data-v-d8cf8b0b]{padding:8px}.stat-value[data-v-d8cf8b0b]{font-size:16px}.stat-label[data-v-d8cf8b0b]{font-size:12px;margin-top:2px}.edit-btn[data-v-d8cf8b0b]{top:3px;right:3px;padding:2px}.edit-dialog-content[data-v-d8cf8b0b]{padding:20px}.boolean-selector[data-v-d8cf8b0b]{flex-direction:column;gap:8px}}@media (max-width: 480px){.stat-card[data-v-d8cf8b0b]{padding:6px}.stat-value[data-v-d8cf8b0b]{font-size:14px}.stat-label[data-v-d8cf8b0b]{font-size:11px;margin-top:1px}.tooltip[data-v-d8cf8b0b]{max-width:200px;font-size:10px}.edit-dialog-content[data-v-d8cf8b0b]{padding:15px}.edit-dialog-content h3[data-v-d8cf8b0b]{font-size:1.1rem}.edit-input[data-v-d8cf8b0b]{padding:10px 14px;font-size:13px}.cancel-btn[data-v-d8cf8b0b],.save-btn[data-v-d8cf8b0b]{padding:8px 14px;font-size:13px}}.fold-header[data-v-d8cf8b0b]{cursor:pointer;-webkit-user-select:none;user-select:none;display:flex;justify-content:space-between;align-items:center;transition:all .3s ease;border-radius:var(--radius-lg);padding:10px 15px;background-color:var(--stats-item-bg);border:1px solid var(--card-border);margin-bottom:15px}.fold-header[data-v-d8cf8b0b]:hover{background-color:var(--color-background-mute);transform:translateY(-2px);box-shadow:var(--shadow-sm)}.fold-icon[data-v-d8cf8b0b]{display:inline-flex;align-items:center;justify-content:center;transition:transform .3s ease;color:var(--button-primary)}.fold-icon.rotated[data-v-d8cf8b0b]{transform:rotate(180deg)}.fold-content[data-v-d8cf8b0b]{overflow:hidden}.fold-enter-active[data-v-d8cf8b0b],.fold-leave-active[data-v-d8cf8b0b]{transition:all .3s ease;max-height:1000px;opacity:1;overflow:hidden}.fold-enter-from[data-v-d8cf8b0b],.fold-leave-to[data-v-d8cf8b0b]{max-height:0;opacity:0;overflow:hidden}@media (max-width: 768px){.fold-header[data-v-d8cf8b0b]{padding:8px 12px}}@media (max-width: 480px){.fold-header[data-v-d8cf8b0b]{padding:6px 10px}}.shared-save-section[data-v-d8cf8b0b]{margin-top:30px;padding-top:20px;border-top:1px solid var(--color-border);display:flex;flex-direction:column;gap:15px}.password-input-group[data-v-d8cf8b0b]{display:flex;flex-direction:column;gap:5px}.shared-password-label[data-v-d8cf8b0b]{font-size:14px;color:var(--color-text);font-weight:500}.config-input[data-v-d8cf8b0b]{width:100%;padding:10px 14px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.config-input[data-v-d8cf8b0b]:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 2px #4f46e533}.save-all-button[data-v-d8cf8b0b]{padding:10px 18px;background:var(--button-primary);color:#fff;border:none;border-radius:var(--radius-md);cursor:pointer;font-weight:500;transition:all .3s ease;text-align:center}.save-all-button[data-v-d8cf8b0b]:hover{background:var(--button-primary-hover);transform:translateY(-2px);box-shadow:var(--shadow-md)}.save-all-button[data-v-d8cf8b0b]:disabled{opacity:.7;cursor:not-allowed;transform:none}.overall-error-message[data-v-d8cf8b0b]{color:var(--color-error);margin-top:10px;font-size:14px;padding:10px;background-color:var(--color-error-bg);border-radius:var(--radius-md);border:1px solid var(--color-error)}.overall-success-message[data-v-d8cf8b0b]{color:var(--color-success);margin-top:10px;font-size:14px;padding:10px;background-color:var(--color-success-bg);border-radius:var(--radius-md);border:1px solid var(--color-success)}.info-box[data-v-d38f4a7d]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:var(--radius-xl);padding:20px;margin-bottom:20px;box-shadow:var(--shadow-md);transition:all .3s ease;position:relative;overflow:hidden}.info-box[data-v-d38f4a7d]:before{content:"";position:absolute;top:0;left:0;width:4px;height:100%;background:var(--gradient-info);opacity:.8}@media (max-width: 768px){.info-box[data-v-d38f4a7d]{margin-bottom:12px;padding:15px 10px;border-radius:var(--radius-lg)}}@media (max-width: 480px){.info-box[data-v-d38f4a7d]{margin-bottom:8px;padding:12px 8px;border-radius:var(--radius-md)}}.section-title[data-v-d38f4a7d]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:all .3s ease;position:relative;font-weight:600}.section-title[data-v-d38f4a7d]:after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-info)}.log-filter[data-v-d38f4a7d]{display:flex;justify-content:center;margin-bottom:15px;gap:10px;flex-wrap:wrap}.log-filter button[data-v-d38f4a7d]{padding:8px 12px;border:1px solid var(--card-border);border-radius:var(--radius-md);background-color:var(--stats-item-bg);color:var(--color-text);cursor:pointer;min-width:70px;transition:all .3s ease;font-weight:500;position:relative;overflow:hidden}.log-filter button[data-v-d38f4a7d]:before{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.1),transparent);transform:translate(-100%);transition:transform .6s ease}.log-filter button[data-v-d38f4a7d]:hover:before{transform:translate(100%)}.log-filter button.active[data-v-d38f4a7d]{background:var(--gradient-info);color:#fff;border-color:transparent;box-shadow:var(--shadow-sm);transform:translateY(-2px)}.log-filter button[data-v-d38f4a7d]:not(.active):hover{background-color:var(--color-background-mute);transform:translateY(-2px);box-shadow:var(--shadow-sm)}@media (max-width: 768px){.log-filter[data-v-d38f4a7d]{gap:6px;margin-bottom:12px}.log-filter button[data-v-d38f4a7d]{padding:6px 10px;font-size:12px;min-width:60px}}@media (max-width: 480px){.log-filter[data-v-d38f4a7d]{gap:4px;margin-bottom:10px}.log-filter button[data-v-d38f4a7d]{padding:5px 8px;font-size:11px;min-width:50px}}.log-container[data-v-d38f4a7d]{background-color:var(--log-entry-bg);border:1px solid var(--log-entry-border);border-radius:var(--radius-lg);padding:15px;margin-top:20px;max-height:500px;overflow-y:auto;font-family:JetBrains Mono,Fira Code,monospace;font-size:14px;line-height:1.5;transition:all .3s ease;box-shadow:var(--shadow-sm);position:relative}.log-container[data-v-d38f4a7d]::-webkit-scrollbar{width:8px}.log-container[data-v-d38f4a7d]::-webkit-scrollbar-track{background:var(--color-background-mute);border-radius:4px}.log-container[data-v-d38f4a7d]::-webkit-scrollbar-thumb{background:var(--button-primary);border-radius:4px;opacity:.7}.log-container[data-v-d38f4a7d]::-webkit-scrollbar-thumb:hover{background:var(--button-primary-hover)}.log-entry[data-v-d38f4a7d]{margin-bottom:8px;padding:10px;border-radius:var(--radius-md);word-break:break-word;transition:all .3s ease;position:relative;overflow:hidden;border-left:4px solid transparent;animation:logEntryAppear-d38f4a7d .3s ease forwards;opacity:0;transform:translateY(10px)}@keyframes logEntryAppear-d38f4a7d{0%{opacity:0;transform:translateY(10px)}to{opacity:1;transform:translateY(0)}}.log-entry[data-v-d38f4a7d]:after{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.05),transparent);transform:translate(-100%);transition:transform .6s ease}.log-entry[data-v-d38f4a7d]:hover:after{transform:translate(100%)}.log-entry.INFO[data-v-d38f4a7d]{background-color:#3b82f61a;border-left:4px solid #3b82f6}.log-entry.WARNING[data-v-d38f4a7d]{background-color:#f59e0b1a;border-left:4px solid #f59e0b}.log-entry.ERROR[data-v-d38f4a7d]{background-color:#ef44441a;border-left:4px solid #ef4444}.log-entry.DEBUG[data-v-d38f4a7d]{background-color:#10b9811a;border-left:4px solid #10b981}.log-timestamp[data-v-d38f4a7d]{color:var(--color-text);font-size:12px;margin-right:10px;opacity:.8;transition:all .3s ease;font-weight:500}.log-level[data-v-d38f4a7d]{font-weight:700;margin-right:10px;padding:2px 6px;border-radius:var(--radius-sm);font-size:12px;text-transform:uppercase;letter-spacing:.5px}.log-level.INFO[data-v-d38f4a7d]{color:#3b82f6;background-color:#3b82f61a}.log-level.WARNING[data-v-d38f4a7d]{color:#f59e0b;background-color:#f59e0b1a}.log-level.ERROR[data-v-d38f4a7d]{color:#ef4444;background-color:#ef44441a}.log-level.DEBUG[data-v-d38f4a7d]{color:#10b981;background-color:#10b9811a}.log-message[data-v-d38f4a7d]{color:var(--color-text);transition:all .3s ease;line-height:1.6}.log-entry[data-v-d38f4a7d]:hover{transform:translate(5px);box-shadow:var(--shadow-sm)}.log-entry:hover .log-timestamp[data-v-d38f4a7d]{opacity:1;color:var(--button-primary)}.log-entry:hover .log-message[data-v-d38f4a7d]{color:var(--color-heading)}@media (max-width: 768px){.log-container[data-v-d38f4a7d]{padding:12px;font-size:13px;max-height:400px}.log-entry[data-v-d38f4a7d]{padding:8px;margin-bottom:6px}.log-timestamp[data-v-d38f4a7d]{font-size:11px;display:block;margin-bottom:3px}.log-level[data-v-d38f4a7d]{font-size:11px;padding:1px 4px}}@media (max-width: 480px){.log-container[data-v-d38f4a7d]{padding:10px;font-size:12px;max-height:350px}.log-entry[data-v-d38f4a7d]{padding:6px;margin-bottom:5px}.log-timestamp[data-v-d38f4a7d]{font-size:10px}.log-level[data-v-d38f4a7d]{font-size:10px;padding:1px 3px;margin-right:5px}.log-message[data-v-d38f4a7d]{font-size:11px}}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif;line-height:1.6;background-color:var(--color-background);color:var(--color-text);margin:0;padding:0;transition:background-color .3s,color .3s}.dashboard{max-width:1200px;margin:0 auto;padding:20px;opacity:0;transform:translateY(20px);transition:opacity .5s cubic-bezier(.25,.46,.45,.94),transform .5s cubic-bezier(.25,.46,.45,.94)}.dashboard.page-loaded{opacity:1;transform:translateY(0)}.header-container{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px;opacity:0;transform:translateY(20px) scale(.95);transition:opacity .4s cubic-bezier(.34,1.56,.64,1),transform .4s cubic-bezier(.34,1.56,.64,1);background:var(--gradient-primary);padding:20px;border-radius:var(--radius-xl);box-shadow:var(--shadow-lg);position:relative;overflow:hidden}.header-container:before{content:"";position:absolute;top:0;left:0;right:0;bottom:0;background:radial-gradient(circle at top right,rgba(255,255,255,.1),transparent 70%);z-index:0}.header-container:after{content:"";position:absolute;top:0;left:0;right:0;bottom:0;background:radial-gradient(circle at bottom left,rgba(255,255,255,.1),transparent 70%);z-index:0}.header-container.animate-in{opacity:1;transform:translateY(0) scale(1)}.title-container{display:flex;align-items:center;gap:15px;flex-wrap:wrap;position:relative;z-index:1}.toggle-container{display:flex;align-items:center;gap:15px;position:relative;z-index:1}.vertex-button,.theme-button{display:flex;align-items:center;justify-content:center;background-color:#ffffff26;padding:8px 16px;border-radius:var(--radius-full);border:1px solid rgba(255,255,255,.2);transition:all .3s ease;box-shadow:var(--shadow-md);cursor:pointer;font-size:.9rem;color:#fff;font-weight:500;min-width:90px;-webkit-backdrop-filter:blur(5px);backdrop-filter:blur(5px)}.vertex-button.active,.theme-button.active{background-color:#ffffff40;border-color:#ffffff4d;color:#fff}.vertex-button:hover,.theme-button:hover{background-color:#ffffff4d;transform:translateY(-2px);box-shadow:var(--shadow-lg)}h1{color:#fff;margin:0;font-size:1.8rem;text-shadow:0 2px 4px rgba(0,0,0,.2)}.vertex-toggle,.theme-toggle,.switch,.slider{display:none}.sections-row{display:flex;flex-direction:column;gap:20px;margin-bottom:20px}.status-section,.config-section{width:100%}@media (max-width: 768px){.dashboard{padding:10px 8px}.header-container{flex-direction:row;align-items:center;margin-bottom:15px;padding:15px}.title-container{width:auto;justify-content:flex-start;margin-bottom:0;flex:1}h1{font-size:1.4rem;text-align:left;max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}h1:before{content:"🤖Gemini代理"}h1 span{display:none}.toggle-container{width:auto;justify-content:flex-end;flex-direction:row;gap:8px;margin-top:0;align-self:center}.vertex-button,.theme-button{padding:6px 12px;font-size:.8rem;min-width:80px}.sections-row{flex-direction:column;gap:15px}}@media (max-width: 480px){.dashboard{padding:6px 4px}.header-container{flex-direction:row;align-items:center;margin-bottom:15px;padding:12px}.title-container{width:auto;justify-content:flex-start;margin-bottom:0;flex:1}h1{font-size:1.1rem;max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.toggle-container{width:auto;justify-content:flex-end;flex-direction:row;gap:4px;margin-top:0;align-self:center}.vertex-button,.theme-button{padding:4px 8px;font-size:.65rem;min-width:70px}.sections-row{flex-direction:column;gap:10px}}.refresh-button{display:block;margin:20px auto;padding:12px 24px;background:var(--gradient-secondary);color:#fff;border:none;border-radius:var(--radius-lg);font-size:16px;cursor:pointer;transition:all .3s ease;opacity:0;transform:translateY(20px) scale(.95);box-shadow:var(--shadow-md);position:relative;overflow:hidden}.refresh-button:before{content:"";position:absolute;top:0;left:0;right:0;bottom:0;background:linear-gradient(to right,transparent,rgba(255,255,255,.2),transparent);transform:translate(-100%);transition:transform .6s ease}.refresh-button:hover:before{transform:translate(100%)}.refresh-button.animate-in{opacity:1;transform:translateY(0) scale(1)}.refresh-button:hover{transform:translateY(-3px);box-shadow:var(--shadow-lg)}@media (max-width: 768px){:deep(.info-box){padding:15px 10px;margin-bottom:15px;border-radius:var(--radius-lg);background-color:var(--card-background);border:1px solid var(--card-border);box-shadow:var(--shadow-md);position:relative;overflow:hidden}:deep(.info-box):before{content:"";position:absolute;top:0;left:0;width:4px;height:100%;background:var(--gradient-primary)}:deep(.section-title){font-size:1.1rem;margin-bottom:15px;padding-bottom:8px;color:var(--color-heading);border-bottom:1px solid var(--color-border);position:relative}:deep(.section-title):after{content:"";position:absolute;bottom:-1px;left:0;width:50px;height:2px;background:var(--gradient-primary)}:deep(.stats-grid){gap:10px;margin-top:15px;margin-bottom:20px}.refresh-button{margin:20px auto;padding:10px 20px;font-size:14px}}@media (max-width: 480px){:deep(.info-box){padding:12px 8px;margin-bottom:10px;border-radius:var(--radius-md)}:deep(.section-title){font-size:1rem;margin-bottom:10px;padding-bottom:6px}:deep(.stats-grid){gap:8px;margin-top:10px;margin-bottom:15px}.refresh-button{margin:15px auto;padding:8px 16px;font-size:13px}}.section-animate{opacity:0;transform:translateY(20px) scale(.95);transition:opacity .4s cubic-bezier(.34,1.56,.64,1),transform .4s cubic-bezier(.34,1.56,.64,1)}.section-animate.animate-in{opacity:1;transform:translateY(0) scale(1)}:deep(.stats-grid){opacity:0;transform:translateY(10px) scale(.98);transition:opacity .3s cubic-bezier(.34,1.56,.64,1),transform .3s cubic-bezier(.34,1.56,.64,1)}.animate-in :deep(.stats-grid){opacity:1;transform:translateY(0) scale(1);transition-delay:.1s}:deep(.stat-card){opacity:0;transform:scale(.9) translateY(10px);transition:opacity .3s cubic-bezier(.34,1.56,.64,1),transform .3s cubic-bezier(.34,1.56,.64,1),box-shadow .3s,background-color .3s;position:relative;overflow:hidden}:deep(.stat-card):before{content:"";position:absolute;top:0;left:0;width:100%;height:4px;background:var(--gradient-secondary);opacity:0;transition:opacity .3s ease}:deep(.stat-card:hover):before{opacity:1}.animate-in :deep(.stat-card){opacity:1;transform:scale(1) translateY(0)}.animate-in :deep(.stat-card:nth-child(1)){transition-delay:.15s}.animate-in :deep(.stat-card:nth-child(2)){transition-delay:.2s}.animate-in :deep(.stat-card:nth-child(3)){transition-delay:.25s}.animate-in :deep(.stat-card:nth-child(4)){transition-delay:.3s}.animate-in :deep(.stat-card:nth-child(5)){transition-delay:.35s}.animate-in :deep(.stat-card:nth-child(6)){transition-delay:.4s}.animate-in :deep(.stat-card:nth-child(7)){transition-delay:.45s}.animate-in :deep(.stat-card:nth-child(8)){transition-delay:.5s}:deep(.log-entry){opacity:0;transform:translate(-10px) scale(.98);transition:opacity .3s cubic-bezier(.34,1.56,.64,1),transform .3s cubic-bezier(.34,1.56,.64,1);position:relative;overflow:hidden}:deep(.log-entry):after{content:"";position:absolute;top:0;left:0;width:100%;height:100%;background:linear-gradient(90deg,transparent,rgba(255,255,255,.05),transparent);transform:translate(-100%);transition:transform .6s ease}:deep(.log-entry:hover):after{transform:translate(100%)}.animate-in :deep(.log-entry){opacity:1;transform:translate(0) scale(1)}.animate-in :deep(.log-entry:nth-child(1)){transition-delay:.15s}.animate-in :deep(.log-entry:nth-child(2)){transition-delay:.2s}.animate-in :deep(.log-entry:nth-child(3)){transition-delay:.25s}.animate-in :deep(.log-entry:nth-child(4)){transition-delay:.3s}.animate-in :deep(.log-entry:nth-child(5)){transition-delay:.35s}.animate-in :deep(.log-entry:nth-child(n+6)){transition-delay:.4s}@keyframes flyIn{0%{opacity:0;transform:translateY(30px) scale(.9)}50%{opacity:.5;transform:translateY(15px) scale(.95)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes flyInFromLeft{0%{opacity:0;transform:translate(-20px) scale(.9)}50%{opacity:.5;transform:translate(-10px) scale(.95)}to{opacity:1;transform:translate(0) scale(1)}}@keyframes flyInFromRight{0%{opacity:0;transform:translate(20px) scale(.9)}50%{opacity:.5;transform:translate(10px) scale(.95)}to{opacity:1;transform:translate(0) scale(1)}}.header-container.animate-in,.section-animate.animate-in{animation:flyIn .5s cubic-bezier(.34,1.56,.64,1) forwards}.animate-in :deep(.stat-card:nth-child(odd)){animation:flyInFromLeft .4s cubic-bezier(.34,1.56,.64,1) forwards}.animate-in :deep(.stat-card:nth-child(even)){animation:flyInFromRight .4s cubic-bezier(.34,1.56,.64,1) forwards}.animate-in :deep(.log-entry){animation:flyInFromLeft .3s cubic-bezier(.34,1.56,.64,1) forwards}.refresh-button.animate-in{animation:flyIn .5s cubic-bezier(.34,1.56,.64,1) forwards}.password-dialog{position:fixed;top:0;left:0;right:0;bottom:0;background-color:#00000080;display:flex;align-items:flex-start;justify-content:center;z-index:1000;padding-top:100px;-webkit-backdrop-filter:blur(5px);backdrop-filter:blur(5px)}.password-dialog-content{background-color:var(--card-background);border-radius:var(--radius-xl);padding:25px;width:90%;max-width:400px;box-shadow:var(--shadow-xl);position:relative;overflow:hidden}.password-dialog-content:before{content:"";position:absolute;top:0;left:0;width:100%;height:5px;background:var(--gradient-primary)}.password-dialog-content h3{margin-top:0;margin-bottom:10px;color:var(--color-heading);font-size:1.3rem}.password-dialog-content p{margin-bottom:15px;color:var(--color-text);font-size:14px}.password-input-container{margin-bottom:20px;position:relative}.password-input{width:100%;padding:12px 16px;border:1px solid var(--color-border);border-radius:var(--radius-md);background-color:var(--color-background);color:var(--color-text);font-size:14px;transition:all .3s ease}.password-input:focus{outline:none;border-color:var(--button-primary);box-shadow:0 0 0 3px #4f46e533}.password-error{color:#ef4444;font-size:12px;margin-top:8px;padding-left:5px}.password-actions{display:flex;justify-content:flex-end;gap:10px}.cancel-btn,.confirm-btn{padding:10px 18px;border-radius:var(--radius-md);font-size:14px;cursor:pointer;transition:all .2s}.cancel-btn{background-color:var(--button-secondary);border:1px solid var(--color-border);color:var(--button-secondary-text)}.confirm-btn{background:var(--gradient-primary);border:none;color:#fff;box-shadow:var(--shadow-sm)}.cancel-btn:hover{background-color:var(--button-secondary-hover);transform:translateY(-2px)}.confirm-btn:hover{transform:translateY(-2px);box-shadow:var(--shadow-md)}@media (max-width: 768px){.password-dialog{padding-top:80px}.password-dialog-content{padding:20px}}@media (max-width: 480px){.password-dialog{padding-top:60px}.password-dialog-content{padding:15px}.password-dialog-content h3{font-size:1.1rem}.password-dialog-content p{font-size:12px}.password-input{font-size:12px;padding:10px 14px}.cancel-btn,.confirm-btn{padding:8px 14px;font-size:12px}}

app/templates/assets/aafbaf642c01961ff24ddb8941d1bf59.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HAJIMI</title>
+    <script type="module" crossorigin src="/main.js"></script>
+    <link rel="stylesheet" crossorigin href="/index.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

app/templates/index.html

@@ -0,0 +1,15 @@
+
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/assets/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini API 代理服务</title>
+    <script type="module" crossorigin src="/assets/0506c607efda914c9388132c9cbb0c53.js"></script>
+    <link rel="stylesheet" href="/assets/9a4f356975f1a7b8b7bad9e93c1becba.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

app/utils/__init__.py

@@ -0,0 +1,12 @@
+# Utils package initialization
+
+from app.utils.logging import logger, log_manager, format_log_message,log
+from app.utils.api_key import APIKeyManager, test_api_key
+from app.utils.error_handling import handle_gemini_error, translate_error, handle_api_error
+from app.utils.rate_limiting import protect_from_abuse
+from app.utils.cache import ResponseCacheManager, generate_cache_key
+from app.utils.request import ActiveRequestsManager
+from app.utils.stats import clean_expired_stats, update_api_call_stats
+from app.utils.version import check_version
+from app.utils.maintenance import handle_exception, schedule_cache_cleanup
+from app.utils.response import openAI_from_text

app/utils/api_key.py

@@ -0,0 +1,87 @@
+import random
+import re
+import os
+import logging
+import asyncio
+from datetime import datetime, timedelta
+from apscheduler.schedulers.background import BackgroundScheduler
+from app.utils.logging import format_log_message
+import app.config.settings as settings
+logger = logging.getLogger("my_logger")
+
+class APIKeyManager:
+    def __init__(self):
+        self.api_keys = re.findall(
+            r"AIzaSy[a-zA-Z0-9_-]{33}", settings.GEMINI_API_KEYS)
+        # 加载更多 GEMINI_API_KEYS
+        for i in range(1, 99):
+            if keys := os.environ.get(f"GEMINI_API_KEYS_{i}", ""):
+                self.api_keys += re.findall(r"AIzaSy[a-zA-Z0-9_-]{33}", keys)
+            else:
+                break
+
+        self.key_stack = [] # 初始化密钥栈
+        self._reset_key_stack() # 初始化时创建随机密钥栈
+        self.scheduler = BackgroundScheduler()
+        self.scheduler.start()
+        self.lock = asyncio.Lock() # Added lock
+
+    def _reset_key_stack(self):
+        """创建并随机化密钥栈"""
+        shuffled_keys = self.api_keys[:]  # 创建 api_keys 的副本以避免直接修改原列表
+        random.shuffle(shuffled_keys)
+        self.key_stack = shuffled_keys
+
+    async def get_available_key(self):
+        """从栈顶获取密钥，若栈空则重新生成
+        
+        实现负载均衡：
+        1. 维护一个随机排序的栈存储apikey
+        2. 每次调用从栈顶取出一个key返回
+        3. 栈空时重新随机生成栈
+        4. 确保异步和并发安全
+        """
+        async with self.lock:
+            # 如果栈为空，重新生成
+            if not self.key_stack:
+                self._reset_key_stack()
+            
+            # 从栈顶取出key
+            if self.key_stack:
+                return self.key_stack.pop()
+            
+            # 如果没有可用的API密钥，记录错误
+            if not self.api_keys:
+                log_msg = format_log_message('ERROR', "没有配置任何 API 密钥！")
+                logger.error(log_msg)
+            log_msg = format_log_message('ERROR', "没有可用的API密钥！")
+            logger.error(log_msg)
+            return None
+
+    def show_all_keys(self):
+        log_msg = format_log_message('INFO', f"当前可用API key个数: {len(self.api_keys)} ")
+        logger.info(log_msg)
+        for i, api_key in enumerate(self.api_keys):
+            log_msg = format_log_message('INFO', f"API Key{i}: {api_key[:8]}...{api_key[-3:]}")
+            logger.info(log_msg)
+
+    # def blacklist_key(self, key):
+    #     log_msg = format_log_message('WARNING', f"{key[:8]} → 暂时禁用 {self.api_key_blacklist_duration} 秒")
+    #     logger.warning(log_msg)
+    #     self.api_key_blacklist.add(key)
+    #     self.scheduler.add_job(lambda: self.api_key_blacklist.discard(key), 'date',
+    #                            run_date=datetime.now() + timedelta(seconds=self.api_key_blacklist_duration))
+
+async def test_api_key(api_key: str) -> bool:
+    """
+    测试 API 密钥是否有效。
+    """
+    try:
+        import httpx
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return True
+    except Exception:
+        return False

app/utils/auth.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from fastapi import HTTPException, Header, Query
+import app.config.settings as settings
+
+# 自定义密码校验依赖函数
+async def custom_verify_password(
+    authorization: Optional[str] = Header(None, description="OpenAI 格式请求 Key, 格式: Bearer sk-xxxx"),
+    x_goog_api_key: Optional[str] = Header(None, description="Gemini 格式请求 Key, 从请求头 x-goog-api-key 获取"),
+    key: Optional[str] = Query(None, description="Gemini 格式请求 Key, 从查询参数 key 获取"),
+    alt: Optional[str] = None
+):
+    """
+@@ -15,22 +18,79 @@
+    2. 根据类型，与项目配置的密钥进行比对。
+    3. 如果 Key 无效、缺失或不匹配，则抛出 HTTPException。
+    """
+    client_provided_api_key: Optional[str] = None
+
+    # 提取客户端提供的 Key 
+    if x_goog_api_key: 
+        client_provided_api_key = x_goog_api_key
+    elif key:
+        client_provided_api_key = key
+    elif authorization and authorization.startswith("Bearer "): 
+        token = authorization.split(" ", 1)[1]
+        client_provided_api_key = token
+
+    # 进行校验和比对
+    if (not client_provided_api_key) or (client_provided_api_key != settings.PASSWORD) :
+            raise HTTPException(
+                status_code=401, detail="Unauthorized: Invalid token")
+
+def verify_web_password(password:str):
+    if password != settings.WEB_PASSWORD:
+        return False
+    return True

app/utils/cache.py

@@ -0,0 +1,291 @@
+import time
+import xxhash 
+import asyncio
+from typing import Dict, Any, Optional, Tuple
+import logging
+from collections import deque
+from app.utils.logging import log
+logger = logging.getLogger("my_logger")
+import heapq
+
+# 定义缓存项的结构
+CacheItem = Dict[str, Any]
+
+class ResponseCacheManager:
+    """管理API响应缓存的类，一个键可以对应多个缓存项（使用deque）"""
+    
+    def __init__(self, expiry_time: int, max_entries: int, 
+                 cache_dict: Dict[str, deque[CacheItem]] = None):
+        """
+        初始化缓存管理器。
+        
+        Args:
+            expiry_time (int): 缓存项的过期时间（秒）。
+            max_entries (int): 缓存中允许的最大总条目数。
+            cache_dict (Dict[str, deque[CacheItem]], optional): 初始缓存字典。默认为 None。
+        """
+        self.cache: Dict[str, deque[CacheItem]] = cache_dict if cache_dict is not None else {}
+        self.expiry_time = expiry_time
+        self.max_entries = max_entries # 总条目数限制
+        self.cur_cache_num = 0 # 当前条目数
+        self.lock = asyncio.Lock() # Added lock
+
+    async def get(self, cache_key: str) -> Tuple[Optional[Any], bool]: # Made async
+        """获取指定键的第一个有效缓存项（不删除）"""
+        now = time.time()
+        async with self.lock:
+            if cache_key in self.cache:
+                cache_deque = self.cache[cache_key]
+                # 查找第一个未过期的项，且不删除
+                for item in cache_deque:
+                    if now < item.get('expiry_time', 0):
+                        response = item.get('response',None)
+                        return response, True
+            
+            return None, False
+
+    async def get_and_remove(self, cache_key: str) -> Tuple[Optional[Any], bool]:
+        """获取并删除指定键的第一个有效缓存项。"""
+        now = time.time()
+        async with self.lock:
+            if cache_key in self.cache:
+                cache_deque = self.cache[cache_key]
+
+                # 查找第一个有效项并收集过期项
+                valid_item_to_remove = None
+                response_to_return = None
+                new_deque = deque()
+                items_removed_count = 0
+
+                for item in cache_deque:
+                    if now < item.get('expiry_time', 0):
+                        if valid_item_to_remove is None: # 找到第一个有效项
+                            valid_item_to_remove = item
+                            response_to_return = item.get('response', None)
+                            items_removed_count += 1 # 计数此项为移除
+                            
+                        else:
+                            new_deque.append(item) # 保留后续有效项
+                    else:
+                        items_removed_count += 1 # 计数过期项为移除
+
+                # 更新缓存状态
+                if items_removed_count > 0:
+                    self.cur_cache_num = max(0, self.cur_cache_num - items_removed_count)
+                    if not new_deque:
+                        # 如果所有项都被移除（过期或我们取的那个）
+                        del self.cache[cache_key]
+                    else:
+                        self.cache[cache_key] = new_deque
+
+                if valid_item_to_remove:
+                    return response_to_return, True # 返回找到的有效项
+
+            # 如果键不存在或未找到有效项
+            return None, False
+
+    async def store(self, cache_key: str, response: Any):
+        """存储响应到缓存（追加到键对应的deque）"""
+        now = time.time()
+        new_item: CacheItem = {
+            'response': response,
+            'expiry_time': now + self.expiry_time,
+            'created_at': now,
+        }
+
+        needs_cleaning = False
+        async with self.lock:
+            if cache_key not in self.cache:
+                self.cache[cache_key] = deque()
+            
+            self.cache[cache_key].append(new_item) # 追加到deque末尾
+            self.cur_cache_num += 1
+            needs_cleaning = self.cur_cache_num > self.max_entries
+
+        if needs_cleaning:
+             # 在锁外调用清理，避免长时间持有锁
+             await self.clean_if_needed()
+
+    async def clean_expired(self):
+        """清理所有缓存项中已过期的项。"""
+        now = time.time()
+        keys_to_remove = []
+        total_cleaned = 0
+        async with self.lock:
+            # 迭代 cache 的副本以允许在循环中安全地修改 cache
+            for key, cache_deque in list(self.cache.items()):
+                original_len = len(cache_deque)
+                # 创建一个新的 deque，只包含未过期的项
+                valid_items = deque(item for item in cache_deque if now < item.get('expiry_time', 0))
+                cleaned_count = original_len - len(valid_items)
+
+                if cleaned_count > 0:
+                    log('info', f"清理键 {key[:8]}... 的过期缓存项 {cleaned_count} 个。")
+                    total_cleaned += cleaned_count
+
+                if not valid_items:
+                    keys_to_remove.append(key) # 标记此键以便稍后删除
+                    # 在持有锁时直接删除键
+                    if key in self.cache:
+                         del self.cache[key]
+                         log('info', f"缓存键 {key[:8]}... 的所有项均已过期，移除该键。")
+                elif cleaned_count > 0:
+                    # 替换为只包含有效项的 deque
+                    self.cache[key] = valid_items
+
+            # 统一更新缓存计数
+            if total_cleaned > 0:
+                 self.cur_cache_num = max(0, self.cur_cache_num - total_cleaned)
+
+    async def clean_if_needed(self):
+        """如果缓存总条目数超过限制，清理全局最旧的项目。"""
+
+        async with self.lock: 
+            if self.cur_cache_num <= self.max_entries:
+                return
+
+            # 计算目标大小和需要移除的数量
+            target_size = max(self.max_entries - 10, 10)
+            if self.cur_cache_num <= target_size:
+                return
+
+            items_to_remove_count = self.cur_cache_num - target_size
+            log('info', f"缓存总数 {self.cur_cache_num} 超过限制 {self.max_entries}，需要清理 {items_to_remove_count} 个")
+
+            # 收集所有缓存项及其元数据
+            all_items_meta = []
+            for key, cache_deque in self.cache.items():
+                for item in cache_deque:
+                    all_items_meta.append({'key': key, 'created_at': item.get('created_at', 0), 'item': item})
+
+            # 找出最旧的 N 项
+            actual_remove_count = min(items_to_remove_count, len(all_items_meta))
+            if actual_remove_count <= 0:
+                return # 没有项目可移除或无需移除
+
+            items_to_remove = heapq.nsmallest(actual_remove_count, all_items_meta, key=lambda x: x['created_at'])
+
+            # 执行移除
+            items_actually_removed = 0
+            keys_potentially_empty = set()
+            for item_meta in items_to_remove:
+                key_to_clean = item_meta['key']
+                item_to_clean = item_meta['item']
+
+                if key_to_clean in self.cache:
+                    try:
+                        # 直接从 deque 中移除指定的 item 对象
+                        self.cache[key_to_clean].remove(item_to_clean)
+                        items_actually_removed += 1
+                        # 计数器在最后统一更新
+                        log('info', f"因容量限制，删除键 {key_to_clean[:8]}... 的旧缓存项 (创建于 {item_meta['created_at']})。")
+                        keys_potentially_empty.add(key_to_clean)
+                    except (KeyError, ValueError):
+                        log('warning', f"尝试因容量限制删除缓存项时未找到 (可能已被提前移除): {key_to_clean[:8]}...")
+                        pass
+
+            # 检查是否有 deque 因本次清理变空
+            for key in keys_potentially_empty:
+                 if key in self.cache and not self.cache[key]:
+                     del self.cache[key]
+                     log('info', f"因容量限制清理后，键 {key[:8]}... 的deque已空，移除该键。")
+
+            # 统一更新缓存计数
+            if items_actually_removed > 0:
+                 self.cur_cache_num = max(0, self.cur_cache_num - items_actually_removed)
+                 log('info', f"因容量限制，共清理了 {items_actually_removed} 个旧缓存项。清理后缓存数: {self.cur_cache_num}")
+
+def generate_cache_key(chat_request, last_n_messages: int = 65536, is_gemini=False) -> str:
+    """
+    根据模型名称和最后 N 条消息生成请求的唯一缓存键。
+    Args:
+        chat_request: 包含模型和消息列表的请求对象 (符合OpenAI格式)。
+        last_n_messages: 需要包含在缓存键计算中的最后消息的数量。
+    Returns:
+        一个代表该请求的唯一缓存键字符串 (xxhash64哈希值)。
+    """
+    h = xxhash.xxh64()
+    
+    # 1. 哈希模型名称
+    h.update(chat_request.model.encode('utf-8'))
+
+    if last_n_messages <= 0:
+        # 如果不考虑消息，直接返回基于模型的哈希
+        return h.hexdigest()
+
+    messages_processed = 0
+    
+    # 2. 增量哈希最后 N 条消息 (从后往前)
+    if is_gemini:    
+        # log('INFO', f"开启增量哈希gemini格式内容")
+        for content_item in reversed(chat_request.payload.contents):
+            if messages_processed >= last_n_messages:
+                break
+            role = content_item.get('role')
+            if role is not None and isinstance(role, str):
+                h.update(b'role:')
+                h.update(role.encode('utf-8'))
+            # log('INFO', f"哈希gemini格式角��{role}")
+            parts = content_item.get('parts', [])
+            if not isinstance(parts, list):
+                parts = []
+            for part in parts:
+                text_content = part.get('text')
+                if text_content is not None and isinstance(text_content, str):
+                    h.update(b'text:')
+                    h.update(text_content.encode('utf-8'))
+                    # log('INFO', f"哈希gemini格式文本内容{text_content}")
+                
+                inline_data_obj = part.get('inline_data')
+                if inline_data_obj is not None and isinstance(inline_data_obj, dict):
+                    h.update(b'inline_data:')
+                    data_payload = inline_data_obj.get('data', '')
+                    # log('INFO', f"哈希gemini格式非文本内容{data_payload[:32]}")
+                    if isinstance(data_payload, str):
+                        h.update(b'data_prefix:')
+                        h.update(data_payload[:32].encode('utf-8'))
+
+                file_data_obj = part.get('file_data')
+                if file_data_obj is not None and isinstance(file_data_obj, dict):
+                    h.update(b'file_data:')
+                    file_uri = file_data_obj.get('file_uri', '')
+                    if isinstance(file_uri, str):
+                        h.update(b'file_uri:')
+                        h.update(file_uri.encode('utf-8'))
+            messages_processed += 1
+    
+    else :
+        for msg in reversed(chat_request.messages):
+            if messages_processed >= last_n_messages:
+                break
+
+            # 哈希角色
+            h.update(b'role:')
+            h.update(msg.get('role', '').encode('utf-8'))
+
+            # 哈希内容
+            content = msg.get('content')
+            if isinstance(content, str):
+                h.update(b'text:')
+                h.update(content.encode('utf-8'))
+            elif isinstance(content, list):
+                # 处理图文混合内容
+                for item in content:
+                    item_type = item.get('type') if hasattr(item, 'get') else None
+                    if item_type == 'text':
+                        text = item.get('text', '') if hasattr(item, 'get') else ''
+                        h.update(b'text:') 
+                        h.update(text.encode('utf-8'))
+                    elif item_type == 'image_url':
+                        image_url = item.get('image_url', {}) if hasattr(item, 'get') else {}
+                        image_data = image_url.get('url', '') if hasattr(image_url, 'get') else ''
+                        
+                        h.update(b'image_url:') # 加入类型标识符
+                        if image_data.startswith('data:image/'):
+                            # 对于base64图像，使用前32字符作为标识符
+                            h.update(image_data[:32].encode('utf-8'))
+                        else:
+                            h.update(image_data.encode('utf-8'))
+
+            messages_processed += 1
+    return h.hexdigest()

app/utils/error_handling.py

@@ -0,0 +1,136 @@
+import requests
+import httpx # 添加 httpx 导入
+import logging
+import asyncio
+from fastapi import HTTPException, status
+from app.utils.logging import format_log_message
+from app.utils.logging import log
+
+logger = logging.getLogger("my_logger")
+
+def handle_gemini_error(error, current_api_key) -> str:
+    # 同时检查 requests 和 httpx 的 HTTPError
+    if isinstance(error, (requests.exceptions.HTTPError, httpx.HTTPStatusError)): 
+        status_code = error.response.status_code
+        if status_code == 400:
+            try:
+                error_data = error.response.json()
+                if 'error' in error_data:
+                    if error_data['error'].get('code') == "invalid_argument":
+                        error_message = "无效的 API 密钥"
+                        log('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 无效，可能已过期或被删除", 
+                            extra={'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message})
+                        # key_manager.blacklist_key(current_api_key)
+                        
+                        return error_message
+                    error_message = error_data['error'].get('message', 'Bad Request')
+                    
+                    log('WARNING', f"400 错误请求: {error_message}", 
+                        extra={'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message})
+                    return f"400 错误请求: {error_message}"
+            except ValueError:
+                error_message = "400 错误请求：响应不是有效的JSON格式"
+                extra_log_400_json = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                log('WARNING', error_message, extra=extra_log_400_json)
+                return error_message
+
+        elif status_code == 403:
+            error_message = f"权限被拒绝"
+            log('ERROR', error_message, 
+                extra={'key': current_api_key[:8], 'status_code': status_code})
+            # key_manager.blacklist_key(current_api_key)
+            
+            return error_message
+        
+        elif status_code == 429:
+            error_message = f"API 密钥配额已用尽或其他原因"
+            log('WARNING', error_message, 
+                extra={'key': current_api_key[:8], 'status_code': status_code})
+            # key_manager.blacklist_key(current_api_key)
+             
+            return error_message
+        
+        if status_code == 500:
+            error_message = f'Gemini API 内部错误' 
+            log('WARNING', error_message, 
+                extra={'key': current_api_key[:8], 'status_code': status_code})
+            return error_message
+  
+        if status_code == 503:
+            error_message = f"Gemini API 服务繁忙"
+            log('WARNING', error_message, 
+                extra={'key': current_api_key[:8], 'status_code': status_code})
+            return error_message
+        
+        else:
+            error_message = f"未知错误: {status_code}"
+            log('WARNING', f"{status_code} 未知错误", 
+                extra={'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message})
+            
+            return f"未知错误/模型不可用: {status_code}"
+
+    elif isinstance(error, requests.exceptions.ConnectionError):
+        error_message = "连接错误"
+        log('WARNING', error_message, extra={'error_message': error_message})
+        return error_message
+
+    elif isinstance(error, requests.exceptions.Timeout):
+        error_message = "请求超时"
+        log('WARNING', error_message, extra={'error_message': error_message})
+        return error_message
+    else:
+        error_message = f"发生未知错误: {error}"
+        log('ERROR', error_message, extra={'error_message': error_message})
+        return error_message
+
+def translate_error(message: str) -> str:
+    if "quota exceeded" in message.lower():
+        return "API 密钥配额已用尽"
+    if "invalid argument" in message.lower():
+        return "无效参数"
+    if "internal server error" in message.lower():
+        return "服务器内部错误"
+    if "service unavailable" in message.lower():
+        return "服务不可用"
+    return message
+
+async def handle_api_error(e: Exception, api_key: str, key_manager, request_type: str, model: str, retry_count: int = 0):
+    """统一处理API错误"""
+    
+    # 同时检查 requests 和 httpx 的 HTTPError
+    if isinstance(e, (requests.exceptions.HTTPError, httpx.HTTPStatusError)):
+        status_code = e.response.status_code
+        # 对500和503错误实现自动重试机制, 最多重试3次
+        if retry_count < 3 and (status_code == 500 or status_code == 503):
+            error_message = 'Gemini API 内部错误' if (status_code == 500) else "Gemini API 服务目前不可用"
+            
+            # 等待时间 : MIN_RETRY_DELAY=1, MAX_RETRY_DELAY=16
+            wait_time = min(1 * (2 ** retry_count), 16)  
+            log('warning', f"{error_message}，将等待{wait_time}秒后重试 ({retry_count+1}/3)", 
+                extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})
+            # 等待后返回重试信号
+            await asyncio.sleep(wait_time)
+            return {'remove_cache': False}        
+        
+        elif status_code == 429:
+            error_message = "API 密钥配额已用尽或其他原因"
+            log('WARNING', f"429 官方资源耗尽或其他原因", 
+                extra={'key': api_key[:8], 'status_code': status_code, 'error_message': error_message})
+            # key_manager.blacklist_key(api_key)
+                     
+            return {'remove_cache': False,'error': error_message, 'should_switch_key': True}             
+
+        else:
+            error_detail = handle_gemini_error(e, api_key)
+            
+            # # 重试次数用尽，在日志中输出错误状态码
+            # log('error', f"Gemini 服务器错误({status_code})", 
+            #     extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})        
+        
+            # 不再切换密钥，直接向客户端抛出HTTP异常
+            raise HTTPException(status_code=int(status_code),
+                          detail=f"Gemini API 服务器错误({status_code})，请稍后重试")
+    
+    # 对于其他错误，返回切换密钥的信号，并输出错误信息到日志中
+    error_detail = handle_gemini_error(e, api_key)
+    return {'should_switch_key': True, 'error': error_detail, 'remove_cache': True}

app/utils/logging.py

@@ -0,0 +1,148 @@
+import logging
+from datetime import datetime
+from collections import deque
+from threading import Lock
+
+DEBUG = False  # 可以从环境变量中获取
+
+LOG_FORMAT_DEBUG = '%(asctime)s - %(levelname)s - [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s - %(error_message)s'
+LOG_FORMAT_NORMAL = '[%(asctime)s] [%(levelname)s] [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s'
+
+# Vertex日志格式
+VERTEX_LOG_FORMAT_DEBUG = '%(asctime)s - %(levelname)s - [%(vertex_id)s]-%(operation)s-[%(status)s]: %(message)s - %(error_message)s'
+VERTEX_LOG_FORMAT_NORMAL = '[%(asctime)s] [%(levelname)s] [%(vertex_id)s]-%(operation)s-[%(status)s]: %(message)s'
+
+# 配置 logger
+logger = logging.getLogger("my_logger")
+logger.setLevel(logging.DEBUG)
+
+# 控制台处理器
+console_handler = logging.StreamHandler() 
+
+# 设置日志格式
+console_formatter = logging.Formatter('%(message)s')
+console_handler.setFormatter(console_formatter) 
+logger.addHandler(console_handler)
+
+# 日志缓存，用于在网页上显示最近的日志
+class LogManager:
+    def __init__(self, max_logs=100):
+        self.logs = deque(maxlen=max_logs)  # 使用双端队列存储最近的日志
+        self.lock = Lock()
+    
+    def add_log(self, log_entry):
+        with self.lock:
+            self.logs.append(log_entry)
+    
+    def get_recent_logs(self, count=50):
+        with self.lock:
+            return list(self.logs)[-count:]
+
+# 创建日志管理器实例 (输出到前端)
+log_manager = LogManager()
+
+# Vertex日志缓存，用于在网页上显示最近的Vertex日志
+class VertexLogManager:
+    def __init__(self, max_logs=100):
+        self.logs = deque(maxlen=max_logs)  # 使用双端队列存储最近的Vertex日志
+        self.lock = Lock()
+    
+    def add_log(self, log_entry):
+        with self.lock:
+            self.logs.append(log_entry)
+    
+    def get_recent_logs(self, count=50):
+        with self.lock:
+            return list(self.logs)[-count:]
+
+# 创建Vertex日志管理器实例 (输出到前端)
+vertex_log_manager = VertexLogManager()
+
+def format_log_message(level, message, extra=None):
+    extra = extra or {}
+    log_values = {
+        'asctime': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'levelname': level,
+        'key': extra.get('key', ''),
+        'request_type': extra.get('request_type', ''),
+        'model': extra.get('model', ''),
+        'status_code': extra.get('status_code', ''),
+        'error_message': extra.get('error_message', ''),
+        'message': message
+    }
+    log_format = LOG_FORMAT_DEBUG if DEBUG else LOG_FORMAT_NORMAL
+    formatted_log = log_format % log_values
+    
+    # 将格式化后的日志添加到日志管理器
+    log_entry = {
+        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'level': level,
+        'key': extra.get('key', ''),
+        'request_type': extra.get('request_type', ''),
+        'model': extra.get('model', ''),
+        'status_code': extra.get('status_code', ''),
+        'message': message,
+        'error_message': extra.get('error_message', ''),
+        'formatted': formatted_log
+    }
+    log_manager.add_log(log_entry)
+    
+    return formatted_log
+
+def vertex_format_log_message(level, message, extra=None):
+    extra = extra or {}
+    log_values = {
+        'asctime': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'levelname': level,
+        'vertex_id': extra.get('vertex_id', ''),
+        'operation': extra.get('operation', ''),
+        'status': extra.get('status', ''),
+        'error_message': extra.get('error_message', ''),
+        'message': message
+    }
+    log_format = VERTEX_LOG_FORMAT_DEBUG if DEBUG else VERTEX_LOG_FORMAT_NORMAL
+    formatted_log = log_format % log_values
+    
+    # 将格式化后的Vertex日志添加到Vertex日志管理器
+    log_entry = {
+        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'level': level,
+        'vertex_id': extra.get('vertex_id', ''),
+        'operation': extra.get('operation', ''),
+        'status': extra.get('status', ''),
+        'message': message,
+        'error_message': extra.get('error_message', ''),
+        'formatted': formatted_log
+    }
+    vertex_log_manager.add_log(log_entry)
+    
+    return formatted_log
+    
+    
+def log(level: str, message: str, extra: dict = None, **kwargs):
+    final_extra = {}
+    
+    if extra is not None and isinstance(extra, dict):
+        final_extra.update(extra)
+    
+    # 将 kwargs 中的其他关键字参数合并进来，kwargs 会覆盖 extra 中的同名键
+    final_extra.update(kwargs)
+    
+    # 调用 format_log_message，传递合并后的 final_extra 字典
+    msg = format_log_message(level.upper(), message, extra=final_extra)
+    
+    getattr(logger, level.lower())(msg)
+
+def vertex_log(level: str, message: str, extra: dict = None, **kwargs):
+    final_extra = {}
+    
+    if extra is not None and isinstance(extra, dict):
+        final_extra.update(extra)
+    
+    # 将 kwargs 中的其他关键字参数合并进来，kwargs 会覆盖 extra 中的同名键
+    final_extra.update(kwargs)
+    
+    # 调用 vertex_format_log_message，传递合并后的 final_extra 字典
+    msg = vertex_format_log_message(level.upper(), message, extra=final_extra)
+    
+    getattr(logger, level.lower())(msg)

app/utils/maintenance.py

@@ -0,0 +1,95 @@
+import sys,asyncio
+#from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.schedulers.asyncio import AsyncIOScheduler  # 替换为异步调度器
+from app.utils.logging import log
+from app.utils.stats import api_stats_manager
+from app.utils import check_version
+from zoneinfo import ZoneInfo
+from app.config import settings,persistence
+import copy  # 添加copy模块导入
+
+def handle_exception(exc_type, exc_value, exc_traceback):
+    """
+    全局异常处理函数
+    
+    处理未捕获的异常，并记录到日志中
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.excepthook(exc_type, exc_value, exc_traceback)
+        return
+    from app.utils.error_handling import translate_error
+    error_message = translate_error(str(exc_value))
+    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)
+
+
+def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
+    """
+    设置定期清理缓存和活跃请求的定时任务
+    顺便定时检查更新
+    Args:
+        response_cache_manager: 响应缓存管理器实例
+        active_requests_manager: 活跃请求管理器实例
+    """
+    beijing_tz = ZoneInfo("Asia/Shanghai")
+    scheduler = AsyncIOScheduler(timezone=beijing_tz)  # 使用 AsyncIOScheduler 替代 BackgroundScheduler
+    
+    # 添加任务时直接传递异步函数（无需额外包装）
+    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)
+    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)
+    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])
+    
+    # 使用同步包装器调用异步函数
+    def run_cleanup():
+        try:
+            # 创建新的事件循环而不是获取现有的
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
+            # 在这个新循环中运行清理操作
+            loop.run_until_complete(api_stats_manager.cleanup())
+        except Exception as e:
+            log('error', f"清理统计数据时出错: {str(e)}")
+        finally:
+            # 确保关闭循环以释放资源
+            loop.close()
+    
+    # 添加同步的清理任务
+    scheduler.add_job(run_cleanup, 'interval', minutes=5)
+    
+    # 同样修改定时重置函数
+    def run_reset():
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(api_call_stats_clean())
+        except Exception as e:
+            log('error', f"重置统计数据时出错: {str(e)}")
+        finally:
+            loop.close()
+    
+    scheduler.add_job(check_version, 'interval', hours=4)
+    scheduler.add_job(run_reset, 'cron', hour=15, minute=0)
+    scheduler.start()
+    return scheduler
+
+async def api_call_stats_clean():
+    """
+    每天定时重置API调用统计数据
+    
+    使用新的统计系统重置
+    """
+    from app.utils.logging import log
+    
+    try:
+        # 记录重置前的状态
+        log('info', "开始重置API调用统计数据")
+        
+        # 使用新的统计系统重置
+        await api_stats_manager.reset()
+        
+        log('info', "API调用统计数据已成功重置")
+        persistence.save_settings()
+            
+    except Exception as e:
+        log('error', f"重置API调用统计数据时发生错误: {str(e)}")
+        raise

app/utils/rate_limiting.py

@@ -0,0 +1,36 @@
+import time
+import asyncio
+from fastapi import HTTPException, Request
+
+rate_limit_data = {}
+rate_limit_lock = asyncio.Lock() 
+
+async def protect_from_abuse(request: Request, max_requests_per_minute: int = 30, max_requests_per_day_per_ip: int = 600):
+    now = int(time.time())
+    minute = now // 60
+    day = now // (60 * 60 * 24)
+
+    minute_key = f"{request.url.path}:{minute}"
+    day_key = f"{request.client.host}:{day}"
+
+    async with rate_limit_lock:
+        minute_count, minute_timestamp = rate_limit_data.get(minute_key, (0, now))
+        
+        if now - minute_timestamp >= 60:
+            minute_count = 0
+            minute_timestamp = now
+        minute_count += 1
+        rate_limit_data[minute_key] = (minute_count, minute_timestamp)
+
+        day_count, day_timestamp = rate_limit_data.get(day_key, (0, now))
+        if now - day_timestamp >= 86400:
+            day_count = 0
+            day_timestamp = now
+        day_count += 1
+        rate_limit_data[day_key] = (day_count, day_timestamp)
+
+    if minute_count > max_requests_per_minute:
+        raise HTTPException(status_code=429, detail={
+            "message": "Too many requests per minute", "limit": max_requests_per_minute})
+    if day_count > max_requests_per_day_per_ip:
+        raise HTTPException(status_code=429, detail={"message": "Too many requests per day from this IP", "limit": max_requests_per_day_per_ip})

app/utils/request.py

@@ -0,0 +1,52 @@
+import asyncio
+import time
+from typing import Dict, Any
+from app.utils.logging import log
+
+class ActiveRequestsManager:
+    """管理活跃API请求的类"""
+    
+    def __init__(self, requests_pool: Dict[str, asyncio.Task] = None):
+        self.active_requests = requests_pool if requests_pool is not None else {}  # 存储活跃请求
+    
+    def add(self, key: str, task: asyncio.Task):
+        """添加新的活跃请求任务"""
+        task.creation_time = time.time()  # 添加创建时间属性
+        self.active_requests[key] = task
+    
+    def get(self, key: str):
+        """获取活跃请求任务"""
+        return self.active_requests.get(key)
+    
+    def remove(self, key: str):
+        """移除活跃请求任务"""
+        if key in self.active_requests:
+            del self.active_requests[key]
+            return True
+        return False
+    
+    def clean_completed(self):
+        """清理所有已完成或已取消的任务"""
+        
+        for key, task in self.active_requests.items():
+            if task.done() or task.cancelled():
+                del self.active_requests[key]        
+        
+        # if keys_to_remove:
+        #    log('info', f"清理已完成请求任务: {len(keys_to_remove)}个", cleanup='active_requests')
+    
+    def clean_long_running(self, max_age_seconds: int = 300):
+        """清理长时间运行的任务"""
+        now = time.time()
+        long_running_keys = []
+        
+        for key, task in list(self.active_requests.items()):
+            if (hasattr(task, 'creation_time') and
+                task.creation_time < now - max_age_seconds and
+                not task.done() and not task.cancelled()):
+                
+                long_running_keys.append(key)
+                task.cancel()  # 取消长时间运行的任务
+        
+        if long_running_keys:
+            log('warning', f"取消长时间运行的任务: {len(long_running_keys)}个", cleanup='long_running_tasks')

app/utils/response.py

@@ -0,0 +1,130 @@
+import json
+import time
+from app.utils.logging import log
+
+def openAI_from_text(model="gemini",content=None,finish_reason=None,total_token_count=0,stream=True):
+    """
+    根据传入参数，创建 OpenAI 标准响应对象块
+    """
+    
+    now_time = int(time.time())
+    content_chunk = {}
+    formatted_chunk = {
+        "id": f"chatcmpl-{now_time}",
+        "created": now_time,
+        "model": model,
+        "choices": [{"index": 0 , "finish_reason": finish_reason}] 
+    }
+    
+    if content:
+        content_chunk = {"role": "assistant", "content": content}
+    
+    if finish_reason:
+        formatted_chunk["usage"]= {"total_tokens": total_token_count}
+    
+    if stream:
+        formatted_chunk["choices"][0]["delta"] = content_chunk
+        formatted_chunk["object"] = "chat.completion.chunk"
+        return f"data: {json.dumps(formatted_chunk, ensure_ascii=False)}\n\n"
+    else:
+        formatted_chunk["choices"][0]["message"] = content_chunk
+        formatted_chunk["object"] = "chat.completion"
+        return formatted_chunk
+
+def gemini_from_text(content=None, finish_reason=None, total_token_count=0, stream=True): 
+    """
+    根据传入参数，创建 Gemini API 标准响应对象块 (GenerateContentResponse 格式)。
+    """
+    gemini_response = {
+        "candidates": {
+            "index": 0,
+            "content": {
+                "parts": [],
+                "role": "model"
+            }
+        }
+    }
+    if content:
+        gemini_response["candidates"]["content"]["parts"].append({"text": content})
+    
+    if finish_reason:
+        gemini_response["usageMetadata"]= {"totalTokenCount": total_token_count}
+    
+    if stream:
+        return f"data: {json.dumps(gemini_response, ensure_ascii=False)}\n\n"
+    else:
+        return gemini_response
+
+
+def openAI_from_Gemini(response,stream=True):
+    """
+    根据 GeminiResponseWrapper 对象创建 OpenAI 标准响应对象块。
+
+    Args:
+        response: GeminiResponseWrapper 对象，包含响应数据。
+
+    Returns:
+        OpenAI 标准响应
+    """
+    now_time = int(time.time())
+    chunk_id = f"chatcmpl-{now_time}" # 使用时间戳生成唯一 ID 
+    content_chunk = {}
+    formatted_chunk = {
+        "id": chunk_id,
+        "created": now_time,
+        "model": response.model,
+        "choices": [{"index": 0 , "finish_reason": response.finish_reason}] 
+    }
+
+    # 准备 usage 数据，处理属性缺失或为 None 的情况
+    prompt_tokens_raw = getattr(response, 'prompt_token_count', None)
+    candidates_tokens_raw = getattr(response, 'candidates_token_count', None)
+    total_tokens_raw = getattr(response, 'total_token_count', None)
+
+    usage_data = {
+        "prompt_tokens": int(prompt_tokens_raw) if prompt_tokens_raw else 0,
+        "completion_tokens": int(candidates_tokens_raw) if candidates_tokens_raw else 0,
+        "total_tokens": int(total_tokens_raw) if total_tokens_raw else 0
+    }
+
+    if response.function_call:
+        tool_calls=[]
+        # 处理函数调用的每一部分
+        for part in response.function_call:
+            function_name = part.get("name")
+            # Gemini 的 args 是 dict, OpenAI 需要 string
+            function_args_str = json.dumps(part.get("args", {}), ensure_ascii=False)
+            
+            tool_call_id = f"call_{function_name}" # 编码函数名到 ID
+            tool_calls.append({
+                "id": tool_call_id,
+                "type": "function",
+                "function": {
+                    "name": function_name,
+                    "arguments": function_args_str,
+                }
+            })
+        
+        content_chunk = {
+            "role": "assistant",
+            "content": None, # 函数调用时 content 为 null
+            "tool_calls": tool_calls
+        }
+    elif response.text:
+        # 处理普通文本响应
+        content_chunk = {"role": "assistant", "content": response.text}
+    
+    if stream:
+        formatted_chunk["choices"][0]["delta"] = content_chunk
+        formatted_chunk["object"] = "chat.completion.chunk"
+        # 仅在流结束时添加 usage 字段
+        if response.finish_reason:
+            formatted_chunk["usage"] = usage_data
+        return f"data: {json.dumps(formatted_chunk, ensure_ascii=False)}\n\n"
+    
+    else:
+        formatted_chunk["choices"][0]["message"] = content_chunk
+        formatted_chunk["object"] = "chat.completion"
+        # 非流式响应总是包含 usage 字段，以满足 response_model 验证
+        formatted_chunk["usage"] = usage_data
+        return formatted_chunk

app/utils/stats.py

@@ -0,0 +1,299 @@
+import asyncio 
+from datetime import datetime, timedelta
+from app.utils.logging import log
+import app.config.settings as settings
+from collections import defaultdict, Counter
+import time
+import threading
+import queue
+import functools
+
+class ApiStatsManager:
+    """API调用统计管理器，优化性能的新实现"""
+    
+    def __init__(self, enable_background=True, batch_interval=1.0):
+        # 使用Counter记录API密钥和模型的调用次数
+        self.api_key_counts = Counter()  # 记录每个API密钥的调用次数
+        self.model_counts = Counter()    # 记录每个模型的调用次数
+        self.api_model_counts = defaultdict(Counter)  # 记录每个API密钥对每个模型的调用次数
+        
+        # 记录token使用量
+        self.api_key_tokens = Counter()  # 记录每个API密钥的token使用量
+        self.model_tokens = Counter()    # 记录每个模型的token使用量
+        self.api_model_tokens = defaultdict(Counter)  # 记录每个API密钥对每个模型的token使用量
+        
+        # 用于时间序列分析的数据结构（最近24小时，按分钟分组）
+        self.time_buckets = {}  # 格式: {timestamp_minute: {"calls": count, "tokens": count}}
+        
+        # 保存与兼容格式相关的调用日志（最小化存储）
+        self.recent_calls = []  # 仅保存最近的少量调用，用于前端展示
+        self.max_recent_calls = 100  # 最大保存的最近调用记录数
+        
+        # 当前时间分钟桶的时间戳（分钟级别）
+        self.current_minute = self._get_minute_timestamp(datetime.now())
+        
+        # 清理间隔（小时）
+        self.cleanup_interval = 1
+        self.last_cleanup = time.time()
+        
+        # 使用线程锁而不是asyncio锁
+        self._counters_lock = threading.Lock()
+        self._time_series_lock = threading.Lock()
+        self._recent_calls_lock = threading.Lock()
+        
+        # 后台处理相关
+        self.enable_background = enable_background
+        self.batch_interval = batch_interval
+        self._update_queue = queue.Queue()
+        self._worker_thread = None
+        self._stop_event = threading.Event()
+        
+        if enable_background:
+            self._start_worker()
+    
+    def _start_worker(self):
+        """启动后台工作线程"""
+        if self._worker_thread is None or not self._worker_thread.is_alive():
+            self._stop_event.clear()
+            self._worker_thread = threading.Thread(
+                target=self._worker_loop,
+                daemon=True
+            )
+            self._worker_thread.start()
+    
+    def _worker_loop(self):
+        """后台工作线程的主循环"""
+        batch = []
+        last_process = time.time()
+        
+        while not self._stop_event.is_set():
+            try:
+                # 非阻塞获取更新
+                try:
+                    update = self._update_queue.get_nowait()
+                    batch.append(update)
+                except queue.Empty:
+                    pass
+                
+                # 处理批次或超时
+                current_time = time.time()
+                if batch and (current_time - last_process >= self.batch_interval):
+                    self._process_batch(batch)
+                    batch = []
+                    last_process = current_time
+                
+                # 短暂休眠以避免CPU占用过高
+                time.sleep(0.01)
+                
+            except Exception as e:
+                log('error', f"后台处理线程错误: {str(e)}")
+                time.sleep(1)  # 发生错误时短暂休眠
+    
+    def _process_batch(self, batch):
+        """处理一批更新"""
+        with self._counters_lock:
+            for api_key, model, tokens in batch:
+                self.api_key_counts[api_key] += 1
+                self.model_counts[model] += 1
+                self.api_model_counts[api_key][model] += 1
+                self.api_key_tokens[api_key] += tokens
+                self.model_tokens[model] += tokens
+                self.api_model_tokens[api_key][model] += tokens
+    
+    async def update_stats(self, api_key, model, tokens=0):
+        """更新API调用统计"""
+        if self.enable_background:
+            # 将更新放入队列
+            self._update_queue.put((api_key, model, tokens))
+        else:
+            # 同步更新
+            with self._counters_lock:
+                self.api_key_counts[api_key] += 1
+                self.model_counts[model] += 1
+                self.api_model_counts[api_key][model] += 1
+                self.api_key_tokens[api_key] += tokens
+                self.model_tokens[model] += tokens
+                self.api_model_tokens[api_key][model] += tokens
+        
+        # 更新时间序列数据
+        now = datetime.now()
+        minute_ts = self._get_minute_timestamp(now)
+        
+        with self._time_series_lock:
+            if minute_ts not in self.time_buckets:
+                self.time_buckets[minute_ts] = {"calls": 0, "tokens": 0}
+            
+            self.time_buckets[minute_ts]["calls"] += 1
+            self.time_buckets[minute_ts]["tokens"] += tokens
+            self.current_minute = minute_ts
+        
+        # 更新最近调用记录
+        with self._recent_calls_lock:
+            compact_call = {
+                'api_key': api_key,
+                'model': model,
+                'timestamp': now,
+                'tokens': tokens
+            }
+            
+            self.recent_calls.append(compact_call)
+            if len(self.recent_calls) > self.max_recent_calls:
+                self.recent_calls.pop(0)
+        
+        # 记录日志
+        log_message = f"API调用已记录: 秘钥 '{api_key[:8]}', 模型 '{model}', 令牌: {tokens if tokens is not None else 0}"
+        log('info', log_message)
+    
+    async def cleanup(self):
+        """清理超过24小时的时间桶数据"""
+        now = datetime.now()
+        day_ago_ts = self._get_minute_timestamp(now - timedelta(days=1))
+        
+        with self._time_series_lock:
+            # 直接删除旧的时间桶
+            for ts in list(self.time_buckets.keys()):
+                if ts < day_ago_ts:
+                    del self.time_buckets[ts]
+        
+        self.last_cleanup = time.time()
+    
+    async def maybe_cleanup(self, force=False):
+        """根据需要清理旧数据"""
+        now = time.time()
+        if force or (now - self.last_cleanup > self.cleanup_interval * 3600):
+            await self.cleanup()
+            self.last_cleanup = now
+    
+    async def get_api_key_usage(self, api_key, model=None):
+        """获取API密钥的使用统计"""
+        with self._counters_lock:
+            if model:
+                return self.api_model_counts[api_key][model]
+            else:
+                return self.api_key_counts[api_key]
+    
+    def get_calls_last_24h(self):
+        """获取过去24小时的总调用次数"""
+        with self._counters_lock:
+            return sum(self.api_key_counts.values())
+    
+    def get_calls_last_hour(self, now=None):
+        """获取过去一小时的总调用次数"""
+        if now is None:
+            now = datetime.now()
+        
+        hour_ago_ts = self._get_minute_timestamp(now - timedelta(hours=1))
+        
+        with self._time_series_lock:
+            return sum(data["calls"] for ts, data in self.time_buckets.items() 
+                      if ts >= hour_ago_ts)
+    
+    def get_calls_last_minute(self, now=None):
+        """获取过去一分钟的总调用次数"""
+        if now is None:
+            now = datetime.now()
+        
+        minute_ago_ts = self._get_minute_timestamp(now - timedelta(minutes=1))
+        
+        with self._time_series_lock:
+            return sum(data["calls"] for ts, data in self.time_buckets.items() 
+                      if ts >= minute_ago_ts)
+    
+    def get_time_series_data(self, minutes=30, now=None):
+        """获取过去N分钟的时间序列数据"""
+        if now is None:
+            now = datetime.now()
+        
+        calls_series = []
+        tokens_series = []
+        
+        with self._time_series_lock:
+            for i in range(minutes, -1, -1):
+                minute_dt = now - timedelta(minutes=i)
+                minute_ts = self._get_minute_timestamp(minute_dt)
+                
+                bucket = self.time_buckets.get(minute_ts, {"calls": 0, "tokens": 0})
+                
+                calls_series.append({
+                    'time': minute_dt.strftime('%H:%M'),
+                    'value': bucket["calls"]
+                })
+                
+                tokens_series.append({
+                    'time': minute_dt.strftime('%H:%M'),
+                    'value': bucket["tokens"]
+                })
+        
+        return calls_series, tokens_series
+    
+    def get_api_key_stats(self, api_keys):
+        """获取API密钥的详细统计信息"""
+        stats = []
+        
+        with self._counters_lock:
+            for api_key in api_keys:
+                api_key_id = api_key[:8]
+                calls_24h = self.api_key_counts[api_key]
+                total_tokens = self.api_key_tokens[api_key]
+                
+                model_stats = {}
+                for model, count in self.api_model_counts[api_key].items():
+                    tokens = self.api_model_tokens[api_key][model]
+                    model_stats[model] = {
+                        'calls': count,
+                        'tokens': tokens
+                    }
+                
+                usage_percent = (calls_24h / settings.API_KEY_DAILY_LIMIT) * 100 if settings.API_KEY_DAILY_LIMIT > 0 else 0
+                
+                stats.append({
+                    'api_key': api_key_id,
+                    'calls_24h': calls_24h,
+                    'total_tokens': total_tokens,
+                    'limit': settings.API_KEY_DAILY_LIMIT,
+                    'usage_percent': round(usage_percent, 2),
+                    'model_stats': model_stats
+                })
+        
+        stats.sort(key=lambda x: x['usage_percent'], reverse=True)
+        return stats
+    
+    async def reset(self):
+        """重置所有统计数据"""
+        with self._counters_lock:
+            self.api_key_counts.clear()
+            self.model_counts.clear()
+            self.api_model_counts.clear()
+            self.api_key_tokens.clear()
+            self.model_tokens.clear()
+            self.api_model_tokens.clear()
+        
+        with self._time_series_lock:
+            self.time_buckets.clear()
+        
+        with self._recent_calls_lock:
+            self.recent_calls.clear()
+        
+        self.current_minute = self._get_minute_timestamp(datetime.now())
+        self.last_cleanup = time.time()
+
+    def _get_minute_timestamp(self, dt):
+        """将时间戳转换为分钟级别的时间戳（按分钟取整）"""
+        return int(dt.timestamp() // 60 * 60)
+
+# 创建全局单例实例
+api_stats_manager = ApiStatsManager()
+
+# 兼容现有代码的函数
+def clean_expired_stats(api_call_stats):
+    """清理过期统计数据的函数 (兼容旧接口)"""
+    asyncio.create_task(api_stats_manager.cleanup())
+
+async def update_api_call_stats(api_call_stats, endpoint=None, model=None, token=None): 
+    """更新API调用统计的函数 (兼容旧接口)"""
+    if endpoint and model:
+        await api_stats_manager.update_stats(endpoint, model, token if token is not None else 0)
+
+async def get_api_key_usage(api_call_stats, api_key, model=None):
+    """获取API密钥的调用次数 (兼容旧接口)"""
+    return await api_stats_manager.get_api_key_usage(api_key, model) 

app/utils/version.py

@@ -0,0 +1,48 @@
+import requests
+from app.utils.logging import log
+import app.config.settings as settings
+async def check_version():
+    """
+    检查应用程序版本更新
+    
+    从本地和远程获取版本信息，并比较版本号以确定是否有更新
+    """
+    # 导入全局变量
+    try:
+        # 读取本地版本
+        with open("./version.txt", "r") as f:
+            version_line = f.read().strip()
+            settings.version['local_version'] = version_line.split("=")[1] if "=" in version_line else "0.0.0"
+        
+        # 获取远程版本
+        github_url = "https://raw.githubusercontent.com/wyeeeee/hajimi/refs/heads/main/version.txt"
+        response = requests.get(github_url, timeout=5)
+        if response.status_code == 200:
+            version_line = response.text.strip()
+            settings.version['remote_version']= version_line.split("=")[1] if "=" in version_line else "0.0.0"
+            # 比较版本号
+            local_parts = [int(x) for x in settings.version['local_version'].split(".")]
+            remote_parts = [int(x) for x in settings.version['remote_version'].split(".")]
+            
+            # 确保两个列表长度相同
+            while len(local_parts) < len(remote_parts):
+                local_parts.append(0)
+            while len(remote_parts) < len(local_parts):
+                remote_parts.append(0)
+                
+            # 比较版本号
+            settings.version['has_update'] = False
+            for i in range(len(local_parts)):
+                if remote_parts[i] > local_parts[i]:
+                    settings.version['has_update'] = True
+                    break
+                elif remote_parts[i] < local_parts[i]:
+                    break
+            
+            log('info', f"版本检查: 本地版本 {settings.version['local_version']}, 远程版本 {settings.version['remote_version']}, 有更新: {settings.version['has_update']}")
+        else:
+            log('warning', f"无法获取远程版本信息，HTTP状态码: {response.status_code}")
+    except Exception as e:
+        log('error', f"版本检查失败: {str(e)}")
+        
+    return settings.version['has_update']

app/vertex/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'app' directory a Python package.

app/vertex/api_helpers.py

@@ -0,0 +1,317 @@
+import json
+import time
+import math
+import asyncio
+from typing import List, Dict, Any, Callable, Union, Optional
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from google.auth.transport.requests import Request as AuthRequest
+from google.genai import types 
+from google import genai # Needed if _execute_gemini_call uses genai.Client directly
+from app.vertex.message_processing import parse_gemini_response_for_reasoning_and_content
+# Local module imports
+from app.vertex.models import OpenAIRequest, OpenAIMessage # Changed from relative
+from app.vertex.message_processing import deobfuscate_text, convert_to_openai_format, convert_chunk_to_openai, create_final_chunk # Changed from relative
+import app.vertex.config as app_config # Changed from relative
+from app.config import settings # 导入settings模块
+
+def create_openai_error_response(status_code: int, message: str, error_type: str) -> Dict[str, Any]:
+    return {
+        "error": {
+            "message": message,
+            "type": error_type,
+            "code": status_code,
+            "param": None,
+        }
+    }
+
+def create_generation_config(request: OpenAIRequest) -> Dict[str, Any]:
+    config = {}
+    if request.temperature is not None: config["temperature"] = request.temperature
+    if request.max_tokens is not None: config["max_output_tokens"] = request.max_tokens
+    if request.top_p is not None: config["top_p"] = request.top_p
+    if request.top_k is not None: config["top_k"] = request.top_k
+    if request.stop is not None: config["stop_sequences"] = request.stop
+    if request.seed is not None: config["seed"] = request.seed
+    if request.presence_penalty is not None: config["presence_penalty"] = request.presence_penalty
+    if request.frequency_penalty is not None: config["frequency_penalty"] = request.frequency_penalty
+    if request.n is not None: config["candidate_count"] = request.n
+    config["safety_settings"] = [
+            types.SafetySetting(category="HARM_CATEGORY_HATE_SPEECH", threshold="OFF"),
+            types.SafetySetting(category="HARM_CATEGORY_DANGEROUS_CONTENT", threshold="OFF"),
+            types.SafetySetting(category="HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold="OFF"),
+            types.SafetySetting(category="HARM_CATEGORY_HARASSMENT", threshold="OFF"),
+            types.SafetySetting(category="HARM_CATEGORY_CIVIC_INTEGRITY", threshold="OFF")
+    ]
+    return config
+
+def is_response_valid(response):
+    if response is None:
+        print("DEBUG: Response is None, therefore invalid.")
+        return False
+    
+    # Check for direct text attribute
+    if hasattr(response, 'text') and isinstance(response.text, str) and response.text.strip():
+        # print("DEBUG: Response valid due to response.text")
+        return True
+        
+    # Check candidates for text content
+    if hasattr(response, 'candidates') and response.candidates:
+        for candidate in response.candidates: # Iterate through all candidates
+            if hasattr(candidate, 'text') and isinstance(candidate.text, str) and candidate.text.strip():
+                # print(f"DEBUG: Response valid due to candidate.text in candidate")
+                return True
+            if hasattr(candidate, 'content') and hasattr(candidate.content, 'parts') and candidate.content.parts:
+                for part in candidate.content.parts:
+                    if hasattr(part, 'text') and isinstance(part.text, str) and part.text.strip():
+                        # print(f"DEBUG: Response valid due to part.text in candidate's content part")
+                        return True
+                        
+    # Removed prompt_feedback as a sole criterion for validity.
+    # It should only be valid if actual text content is found.
+    # Block reasons will be checked explicitly by callers if they need to treat it as an error for retries.
+    print("DEBUG: Response is invalid, no usable text content found by is_response_valid.")
+    return False
+
+async def _base_fake_stream_engine(
+    api_call_task_creator: Callable[[], asyncio.Task],
+    extract_text_from_response_func: Callable[[Any], str], 
+    response_id: str,
+    sse_model_name: str,
+    is_auto_attempt: bool,
+    is_valid_response_func: Callable[[Any], bool],
+    keep_alive_interval_seconds: float, 
+    process_text_func: Optional[Callable[[str, str], str]] = None, 
+    check_block_reason_func: Optional[Callable[[Any], None]] = None,
+    reasoning_text_to_yield: Optional[str] = None,
+    actual_content_text_to_yield: Optional[str] = None
+):
+    api_call_task = api_call_task_creator()
+
+    if keep_alive_interval_seconds > 0:
+        while not api_call_task.done():
+            keep_alive_data = {"id": "chatcmpl-keepalive", "object": "chat.completion.chunk", "created": int(time.time()), "model": sse_model_name, "choices": [{"delta": {"reasoning_content": ""}, "index": 0, "finish_reason": None}]}
+            yield f"data: {json.dumps(keep_alive_data)}\n\n"
+            await asyncio.sleep(keep_alive_interval_seconds) 
+    
+    try:
+        full_api_response = await api_call_task 
+
+        if check_block_reason_func:
+            check_block_reason_func(full_api_response) 
+
+        if not is_valid_response_func(full_api_response): 
+             raise ValueError(f"Invalid/empty API response in fake stream for model {sse_model_name}: {str(full_api_response)[:200]}")
+
+        final_reasoning_text = reasoning_text_to_yield
+        final_actual_content_text = actual_content_text_to_yield
+
+        if final_reasoning_text is None and final_actual_content_text is None:
+            extracted_full_text = extract_text_from_response_func(full_api_response)
+            if process_text_func:
+                final_actual_content_text = process_text_func(extracted_full_text, sse_model_name)
+            else:
+                final_actual_content_text = extracted_full_text
+        else:
+            if process_text_func:
+                if final_reasoning_text is not None:
+                    final_reasoning_text = process_text_func(final_reasoning_text, sse_model_name)
+                if final_actual_content_text is not None:
+                    final_actual_content_text = process_text_func(final_actual_content_text, sse_model_name)
+        
+        if final_reasoning_text: 
+            reasoning_delta_data = {
+                "id": response_id, "object": "chat.completion.chunk", "created": int(time.time()),
+                "model": sse_model_name, "choices": [{"index": 0, "delta": {"reasoning_content": final_reasoning_text}, "finish_reason": None}]
+            }
+            yield f"data: {json.dumps(reasoning_delta_data)}\n\n"
+            if final_actual_content_text: 
+                await asyncio.sleep(0.05) 
+
+        content_to_chunk = final_actual_content_text or "" 
+        chunk_size = max(20, math.ceil(len(content_to_chunk) / 10)) if content_to_chunk else 0
+        
+        if not content_to_chunk and content_to_chunk != "": 
+            empty_delta_data = {"id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": sse_model_name, "choices": [{"index": 0, "delta": {"content": ""}, "finish_reason": None}]}
+            yield f"data: {json.dumps(empty_delta_data)}\n\n"
+        else: 
+            for i in range(0, len(content_to_chunk), chunk_size):
+                chunk_text = content_to_chunk[i:i+chunk_size]
+                content_delta_data = {"id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": sse_model_name, "choices": [{"index": 0, "delta": {"content": chunk_text}, "finish_reason": None}]}
+                yield f"data: {json.dumps(content_delta_data)}\n\n"
+                if len(content_to_chunk) > chunk_size: await asyncio.sleep(0.05)
+
+        yield create_final_chunk(sse_model_name, response_id)
+        yield "data: [DONE]\n\n"
+
+    except Exception as e:
+        err_msg_detail = f"Error in _base_fake_stream_engine (model: '{sse_model_name}'): {type(e).__name__} - {str(e)}"
+        print(f"ERROR: {err_msg_detail}")
+        sse_err_msg_display = str(e) 
+        if len(sse_err_msg_display) > 512: sse_err_msg_display = sse_err_msg_display[:512] + "..."
+        err_resp_for_sse = create_openai_error_response(500, sse_err_msg_display, "server_error")
+        json_payload_for_fake_stream_error = json.dumps(err_resp_for_sse)
+        if not is_auto_attempt:
+            yield f"data: {json_payload_for_fake_stream_error}\n\n"
+            yield "data: [DONE]\n\n"
+        raise
+
+async def gemini_fake_stream_generator(
+    gemini_client_instance: Any, 
+    model_for_api_call: str, 
+    prompt_for_api_call: Union[types.Content, List[types.Content]],
+    gen_config_for_api_call: Dict[str, Any],
+    request_obj: OpenAIRequest,
+    is_auto_attempt: bool
+):
+    model_name_for_log = getattr(gemini_client_instance, 'model_name', 'unknown_gemini_model_object')
+    print(f"FAKE STREAMING (Gemini): Prep for '{request_obj.model}' (API model string: '{model_for_api_call}', client obj: '{model_name_for_log}') with reasoning separation.")
+    response_id = f"chatcmpl-{int(time.time())}"
+
+    # 1. Create and await the API call task
+    api_call_task = asyncio.create_task(
+        gemini_client_instance.aio.models.generate_content(
+            model=model_for_api_call, 
+            contents=prompt_for_api_call, 
+            config=gen_config_for_api_call
+        )
+    )
+
+    # Keep-alive loop while the main API call is in progress
+    outer_keep_alive_interval = app_config.FAKE_STREAMING_INTERVAL_SECONDS
+    if outer_keep_alive_interval > 0:
+        while not api_call_task.done():
+            keep_alive_data = {"id": "chatcmpl-keepalive", "object": "chat.completion.chunk", "created": int(time.time()), "model": request_obj.model, "choices": [{"delta": {"reasoning_content": ""}, "index": 0, "finish_reason": None}]}
+            yield f"data: {json.dumps(keep_alive_data)}\n\n"
+            await asyncio.sleep(outer_keep_alive_interval)
+    
+    try:
+        raw_response = await api_call_task # Get the full Gemini response
+
+        # 2. Parse the response for reasoning and content using the centralized parser
+        separated_reasoning_text = ""
+        separated_actual_content_text = ""
+        if hasattr(raw_response, 'candidates') and raw_response.candidates:
+            # Typically, fake streaming would focus on the first candidate
+            separated_reasoning_text, separated_actual_content_text = parse_gemini_response_for_reasoning_and_content(raw_response.candidates[0])
+        elif hasattr(raw_response, 'text') and raw_response.text is not None: # Fallback for simpler response structures
+             separated_actual_content_text = raw_response.text
+
+        # 3. Define a text processing function (e.g., for deobfuscation)
+        def _process_gemini_text_if_needed(text: str, model_name: str) -> str:
+            if model_name.endswith("-encrypt-full"):
+                return deobfuscate_text(text)
+            return text
+
+        final_reasoning_text = _process_gemini_text_if_needed(separated_reasoning_text, request_obj.model)
+        final_actual_content_text = _process_gemini_text_if_needed(separated_actual_content_text, request_obj.model)
+
+        # Define block checking for the raw response
+        def _check_gemini_block_wrapper(response_to_check: Any):
+            if hasattr(response_to_check, 'prompt_feedback') and hasattr(response_to_check.prompt_feedback, 'block_reason') and response_to_check.prompt_feedback.block_reason:
+                block_message = f"Response blocked by Gemini safety filter: {response_to_check.prompt_feedback.block_reason}"
+                if hasattr(response_to_check.prompt_feedback, 'block_reason_message') and response_to_check.prompt_feedback.block_reason_message:
+                    block_message += f" (Message: {response_to_check.prompt_feedback.block_reason_message})"
+                raise ValueError(block_message)
+
+        # Call _base_fake_stream_engine with pre-split and processed texts
+        async for chunk in _base_fake_stream_engine(
+            api_call_task_creator=lambda: asyncio.create_task(asyncio.sleep(0, result=raw_response)), # Dummy task
+            extract_text_from_response_func=lambda r: "", # Not directly used as text is pre-split
+            is_valid_response_func=is_response_valid, # Validates raw_response
+            check_block_reason_func=_check_gemini_block_wrapper, # Checks raw_response
+            process_text_func=None, # Text processing already done above
+            response_id=response_id, 
+            sse_model_name=request_obj.model,
+            keep_alive_interval_seconds=0, # Keep-alive for this inner call is 0
+            is_auto_attempt=is_auto_attempt,
+            reasoning_text_to_yield=final_reasoning_text,
+            actual_content_text_to_yield=final_actual_content_text
+        ):
+            yield chunk
+
+    except Exception as e_outer_gemini:
+        err_msg_detail = f"Error in gemini_fake_stream_generator (model: '{request_obj.model}'): {type(e_outer_gemini).__name__} - {str(e_outer_gemini)}"
+        print(f"ERROR: {err_msg_detail}")
+        sse_err_msg_display = str(e_outer_gemini)
+        if len(sse_err_msg_display) > 512: sse_err_msg_display = sse_err_msg_display[:512] + "..."
+        err_resp_sse = create_openai_error_response(500, sse_err_msg_display, "server_error")
+        json_payload_error = json.dumps(err_resp_sse)
+        if not is_auto_attempt:
+            yield f"data: {json_payload_error}\n\n"
+            yield "data: [DONE]\n\n"
+
+async def execute_gemini_call(
+    current_client: Any, 
+    model_to_call: str,  
+    prompt_func: Callable[[List[OpenAIMessage]], Union[types.Content, List[types.Content]]], 
+    gen_config_for_call: Dict[str, Any], 
+    request_obj: OpenAIRequest, 
+    is_auto_attempt: bool = False
+):
+    actual_prompt_for_call = prompt_func(request_obj.messages)
+    client_model_name_for_log = getattr(current_client, 'model_name', 'unknown_direct_client_object')
+    print(f"INFO: execute_gemini_call for requested API model '{model_to_call}', using client object with internal name '{client_model_name_for_log}'. Original request model: '{request_obj.model}'")
+
+    # 每次调用时直接从settings获取最新的FAKE_STREAMING值
+    fake_streaming_enabled = False
+    if hasattr(settings, 'FAKE_STREAMING'):
+        fake_streaming_enabled = settings.FAKE_STREAMING
+    else:
+        fake_streaming_enabled = app_config.FAKE_STREAMING_ENABLED
+    
+    print(f"DEBUG: FAKE_STREAMING setting is {fake_streaming_enabled} for model {request_obj.model}")
+
+    if request_obj.stream:
+        if fake_streaming_enabled:
+            return StreamingResponse(
+                gemini_fake_stream_generator( 
+                    current_client, 
+                    model_to_call, 
+                    actual_prompt_for_call, 
+                    gen_config_for_call, 
+                    request_obj, 
+                    is_auto_attempt
+                ), 
+                media_type="text/event-stream"
+            )
+        
+        response_id_for_stream = f"chatcmpl-{int(time.time())}"
+        cand_count_stream = request_obj.n or 1
+        
+        async def _gemini_real_stream_generator_inner():
+            try:
+                async for chunk_item_call in await current_client.aio.models.generate_content_stream(
+                    model=model_to_call, 
+                    contents=actual_prompt_for_call, 
+                    config=gen_config_for_call
+                ):
+                    yield convert_chunk_to_openai(chunk_item_call, request_obj.model, response_id_for_stream, 0)
+                yield create_final_chunk(request_obj.model, response_id_for_stream, cand_count_stream)
+                yield "data: [DONE]\n\n"
+            except Exception as e_stream_call:
+                err_msg_detail_stream = f"Streaming Error (Gemini API, model string: '{model_to_call}'): {type(e_stream_call).__name__} - {str(e_stream_call)}"
+                print(f"ERROR: {err_msg_detail_stream}")
+                s_err = str(e_stream_call); s_err = s_err[:1024]+"..." if len(s_err)>1024 else s_err
+                err_resp = create_openai_error_response(500,s_err,"server_error")
+                j_err = json.dumps(err_resp)
+                if not is_auto_attempt: 
+                    yield f"data: {j_err}\n\n"
+                    yield "data: [DONE]\n\n"
+                raise e_stream_call
+        return StreamingResponse(_gemini_real_stream_generator_inner(), media_type="text/event-stream")
+    else: 
+        response_obj_call = await current_client.aio.models.generate_content(
+            model=model_to_call, 
+            contents=actual_prompt_for_call, 
+            config=gen_config_for_call
+        )
+        if hasattr(response_obj_call, 'prompt_feedback') and hasattr(response_obj_call.prompt_feedback, 'block_reason') and response_obj_call.prompt_feedback.block_reason:
+            block_msg = f"Blocked (Gemini): {response_obj_call.prompt_feedback.block_reason}"
+            if hasattr(response_obj_call.prompt_feedback,'block_reason_message') and response_obj_call.prompt_feedback.block_reason_message: 
+                block_msg+=f" ({response_obj_call.prompt_feedback.block_reason_message})"
+            raise ValueError(block_msg)
+        
+        if not is_response_valid(response_obj_call): 
+            raise ValueError(f"Invalid non-streaming Gemini response for model string '{model_to_call}'. Resp: {str(response_obj_call)[:200]}")
+        return JSONResponse(content=convert_to_openai_format(response_obj_call, request_obj.model))

app/vertex/auth.py

@@ -0,0 +1,109 @@
+from fastapi import HTTPException, Header, Depends
+from fastapi.security import APIKeyHeader
+from typing import Optional
+from app.config import settings
+import app.vertex.config as config
+import os
+import json
+from app.utils.logging import vertex_log
+
+# API Key security scheme
+api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
+
+# Function to validate API key
+def validate_api_key(api_key_to_validate: str) -> bool:
+
+    return True
+
+# Dependency for API key validation
+async def get_api_key(authorization: Optional[str] = Header(None)):
+    if authorization is None:
+        raise HTTPException(
+            status_code=401,
+            detail="Missing API key. Please include 'Authorization: Bearer YOUR_API_KEY' header."
+        )
+    
+    # Check if the header starts with "Bearer "
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key format. Use 'Authorization: Bearer YOUR_API_KEY'"
+        )
+    
+    # Extract the API key
+    api_key = authorization.replace("Bearer ", "")
+    
+    # Validate the API key
+    if not validate_api_key(api_key): # Call local validate_api_key
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid API key"
+        )
+    
+    return api_key
+
+def validate_settings():
+    """Validate settings for Vertex API access."""
+    
+    # 检查API key
+    api_key = None
+    if hasattr(settings, 'API_KEY') and settings.API_KEY:
+        api_key = settings.API_KEY
+    else:
+        api_key = config.API_KEY
+    
+    if not api_key:
+        vertex_log('warning', "API key is not set. Some functionality may be limited.")
+    
+    # 检查Google credentials JSON
+    google_credentials_json = None
+    if hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') and settings.GOOGLE_CREDENTIALS_JSON:
+        google_credentials_json = settings.GOOGLE_CREDENTIALS_JSON
+    else:
+        google_credentials_json = config.GOOGLE_CREDENTIALS_JSON
+    
+    if google_credentials_json:
+        try:
+            # 尝试解析JSON确保其有效
+            json.loads(google_credentials_json)
+            vertex_log('info', "Google Credentials JSON is valid")
+        except json.JSONDecodeError:
+            vertex_log('error', "Google Credentials JSON is not valid JSON. Please check the format.")
+            return False
+    
+    # 检查project ID
+    project_id = None
+    if hasattr(settings, 'PROJECT_ID') and settings.PROJECT_ID:
+        project_id = settings.PROJECT_ID
+    else:
+        project_id = config.PROJECT_ID
+    
+    if not project_id:
+        vertex_log('warning', "Vertex AI Project ID is not set. Required for non-API key methods.")
+    
+    # 检查location
+    location = None
+    if hasattr(settings, 'LOCATION') and settings.LOCATION:
+        location = settings.LOCATION
+    else:
+        location = config.LOCATION
+    
+    if not location:
+        vertex_log('warning', "Vertex AI Location is not set, using default: us-central1")
+    
+    # 验证凭证目录
+    credentials_dir = None
+    if hasattr(settings, 'CREDENTIALS_DIR') and settings.CREDENTIALS_DIR:
+        credentials_dir = settings.CREDENTIALS_DIR
+    else:
+        credentials_dir = config.CREDENTIALS_DIR
+    
+    if not os.path.exists(credentials_dir):
+        try:
+            os.makedirs(credentials_dir, exist_ok=True)
+            vertex_log('info', f"Created credentials directory at: {credentials_dir}")
+        except Exception as e:
+            vertex_log('error', f"Failed to create credentials directory: {e}")
+            return False
+    
+    return True

app/vertex/config.py

@@ -0,0 +1,139 @@
+import os
+import pathlib
+from app.config import settings
+from app.utils.logging import vertex_log
+
+# 确保设置中存在所需的配置项，如果不存在则使用默认值
+if not hasattr(settings, 'CREDENTIALS_DIR'):
+    # 设置默认目录为storage_dir下的credentials
+    settings.CREDENTIALS_DIR = os.path.join(settings.STORAGE_DIR, "credentials")
+
+# 使用settings中的配置，保持原有变量名
+CREDENTIALS_DIR = settings.CREDENTIALS_DIR
+vertex_log('info', f"Using credentials directory: {CREDENTIALS_DIR}")
+
+# API Key 配置
+API_KEY = settings.PASSWORD if hasattr(settings, 'PASSWORD') else ""
+if API_KEY:
+    vertex_log('info', "Using API Key authentication")
+else:
+    vertex_log('info', "No API Key found, falling back to credentials file")
+
+# Google Credentials JSON
+GOOGLE_CREDENTIALS_JSON = settings.GOOGLE_CREDENTIALS_JSON if hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') else ""
+if GOOGLE_CREDENTIALS_JSON:
+    vertex_log('info', "Using GOOGLE_CREDENTIALS_JSON environment variable for authentication")
+
+# 项目和位置配置
+PROJECT_ID = os.environ.get('VERTEX_PROJECT_ID', '')
+LOCATION = os.environ.get('VERTEX_LOCATION', 'us-central1')
+
+# 模型配置URL
+default_models_config_url = "https://raw.githubusercontent.com/gzzhongqi/vertex2openai/refs/heads/main/vertexModels.json"
+MODELS_CONFIG_URL = os.environ.get('VERTEX_MODELS_CONFIG_URL', default_models_config_url)
+vertex_log('info', f"Using models config URL: {MODELS_CONFIG_URL}")
+
+# Vertex Express API Key 配置
+VERTEX_EXPRESS_API_KEY_VAL = []
+if hasattr(settings, 'VERTEX_EXPRESS_API_KEY') and settings.VERTEX_EXPRESS_API_KEY:
+    VERTEX_EXPRESS_API_KEY_VAL = [key.strip() for key in settings.VERTEX_EXPRESS_API_KEY.split(',') if key.strip()]
+    if VERTEX_EXPRESS_API_KEY_VAL:
+        vertex_log('info', f"Loaded {len(VERTEX_EXPRESS_API_KEY_VAL)} Vertex Express API keys from settings")
+
+# 假流式响应配置
+FAKE_STREAMING_ENABLED = settings.FAKE_STREAMING if hasattr(settings, 'FAKE_STREAMING') else False
+FAKE_STREAMING_INTERVAL_SECONDS = settings.FAKE_STREAMING_INTERVAL if hasattr(settings, 'FAKE_STREAMING_INTERVAL') else 1.0
+FAKE_STREAMING_CHUNK_SIZE = settings.FAKE_STREAMING_CHUNK_SIZE if hasattr(settings, 'FAKE_STREAMING_CHUNK_SIZE') else 10
+FAKE_STREAMING_DELAY_PER_CHUNK = settings.FAKE_STREAMING_DELAY_PER_CHUNK if hasattr(settings, 'FAKE_STREAMING_DELAY_PER_CHUNK') else 0.1
+vertex_log('info', f"Fake streaming is {'enabled' if FAKE_STREAMING_ENABLED else 'disabled'} with interval {FAKE_STREAMING_INTERVAL_SECONDS} seconds, chunk size {FAKE_STREAMING_CHUNK_SIZE}, delay per chunk {FAKE_STREAMING_DELAY_PER_CHUNK} seconds")
+
+def update_env_var(name, value):
+    """Update environment variable in memory."""
+    os.environ[name] = value
+    vertex_log('info', f"Updated environment variable: {name}")
+
+def reload_config():
+    """重新加载配置，通常在持久化设置加载后调用"""
+    global GOOGLE_CREDENTIALS_JSON, VERTEX_EXPRESS_API_KEY_VAL, API_KEY
+    
+    # 重新加载Google Credentials JSON
+    GOOGLE_CREDENTIALS_JSON = settings.GOOGLE_CREDENTIALS_JSON if hasattr(settings, 'GOOGLE_CREDENTIALS_JSON') else ""
+    if GOOGLE_CREDENTIALS_JSON:
+        vertex_log('info', "重新加载了GOOGLE_CREDENTIALS_JSON配置")
+    
+    # 重新加载Vertex Express API Key
+    VERTEX_EXPRESS_API_KEY_VAL = []
+    if hasattr(settings, 'VERTEX_EXPRESS_API_KEY') and settings.VERTEX_EXPRESS_API_KEY:
+        VERTEX_EXPRESS_API_KEY_VAL = [key.strip() for key in settings.VERTEX_EXPRESS_API_KEY.split(',') if key.strip()]
+        if VERTEX_EXPRESS_API_KEY_VAL:
+            vertex_log('info', f"重新加载了{len(VERTEX_EXPRESS_API_KEY_VAL)}个Vertex Express API keys")
+    
+    # 重新加载API Key
+    API_KEY = settings.PASSWORD if hasattr(settings, 'PASSWORD') else ""
+    if API_KEY:
+        vertex_log('info', "重新加载了API Key配置")
+
+def update_config(name, value):
+    """Update config variables in settings and environment variables."""
+    if name == 'VERTEX_API_KEY':
+        settings.PASSWORD = value  # 更新settings中的值
+        global API_KEY
+        API_KEY = value  # 更新本地变量
+        vertex_log('info', "Updated API Key")
+    elif name == 'GOOGLE_CREDENTIALS_JSON':
+        settings.GOOGLE_CREDENTIALS_JSON = value
+        global GOOGLE_CREDENTIALS_JSON
+        GOOGLE_CREDENTIALS_JSON = value
+        vertex_log('info', "Updated Google Credentials JSON")
+    elif name == 'VERTEX_PROJECT_ID':
+        os.environ['VERTEX_PROJECT_ID'] = value  # 这个值只在环境变量中
+        global PROJECT_ID
+        PROJECT_ID = value
+        vertex_log('info', f"Updated Project ID to {value}")
+    elif name == 'VERTEX_LOCATION':
+        os.environ['VERTEX_LOCATION'] = value
+        global LOCATION
+        LOCATION = value
+        vertex_log('info', f"Updated Location to {value}")
+    elif name == 'VERTEX_MODELS_CONFIG_URL':
+        os.environ['VERTEX_MODELS_CONFIG_URL'] = value
+        global MODELS_CONFIG_URL
+        MODELS_CONFIG_URL = value
+        vertex_log('info', f"Updated Models Config URL to {value}")
+    elif name == 'VERTEX_EXPRESS_API_KEY':
+        settings.VERTEX_EXPRESS_API_KEY = value
+        global VERTEX_EXPRESS_API_KEY_VAL
+        VERTEX_EXPRESS_API_KEY_VAL = [key.strip() for key in value.split(',') if key.strip()]
+        vertex_log('info', f"Updated Vertex Express API Key, now have {len(VERTEX_EXPRESS_API_KEY_VAL)} keys")
+    elif name == 'FAKE_STREAMING':
+        # 更新FAKE_STREAMING配置
+        settings.FAKE_STREAMING = value
+        global FAKE_STREAMING_ENABLED
+        FAKE_STREAMING_ENABLED = value
+        vertex_log('info', f"Updated FAKE_STREAMING to {value}")
+        # 确保环境变量也被更新
+        os.environ['FAKE_STREAMING'] = str(value).lower()
+    elif name == 'FAKE_STREAMING_INTERVAL':
+        # 更新FAKE_STREAMING_INTERVAL配置
+        settings.FAKE_STREAMING_INTERVAL = value
+        global FAKE_STREAMING_INTERVAL_SECONDS
+        FAKE_STREAMING_INTERVAL_SECONDS = value
+        vertex_log('info', f"Updated FAKE_STREAMING_INTERVAL to {value}")
+    elif name == 'FAKE_STREAMING_CHUNK_SIZE':
+        settings.FAKE_STREAMING_CHUNK_SIZE = value
+        global FAKE_STREAMING_CHUNK_SIZE
+        FAKE_STREAMING_CHUNK_SIZE = value
+        vertex_log('info', f"Updated FAKE_STREAMING_CHUNK_SIZE to {value}")
+    elif name == 'FAKE_STREAMING_DELAY_PER_CHUNK':
+        settings.FAKE_STREAMING_DELAY_PER_CHUNK = value
+        global FAKE_STREAMING_DELAY_PER_CHUNK
+        FAKE_STREAMING_DELAY_PER_CHUNK = value
+        vertex_log('info', f"Updated FAKE_STREAMING_DELAY_PER_CHUNK to {value}")
+    else:
+        vertex_log('warning', f"Unknown config variable: {name}")
+        return
+
+    # 更新环境变量
+    update_env_var(name, value)
+
+# Validation logic moved to app/auth.py

app/vertex/credentials_manager.py

@@ -0,0 +1,271 @@
+import os
+import glob
+import random
+import json
+from typing import List, Dict, Any
+from google.auth.transport.requests import Request as AuthRequest
+from google.oauth2 import service_account
+import app.vertex.config as app_config # Changed from relative
+from app.utils.logging import vertex_log
+
+# Helper function to parse multiple JSONs from a string
+def parse_multiple_json_credentials(json_str: str) -> List[Dict[str, Any]]:
+    """
+    Parse multiple JSON objects from a string separated by commas.
+    Format expected: {json_object1},{json_object2},...
+    Returns a list of parsed JSON objects.
+    """
+    # 检查输入是否为None或空字符串
+    if not json_str or not json_str.strip():
+        vertex_log('debug', "parse_multiple_json_credentials received empty or None input")
+        return []
+    
+    credentials_list = []
+    nesting_level = 0
+    current_object_start = -1
+    str_length = len(json_str)
+
+    for i, char in enumerate(json_str):
+        if char == '{':
+            if nesting_level == 0:
+                current_object_start = i
+            nesting_level += 1
+        elif char == '}':
+            if nesting_level > 0:
+                nesting_level -= 1
+                if nesting_level == 0 and current_object_start != -1:
+                    # Found a complete top-level JSON object
+                    json_object_str = json_str[current_object_start : i + 1]
+                    try:
+                        credentials_info = json.loads(json_object_str)
+                        # Basic validation for service account structure
+                        required_fields = ["type", "project_id", "private_key_id", "private_key", "client_email"]
+                        if all(field in credentials_info for field in required_fields):
+                             credentials_list.append(credentials_info)
+                             vertex_log('debug', "Successfully parsed a JSON credential object.")
+                        else:
+                             vertex_log('warning', f"Parsed JSON object missing required fields: {json_object_str[:100]}...")
+                    except json.JSONDecodeError as e:
+                        vertex_log('error', f"Failed to parse JSON object segment: {json_object_str[:100]}... Error: {e}")
+                    current_object_start = -1 # Reset for the next object
+            else:
+                # Found a closing brace without a matching open brace in scope, might indicate malformed input
+                 vertex_log('warning', f"Encountered unexpected '}}' at index {i}. Input might be malformed.")
+
+
+    if nesting_level != 0:
+        vertex_log('warning', f"JSON string parsing ended with non-zero nesting level ({nesting_level}). Check for unbalanced braces.")
+
+    vertex_log('debug', f"Parsed {len(credentials_list)} credential objects from the input string.")
+    return credentials_list
+
+def _refresh_auth(credentials):
+    """Helper function to refresh GCP token."""
+    if not credentials:
+        vertex_log('error', "_refresh_auth called with no credentials.")
+        return None
+    try:
+        # Assuming credentials object has a project_id attribute for logging
+        project_id_for_log = getattr(credentials, 'project_id', 'Unknown')
+        vertex_log('info', f"Attempting to refresh token for project: {project_id_for_log}...")
+        credentials.refresh(AuthRequest())
+        vertex_log('info', f"Token refreshed successfully for project: {project_id_for_log}")
+        return credentials.token
+    except Exception as e:
+        project_id_for_log = getattr(credentials, 'project_id', 'Unknown')
+        vertex_log('error', f"Error refreshing GCP token for project {project_id_for_log}: {e}")
+        return None
+
+
+# Credential Manager for handling multiple service accounts
+class CredentialManager:
+    def __init__(self): # default_credentials_dir is now handled by config
+        # Use CREDENTIALS_DIR from config
+        self.credentials_dir = app_config.CREDENTIALS_DIR
+        self.credentials_files = []
+        self.current_index = 0
+        self.credentials = None
+        self.project_id = None
+        # New: Store credentials loaded directly from JSON objects
+        self.in_memory_credentials: List[Dict[str, Any]] = []
+        self.load_credentials_list() # Load file-based credentials initially
+
+    def clear_json_string_credentials(self) -> int:
+        """
+        清除所有通过JSON字符串加载的内存凭证。
+        返回清除的凭证数量。
+        """
+        count_before = len(self.in_memory_credentials)
+        # 只保留不是从json字符串加载的凭证
+        self.in_memory_credentials = [cred for cred in self.in_memory_credentials if cred.get('source') != 'json_string']
+        count_after = len(self.in_memory_credentials)
+        removed_count = count_before - count_after
+        vertex_log('debug', f"从CredentialManager中清除了{removed_count}个由JSON字符串加载的凭证")
+        return removed_count
+
+    def add_credential_from_json(self, credentials_info: Dict[str, Any]) -> bool:
+        """
+        Add a credential from a JSON object to the manager's in-memory list.
+
+        Args:
+            credentials_info: Dict containing service account credentials
+
+        Returns:
+            bool: True if credential was added successfully, False otherwise
+        """
+        try:
+            # Validate structure again before creating credentials object
+            required_fields = ["type", "project_id", "private_key_id", "private_key", "client_email"]
+            if not all(field in credentials_info for field in required_fields):
+                 vertex_log('warning', "Skipping JSON credential due to missing required fields.")
+                 return False
+
+            credentials = service_account.Credentials.from_service_account_info(
+                credentials_info,
+                scopes=['https://www.googleapis.com/auth/cloud-platform']
+            )
+            project_id = credentials.project_id
+            vertex_log('debug', f"Successfully created credentials object from JSON for project: {project_id}")
+
+            # Store the credentials object and project ID
+            self.in_memory_credentials.append({
+                'credentials': credentials,
+                'project_id': project_id,
+                 'source': 'json_string' # Add source for clarity
+            })
+            vertex_log('info', f"Added credential for project {project_id} from JSON string to Credential Manager.")
+            return True
+        except Exception as e:
+            vertex_log('error', f"Failed to create credentials from parsed JSON object: {e}")
+            return False
+
+    def load_credentials_from_json_list(self, json_list: List[Dict[str, Any]]) -> int:
+        """
+        Load multiple credentials from a list of JSON objects into memory.
+
+        Args:
+            json_list: List of dicts containing service account credentials
+
+        Returns:
+            int: Number of credentials successfully loaded
+        """
+        # Avoid duplicates if called multiple times
+        existing_projects = {cred['project_id'] for cred in self.in_memory_credentials}
+        success_count = 0
+        newly_added_projects = set()
+
+        for credentials_info in json_list:
+             project_id = credentials_info.get('project_id')
+             # Check if this project_id from JSON exists in files OR already added from JSON
+             is_duplicate_file = any(os.path.basename(f) == f"{project_id}.json" for f in self.credentials_files) # Basic check
+             is_duplicate_mem = project_id in existing_projects or project_id in newly_added_projects
+
+             if project_id and not is_duplicate_file and not is_duplicate_mem:
+                 if self.add_credential_from_json(credentials_info):
+                     success_count += 1
+                     newly_added_projects.add(project_id)
+             elif project_id:
+                  vertex_log('debug', f"Skipping duplicate credential for project {project_id} from JSON list.")
+
+
+        if success_count > 0:
+             vertex_log('info', f"Loaded {success_count} new credentials from JSON list into memory.")
+        return success_count
+
+    def load_credentials_list(self):
+        """Load the list of available credential files"""
+        # Look for all .json files in the credentials directory
+        pattern = os.path.join(self.credentials_dir, "*.json")
+        self.credentials_files = glob.glob(pattern)
+
+        if not self.credentials_files:
+            # vertex_log('info', f"No credential files found in {self.credentials_dir}")
+            pass # Don't return False yet, might have in-memory creds
+        else:
+             vertex_log('info', f"Found {len(self.credentials_files)} credential files: {[os.path.basename(f) for f in self.credentials_files]}")
+
+        # Check total credentials
+        return self.get_total_credentials() > 0
+
+    def refresh_credentials_list(self):
+        """Refresh the list of credential files and return if any credentials exist"""
+        old_file_count = len(self.credentials_files)
+        self.load_credentials_list() # Reloads file list
+        new_file_count = len(self.credentials_files)
+
+        if old_file_count != new_file_count:
+            vertex_log('info', f"Credential files updated: {old_file_count} -> {new_file_count}")
+
+        # Total credentials = files + in-memory
+        total_credentials = self.get_total_credentials()
+        vertex_log('debug', f"Refresh check - Total credentials available: {total_credentials}")
+        return total_credentials > 0
+
+    def get_total_credentials(self):
+        """Returns the total number of credentials (file + in-memory)."""
+        return len(self.credentials_files) + len(self.in_memory_credentials)
+
+
+    def get_random_credentials(self):
+        """
+        Get a random credential (file or in-memory) and load it.
+        Tries each available credential source at most once in a random order.
+        """
+        all_sources = []
+        # Add file paths (as type 'file')
+        for file_path in self.credentials_files:
+            all_sources.append({'type': 'file', 'value': file_path})
+        
+        # Add in-memory credentials (as type 'memory_object')
+        # Assuming self.in_memory_credentials stores dicts like {'credentials': cred_obj, 'project_id': pid, 'source': 'json_string'}
+        for idx, mem_cred_info in enumerate(self.in_memory_credentials):
+            all_sources.append({'type': 'memory_object', 'value': mem_cred_info, 'original_index': idx})
+
+        if not all_sources:
+            vertex_log('warning', "No credentials available for random selection (no files or in-memory).")
+            return None, None
+
+        random.shuffle(all_sources) # Shuffle to try in a random order
+
+        for source_info in all_sources:
+            source_type = source_info['type']
+            
+            if source_type == 'file':
+                file_path = source_info['value']
+                vertex_log('debug', f"Attempting to load credential from file: {os.path.basename(file_path)}")
+                try:
+                    credentials = service_account.Credentials.from_service_account_file(
+                        file_path,
+                        scopes=['https://www.googleapis.com/auth/cloud-platform']
+                    )
+                    project_id = credentials.project_id
+                    vertex_log('info', f"Successfully loaded credential from file {os.path.basename(file_path)} for project: {project_id}")
+                    self.credentials = credentials # Cache last successfully loaded
+                    self.project_id = project_id
+                    return credentials, project_id
+                except Exception as e:
+                    vertex_log('error', f"Failed loading credentials file {os.path.basename(file_path)}: {e}. Trying next available source.")
+                    continue # Try next source
+            
+            elif source_type == 'memory_object':
+                mem_cred_detail = source_info['value']
+                # The 'credentials' object is already a service_account.Credentials instance
+                credentials = mem_cred_detail.get('credentials')
+                project_id = mem_cred_detail.get('project_id')
+                
+                if credentials and project_id:
+                    vertex_log('info', f"Using in-memory credential for project: {project_id} (Source: {mem_cred_detail.get('source', 'unknown')})")
+                    # Here, we might want to ensure the credential object is still valid if it can expire
+                    # For service_account.Credentials from_service_account_info, they typically don't self-refresh
+                    # in the same way as ADC, but are long-lived based on the private key.
+                    # If validation/refresh were needed, it would be complex here.
+                    # For now, assume it's usable if present.
+                    self.credentials = credentials # Cache last successfully loaded/used
+                    self.project_id = project_id
+                    return credentials, project_id
+                else:
+                    vertex_log('warning', f"In-memory credential entry missing 'credentials' or 'project_id' at original index {source_info.get('original_index', 'N/A')}. Skipping.")
+                    continue # Try next source
+        
+        vertex_log('warning', "All available credential sources failed to load.")
+        return None, None