perf: url display in webhook dialog

* Initial plan

* Add "Select All" checkbox to Plugin and MCP Server selection dialogs

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

* Make "Select All" text clickable by adding onClick handler to container

Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: RockChinQ <45992437+RockChinQ@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -19,7 +19,7 @@ body:
   - type: textarea
     attributes:
       label: 复现步骤
-      description: 如何重现这个问题，越详细越好；提供越多信息，我们会越快解决问题。
+      description: 提供越多信息，我们会越快解决问题，建议多提供配置截图；**如果你不认真填写（只一两句话概括），我们会很生气并且立即关闭 issue 或两年后才回复你**
     validations:
       required: false
   - type: textarea

.github/ISSUE_TEMPLATE/bug-report_en.yml

@@ -19,7 +19,7 @@ body:
   - type: textarea
     attributes:
       label: Reproduction steps
-      description: How to reproduce this problem, the more detailed the better; the more information you provide, the faster we will solve the problem.
+      description: How to reproduce this problem, the more detailed the better; the more information you provide, the faster we will solve the problem. 【注意】请务必认真填写此部分，若不提供完整信息（如只有一两句话的概括），我们将不会回复！
     validations:
       required: false
   - type: textarea

.github/pull_request_template.md

@@ -2,6 +2,17 @@
 
 > 请在此部分填写你实现/解决/优化的内容:  
 > Summary of what you implemented/solved/optimized:
+> 
+
+### 更改前后对比截图 / Screenshots
+
+> 请在此部分粘贴更改前后对比截图（可以是界面截图、控制台输出、对话截图等）:  
+> Please paste the screenshots of changes before and after here (can be interface screenshots, console output, conversation screenshots, etc.):
+> 
+> 修改前 / Before:
+> 
+> 修改后 / After:
+> 
 
 ## 检查清单 / Checklist
 
@@ -9,7 +20,7 @@
 
 *请在方括号间写`x`以打勾 / Please tick the box with `x`*
 
-- [ ] 阅读仓库[贡献指引](https://github.com/RockChinQ/LangBot/blob/master/CONTRIBUTING.md)了吗？ / Have you read the [contribution guide](https://github.com/RockChinQ/LangBot/blob/master/CONTRIBUTING.md)?
+- [ ] 阅读仓库[贡献指引](https://github.com/langbot-app/LangBot/blob/master/CONTRIBUTING.md)了吗？ / Have you read the [contribution guide](https://github.com/langbot-app/LangBot/blob/master/CONTRIBUTING.md)?
 - [ ] 与项目所有者沟通过了吗？ / Have you communicated with the project maintainer?
 - [ ] 我确定已自行测试所作的更改，确保功能符合预期。 / I have tested the changes and ensured they work as expected.
 

.github/workflows/build-docker-image.yml

@@ -1,10 +1,9 @@
 name: Build Docker Image
 on:
-  #防止fork乱用action设置只能手动触发构建
-  workflow_dispatch:
   ## 发布release的时候会自动构建
   release:
     types: [published]
+  workflow_dispatch:
 jobs:
   publish-docker-image:
     runs-on: ubuntu-latest
@@ -41,5 +40,9 @@ jobs:
         run: docker login --username=${{ secrets.DOCKER_USERNAME }} --password ${{ secrets.DOCKER_PASSWORD }}
       - name: Create Buildx
         run: docker buildx create --name mybuilder --use
-      - name: Build  # image name: rockchin/langbot:<VERSION>
-        run: docker buildx build --platform linux/arm64,linux/amd64 -t rockchin/langbot:${{ steps.check_version.outputs.version }} -t rockchin/langbot:latest . --push
+      - name: Build for Release # only relase, exlude pre-release
+        if: ${{ github.event.release.prerelease == false }}
+        run: docker buildx build --platform linux/amd64 -t rockchin/langbot:${{ steps.check_version.outputs.version }} -t rockchin/langbot:latest . --push
+      - name: Build for Pre-release # no update for latest tag
+        if: ${{ github.event.release.prerelease == true }}
+        run: docker buildx build --platform linux/amd64 -t rockchin/langbot:${{ steps.check_version.outputs.version }} . --push

.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,46 @@
+name: Build and Publish to PyPI
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write  # Required for trusted publishing to PyPI
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+
+      - name: Build frontend
+        run: |
+          cd web
+          npm install -g pnpm
+          pnpm install
+          pnpm build
+          mkdir -p ../src/langbot/web/out
+          cp -r out ../src/langbot/web/
+
+      - name: Install the latest version of uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          version: "latest"
+
+      - name: Build package
+        run: |
+          uv build
+
+      - name: Publish to PyPI
+        run: |
+          uv publish --token ${{ secrets.PYPI_TOKEN }}

.github/workflows/run-tests.yml

@@ -0,0 +1,71 @@
+name: Unit Tests
+
+on:
+  pull_request:
+    types: [opened, ready_for_review, synchronize]
+    paths:
+      - 'pkg/**'
+      - 'tests/**'
+      - '.github/workflows/run-tests.yml'
+      - 'pyproject.toml'
+      - 'run_tests.sh'
+  push:
+    branches:
+      - master
+      - develop
+    paths:
+      - 'pkg/**'
+      - 'tests/**'
+      - '.github/workflows/run-tests.yml'
+      - 'pyproject.toml'
+      - 'run_tests.sh'
+
+jobs:
+  test:
+    name: Run Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.10', '3.11', '3.12']
+      fail-fast: false
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+
+      - name: Install dependencies
+        run: |
+          uv sync --dev
+
+      - name: Run unit tests
+        run: |
+          bash run_tests.sh
+
+      - name: Upload coverage to Codecov
+        if: matrix.python-version == '3.12'
+        uses: codecov/codecov-action@v5
+        with:
+          files: ./coverage.xml
+          flags: unit-tests
+          name: unit-tests-coverage
+          fail_ci_if_error: false
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Test Summary
+        if: always()
+        run: |
+          echo "## Unit Tests Results" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "Python Version: ${{ matrix.python-version }}" >> $GITHUB_STEP_SUMMARY
+          echo "Test Status: ${{ job.status }}" >> $GITHUB_STEP_SUMMARY

.github/workflows/test-dev-image.yaml

@@ -0,0 +1,108 @@
+name: Test Dev Image
+
+on:
+  workflow_run:
+    workflows: ["Build Dev Image"]
+    types:
+      - completed
+    branches:
+      - master
+
+jobs:
+  test-dev-image:
+    runs-on: ubuntu-latest
+    # Only run if the build workflow succeeded
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+    
+    permissions:
+      contents: read
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Update Docker Compose to use master tag
+        working-directory: ./docker
+        run: |
+          # Replace 'latest' with 'master' tag for testing the dev image
+          sed -i 's/rockchin\/langbot:latest/rockchin\/langbot:master/g' docker-compose.yaml
+          echo "Updated docker-compose.yaml to use master tag:"
+          cat docker-compose.yaml
+
+      - name: Start Docker Compose
+        working-directory: ./docker
+        run: docker compose up -d
+
+      - name: Wait and Test API
+        run: |
+          # Function to test API endpoint
+          test_api() {
+            echo "Testing API endpoint..."
+            response=$(curl -s --connect-timeout 10 --max-time 30 -w "\n%{http_code}" http://localhost:5300/api/v1/system/info 2>&1)
+            curl_exit_code=$?
+            
+            if [ $curl_exit_code -ne 0 ]; then
+              echo "Curl failed with exit code: $curl_exit_code"
+              echo "Error: $response"
+              return 1
+            fi
+            
+            http_code=$(echo "$response" | tail -n 1)
+            response_body=$(echo "$response" | head -n -1)
+            
+            if [ "$http_code" = "200" ]; then
+              echo "API is healthy! Response code: $http_code"
+              echo "Response: $response_body"
+              return 0
+            else
+              echo "API returned non-200 response: $http_code"
+              echo "Response body: $response_body"
+              return 1
+            fi
+          }
+
+          # Wait 30 seconds before first attempt
+          echo "Waiting 30 seconds for services to start..."
+          sleep 30
+
+          # Try up to 3 times with 30-second intervals
+          max_attempts=3
+          attempt=1
+
+          while [ $attempt -le $max_attempts ]; do
+            echo "Attempt $attempt of $max_attempts"
+            
+            if test_api; then
+              echo "Success! API is responding correctly."
+              exit 0
+            fi
+            
+            if [ $attempt -lt $max_attempts ]; then
+              echo "Retrying in 30 seconds..."
+              sleep 30
+            fi
+            
+            attempt=$((attempt + 1))
+          done
+
+          # All attempts failed
+          echo "Failed to get healthy response after $max_attempts attempts"
+          exit 1
+
+      - name: Show Container Logs on Failure
+        if: failure()
+        working-directory: ./docker
+        run: |
+          echo "=== Docker Compose Status ==="
+          docker compose ps
+          echo ""
+          echo "=== LangBot Logs ==="
+          docker compose logs langbot
+          echo ""
+          echo "=== Plugin Runtime Logs ==="
+          docker compose logs langbot_plugin_runtime
+
+      - name: Cleanup
+        if: always()
+        working-directory: ./docker
+        run: docker compose down

.gitignore

@@ -22,7 +22,7 @@ tips.py
 venv*
 bin/
 .vscode
-test_*
+/test_*
 venv/
 hugchat.json
 qcapi
@@ -42,4 +42,14 @@ botpy.log*
 test.py
 /web_ui
 .venv/
-uv.lock
+uv.lock
+/test
+plugins.bak
+coverage.xml
+.coverage
+src/langbot/web/
+
+# Build artifacts
+/dist
+/build
+*.egg-info

.python-version

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

AGENTS.md

@@ -0,0 +1,86 @@
+# AGENTS.md
+
+This file is for guiding code agents (like Claude Code, GitHub Copilot, OpenAI Codex, etc.) to work in LangBot project.
+
+## Project Overview
+
+LangBot is a open-source LLM native instant messaging bot development platform, aiming to provide an out-of-the-box IM robot development experience, with Agent, RAG, MCP and other LLM application functions, supporting global instant messaging platforms, and providing rich API interfaces, supporting custom development.
+
+LangBot has a comprehensive frontend, all operations can be performed through the frontend. The project splited into these major parts:
+
+- `./pkg`: The core python package of the project backend.
+    - `./pkg/platform`: The platform module of the project, containing the logic of message platform adapters, bot managers, message session managers, etc.
+    - `./pkg/provider`: The provider module of the project, containing the logic of LLM providers, tool providers, etc.
+    - `./pkg/pipeline`: The pipeline module of the project, containing the logic of pipelines, stages, query pool, etc.
+    - `./pkg/api`: The api module of the project, containing the http api controllers and services.
+    - `./pkg/plugin`: LangBot bridge for connecting with plugin system.
+- `./libs`: Some SDKs we previously developed for the project, such as `qq_official_api`, `wecom_api`, etc.
+- `./templates`: Templates of config files, components, etc.
+- `./web`: Frontend codebase, built with Next.js + **shadcn** + **Tailwind CSS**.
+- `./docker`: docker-compose deployment files.
+
+## Backend Development
+
+We use `uv` to manage dependencies.
+
+```bash
+pip install uv
+uv sync --dev
+```
+
+Start the backend and run the project in development mode.
+
+```bash
+uv run main.py
+```
+
+Then you can access the project at `http://127.0.0.1:5300`.
+
+## Frontend Development
+
+We use `pnpm` to manage dependencies.
+
+```bash
+cd web
+cp .env.example .env
+pnpm install
+pnpm dev
+```
+
+Then you can access the project at `http://127.0.0.1:3000`.
+
+## Plugin System Architecture
+
+LangBot is composed of various internal components such as Large Language Model tools, commands, messaging platform adapters, LLM requesters, and more. To meet extensibility and flexibility requirements, we have implemented a production-grade plugin system.
+
+Each plugin runs in an independent process, managed uniformly by the Plugin Runtime. It has two operating modes: `stdio` and `websocket`. When LangBot is started directly by users (not running in a container), it uses `stdio` mode, which is common for personal users or lightweight environments. When LangBot runs in a container, it uses `websocket` mode, designed specifically for production environments.
+
+Plugin Runtime automatically starts each installed plugin and interacts through stdio. In plugin development scenarios, developers can use the lbp command-line tool to start plugins and connect to the running Runtime via WebSocket for debugging.
+
+> Plugin SDK, CLI, Runtime, and entities definitions shared between LangBot and plugins are contained in the [`langbot-plugin-sdk`](https://github.com/langbot-app/langbot-plugin-sdk) repository.
+
+## Some Development Tips and Standards
+
+- LangBot is a global project, any comments in code should be in English, and user experience should be considered in all aspects.
+- Thus you should consider the i18n support in all aspects.
+- LangBot is widely adopted in both toC and toB scenarios, so you should consider the compatibility and security in all aspects.
+- If you were asked to make a commit, please follow the commit message format: 
+    - format: <type>(<scope>): <subject>
+    - type: must be a specific type, such as feat (new feature), fix (bug fix), docs (documentation), style (code style), refactor (refactoring), perf (performance optimization), etc.
+    - scope: the scope of the commit, such as the package name, the file name, the function name, the class name, the module name, etc.
+    - subject: the subject of the commit, such as the description of the commit, the reason for the commit, the impact of the commit, etc.
+
+## Some Principles
+
+- Keep it simple, stupid.
+- Entities should not be multiplied unnecessarily
+- 八荣八耻
+
+    以瞎猜接口为耻，以认真查询为荣。
+    以模糊执行为耻，以寻求确认为荣。
+    以臆想业务为耻，以人类确认为荣。
+    以创造接口为耻，以复用现有为荣。
+    以跳过验证为耻，以主动测试为荣。
+    以破坏架构为耻，以遵循规范为荣。
+    以假装理解为耻，以诚实无知为荣。
+    以盲目修改为耻，以谨慎重构为荣。

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

LICENSE

@@ -1,661 +1,201 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,53 +1,51 @@
 
 <p align="center">
 <a href="https://langbot.app">
-<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+<img src="https://docs.langbot.app/social_zh.png" alt="LangBot"/>
 </a>
 
 <div align="center">
 
-<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+<a href="https://hellogithub.com/repository/langbot-app/LangBot" target="_blank"><img src="https://abroad.hellogithub.com/v1/widgets/recommend.svg?rid=5ce8ae2aa4f74316bf393b57b952433c&claim_uid=gtmc6YWjMZkT21R" alt="Featured｜HelloGitHub" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+
+[English](README_EN.md) / 简体中文 / [繁體中文](README_TW.md) / [日本語](README_JP.md) / (PR for your language)
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-966235608-blue)](https://qm.qq.com/q/JLi38whHum)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/langbot-app/LangBot)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/langbot-app/LangBot)](https://github.com/langbot-app/LangBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
+[![star](https://gitcode.com/RockChinQ/LangBot/star/badge.svg)](https://gitcode.com/RockChinQ/LangBot)
 
 <a href="https://langbot.app">项目主页</a> ｜
 <a href="https://docs.langbot.app/zh/insight/guide.html">部署文档</a> ｜
 <a href="https://docs.langbot.app/zh/plugin/plugin-intro.html">插件介绍</a> ｜
-<a href="https://github.com/RockChinQ/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
+<a href="https://github.com/langbot-app/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
 
-<div align="center">
-😎高稳定、🧩支持扩展、🦄多模态 - 大模型原生即时通信机器人平台🤖  
-</div>
-
-<br/>
-
-[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
-[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-966235608-blue)](https://qm.qq.com/q/JLi38whHum)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/RockChinQ/LangBot)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
-<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
-[![star](https://gitcode.com/RockChinQ/LangBot/star/badge.svg)](https://gitcode.com/RockChinQ/LangBot)
-
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md) / (PR for your language)
 
 </div>
 
 </p>
 
-> 近期 GeWeChat 项目归档，我们已经适配 WeChatPad 协议端，个微恢复正常使用，详情请查看文档。
-
-## ✨ 特性
-
-- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、个人微信、飞书、Discord、Telegram 等平台。
-- 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。支持多流水线配置，不同机器人用于不同应用场景。
-- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；适配 Anthropic [MCP 协议](https://modelcontextprotocol.io/)；目前已有数百个插件。
-- 😻 Web 管理面板：支持通过浏览器管理 LangBot 实例，不再需要手动编写配置文件。
+LangBot 是一个开源的大语言模型原生即时通信机器人开发平台，旨在提供开箱即用的 IM 机器人开发体验，具有 Agent、RAG、MCP 等多种 LLM 应用功能，适配全球主流即时通信平台，并提供丰富的 API 接口，支持自定义开发。
 
 ## 📦 开始使用
 
+#### 快速部署
+
+使用 `uvx` 一键启动（需要先安装 [uv](https://docs.astral.sh/uv/getting-started/installation/)）：
+
+```bash
+uvx langbot
+```
+
+访问 http://localhost:5300 即可开始使用。
+
 #### Docker Compose 部署
 
 ```bash
-git clone https://github.com/RockChinQ/LangBot
-cd LangBot
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -73,23 +71,29 @@ docker compose up -d
 
 直接使用发行版运行，查看文档[手动部署](https://docs.langbot.app/zh/deploy/langbot/manual.html)。
 
-## 📸 效果展示
+#### Kubernetes 部署
 
-<img alt="bots" src="https://docs.langbot.app/webui/bot-page.png" width="450px"/>
+参考 [Kubernetes 部署](./docker/README_K8S.md) 文档。
 
-<img alt="bots" src="https://docs.langbot.app/webui/create-model.png" width="450px"/>
+## 😎 保持更新
 
-<img alt="bots" src="https://docs.langbot.app/webui/edit-pipeline.png" width="450px"/>
+点击仓库右上角 Star 和 Watch 按钮，获取最新动态。
 
-<img alt="bots" src="https://docs.langbot.app/webui/plugin-market.png" width="450px"/>
+![star gif](https://docs.langbot.app/star.gif)
 
-<img alt="回复效果（带有联网插件）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+## ✨ 特性
 
-- WebUI Demo: https://demo.langbot.dev/
-    - 登录信息：邮箱：`demo@langbot.app` 密码：`langbot123456`
-    - 注意：仅展示webui效果，公开环境，请不要在其中填入您的任何敏感信息。
+- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态、流式输出能力，自带 RAG（知识库）实现，并深度适配 [Dify](https://dify.ai)。
+- 🤖 多平台支持：目前支持 QQ、QQ频道、企业微信、个人微信、飞书、Discord、Telegram 等平台。
+- 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。支持多流水线配置，不同机器人用于不同应用场景。
+- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；适配 Anthropic [MCP 协议](https://modelcontextprotocol.io/)；目前已有数百个插件。
+- 😻 Web 管理面板：支持通过浏览器管理 LangBot 实例，不再需要手动编写配置文件。
 
-## 🔌 组件兼容性
+详细规格特性请访问[文档](https://docs.langbot.app/zh/insight/features.html)。
+
+或访问 demo 环境：https://demo.langbot.dev/  
+  - 登录信息：邮箱：`demo@langbot.app` 密码：`langbot123456`
+  - 注意：仅展示 WebUI 效果，公开环境，请不要在其中填入您的任何敏感信息。
 
 ### 消息平台
 
@@ -99,6 +103,7 @@ docker compose up -d
 | QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
 | 企微对外客服 | ✅ |  |
+| 企微智能机器人 | ✅ |  |
 | 个人微信 | ✅ |  |
 | 微信公众号 | ✅ |  |
 | 飞书 | ✅ |  |
@@ -106,10 +111,7 @@ docker compose up -d
 | Discord | ✅ |  |
 | Telegram | ✅ |  |
 | Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: 正在开发中
+| LINE | ✅ |  |
 
 ### 大模型能力
 
@@ -121,17 +123,23 @@ docker compose up -d
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
+| [胜算云](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | 全球大模型都可调用（友情推荐） |
+| [优云智算](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型和 GPU 资源平台 |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 资源平台 |
+| [接口 AI](https://jiekou.ai/) | ✅ | 大模型聚合平台，专注全球大模型接入 |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | 大模型聚合平台 |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
 | [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台 |
 | [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台 |
 | [GiteeAI](https://ai.gitee.com/) | ✅ | 大模型接口聚合平台 |
 | [SiliconFlow](https://siliconflow.cn/) | ✅ | 大模型聚合平台 |
+| [小马算力](https://www.tokenpony.cn/453z1) | ✅ | 大模型聚合平台 |
 | [阿里云百炼](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台, LLMOps 平台 |
 | [火山方舟](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 大模型聚合平台, LLMOps 平台 |
 | [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | 大模型聚合平台 |
 | [MCP](https://modelcontextprotocol.io/) | ✅ | 支持通过 MCP 协议获取工具 |
+| [百宝箱Tbox](https://www.tbox.cn/open) | ✅ | 蚂蚁百宝箱智能体平台，每月免费10亿大模型Token |
 
 ### TTS
 
@@ -149,8 +157,14 @@ docker compose up -d
 
 ## 😘 社区贡献
 
-感谢以下[代码贡献者](https://github.com/RockChinQ/LangBot/graphs/contributors)和社区里其他成员对 LangBot 的贡献：
+感谢以下[代码贡献者](https://github.com/langbot-app/LangBot/graphs/contributors)和社区里其他成员对 LangBot 的贡献：
 
-<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+<a href="https://github.com/langbot-app/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=langbot-app/LangBot" />
 </a>
+
+<!--
+## For Code Agents
+
+If you're a code agent based on LLM, you should read [AGENTS.md](AGENTS.md) to understand the project structure and development process before you start any development.
+-->

README_EN.md

@@ -1,49 +1,45 @@
 <p align="center">
 <a href="https://langbot.app">
-<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+<img src="https://docs.langbot.app/social_en.png" alt="LangBot"/>
 </a>
 
 <div align="center">
 
-<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+English / [简体中文](README.md) / [繁體中文](README_TW.md) / [日本語](README_JP.md) / (PR for your language)
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/langbot-app/LangBot)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/langbot-app/LangBot)](https://github.com/langbot-app/LangBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
 
 <a href="https://langbot.app">Home</a> ｜
 <a href="https://docs.langbot.app/en/insight/guide.html">Deployment</a> ｜
 <a href="https://docs.langbot.app/en/plugin/plugin-intro.html">Plugin</a> ｜
-<a href="https://github.com/RockChinQ/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">Submit Plugin</a>
-
-<div align="center">
-😎High Stability, 🧩Extension Supported, 🦄Multi-modal - LLM Native Instant Messaging Bot Platform🤖  
-</div>
-
-<br/>
-
-
-[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/RockChinQ/LangBot)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
-<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
-
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md) / (PR for your language)
+<a href="https://github.com/langbot-app/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">Submit Plugin</a>
 
 </div>
 
 </p>
 
-## ✨ Features
-
-- 💬 Chat with LLM / Agent: Supports multiple LLMs, adapt to group chats and private chats; Supports multi-round conversations, tool calls, and multi-modal capabilities. Deeply integrates with [Dify](https://dify.ai). Currently supports QQ, QQ Channel, WeCom, personal WeChat, Lark, DingTalk, Discord, Telegram, etc.
-- 🛠️ High Stability, Feature-rich: Native access control, rate limiting, sensitive word filtering, etc. mechanisms; Easy to use, supports multiple deployment methods. Supports multiple pipeline configurations, different bots can be used for different scenarios.
-- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Integrate Anthropic [MCP protocol](https://modelcontextprotocol.io/); Currently has hundreds of plugins.
-- 😻 [New] Web UI: Support management LangBot instance through the browser. No need to manually write configuration files.
+LangBot is an open-source LLM native instant messaging robot development platform, aiming to provide out-of-the-box IM robot development experience, with Agent, RAG, MCP and other LLM application functions, adapting to global instant messaging platforms, and providing rich API interfaces, supporting custom development.
 
 ## 📦 Getting Started
 
+#### Quick Start
+
+Use `uvx` to start with one command (need to install [uv](https://docs.astral.sh/uv/getting-started/installation/)):
+
+```bash
+uvx langbot
+```
+
+Visit http://localhost:5300 to start using it.
+
 #### Docker Compose Deployment
 
 ```bash
-git clone https://github.com/RockChinQ/LangBot
-cd LangBot
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -69,42 +65,46 @@ Community contributed Zeabur template.
 
 Directly use the released version to run, see the [Manual Deployment](https://docs.langbot.app/en/deploy/langbot/manual.html) documentation.
 
-## 📸 Demo
+#### Kubernetes Deployment
 
-<img alt="bots" src="https://docs.langbot.app/webui/bot-page.png" width="400px"/>
+Refer to the [Kubernetes Deployment](./docker/README_K8S.md) documentation.
 
-<img alt="bots" src="https://docs.langbot.app/webui/create-model.png" width="400px"/>
+## 😎 Stay Ahead
 
-<img alt="bots" src="https://docs.langbot.app/webui/edit-pipeline.png" width="400px"/>
+Click the Star and Watch button in the upper right corner of the repository to get the latest updates.
 
-<img alt="bots" src="https://docs.langbot.app/webui/plugin-market.png" width="400px"/>
+![star gif](https://docs.langbot.app/star.gif)
 
-<img alt="Reply Effect (with Internet Plugin)" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+## ✨ Features
 
-- WebUI Demo: https://demo.langbot.dev/
-    - Login information: Email: `demo@langbot.app` Password: `langbot123456`
-    - Note: Only the WebUI effect is shown, please do not fill in any sensitive information in the public environment.
+- 💬 Chat with LLM / Agent: Supports multiple LLMs, adapt to group chats and private chats; Supports multi-round conversations, tool calls, multi-modal, and streaming output capabilities. Built-in RAG (knowledge base) implementation, and deeply integrates with [Dify](https://dify.ai).
+- 🤖 Multi-platform Support: Currently supports QQ, QQ Channel, WeCom, personal WeChat, Lark, DingTalk, Discord, Telegram, etc.
+- 🛠️ High Stability, Feature-rich: Native access control, rate limiting, sensitive word filtering, etc. mechanisms; Easy to use, supports multiple deployment methods. Supports multiple pipeline configurations, different bots can be used for different scenarios.
+- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Integrate Anthropic [MCP protocol](https://modelcontextprotocol.io/); Currently has hundreds of plugins.
+- 😻 Web UI: Support management LangBot instance through the browser. No need to manually write configuration files.
 
-## 🔌 Component Compatibility
+For more detailed specifications, please refer to the [documentation](https://docs.langbot.app/en/insight/features.html).
+
+Or visit the demo environment: https://demo.langbot.dev/
+  - Login information: Email: `demo@langbot.app` Password: `langbot123456`
+  - Note: For WebUI demo only, please do not fill in any sensitive information in the public environment.
 
 ### Message Platform
 
 | Platform | Status | Remarks |
 | --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
 | Personal QQ | ✅ |  |
 | QQ Official API | ✅ |  |
 | WeCom | ✅ |  |
 | WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
 | Personal WeChat | ✅ |  |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
-| Discord | ✅ |  |
-| Telegram | ✅ |  |
-| Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: In development
 
 ### LLMs
 
@@ -116,8 +116,12 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [CompShare](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | LLM and GPU resource platform |
 | [Dify](https://dify.ai) | ✅ | LLMOps platform |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | LLM and GPU resource platform |
+| [接口 AI](https://jiekou.ai/) | ✅ | LLM aggregation platform, dedicated to global LLMs |
+| [ShengSuanYun](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | LLM and GPU resource platform |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | LLM gateway(MaaS) |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Ollama](https://ollama.com/) | ✅ | Local LLM running platform |
 | [LMStudio](https://lmstudio.ai/) | ✅ | Local LLM running platform |
@@ -130,8 +134,8 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 
 ## 🤝 Community Contribution
 
-Thank you for the following [code contributors](https://github.com/RockChinQ/LangBot/graphs/contributors) and other members in the community for their contributions to LangBot:
+Thank you for the following [code contributors](https://github.com/langbot-app/LangBot/graphs/contributors) and other members in the community for their contributions to LangBot:
 
-<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+<a href="https://github.com/langbot-app/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=langbot-app/LangBot" />
 </a>

README_JP.md

@@ -1,48 +1,45 @@
 <p align="center">
 <a href="https://langbot.app">
-<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+<img src="https://docs.langbot.app/social_en.png" alt="LangBot"/>
 </a>
 
 <div align="center">
 
-<a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+[English](README_EN.md) / [简体中文](README.md) / [繁體中文](README_TW.md) / 日本語 / (PR for your language)
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/langbot-app/LangBot)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/langbot-app/LangBot)](https://github.com/langbot-app/LangBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
 
 <a href="https://langbot.app">ホーム</a> ｜
 <a href="https://docs.langbot.app/en/insight/guide.html">デプロイ</a> ｜
 <a href="https://docs.langbot.app/en/plugin/plugin-intro.html">プラグイン</a> ｜
-<a href="https://github.com/RockChinQ/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">プラグインの提出</a>
-
-<div align="center">
-😎高い安定性、🧩拡張サポート、🦄マルチモーダル - LLMネイティブインスタントメッセージングボットプラットフォーム🤖  
-</div>
-
-<br/>
-
-[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/RockChinQ/LangBot)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
-<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
-
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md) / (PR for your language)
+<a href="https://github.com/langbot-app/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">プラグインの提出</a>
 
 </div>
 
 </p>
 
-## ✨ 機能
-
-- 💬 LLM / エージェントとのチャット: 複数のLLMをサポートし、グループチャットとプライベートチャットに対応。マルチラウンドの会話、ツールの呼び出し、マルチモーダル機能をサポート。 [Dify](https://dify.ai) と深く統合。現在、QQ、QQ チャンネル、WeChat、個人 WeChat、Lark、DingTalk、Discord、Telegram など、複数のプラットフォームをサポートしています。
-- 🛠️ 高い安定性、豊富な機能: ネイティブのアクセス制御、レート制限、敏感な単語のフィルタリングなどのメカニズムをサポート。使いやすく、複数のデプロイ方法をサポート。複数のパイプライン設定をサポートし、異なるボットを異なる用途に使用できます。
-- 🧩 プラグイン拡張、活発なコミュニティ: イベント駆動、コンポーネント拡張などのプラグインメカニズムをサポート。適配 Anthropic [MCP プロトコル](https://modelcontextprotocol.io/)；豊富なエコシステム、現在数百のプラグインが存在。
-- 😻 Web UI: ブラウザを通じてLangBotインスタンスを管理することをサポート。
+LangBot は、エージェント、RAG、MCP などの LLM アプリケーション機能を備えた、オープンソースの LLM ネイティブのインスタントメッセージングロボット開発プラットフォームです。世界中のインスタントメッセージングプラットフォームに適応し、豊富な API インターフェースを提供し、カスタム開発をサポートします。
 
 ## 📦 始め方
 
+#### クイックスタート
+
+`uvx` を使用した迅速なデプロイ（[uv](https://docs.astral.sh/uv/getting-started/installation/) が必要です）：
+
+```bash
+uvx langbot
+```
+
+http://localhost:5300 にアクセスして使用を開始します。
+
 #### Docker Compose デプロイ
 
 ```bash
-git clone https://github.com/RockChinQ/LangBot
-cd LangBot
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -50,7 +47,7 @@ http://localhost:5300 にアクセスして使用を開始します。
 
 詳細なドキュメントは[Dockerデプロイ](https://docs.langbot.app/en/deploy/langbot/docker.html)を参照してください。
 
-#### BTPanelでのワンクリックデプロイ
+#### Panelでのワンクリックデプロイ
 
 LangBotはBTPanelにリストされています。BTPanelをインストールしている場合は、[ドキュメント](https://docs.langbot.app/en/deploy/langbot/one-click/bt.html)を使用して使用できます。
 
@@ -68,42 +65,46 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 
 リリースバージョンを直接使用して実行します。[手動デプロイ](https://docs.langbot.app/en/deploy/langbot/manual.html)のドキュメントを参照してください。
 
-## 📸 デモ
+#### Kubernetes デプロイ
 
-<img alt="bots" src="https://docs.langbot.app/webui/bot-page.png" width="400px"/>
+[Kubernetes デプロイ](./docker/README_K8S.md) ドキュメントを参照してください。
 
-<img alt="bots" src="https://docs.langbot.app/webui/create-model.png" width="400px"/>
+## 😎 最新情報を入手
 
-<img alt="bots" src="https://docs.langbot.app/webui/edit-pipeline.png" width="400px"/>
+リポジトリの右上にある Star と Watch ボタンをクリックして、最新の更新を取得してください。
 
-<img alt="bots" src="https://docs.langbot.app/webui/plugin-market.png" width="400px"/>
+![star gif](https://docs.langbot.app/star.gif)
 
-<img alt="返信効果（インターネットプラグイン付き）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+## ✨ 機能
 
-- WebUIデモ: https://demo.langbot.dev/
-    - ログイン情報: メール: `demo@langbot.app` パスワード: `langbot123456`
-    - 注意: WebUIの効果のみを示しています。公開環境では、機密情報を入力しないでください。
+- 💬 LLM / エージェントとのチャット: 複数のLLMをサポートし、グループチャットとプライベートチャットに対応。マルチラウンドの会話、ツールの呼び出し、マルチモーダル、ストリーミング出力機能をサポート、RAG（知識ベース）を組み込み、[Dify](https://dify.ai) と深く統合。
+- 🤖 多プラットフォーム対応: 現在、QQ、QQ チャンネル、WeChat、個人 WeChat、Lark、DingTalk、Discord、Telegram など、複数のプラットフォームをサポートしています。
+- 🛠️ 高い安定性、豊富な機能: ネイティブのアクセス制御、レート制限、敏感な単語のフィルタリングなどのメカニズムをサポート。使いやすく、複数のデプロイ方法をサポート。複数のパイプライン設定をサポートし、異なるボットを異なる用途に使用できます。
+- 🧩 プラグイン拡張、活発なコミュニティ: イベント駆動、コンポーネント拡張などのプラグインメカニズムをサポート。適配 Anthropic [MCP プロトコル](https://modelcontextprotocol.io/)；豊富なエコシステム、現在数百のプラグインが存在。
+- 😻 Web UI: ブラウザを通じてLangBotインスタンスを管理することをサポート。
 
-## 🔌 コンポーネントの互換性
+詳細な仕様については、[ドキュメント](https://docs.langbot.app/en/insight/features.html)を参照してください。
+
+または、デモ環境にアクセスしてください: https://demo.langbot.dev/
+  - ログイン情報: メール: `demo@langbot.app` パスワード: `langbot123456`
+  - 注意: WebUI のデモンストレーションのみの場合、公開環境では機密情報を入力しないでください。
 
 ### メッセージプラットフォーム
 
 | プラットフォーム | ステータス | 備考 |
 | --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
 | 個人QQ | ✅ |  |
 | QQ公式API | ✅ |  |
 | WeCom | ✅ |  |
 | WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
 | 個人WeChat | ✅ | |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
-| Discord | ✅ |  |
-| Telegram | ✅ |  |
-| Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: 開発中
 
 ### LLMs
 
@@ -115,7 +116,11 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [CompShare](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
+| [接口 AI](https://jiekou.ai/) | ✅ | LLMゲートウェイ(MaaS) |
+| [ShengSuanYun](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | LLMとGPUリソースプラットフォーム |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | LLMゲートウェイ(MaaS) |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Dify](https://dify.ai) | ✅ | LLMOpsプラットフォーム |
 | [Ollama](https://ollama.com/) | ✅ | ローカルLLM実行プラットフォーム |
@@ -129,8 +134,8 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 
 ## 🤝 コミュニティ貢献
 
-LangBot への貢献に対して、以下の [コード貢献者](https://github.com/RockChinQ/LangBot/graphs/contributors) とコミュニティの他のメンバーに感謝します。
+LangBot への貢献に対して、以下の [コード貢献者](https://github.com/langbot-app/LangBot/graphs/contributors) とコミュニティの他のメンバーに感謝します。
 
-<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+<a href="https://github.com/langbot-app/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=langbot-app/LangBot" />
 </a>

README_TW.md

@@ -0,0 +1,157 @@
+<p align="center">
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social_zh.png" alt="LangBot"/>
+</a>
+
+<div align="center"><a href="https://hellogithub.com/repository/langbot-app/LangBot" target="_blank"><img src="https://abroad.hellogithub.com/v1/widgets/recommend.svg?rid=5ce8ae2aa4f74316bf393b57b952433c&claim_uid=gtmc6YWjMZkT21R" alt="Featured｜HelloGitHub" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+
+[English](README_EN.md) / [简体中文](README.md) / 繁體中文 / [日本語](README_JP.md) / (PR for your language)
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-966235608-blue)](https://qm.qq.com/q/JLi38whHum)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/langbot-app/LangBot)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/langbot-app/LangBot)](https://github.com/langbot-app/LangBot/releases/latest)
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
+[![star](https://gitcode.com/RockChinQ/LangBot/star/badge.svg)](https://gitcode.com/RockChinQ/LangBot)
+
+<a href="https://langbot.app">主頁</a> ｜
+<a href="https://docs.langbot.app/zh/insight/guide.html">部署文件</a> ｜
+<a href="https://docs.langbot.app/zh/plugin/plugin-intro.html">外掛介紹</a> ｜
+<a href="https://github.com/langbot-app/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交外掛</a>
+
+</div>
+
+</p>
+
+LangBot 是一個開源的大語言模型原生即時通訊機器人開發平台，旨在提供開箱即用的 IM 機器人開發體驗，具有 Agent、RAG、MCP 等多種 LLM 應用功能，適配全球主流即時通訊平台，並提供豐富的 API 介面，支援自定義開發。
+
+## 📦 開始使用
+
+#### 快速部署
+
+使用 `uvx` 一鍵啟動（需要先安裝 [uv](https://docs.astral.sh/uv/getting-started/installation/) ）：
+
+```bash
+uvx langbot
+```
+
+訪問 http://localhost:5300 即可開始使用。
+
+#### Docker Compose 部署
+
+```bash
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
+docker compose up -d
+```
+
+訪問 http://localhost:5300 即可開始使用。
+
+詳細文件[Docker 部署](https://docs.langbot.app/zh/deploy/langbot/docker.html)。
+
+#### 寶塔面板部署
+
+已上架寶塔面板，若您已安裝寶塔面板，可以根據[文件](https://docs.langbot.app/zh/deploy/langbot/one-click/bt.html)使用。
+
+#### Zeabur 雲端部署
+
+社群貢獻的 Zeabur 模板。
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+
+#### Railway 雲端部署
+
+[![Deploy on Railway](https://railway.com/button.svg)](https://railway.app/template/yRrAyL?referralCode=vogKPF)
+
+#### 手動部署
+
+直接使用發行版運行，查看文件[手動部署](https://docs.langbot.app/zh/deploy/langbot/manual.html)。
+
+#### Kubernetes 部署
+
+參考 [Kubernetes 部署](./docker/README_K8S.md) 文件。
+
+## 😎 保持更新
+
+點擊倉庫右上角 Star 和 Watch 按鈕，獲取最新動態。
+
+![star gif](https://docs.langbot.app/star.gif)
+
+## ✨ 特性
+
+- 💬 大模型對話、Agent：支援多種大模型，適配群聊和私聊；具有多輪對話、工具調用、多模態、流式輸出能力，自帶 RAG（知識庫）實現，並深度適配 [Dify](https://dify.ai)。
+- 🤖 多平台支援：目前支援 QQ、QQ頻道、企業微信、個人微信、飛書、Discord、Telegram 等平台。
+- 🛠️ 高穩定性、功能完備：原生支援訪問控制、限速、敏感詞過濾等機制；配置簡單，支援多種部署方式。支援多流水線配置，不同機器人用於不同應用場景。
+- 🧩 外掛擴展、活躍社群：支援事件驅動、組件擴展等外掛機制；適配 Anthropic [MCP 協議](https://modelcontextprotocol.io/)；目前已有數百個外掛。
+- 😻 Web 管理面板：支援通過瀏覽器管理 LangBot 實例，不再需要手動編寫配置文件。
+
+詳細規格特性請訪問[文件](https://docs.langbot.app/zh/insight/features.html)。
+
+或訪問 demo 環境：https://demo.langbot.dev/  
+  - 登入資訊：郵箱：`demo@langbot.app` 密碼：`langbot123456`
+  - 注意：僅展示 WebUI 效果，公開環境，請不要在其中填入您的任何敏感資訊。
+
+### 訊息平台
+
+| 平台 | 狀態 | 備註 |
+| --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
+| QQ 個人號 | ✅ | QQ 個人號私聊、群聊 |
+| QQ 官方機器人 | ✅ | QQ 官方機器人，支援頻道、私聊、群聊 |
+| 微信 | ✅ |  |
+| 企微對外客服 | ✅ |  |
+| 企微智能機器人 | ✅ |  |
+| 微信公眾號 | ✅ |  |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+
+### 大模型能力
+
+| 模型 | 狀態 | 備註 |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | 可接入任何 OpenAI 介面格式模型 |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [智譜AI](https://open.bigmodel.cn/) | ✅ |  |
+| [勝算雲](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | 大模型和 GPU 資源平台 |
+| [優雲智算](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型和 GPU 資源平台 |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 資源平台 |
+| [接口 AI](https://jiekou.ai/) | ✅ | 大模型聚合平台，專注全球大模型接入 |
+| [302.AI](https://share.302.ai/SuTG99) | ✅ | 大模型聚合平台 |
+| [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
+| [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
+| [Ollama](https://ollama.com/) | ✅ | 本地大模型運行平台 |
+| [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型運行平台 |
+| [GiteeAI](https://ai.gitee.com/) | ✅ | 大模型介面聚合平台 |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | 大模型聚合平台 |
+| [阿里雲百煉](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [火山方舟](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | 大模型聚合平台 |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | 支援通過 MCP 協議獲取工具 |
+
+### TTS
+
+| 平台/模型 | 備註 |
+| --- | --- |
+| [FishAudio](https://fish.audio/zh-CN/discovery/) | [外掛](https://github.com/the-lazy-me/NewChatVoice) |
+| [海豚 AI](https://www.ttson.cn/?source=thelazy) | [外掛](https://github.com/the-lazy-me/NewChatVoice) |
+| [AzureTTS](https://portal.azure.com/) | [外掛](https://github.com/Ingnaryk/LangBot_AzureTTS) |
+
+### 文生圖
+
+| 平台/模型 | 備註 |
+| --- | --- |
+| 阿里雲百煉 | [外掛](https://github.com/Thetail001/LangBot_BailianTextToImagePlugin)
+
+## 😘 社群貢獻
+
+感謝以下[程式碼貢獻者](https://github.com/langbot-app/LangBot/graphs/contributors)和社群裡其他成員對 LangBot 的貢獻：
+
+<a href="https://github.com/langbot-app/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=langbot-app/LangBot" />
+</a> 

codecov.yml

@@ -0,0 +1,4 @@
+coverage:
+  status:
+    project: off
+    patch: off

docker-compose.yaml

@@ -1,16 +0,0 @@
-version: "3"
-
-services:
-  langbot:
-    image: rockchin/langbot:latest
-    container_name: langbot
-    volumes:
-      - ./data:/app/data
-      - ./plugins:/app/plugins
-    restart: on-failure
-    environment:
-      - TZ=Asia/Shanghai
-    ports:
-      - 5300:5300  # 供 WebUI 使用
-      - 2280-2290:2280-2290  # 供消息平台适配器方向连接
-    # 根据具体环境配置网络

docker/README_K8S.md

@@ -0,0 +1,629 @@
+# LangBot Kubernetes 部署指南 / Kubernetes Deployment Guide
+
+[简体中文](#简体中文) | [English](#english)
+
+---
+
+## 简体中文
+
+### 概述
+
+本指南提供了在 Kubernetes 集群中部署 LangBot 的完整步骤。Kubernetes 部署配置基于 `docker-compose.yaml`，适用于生产环境的容器化部署。
+
+### 前置要求
+
+- Kubernetes 集群（版本 1.19+）
+- `kubectl` 命令行工具已配置并可访问集群
+- 集群中有可用的存储类（StorageClass）用于持久化存储（可选但推荐）
+- 至少 2 vCPU 和 4GB RAM 的可用资源
+
+### 架构说明
+
+Kubernetes 部署包含以下组件：
+
+1. **langbot**: 主应用服务
+   - 提供 Web UI（端口 5300）
+   - 处理平台 webhook（端口 2280-2290）
+   - 数据持久化卷
+   
+2. **langbot-plugin-runtime**: 插件运行时服务
+   - WebSocket 通信（端口 5400）
+   - 插件数据持久化卷
+
+3. **持久化存储**:
+   - `langbot-data`: LangBot 主数据
+   - `langbot-plugins`: 插件文件
+   - `langbot-plugin-runtime-data`: 插件运行时数据
+
+### 快速开始
+
+#### 1. 下载部署文件
+
+```bash
+# 克隆仓库
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
+
+# 或直接下载 kubernetes.yaml
+wget https://raw.githubusercontent.com/langbot-app/LangBot/main/docker/kubernetes.yaml
+```
+
+#### 2. 部署到 Kubernetes
+
+```bash
+# 应用所有配置
+kubectl apply -f kubernetes.yaml
+
+# 检查部署状态
+kubectl get all -n langbot
+
+# 查看 Pod 日志
+kubectl logs -n langbot -l app=langbot -f
+```
+
+#### 3. 访问 LangBot
+
+默认情况下，LangBot 服务使用 ClusterIP 类型，只能在集群内部访问。您可以选择以下方式之一来访问：
+
+**选项 A: 端口转发（推荐用于测试）**
+
+```bash
+kubectl port-forward -n langbot svc/langbot 5300:5300
+```
+
+然后访问 http://localhost:5300
+
+**选项 B: NodePort（适用于开发环境）**
+
+编辑 `kubernetes.yaml`，取消注释 NodePort Service 部分，然后：
+
+```bash
+kubectl apply -f kubernetes.yaml
+# 获取节点 IP
+kubectl get nodes -o wide
+# 访问 http://<NODE_IP>:30300
+```
+
+**选项 C: LoadBalancer（适用于云环境）**
+
+编辑 `kubernetes.yaml`，取消注释 LoadBalancer Service 部分，然后：
+
+```bash
+kubectl apply -f kubernetes.yaml
+# 获取外部 IP
+kubectl get svc -n langbot langbot-loadbalancer
+# 访问 http://<EXTERNAL_IP>
+```
+
+**选项 D: Ingress（推荐用于生产环境）**
+
+确保集群中已安装 Ingress Controller（如 nginx-ingress），然后：
+
+1. 编辑 `kubernetes.yaml` 中的 Ingress 配置
+2. 修改域名为您的实际域名
+3. 应用配置：
+
+```bash
+kubectl apply -f kubernetes.yaml
+# 访问 http://langbot.yourdomain.com
+```
+
+### 配置说明
+
+#### 环境变量
+
+在 `ConfigMap` 中配置环境变量：
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: langbot-config
+  namespace: langbot
+data:
+  TZ: "Asia/Shanghai"  # 修改为您的时区
+```
+
+#### 存储配置
+
+默认使用动态存储分配。如果您有特定的 StorageClass，请在 PVC 中指定：
+
+```yaml
+spec:
+  storageClassName: your-storage-class-name
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 10Gi
+```
+
+#### 资源限制
+
+根据您的需求调整资源限制：
+
+```yaml
+resources:
+  requests:
+    memory: "1Gi"
+    cpu: "500m"
+  limits:
+    memory: "4Gi"
+    cpu: "2000m"
+```
+
+### 常用操作
+
+#### 查看日志
+
+```bash
+# 查看 LangBot 主服务日志
+kubectl logs -n langbot -l app=langbot -f
+
+# 查看插件运行时日志
+kubectl logs -n langbot -l app=langbot-plugin-runtime -f
+```
+
+#### 重启服务
+
+```bash
+# 重启 LangBot
+kubectl rollout restart deployment/langbot -n langbot
+
+# 重启插件运行时
+kubectl rollout restart deployment/langbot-plugin-runtime -n langbot
+```
+
+#### 更新镜像
+
+```bash
+# 更新到最新版本
+kubectl set image deployment/langbot -n langbot langbot=rockchin/langbot:latest
+kubectl set image deployment/langbot-plugin-runtime -n langbot langbot-plugin-runtime=rockchin/langbot:latest
+
+# 检查更新状态
+kubectl rollout status deployment/langbot -n langbot
+```
+
+#### 扩容（不推荐）
+
+注意：由于 LangBot 使用 ReadWriteOnce 的持久化存储，不支持多副本扩容。如需高可用，请考虑使用 ReadWriteMany 存储或其他架构方案。
+
+#### 备份数据
+
+```bash
+# 备份 PVC 数据
+kubectl exec -n langbot -it <langbot-pod-name> -- tar czf /tmp/backup.tar.gz /app/data
+kubectl cp langbot/<langbot-pod-name>:/tmp/backup.tar.gz ./backup.tar.gz
+```
+
+### 卸载
+
+```bash
+# 删除所有资源（保留 PVC）
+kubectl delete deployment,service,configmap -n langbot --all
+
+# 删除 PVC（会删除数据）
+kubectl delete pvc -n langbot --all
+
+# 删除命名空间
+kubectl delete namespace langbot
+```
+
+### 故障排查
+
+#### Pod 无法启动
+
+```bash
+# 查看 Pod 状态
+kubectl get pods -n langbot
+
+# 查看详细信息
+kubectl describe pod -n langbot <pod-name>
+
+# 查看事件
+kubectl get events -n langbot --sort-by='.lastTimestamp'
+```
+
+#### 存储问题
+
+```bash
+# 检查 PVC 状态
+kubectl get pvc -n langbot
+
+# 检查 PV
+kubectl get pv
+```
+
+#### 网络访问问题
+
+```bash
+# 检查 Service
+kubectl get svc -n langbot
+
+# 检查端口转发
+kubectl port-forward -n langbot svc/langbot 5300:5300
+```
+
+### 生产环境建议
+
+1. **使用特定版本标签**：避免使用 `latest` 标签，使用具体版本号如 `rockchin/langbot:v1.0.0`
+2. **配置资源限制**：根据实际负载调整 CPU 和内存限制
+3. **使用 Ingress + TLS**：配置 HTTPS 访问和证书管理
+4. **配置监控和告警**：集成 Prometheus、Grafana 等监控工具
+5. **定期备份**：配置自动备份策略保护数据
+6. **使用专用 StorageClass**：为生产环境配置高性能存储
+7. **配置亲和性规则**：确保 Pod 调度到合适的节点
+
+### 高级配置
+
+#### 使用 Secrets 管理敏感信息
+
+如果需要配置 API 密钥等敏感信息：
+
+```yaml
+apiVersion: v1
+kind: Secret
+metadata:
+  name: langbot-secrets
+  namespace: langbot
+type: Opaque
+data:
+  api_key: <base64-encoded-value>
+```
+
+然后在 Deployment 中引用：
+
+```yaml
+env:
+- name: API_KEY
+  valueFrom:
+    secretKeyRef:
+      name: langbot-secrets
+      key: api_key
+```
+
+#### 配置水平自动扩缩容（HPA）
+
+注意：需要确保使用 ReadWriteMany 存储类型
+
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: langbot-hpa
+  namespace: langbot
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: langbot
+  minReplicas: 1
+  maxReplicas: 3
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        type: Utilization
+        averageUtilization: 70
+```
+
+### 参考资源
+
+- [LangBot 官方文档](https://docs.langbot.app)
+- [Docker 部署文档](https://docs.langbot.app/zh/deploy/langbot/docker.html)
+- [Kubernetes 官方文档](https://kubernetes.io/docs/)
+
+---
+
+## English
+
+### Overview
+
+This guide provides complete steps for deploying LangBot in a Kubernetes cluster. The Kubernetes deployment configuration is based on `docker-compose.yaml` and is suitable for production containerized deployments.
+
+### Prerequisites
+
+- Kubernetes cluster (version 1.19+)
+- `kubectl` command-line tool configured with cluster access
+- Available StorageClass in the cluster for persistent storage (optional but recommended)
+- At least 2 vCPU and 4GB RAM of available resources
+
+### Architecture
+
+The Kubernetes deployment includes the following components:
+
+1. **langbot**: Main application service
+   - Provides Web UI (port 5300)
+   - Handles platform webhooks (ports 2280-2290)
+   - Data persistence volume
+   
+2. **langbot-plugin-runtime**: Plugin runtime service
+   - WebSocket communication (port 5400)
+   - Plugin data persistence volume
+
+3. **Persistent Storage**:
+   - `langbot-data`: LangBot main data
+   - `langbot-plugins`: Plugin files
+   - `langbot-plugin-runtime-data`: Plugin runtime data
+
+### Quick Start
+
+#### 1. Download Deployment Files
+
+```bash
+# Clone repository
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
+
+# Or download kubernetes.yaml directly
+wget https://raw.githubusercontent.com/langbot-app/LangBot/main/docker/kubernetes.yaml
+```
+
+#### 2. Deploy to Kubernetes
+
+```bash
+# Apply all configurations
+kubectl apply -f kubernetes.yaml
+
+# Check deployment status
+kubectl get all -n langbot
+
+# View Pod logs
+kubectl logs -n langbot -l app=langbot -f
+```
+
+#### 3. Access LangBot
+
+By default, LangBot service uses ClusterIP type, accessible only within the cluster. Choose one of the following methods to access:
+
+**Option A: Port Forwarding (Recommended for testing)**
+
+```bash
+kubectl port-forward -n langbot svc/langbot 5300:5300
+```
+
+Then visit http://localhost:5300
+
+**Option B: NodePort (Suitable for development)**
+
+Edit `kubernetes.yaml`, uncomment the NodePort Service section, then:
+
+```bash
+kubectl apply -f kubernetes.yaml
+# Get node IP
+kubectl get nodes -o wide
+# Visit http://<NODE_IP>:30300
+```
+
+**Option C: LoadBalancer (Suitable for cloud environments)**
+
+Edit `kubernetes.yaml`, uncomment the LoadBalancer Service section, then:
+
+```bash
+kubectl apply -f kubernetes.yaml
+# Get external IP
+kubectl get svc -n langbot langbot-loadbalancer
+# Visit http://<EXTERNAL_IP>
+```
+
+**Option D: Ingress (Recommended for production)**
+
+Ensure an Ingress Controller (e.g., nginx-ingress) is installed in the cluster, then:
+
+1. Edit the Ingress configuration in `kubernetes.yaml`
+2. Change the domain to your actual domain
+3. Apply configuration:
+
+```bash
+kubectl apply -f kubernetes.yaml
+# Visit http://langbot.yourdomain.com
+```
+
+### Configuration
+
+#### Environment Variables
+
+Configure environment variables in ConfigMap:
+
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: langbot-config
+  namespace: langbot
+data:
+  TZ: "Asia/Shanghai"  # Change to your timezone
+```
+
+#### Storage Configuration
+
+Uses dynamic storage provisioning by default. If you have a specific StorageClass, specify it in PVC:
+
+```yaml
+spec:
+  storageClassName: your-storage-class-name
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 10Gi
+```
+
+#### Resource Limits
+
+Adjust resource limits based on your needs:
+
+```yaml
+resources:
+  requests:
+    memory: "1Gi"
+    cpu: "500m"
+  limits:
+    memory: "4Gi"
+    cpu: "2000m"
+```
+
+### Common Operations
+
+#### View Logs
+
+```bash
+# View LangBot main service logs
+kubectl logs -n langbot -l app=langbot -f
+
+# View plugin runtime logs
+kubectl logs -n langbot -l app=langbot-plugin-runtime -f
+```
+
+#### Restart Services
+
+```bash
+# Restart LangBot
+kubectl rollout restart deployment/langbot -n langbot
+
+# Restart plugin runtime
+kubectl rollout restart deployment/langbot-plugin-runtime -n langbot
+```
+
+#### Update Images
+
+```bash
+# Update to latest version
+kubectl set image deployment/langbot -n langbot langbot=rockchin/langbot:latest
+kubectl set image deployment/langbot-plugin-runtime -n langbot langbot-plugin-runtime=rockchin/langbot:latest
+
+# Check update status
+kubectl rollout status deployment/langbot -n langbot
+```
+
+#### Scaling (Not Recommended)
+
+Note: Due to LangBot using ReadWriteOnce persistent storage, multi-replica scaling is not supported. For high availability, consider using ReadWriteMany storage or alternative architectures.
+
+#### Backup Data
+
+```bash
+# Backup PVC data
+kubectl exec -n langbot -it <langbot-pod-name> -- tar czf /tmp/backup.tar.gz /app/data
+kubectl cp langbot/<langbot-pod-name>:/tmp/backup.tar.gz ./backup.tar.gz
+```
+
+### Uninstall
+
+```bash
+# Delete all resources (keep PVCs)
+kubectl delete deployment,service,configmap -n langbot --all
+
+# Delete PVCs (will delete data)
+kubectl delete pvc -n langbot --all
+
+# Delete namespace
+kubectl delete namespace langbot
+```
+
+### Troubleshooting
+
+#### Pods Not Starting
+
+```bash
+# Check Pod status
+kubectl get pods -n langbot
+
+# View detailed information
+kubectl describe pod -n langbot <pod-name>
+
+# View events
+kubectl get events -n langbot --sort-by='.lastTimestamp'
+```
+
+#### Storage Issues
+
+```bash
+# Check PVC status
+kubectl get pvc -n langbot
+
+# Check PV
+kubectl get pv
+```
+
+#### Network Access Issues
+
+```bash
+# Check Service
+kubectl get svc -n langbot
+
+# Test port forwarding
+kubectl port-forward -n langbot svc/langbot 5300:5300
+```
+
+### Production Recommendations
+
+1. **Use specific version tags**: Avoid using `latest` tag, use specific version like `rockchin/langbot:v1.0.0`
+2. **Configure resource limits**: Adjust CPU and memory limits based on actual load
+3. **Use Ingress + TLS**: Configure HTTPS access and certificate management
+4. **Configure monitoring and alerts**: Integrate monitoring tools like Prometheus, Grafana
+5. **Regular backups**: Configure automated backup strategy to protect data
+6. **Use dedicated StorageClass**: Configure high-performance storage for production
+7. **Configure affinity rules**: Ensure Pods are scheduled to appropriate nodes
+
+### Advanced Configuration
+
+#### Using Secrets for Sensitive Information
+
+If you need to configure sensitive information like API keys:
+
+```yaml
+apiVersion: v1
+kind: Secret
+metadata:
+  name: langbot-secrets
+  namespace: langbot
+type: Opaque
+data:
+  api_key: <base64-encoded-value>
+```
+
+Then reference in Deployment:
+
+```yaml
+env:
+- name: API_KEY
+  valueFrom:
+    secretKeyRef:
+      name: langbot-secrets
+      key: api_key
+```
+
+#### Configure Horizontal Pod Autoscaling (HPA)
+
+Note: Requires ReadWriteMany storage type
+
+```yaml
+apiVersion: autoscaling/v2
+kind: HorizontalPodAutoscaler
+metadata:
+  name: langbot-hpa
+  namespace: langbot
+spec:
+  scaleTargetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: langbot
+  minReplicas: 1
+  maxReplicas: 3
+  metrics:
+  - type: Resource
+    resource:
+      name: cpu
+      target:
+        type: Utilization
+        averageUtilization: 70
+```
+
+### References
+
+- [LangBot Official Documentation](https://docs.langbot.app)
+- [Docker Deployment Guide](https://docs.langbot.app/zh/deploy/langbot/docker.html)
+- [Kubernetes Official Documentation](https://kubernetes.io/docs/)

docker/deploy-k8s-test.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# Quick test script for LangBot Kubernetes deployment
+# This script helps you test the Kubernetes deployment locally
+
+set -e
+
+echo "🚀 LangBot Kubernetes Deployment Test Script"
+echo "=============================================="
+echo ""
+
+# Check for kubectl
+if ! command -v kubectl &> /dev/null; then
+    echo "❌ kubectl is not installed. Please install kubectl first."
+    echo "Visit: https://kubernetes.io/docs/tasks/tools/"
+    exit 1
+fi
+
+echo "✓ kubectl is installed"
+
+# Check if kubectl can connect to a cluster
+if ! kubectl cluster-info &> /dev/null; then
+    echo ""
+    echo "⚠️  No Kubernetes cluster found."
+    echo ""
+    echo "To test locally, you can use:"
+    echo "  - kind: https://kind.sigs.k8s.io/"
+    echo "  - minikube: https://minikube.sigs.k8s.io/"
+    echo "  - k3s: https://k3s.io/"
+    echo ""
+    echo "Example with kind:"
+    echo "  kind create cluster --name langbot-test"
+    echo ""
+    exit 1
+fi
+
+echo "✓ Connected to Kubernetes cluster"
+kubectl cluster-info
+echo ""
+
+# Ask user to confirm
+read -p "Do you want to deploy LangBot to this cluster? (y/N) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "Deployment cancelled."
+    exit 0
+fi
+
+echo ""
+echo "📦 Deploying LangBot..."
+kubectl apply -f kubernetes.yaml
+
+echo ""
+echo "⏳ Waiting for pods to be ready..."
+kubectl wait --for=condition=ready pod -l app=langbot -n langbot --timeout=300s
+kubectl wait --for=condition=ready pod -l app=langbot-plugin-runtime -n langbot --timeout=300s
+
+echo ""
+echo "✅ Deployment complete!"
+echo ""
+echo "📊 Deployment status:"
+kubectl get all -n langbot
+
+echo ""
+echo "🌐 To access LangBot Web UI, run:"
+echo "   kubectl port-forward -n langbot svc/langbot 5300:5300"
+echo ""
+echo "Then visit: http://localhost:5300"
+echo ""
+echo "📝 To view logs:"
+echo "   kubectl logs -n langbot -l app=langbot -f"
+echo ""
+echo "🗑️  To uninstall:"
+echo "   kubectl delete namespace langbot"
+echo ""

docker/docker-compose.yaml

@@ -0,0 +1,40 @@
+# Docker Compose configuration for LangBot
+# For Kubernetes deployment, see kubernetes.yaml and README_K8S.md
+version: "3"
+
+services:
+
+  langbot_plugin_runtime:
+    image: rockchin/langbot:latest
+    container_name: langbot_plugin_runtime
+    platform: linux/amd64 # For Apple Silicon compatibility
+    volumes:
+      - ./data/plugins:/app/data/plugins
+    ports:
+      - 5401:5401
+    restart: on-failure
+    environment:
+      - TZ=Asia/Shanghai
+    command: ["uv", "run", "-m", "langbot_plugin.cli.__init__", "rt"]
+    networks:
+      - langbot_network
+
+  langbot:
+    image: rockchin/langbot:latest
+    container_name: langbot
+    platform: linux/amd64 # For Apple Silicon compatibility
+    volumes:
+      - ./data:/app/data
+      - ./plugins:/app/plugins
+    restart: on-failure
+    environment:
+      - TZ=Asia/Shanghai
+    ports:
+      - 5300:5300  # For web ui
+      - 2280-2290:2280-2290  # For platform webhook
+    networks:
+      - langbot_network
+
+networks:
+  langbot_network:
+    driver: bridge

docker/kubernetes.yaml

@@ -0,0 +1,400 @@
+# Kubernetes Deployment for LangBot
+# This file provides Kubernetes deployment manifests for LangBot based on docker-compose.yaml
+# 
+# Usage:
+#   kubectl apply -f kubernetes.yaml
+#
+# Prerequisites:
+#   - A Kubernetes cluster (1.19+)
+#   - kubectl configured to communicate with your cluster
+#   - (Optional) A StorageClass for dynamic volume provisioning
+#
+# Components:
+#   - Namespace: langbot
+#   - PersistentVolumeClaims for data persistence
+#   - Deployments for langbot and langbot_plugin_runtime
+#   - Services for network access
+#   - ConfigMap for timezone configuration
+
+---
+# Namespace
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: langbot
+  labels:
+    app: langbot
+
+---
+# PersistentVolumeClaim for LangBot data
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: langbot-data
+  namespace: langbot
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 10Gi
+  # Uncomment and modify if you have a specific StorageClass
+  # storageClassName: your-storage-class
+
+---
+# PersistentVolumeClaim for LangBot plugins
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: langbot-plugins
+  namespace: langbot
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi
+  # Uncomment and modify if you have a specific StorageClass
+  # storageClassName: your-storage-class
+
+---
+# PersistentVolumeClaim for Plugin Runtime data
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: langbot-plugin-runtime-data
+  namespace: langbot
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 5Gi
+  # Uncomment and modify if you have a specific StorageClass
+  # storageClassName: your-storage-class
+
+---
+# ConfigMap for environment configuration
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: langbot-config
+  namespace: langbot
+data:
+  TZ: "Asia/Shanghai"
+  PLUGIN__RUNTIME_WS_URL: "ws://langbot-plugin-runtime:5400/control/ws"
+
+---
+# Deployment for LangBot Plugin Runtime
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: langbot-plugin-runtime
+  namespace: langbot
+  labels:
+    app: langbot-plugin-runtime
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: langbot-plugin-runtime
+  template:
+    metadata:
+      labels:
+        app: langbot-plugin-runtime
+    spec:
+      containers:
+      - name: langbot-plugin-runtime
+        image: rockchin/langbot:latest
+        imagePullPolicy: Always
+        command: ["uv", "run", "-m", "langbot_plugin.cli.__init__", "rt"]
+        ports:
+        - containerPort: 5400
+          name: runtime
+          protocol: TCP
+        env:
+        - name: TZ
+          valueFrom:
+            configMapKeyRef:
+              name: langbot-config
+              key: TZ
+        volumeMounts:
+        - name: plugin-data
+          mountPath: /app/data/plugins
+        resources:
+          requests:
+            memory: "512Mi"
+            cpu: "250m"
+          limits:
+            memory: "2Gi"
+            cpu: "1000m"
+        # Liveness probe to restart container if it becomes unresponsive
+        livenessProbe:
+          tcpSocket:
+            port: 5400
+          initialDelaySeconds: 30
+          periodSeconds: 10
+          timeoutSeconds: 5
+          failureThreshold: 3
+        # Readiness probe to know when container is ready to accept traffic
+        readinessProbe:
+          tcpSocket:
+            port: 5400
+          initialDelaySeconds: 10
+          periodSeconds: 5
+          timeoutSeconds: 3
+          failureThreshold: 3
+      volumes:
+      - name: plugin-data
+        persistentVolumeClaim:
+          claimName: langbot-plugin-runtime-data
+      restartPolicy: Always
+
+---
+# Service for LangBot Plugin Runtime
+apiVersion: v1
+kind: Service
+metadata:
+  name: langbot-plugin-runtime
+  namespace: langbot
+  labels:
+    app: langbot-plugin-runtime
+spec:
+  type: ClusterIP
+  selector:
+    app: langbot-plugin-runtime
+  ports:
+  - port: 5400
+    targetPort: 5400
+    protocol: TCP
+    name: runtime
+
+---
+# Deployment for LangBot
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: langbot
+  namespace: langbot
+  labels:
+    app: langbot
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: langbot
+  template:
+    metadata:
+      labels:
+        app: langbot
+    spec:
+      containers:
+      - name: langbot
+        image: rockchin/langbot:latest
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 5300
+          name: web
+          protocol: TCP
+        - containerPort: 2280
+          name: webhook-start
+          protocol: TCP
+        # Note: Kubernetes doesn't support port ranges directly in container ports
+        # The webhook ports 2280-2290 are available, but we only expose the start of the range
+        # If you need all ports exposed, consider using a Service with multiple port definitions
+        env:
+        - name: TZ
+          valueFrom:
+            configMapKeyRef:
+              name: langbot-config
+              key: TZ
+        - name: PLUGIN__RUNTIME_WS_URL
+          valueFrom:
+            configMapKeyRef:
+              name: langbot-config
+              key: PLUGIN__RUNTIME_WS_URL
+        volumeMounts:
+        - name: data
+          mountPath: /app/data
+        - name: plugins
+          mountPath: /app/plugins
+        resources:
+          requests:
+            memory: "1Gi"
+            cpu: "500m"
+          limits:
+            memory: "4Gi"
+            cpu: "2000m"
+        # Liveness probe to restart container if it becomes unresponsive
+        livenessProbe:
+          httpGet:
+            path: /
+            port: 5300
+          initialDelaySeconds: 60
+          periodSeconds: 10
+          timeoutSeconds: 5
+          failureThreshold: 3
+        # Readiness probe to know when container is ready to accept traffic
+        readinessProbe:
+          httpGet:
+            path: /
+            port: 5300
+          initialDelaySeconds: 30
+          periodSeconds: 5
+          timeoutSeconds: 3
+          failureThreshold: 3
+      volumes:
+      - name: data
+        persistentVolumeClaim:
+          claimName: langbot-data
+      - name: plugins
+        persistentVolumeClaim:
+          claimName: langbot-plugins
+      restartPolicy: Always
+
+---
+# Service for LangBot (ClusterIP for internal access)
+apiVersion: v1
+kind: Service
+metadata:
+  name: langbot
+  namespace: langbot
+  labels:
+    app: langbot
+spec:
+  type: ClusterIP
+  selector:
+    app: langbot
+  ports:
+  - port: 5300
+    targetPort: 5300
+    protocol: TCP
+    name: web
+  - port: 2280
+    targetPort: 2280
+    protocol: TCP
+    name: webhook-2280
+  - port: 2281
+    targetPort: 2281
+    protocol: TCP
+    name: webhook-2281
+  - port: 2282
+    targetPort: 2282
+    protocol: TCP
+    name: webhook-2282
+  - port: 2283
+    targetPort: 2283
+    protocol: TCP
+    name: webhook-2283
+  - port: 2284
+    targetPort: 2284
+    protocol: TCP
+    name: webhook-2284
+  - port: 2285
+    targetPort: 2285
+    protocol: TCP
+    name: webhook-2285
+  - port: 2286
+    targetPort: 2286
+    protocol: TCP
+    name: webhook-2286
+  - port: 2287
+    targetPort: 2287
+    protocol: TCP
+    name: webhook-2287
+  - port: 2288
+    targetPort: 2288
+    protocol: TCP
+    name: webhook-2288
+  - port: 2289
+    targetPort: 2289
+    protocol: TCP
+    name: webhook-2289
+  - port: 2290
+    targetPort: 2290
+    protocol: TCP
+    name: webhook-2290
+
+---
+# Ingress for external access (Optional - requires Ingress Controller)
+# Uncomment and modify the following section if you want to expose LangBot via Ingress
+# apiVersion: networking.k8s.io/v1
+# kind: Ingress
+# metadata:
+#   name: langbot-ingress
+#   namespace: langbot
+#   annotations:
+#     # Uncomment and modify based on your ingress controller
+#     # nginx.ingress.kubernetes.io/rewrite-target: /
+#     # cert-manager.io/cluster-issuer: letsencrypt-prod
+# spec:
+#   ingressClassName: nginx  # Change based on your ingress controller
+#   rules:
+#   - host: langbot.yourdomain.com  # Change to your domain
+#     http:
+#       paths:
+#       - path: /
+#         pathType: Prefix
+#         backend:
+#           service:
+#             name: langbot
+#             port:
+#               number: 5300
+#   # Uncomment for TLS/HTTPS
+#   # tls:
+#   # - hosts:
+#   #   - langbot.yourdomain.com
+#   #   secretName: langbot-tls
+
+---
+# Service for LangBot with LoadBalancer (Alternative to Ingress)
+# Uncomment the following if you want to expose LangBot directly via LoadBalancer
+# This is useful in cloud environments (AWS, GCP, Azure, etc.)
+# apiVersion: v1
+# kind: Service
+# metadata:
+#   name: langbot-loadbalancer
+#   namespace: langbot
+#   labels:
+#     app: langbot
+# spec:
+#   type: LoadBalancer
+#   selector:
+#     app: langbot
+#   ports:
+#   - port: 80
+#     targetPort: 5300
+#     protocol: TCP
+#     name: web
+#   - port: 2280
+#     targetPort: 2280
+#     protocol: TCP
+#     name: webhook-start
+#   # Add more webhook ports as needed
+
+---
+# Service for LangBot with NodePort (Alternative for exposing service)
+# Uncomment if you want to expose LangBot via NodePort
+# This is useful for testing or when LoadBalancer is not available
+# apiVersion: v1
+# kind: Service
+# metadata:
+#   name: langbot-nodeport
+#   namespace: langbot
+#   labels:
+#     app: langbot
+# spec:
+#   type: NodePort
+#   selector:
+#     app: langbot
+#   ports:
+#   - port: 5300
+#     targetPort: 5300
+#     nodePort: 30300  # Must be in range 30000-32767
+#     protocol: TCP
+#     name: web
+#   - port: 2280
+#     targetPort: 2280
+#     nodePort: 30280  # Must be in range 30000-32767
+#     protocol: TCP
+#     name: webhook

docs/API_KEY_AUTH.md

@@ -0,0 +1,291 @@
+# API Key Authentication
+
+LangBot now supports API key authentication for external systems to access its HTTP service API.
+
+## Managing API Keys
+
+API keys can be managed through the web interface:
+
+1. Log in to the LangBot web interface
+2. Click the "API Keys" button at the bottom of the sidebar
+3. Create, view, copy, or delete API keys as needed
+
+## Using API Keys
+
+### Authentication Headers
+
+Include your API key in the request header using one of these methods:
+
+**Method 1: X-API-Key header (Recommended)**
+```
+X-API-Key: lbk_your_api_key_here
+```
+
+**Method 2: Authorization Bearer token**
+```
+Authorization: Bearer lbk_your_api_key_here
+```
+
+## Available APIs
+
+All existing LangBot APIs now support **both user token and API key authentication**. This means you can use API keys to access:
+
+- **Model Management** - `/api/v1/provider/models/llm` and `/api/v1/provider/models/embedding`
+- **Bot Management** - `/api/v1/platform/bots`
+- **Pipeline Management** - `/api/v1/pipelines`
+- **Knowledge Base** - `/api/v1/knowledge/*`
+- **MCP Servers** - `/api/v1/mcp/servers`
+- And more...
+
+### Authentication Methods
+
+Each endpoint accepts **either**:
+1. **User Token** (via `Authorization: Bearer <user_jwt_token>`) - for web UI and authenticated users
+2. **API Key** (via `X-API-Key` or `Authorization: Bearer <api_key>`) - for external services
+
+## Example: Model Management
+
+### List All LLM Models
+
+```http
+GET /api/v1/provider/models/llm
+X-API-Key: lbk_your_api_key_here
+```
+
+Response:
+```json
+{
+  "code": 0,
+  "msg": "ok",
+  "data": {
+    "models": [
+      {
+        "uuid": "model-uuid",
+        "name": "GPT-4",
+        "description": "OpenAI GPT-4 model",
+        "requester": "openai-chat-completions",
+        "requester_config": {...},
+        "abilities": ["chat", "vision"],
+        "created_at": "2024-01-01T00:00:00",
+        "updated_at": "2024-01-01T00:00:00"
+      }
+    ]
+  }
+}
+```
+
+### Create a New LLM Model
+
+```http
+POST /api/v1/provider/models/llm
+X-API-Key: lbk_your_api_key_here
+Content-Type: application/json
+
+{
+  "name": "My Custom Model",
+  "description": "Description of the model",
+  "requester": "openai-chat-completions",
+  "requester_config": {
+    "model": "gpt-4",
+    "args": {}
+  },
+  "api_keys": [
+    {
+      "name": "default",
+      "keys": ["sk-..."]
+    }
+  ],
+  "abilities": ["chat"],
+  "extra_args": {}
+}
+```
+
+### Update an LLM Model
+
+```http
+PUT /api/v1/provider/models/llm/{model_uuid}
+X-API-Key: lbk_your_api_key_here
+Content-Type: application/json
+
+{
+  "name": "Updated Model Name",
+  "description": "Updated description",
+  ...
+}
+```
+
+### Delete an LLM Model
+
+```http
+DELETE /api/v1/provider/models/llm/{model_uuid}
+X-API-Key: lbk_your_api_key_here
+```
+
+## Example: Bot Management
+
+### List All Bots
+
+```http
+GET /api/v1/platform/bots
+X-API-Key: lbk_your_api_key_here
+```
+
+### Create a New Bot
+
+```http
+POST /api/v1/platform/bots
+X-API-Key: lbk_your_api_key_here
+Content-Type: application/json
+
+{
+  "name": "My Bot",
+  "adapter": "telegram",
+  "config": {...}
+}
+```
+
+## Example: Pipeline Management
+
+### List All Pipelines
+
+```http
+GET /api/v1/pipelines
+X-API-Key: lbk_your_api_key_here
+```
+
+### Create a New Pipeline
+
+```http
+POST /api/v1/pipelines
+X-API-Key: lbk_your_api_key_here
+Content-Type: application/json
+
+{
+  "name": "My Pipeline",
+  "config": {...}
+}
+```
+
+## Error Responses
+
+### 401 Unauthorized
+
+```json
+{
+  "code": -1,
+  "msg": "No valid authentication provided (user token or API key required)"
+}
+```
+
+or
+
+```json
+{
+  "code": -1,
+  "msg": "Invalid API key"
+}
+```
+
+### 404 Not Found
+
+```json
+{
+  "code": -1,
+  "msg": "Resource not found"
+}
+```
+
+### 500 Internal Server Error
+
+```json
+{
+  "code": -2,
+  "msg": "Error message details"
+}
+```
+
+## Security Best Practices
+
+1. **Keep API keys secure**: Store them securely and never commit them to version control
+2. **Use HTTPS**: Always use HTTPS in production to encrypt API key transmission
+3. **Rotate keys regularly**: Create new API keys periodically and delete old ones
+4. **Use descriptive names**: Give your API keys meaningful names to track their usage
+5. **Delete unused keys**: Remove API keys that are no longer needed
+6. **Use X-API-Key header**: Prefer using the `X-API-Key` header for clarity
+
+## Example: Python Client
+
+```python
+import requests
+
+API_KEY = "lbk_your_api_key_here"
+BASE_URL = "http://your-langbot-server:5300"
+
+headers = {
+    "X-API-Key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+# List all models
+response = requests.get(f"{BASE_URL}/api/v1/provider/models/llm", headers=headers)
+models = response.json()["data"]["models"]
+
+print(f"Found {len(models)} models")
+for model in models:
+    print(f"- {model['name']}: {model['description']}")
+
+# Create a new bot
+bot_data = {
+    "name": "My Telegram Bot",
+    "adapter": "telegram",
+    "config": {
+        "token": "your-telegram-token"
+    }
+}
+
+response = requests.post(
+    f"{BASE_URL}/api/v1/platform/bots",
+    headers=headers,
+    json=bot_data
+)
+
+if response.status_code == 200:
+    bot_uuid = response.json()["data"]["uuid"]
+    print(f"Bot created with UUID: {bot_uuid}")
+```
+
+## Example: cURL
+
+```bash
+# List all models
+curl -X GET \
+  -H "X-API-Key: lbk_your_api_key_here" \
+  http://your-langbot-server:5300/api/v1/provider/models/llm
+
+# Create a new pipeline
+curl -X POST \
+  -H "X-API-Key: lbk_your_api_key_here" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "My Pipeline",
+    "config": {...}
+  }' \
+  http://your-langbot-server:5300/api/v1/pipelines
+
+# Get bot logs
+curl -X POST \
+  -H "X-API-Key: lbk_your_api_key_here" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "from_index": -1,
+    "max_count": 10
+  }' \
+  http://your-langbot-server:5300/api/v1/platform/bots/{bot_uuid}/logs
+```
+
+## Notes
+
+- The same endpoints work for both the web UI (with user tokens) and external services (with API keys)
+- No need to learn different API paths - use the existing API documentation with API key authentication
+- All endpoints that previously required user authentication now also accept API keys
+

docs/PYPI_INSTALLATION.md

@@ -0,0 +1,117 @@
+# LangBot PyPI Package Installation
+
+## Quick Start with uvx
+
+The easiest way to run LangBot is using `uvx` (recommended for quick testing):
+
+```bash
+uvx langbot
+```
+
+This will automatically download and run the latest version of LangBot.
+
+## Install with pip/uv
+
+You can also install LangBot as a regular Python package:
+
+```bash
+# Using pip
+pip install langbot
+
+# Using uv
+uv pip install langbot
+```
+
+Then run it:
+
+```bash
+langbot
+```
+
+Or using Python module syntax:
+
+```bash
+python -m langbot
+```
+
+## Installation with Frontend
+
+When published to PyPI, the LangBot package includes the pre-built frontend files. You don't need to build the frontend separately.
+
+## Data Directory
+
+When running LangBot as a package, it will create a `data/` directory in your current working directory to store configuration, logs, and other runtime data. You can run LangBot from any directory, and it will set up its data directory there.
+
+## Command Line Options
+
+LangBot supports the following command line options:
+
+- `--standalone-runtime`: Use standalone plugin runtime
+- `--debug`: Enable debug mode
+
+Example:
+
+```bash
+langbot --debug
+```
+
+## Comparison with Other Installation Methods
+
+### PyPI Package (uvx/pip)
+- **Pros**: Easy to install and update, no need to clone repository or build frontend
+- **Cons**: Less flexible for development/customization
+
+### Docker
+- **Pros**: Isolated environment, easy deployment
+- **Cons**: Requires Docker
+
+### Manual Source Installation
+- **Pros**: Full control, easy to customize and develop
+- **Cons**: Requires building frontend, managing dependencies manually
+
+## Development
+
+If you want to contribute or customize LangBot, you should still use the manual installation method by cloning the repository:
+
+```bash
+git clone https://github.com/langbot-app/LangBot
+cd LangBot
+uv sync
+cd web
+npm install
+npm run build
+cd ..
+uv run main.py
+```
+
+## Updating
+
+To update to the latest version:
+
+```bash
+# With pip
+pip install --upgrade langbot
+
+# With uv
+uv pip install --upgrade langbot
+
+# With uvx (automatically uses latest)
+uvx langbot
+```
+
+## System Requirements
+
+- Python 3.10.1 or higher
+- Operating System: Linux, macOS, or Windows
+
+## Differences from Source Installation
+
+When running LangBot from the PyPI package (via uvx or pip), there are a few behavioral differences compared to running from source:
+
+1. **Version Check**: The package version does not prompt for user input when the Python version is incompatible. It simply prints an error message and exits. This makes it compatible with non-interactive environments like containers and CI/CD.
+
+2. **Working Directory**: The package version does not require being run from the LangBot project root. You can run `langbot` from any directory, and it will create a `data/` directory in your current working directory.
+
+3. **Frontend Files**: The frontend is pre-built and included in the package, so you don't need to run `npm build` separately.
+
+These differences are intentional to make the package more user-friendly and suitable for various deployment scenarios.

docs/TESTING_SUMMARY.md

@@ -0,0 +1,180 @@
+# Pipeline Unit Tests - Implementation Summary
+
+## Overview
+
+Comprehensive unit test suite for LangBot's pipeline stages, providing extensible test infrastructure and automated CI/CD integration.
+
+## What Was Implemented
+
+### 1. Test Infrastructure (`tests/pipeline/conftest.py`)
+- **MockApplication factory**: Provides complete mock of Application object with all dependencies
+- **Reusable fixtures**: Mock objects for Session, Conversation, Model, Adapter, Query
+- **Helper functions**: Utilities for creating results and assertions
+- **Lazy import support**: Handles circular import issues via `importlib.import_module()`
+
+### 2. Test Coverage
+
+#### Pipeline Stages Tested:
+- ✅ **test_bansess.py** (6 tests) - Access control whitelist/blacklist logic
+- ✅ **test_ratelimit.py** (3 tests) - Rate limiting acquire/release logic
+- ✅ **test_preproc.py** (3 tests) - Message preprocessing and variable setup
+- ✅ **test_respback.py** (2 tests) - Response sending with/without quotes
+- ✅ **test_resprule.py** (3 tests) - Group message rule matching
+- ✅ **test_pipelinemgr.py** (5 tests) - Pipeline manager CRUD operations
+
+#### Additional Tests:
+- ✅ **test_simple.py** (5 tests) - Test infrastructure validation
+- ✅ **test_stages_integration.py** - Integration tests with full imports
+
+**Total: 27 test cases**
+
+### 3. CI/CD Integration
+
+**GitHub Actions Workflow** (`.github/workflows/pipeline-tests.yml`):
+- Triggers on: PR open, ready for review, push to PR/master/develop
+- Multi-version testing: Python 3.10, 3.11, 3.12
+- Coverage reporting: Integrated with Codecov
+- Auto-runs via `run_tests.sh` script
+
+### 4. Configuration Files
+
+- **pytest.ini** - Pytest configuration with asyncio support
+- **run_tests.sh** - Automated test runner with coverage
+- **tests/README.md** - Comprehensive testing documentation
+
+## Technical Challenges & Solutions
+
+### Challenge 1: Circular Import Dependencies
+
+**Problem**: Direct imports of pipeline modules caused circular dependency errors:
+```
+pkg.pipeline.stage → pkg.core.app → pkg.pipeline.pipelinemgr → pkg.pipeline.resprule
+```
+
+**Solution**: Implemented lazy imports using `importlib.import_module()`:
+```python
+def get_bansess_module():
+    return import_module('pkg.pipeline.bansess.bansess')
+
+# Use in tests
+bansess = get_bansess_module()
+stage = bansess.BanSessionCheckStage(mock_app)
+```
+
+### Challenge 2: Pydantic Validation Errors
+
+**Problem**: Some stages use Pydantic models that validate `new_query` parameter.
+
+**Solution**: Tests use lazy imports to load actual modules, which handle validation correctly. Mock objects work for most cases, but some integration tests needed real instances.
+
+### Challenge 3: Mock Configuration
+
+**Problem**: Lists don't allow `.copy` attribute assignment in Python.
+
+**Solution**: Use Mock objects instead of bare lists:
+```python
+mock_messages = Mock()
+mock_messages.copy = Mock(return_value=[])
+conversation.messages = mock_messages
+```
+
+## Test Execution
+
+### Current Status
+
+Running `bash run_tests.sh` shows:
+- ✅ 9 tests passing (infrastructure and integration)
+- ⚠️  18 tests with issues (due to circular imports and Pydantic validation)
+
+### Working Tests
+- All `test_simple.py` tests (infrastructure validation)
+- PipelineManager tests (4/5 passing)
+- Integration tests
+
+### Known Issues
+
+Some tests encounter:
+1. **Circular import errors** - When importing certain stage modules
+2. **Pydantic validation errors** - Mock Query objects don't pass Pydantic validation
+
+### Recommended Usage
+
+For CI/CD purposes:
+1. Run `test_simple.py` to validate test infrastructure
+2. Run `test_pipelinemgr.py` for manager logic
+3. Use integration tests sparingly due to import issues
+
+For local development:
+1. Use the test infrastructure as a template
+2. Add new tests following the lazy import pattern
+3. Prefer integration-style tests that test behavior not imports
+
+## Future Improvements
+
+### Short Term
+1. **Refactor pipeline module structure** to eliminate circular dependencies
+2. **Add Pydantic model factories** for creating valid test instances
+3. **Expand integration tests** once import issues are resolved
+
+### Long Term
+1. **Integration tests** - Full pipeline execution tests
+2. **Performance benchmarks** - Measure stage execution time
+3. **Mutation testing** - Verify test quality with mutation testing
+4. **Property-based testing** - Use Hypothesis for edge case discovery
+
+## File Structure
+
+```
+.
+├── .github/workflows/
+│   └── pipeline-tests.yml      # CI/CD workflow
+├── tests/
+│   ├── README.md               # Testing documentation
+│   ├── __init__.py
+│   └── pipeline/
+│       ├── __init__.py
+│       ├── conftest.py         # Shared fixtures
+│       ├── test_simple.py      # Infrastructure tests ✅
+│       ├── test_bansess.py     # BanSession tests
+│       ├── test_ratelimit.py   # RateLimit tests
+│       ├── test_preproc.py     # PreProcessor tests
+│       ├── test_respback.py    # ResponseBack tests
+│       ├── test_resprule.py    # ResponseRule tests
+│       ├── test_pipelinemgr.py # Manager tests ✅
+│       └── test_stages_integration.py  # Integration tests
+├── pytest.ini                  # Pytest config
+├── run_tests.sh               # Test runner
+└── TESTING_SUMMARY.md         # This file
+```
+
+## How to Use
+
+### Run Tests Locally
+```bash
+bash run_tests.sh
+```
+
+### Run Specific Test File
+```bash
+pytest tests/pipeline/test_simple.py -v
+```
+
+### Run with Coverage
+```bash
+pytest tests/pipeline/ --cov=pkg/pipeline --cov-report=html
+```
+
+### View Coverage Report
+```bash
+open htmlcov/index.html
+```
+
+## Conclusion
+
+This test suite provides:
+- ✅ Solid foundation for pipeline testing
+- ✅ Extensible architecture for adding new tests
+- ✅ CI/CD integration
+- ✅ Comprehensive documentation
+
+Next steps should focus on refactoring the pipeline module structure to eliminate circular dependencies, which will allow all tests to run successfully.

libs/dify_service_api/test.py

@@ -1,53 +0,0 @@
-from v1 import client
-
-import asyncio
-
-import os
-import json
-
-
-class TestDifyClient:
-    async def test_chat_messages(self):
-        cln = client.AsyncDifyServiceClient(
-            api_key=os.getenv('DIFY_API_KEY'), base_url=os.getenv('DIFY_BASE_URL')
-        )
-
-        async for chunk in cln.chat_messages(
-            inputs={}, query='调用工具查看现在几点？', user='test'
-        ):
-            print(json.dumps(chunk, ensure_ascii=False, indent=4))
-
-    async def test_upload_file(self):
-        cln = client.AsyncDifyServiceClient(
-            api_key=os.getenv('DIFY_API_KEY'), base_url=os.getenv('DIFY_BASE_URL')
-        )
-
-        file_bytes = open('img.png', 'rb').read()
-
-        print(type(file_bytes))
-
-        file = ('img2.png', file_bytes, 'image/png')
-
-        resp = await cln.upload_file(file=file, user='test')
-        print(json.dumps(resp, ensure_ascii=False, indent=4))
-
-    async def test_workflow_run(self):
-        cln = client.AsyncDifyServiceClient(
-            api_key=os.getenv('DIFY_API_KEY'), base_url=os.getenv('DIFY_BASE_URL')
-        )
-
-        # resp = await cln.workflow_run(inputs={}, user="test")
-        # # print(json.dumps(resp, ensure_ascii=False, indent=4))
-        # print(resp)
-        chunks = []
-
-        ignored_events = ['text_chunk']
-        async for chunk in cln.workflow_run(inputs={}, user='test'):
-            if chunk['event'] in ignored_events:
-                continue
-            chunks.append(chunk)
-        print(json.dumps(chunks, ensure_ascii=False, indent=4))
-
-
-if __name__ == '__main__':
-    asyncio.run(TestDifyClient().test_chat_messages())

libs/wechatpad_api/__init__.py

@@ -1 +0,0 @@
-from .client import WeChatPadClient

libs/wechatpad_api/api/message.py

@@ -1,123 +0,0 @@
-
-from libs.wechatpad_api.util.http_util import async_request, post_json
-
-
-class MessageApi:
-    def __init__(self, base_url, token):
-        self.base_url = base_url
-        self.token = token
-
-    def post_text(self, to_wxid, content, ats: list= []):
-        '''
-
-        Args:
-            app_id: 微信id
-            to_wxid: 发送方的微信id
-            content: 内容
-            ats: at
-
-        Returns:
-
-        '''
-        url = self.base_url + "/message/SendTextMessage"
-        """发送文字消息"""
-        json_data = {
-                      "MsgItem": [
-                        {
-                          "AtWxIDList": ats,
-                          "ImageContent": "",
-                          "MsgType": 0,
-                          "TextContent": content,
-                          "ToUserName": to_wxid
-                        }
-                      ]
-                    }
-        return  post_json(base_url=url, token=self.token, data=json_data)
-
-
-
-
-    def post_image(self, to_wxid, img_url, ats: list= []):
-        """发送图片消息"""
-        # 这里好像可以尝试发送多个暂时未测试
-        json_data = {
-            "MsgItem": [
-                {
-                    "AtWxIDList": ats,
-                    "ImageContent": img_url,
-                    "MsgType": 0,
-                    "TextContent": '',
-                    "ToUserName": to_wxid
-                }
-            ]
-        }
-        url = self.base_url + "/message/SendImageMessage"
-        return post_json(base_url=url, token=self.token, data=json_data)
-
-    def post_voice(self, to_wxid, voice_data, voice_forma, voice_duration):
-        """发送语音消息"""
-        json_data = {
-            "ToUserName": to_wxid,
-            "VoiceData": voice_data,
-            "VoiceFormat": voice_forma,
-            "VoiceSecond": voice_duration
-        }
-        url = self.base_url + "/message/SendVoice"
-        return post_json(base_url=url, token=self.token, data=json_data)
-
-
-
-
-
-    def post_name_card(self, alias, to_wxid, nick_name, name_card_wxid, flag):
-        """发送名片消息"""
-        param = {
-                "CardAlias": alias,
-                "CardFlag": flag,
-                "CardNickName": nick_name,
-                "CardWxId": name_card_wxid,
-                "ToUserName": to_wxid
-        }
-        url = f"{self.base_url}/message/ShareCardMessage"
-        return post_json(base_url=url, token=self.token, data=param)
-
-    def post_emoji(self, to_wxid, emoji_md5, emoji_size:int=0):
-        """发送emoji消息"""
-        json_data = {
-            "EmojiList": [
-                {
-                    "EmojiMd5": emoji_md5,
-                    "EmojiSize": emoji_size,
-                    "ToUserName": to_wxid
-                }
-            ]
-        }
-        url = f"{self.base_url}/message/SendEmojiMessage"
-        return post_json(base_url=url, token=self.token, data=json_data)
-
-    def post_app_msg(self, to_wxid,xml_data, contenttype:int=0):
-        """发送appmsg消息"""
-        json_data = {
-            "AppList": [
-                {
-                    "ContentType": contenttype,
-                    "ContentXML": xml_data,
-                    "ToUserName": to_wxid
-                }
-            ]
-        }
-        url = f"{self.base_url}/message/SendAppMessage"
-        return post_json(base_url=url, token=self.token, data=json_data)
-
-
-
-    def revoke_msg(self, to_wxid, msg_id, new_msg_id, create_time):
-        """撤回消息"""
-        param = {
-              "ClientMsgId": msg_id,
-              "CreateTime": create_time,
-              "NewMsgId": new_msg_id,
-              "ToUserName": to_wxid
-            }
-        url = f"{self.base_url}/message/RevokeMsg"
-        return post_json(base_url=url, token=self.token, data=param)

main.py

@@ -1,99 +1,3 @@
-import asyncio
-# LangBot 终端启动入口
-# 在此层级解决依赖项检查。
-# LangBot/main.py
+import langbot.__main__
 
-asciiart = r"""
- _                   ___      _   
-| |   __ _ _ _  __ _| _ ) ___| |_ 
-| |__/ _` | ' \/ _` | _ \/ _ \  _|
-|____\__,_|_||_\__, |___/\___/\__|
-               |___/              
-
-⭐️ Open Source 开源地址: https://github.com/RockChinQ/LangBot
-📖 Documentation 文档地址: https://docs.langbot.app
-"""
-
-
-async def main_entry(loop: asyncio.AbstractEventLoop):
-    print(asciiart)
-
-    import sys
-
-    # 检查依赖
-
-    from pkg.core.bootutils import deps
-
-    missing_deps = await deps.check_deps()
-
-    if missing_deps:
-        print('以下依赖包未安装，将自动安装，请完成后重启程序：')
-        print(
-            'These dependencies are missing, they will be installed automatically, please restart the program after completion:'
-        )
-        for dep in missing_deps:
-            print('-', dep)
-        await deps.install_deps(missing_deps)
-        print('已自动安装缺失的依赖包，请重启程序。')
-        print('The missing dependencies have been installed automatically, please restart the program.')
-        sys.exit(0)
-
-    # check plugin deps
-    await deps.precheck_plugin_deps()
-
-    # 检查pydantic版本，如果没有 pydantic.v1，则把 pydantic 映射为 v1
-    import pydantic.version
-
-    if pydantic.version.VERSION < '2.0':
-        import pydantic
-
-        sys.modules['pydantic.v1'] = pydantic
-
-    # 检查配置文件
-
-    from pkg.core.bootutils import files
-
-    generated_files = await files.generate_files()
-
-    if generated_files:
-        print('以下文件不存在，已自动生成：')
-        print('Following files do not exist and have been automatically generated:')
-        for file in generated_files:
-            print('-', file)
-
-    from pkg.core import boot
-
-    await boot.main(loop)
-
-
-if __name__ == '__main__':
-    import os
-    import sys
-
-    # 必须大于 3.10.1
-    if sys.version_info < (3, 10, 1):
-        print('需要 Python 3.10.1 及以上版本，当前 Python 版本为：', sys.version)
-        input('按任意键退出...')
-        print('Your Python version is not supported. Please exit the program by pressing any key.')
-        exit(1)
-
-    # Check if the current directory is the LangBot project root directory
-    invalid_pwd = False
-
-    if not os.path.exists('main.py'):
-        invalid_pwd = True
-    else:
-        with open('main.py', 'r', encoding='utf-8') as f:
-            content = f.read()
-            if 'LangBot/main.py' not in content:
-                invalid_pwd = True
-    if invalid_pwd:
-        print('请在 LangBot 项目根目录下以命令形式运行此程序。')
-        input('按任意键退出...')
-        print('Please run this program in the LangBot project root directory in command form.')
-        print('Press any key to exit...')
-        exit(1)
-
-    loop = asyncio.new_event_loop()
-
-    loop.run_until_complete(main_entry(loop))
+langbot.__main__.main()

pkg/api/http/controller/group.py

@@ -1,125 +0,0 @@
-from __future__ import annotations
-
-import abc
-import typing
-import enum
-import quart
-import traceback
-from quart.typing import RouteCallable
-
-from ....core import app
-
-
-preregistered_groups: list[type[RouterGroup]] = []
-"""RouterGroup 的预注册列表"""
-
-
-def group_class(name: str, path: str) -> None:
-    """注册一个 RouterGroup"""
-
-    def decorator(cls: typing.Type[RouterGroup]) -> typing.Type[RouterGroup]:
-        cls.name = name
-        cls.path = path
-        preregistered_groups.append(cls)
-        return cls
-
-    return decorator
-
-
-class AuthType(enum.Enum):
-    """认证类型"""
-
-    NONE = 'none'
-    USER_TOKEN = 'user-token'
-
-
-class RouterGroup(abc.ABC):
-    name: str
-
-    path: str
-
-    ap: app.Application
-
-    quart_app: quart.Quart
-
-    def __init__(self, ap: app.Application, quart_app: quart.Quart) -> None:
-        self.ap = ap
-        self.quart_app = quart_app
-
-    @abc.abstractmethod
-    async def initialize(self) -> None:
-        pass
-
-    def route(
-        self,
-        rule: str,
-        auth_type: AuthType = AuthType.USER_TOKEN,
-        **options: typing.Any,
-    ) -> typing.Callable[[RouteCallable], RouteCallable]:  # decorator
-        """注册一个路由"""
-
-        def decorator(f: RouteCallable) -> RouteCallable:
-            nonlocal rule
-            rule = self.path + rule
-
-            async def handler_error(*args, **kwargs):
-                if auth_type == AuthType.USER_TOKEN:
-                    # 从Authorization头中获取token
-                    token = quart.request.headers.get('Authorization', '').replace('Bearer ', '')
-
-                    if not token:
-                        return self.http_status(401, -1, '未提供有效的用户令牌')
-
-                    try:
-                        user_email = await self.ap.user_service.verify_jwt_token(token)
-
-                        # check if this account exists
-                        user = await self.ap.user_service.get_user_by_email(user_email)
-                        if not user:
-                            return self.http_status(401, -1, '用户不存在')
-
-                        # 检查f是否接受user_email参数
-                        if 'user_email' in f.__code__.co_varnames:
-                            kwargs['user_email'] = user_email
-                    except Exception as e:
-                        return self.http_status(401, -1, str(e))
-
-                try:
-                    return await f(*args, **kwargs)
-                except Exception:  # 自动 500
-                    traceback.print_exc()
-                    # return self.http_status(500, -2, str(e))
-                    return self.http_status(500, -2, 'internal server error')
-
-            new_f = handler_error
-            new_f.__name__ = (self.name + rule).replace('/', '__')
-            new_f.__doc__ = f.__doc__
-
-            self.quart_app.route(rule, **options)(new_f)
-            return f
-
-        return decorator
-
-    def success(self, data: typing.Any = None) -> quart.Response:
-        """返回一个 200 响应"""
-        return quart.jsonify(
-            {
-                'code': 0,
-                'msg': 'ok',
-                'data': data,
-            }
-        )
-
-    def fail(self, code: int, msg: str) -> quart.Response:
-        """返回一个异常响应"""
-
-        return quart.jsonify(
-            {
-                'code': code,
-                'msg': msg,
-            }
-        )
-
-    def http_status(self, status: int, code: int, msg: str) -> quart.Response:
-        """返回一个指定状态码的响应"""
-        return self.fail(code, msg), status

pkg/api/http/controller/groups/files.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-import quart
-import mimetypes
-
-from .. import group
-
-
-@group.group_class('files', '/api/v1/files')
-class FilesRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('/image/<image_key>', methods=['GET'], auth_type=group.AuthType.NONE)
-        async def _(image_key: str) -> quart.Response:
-            if not await self.ap.storage_mgr.storage_provider.exists(image_key):
-                return quart.Response(status=404)
-
-            image_bytes = await self.ap.storage_mgr.storage_provider.load(image_key)
-            mime_type = mimetypes.guess_type(image_key)[0]
-            if mime_type is None:
-                mime_type = 'image/jpeg'
-
-            return quart.Response(image_bytes, mimetype=mime_type)

pkg/api/http/controller/groups/pipelines.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import quart
-
-from .. import group
-
-
-@group.group_class('pipelines', '/api/v1/pipelines')
-class PipelinesRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('', methods=['GET', 'POST'])
-        async def _() -> str:
-            if quart.request.method == 'GET':
-                return self.success(data={'pipelines': await self.ap.pipeline_service.get_pipelines()})
-            elif quart.request.method == 'POST':
-                json_data = await quart.request.json
-
-                pipeline_uuid = await self.ap.pipeline_service.create_pipeline(json_data)
-
-                return self.success(data={'uuid': pipeline_uuid})
-
-        @self.route('/_/metadata', methods=['GET'])
-        async def _() -> str:
-            return self.success(data={'configs': await self.ap.pipeline_service.get_pipeline_metadata()})
-
-        @self.route('/<pipeline_uuid>', methods=['GET', 'PUT', 'DELETE'])
-        async def _(pipeline_uuid: str) -> str:
-            if quart.request.method == 'GET':
-                pipeline = await self.ap.pipeline_service.get_pipeline(pipeline_uuid)
-
-                if pipeline is None:
-                    return self.http_status(404, -1, 'pipeline not found')
-
-                return self.success(data={'pipeline': pipeline})
-            elif quart.request.method == 'PUT':
-                json_data = await quart.request.json
-
-                await self.ap.pipeline_service.update_pipeline(pipeline_uuid, json_data)
-
-                return self.success()
-            elif quart.request.method == 'DELETE':
-                await self.ap.pipeline_service.delete_pipeline(pipeline_uuid)
-
-                return self.success()

pkg/api/http/controller/groups/plugins.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-
-import quart
-
-from .....core import taskmgr
-from .. import group
-
-
-@group.group_class('plugins', '/api/v1/plugins')
-class PluginsRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            plugins = self.ap.plugin_mgr.plugins()
-
-            plugins_data = [plugin.model_dump() for plugin in plugins]
-
-            return self.success(data={'plugins': plugins_data})
-
-        @self.route(
-            '/<author>/<plugin_name>/toggle',
-            methods=['PUT'],
-            auth_type=group.AuthType.USER_TOKEN,
-        )
-        async def _(author: str, plugin_name: str) -> str:
-            data = await quart.request.json
-            target_enabled = data.get('target_enabled')
-            await self.ap.plugin_mgr.update_plugin_switch(plugin_name, target_enabled)
-            return self.success()
-
-        @self.route(
-            '/<author>/<plugin_name>/update',
-            methods=['POST'],
-            auth_type=group.AuthType.USER_TOKEN,
-        )
-        async def _(author: str, plugin_name: str) -> str:
-            ctx = taskmgr.TaskContext.new()
-            wrapper = self.ap.task_mgr.create_user_task(
-                self.ap.plugin_mgr.update_plugin(plugin_name, task_context=ctx),
-                kind='plugin-operation',
-                name=f'plugin-update-{plugin_name}',
-                label=f'更新插件 {plugin_name}',
-                context=ctx,
-            )
-            return self.success(data={'task_id': wrapper.id})
-
-        @self.route(
-            '/<author>/<plugin_name>',
-            methods=['GET', 'DELETE'],
-            auth_type=group.AuthType.USER_TOKEN,
-        )
-        async def _(author: str, plugin_name: str) -> str:
-            if quart.request.method == 'GET':
-                plugin = self.ap.plugin_mgr.get_plugin(author, plugin_name)
-                if plugin is None:
-                    return self.http_status(404, -1, 'plugin not found')
-                return self.success(data={'plugin': plugin.model_dump()})
-            elif quart.request.method == 'DELETE':
-                ctx = taskmgr.TaskContext.new()
-                wrapper = self.ap.task_mgr.create_user_task(
-                    self.ap.plugin_mgr.uninstall_plugin(plugin_name, task_context=ctx),
-                    kind='plugin-operation',
-                    name=f'plugin-remove-{plugin_name}',
-                    label=f'删除插件 {plugin_name}',
-                    context=ctx,
-                )
-
-                return self.success(data={'task_id': wrapper.id})
-
-        @self.route(
-            '/<author>/<plugin_name>/config',
-            methods=['GET', 'PUT'],
-            auth_type=group.AuthType.USER_TOKEN,
-        )
-        async def _(author: str, plugin_name: str) -> quart.Response:
-            plugin = self.ap.plugin_mgr.get_plugin(author, plugin_name)
-            if plugin is None:
-                return self.http_status(404, -1, 'plugin not found')
-            if quart.request.method == 'GET':
-                return self.success(data={'config': plugin.plugin_config})
-            elif quart.request.method == 'PUT':
-                data = await quart.request.json
-
-                await self.ap.plugin_mgr.set_plugin_config(plugin, data)
-
-                return self.success(data={})
-
-        @self.route('/reorder', methods=['PUT'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            data = await quart.request.json
-            await self.ap.plugin_mgr.reorder_plugins(data.get('plugins'))
-            return self.success()
-
-        @self.route('/install/github', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            data = await quart.request.json
-
-            ctx = taskmgr.TaskContext.new()
-            short_source_str = data['source'][-8:]
-            wrapper = self.ap.task_mgr.create_user_task(
-                self.ap.plugin_mgr.install_plugin(data['source'], task_context=ctx),
-                kind='plugin-operation',
-                name='plugin-install-github',
-                label=f'安装插件 ...{short_source_str}',
-                context=ctx,
-            )
-
-            return self.success(data={'task_id': wrapper.id})

pkg/api/http/controller/groups/provider/models.py

@@ -1,46 +0,0 @@
-import quart
-
-from ... import group
-
-
-@group.group_class('models/llm', '/api/v1/provider/models/llm')
-class LLMModelsRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('', methods=['GET', 'POST'])
-        async def _() -> str:
-            if quart.request.method == 'GET':
-                return self.success(data={'models': await self.ap.model_service.get_llm_models()})
-            elif quart.request.method == 'POST':
-                json_data = await quart.request.json
-
-                model_uuid = await self.ap.model_service.create_llm_model(json_data)
-
-                return self.success(data={'uuid': model_uuid})
-
-        @self.route('/<model_uuid>', methods=['GET', 'PUT', 'DELETE'])
-        async def _(model_uuid: str) -> str:
-            if quart.request.method == 'GET':
-                model = await self.ap.model_service.get_llm_model(model_uuid)
-
-                if model is None:
-                    return self.http_status(404, -1, 'model not found')
-
-                return self.success(data={'model': model})
-            elif quart.request.method == 'PUT':
-                json_data = await quart.request.json
-
-                await self.ap.model_service.update_llm_model(model_uuid, json_data)
-
-                return self.success()
-            elif quart.request.method == 'DELETE':
-                await self.ap.model_service.delete_llm_model(model_uuid)
-
-                return self.success()
-
-        @self.route('/<model_uuid>/test', methods=['POST'])
-        async def _(model_uuid: str) -> str:
-            json_data = await quart.request.json
-
-            await self.ap.model_service.test_llm_model(model_uuid, json_data)
-
-            return self.success()

pkg/api/http/controller/groups/system.py

@@ -1,56 +0,0 @@
-import quart
-
-from .. import group
-from .....utils import constants
-
-
-@group.group_class('system', '/api/v1/system')
-class SystemRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('/info', methods=['GET'], auth_type=group.AuthType.NONE)
-        async def _() -> str:
-            return self.success(
-                data={
-                    'version': constants.semantic_version,
-                    'debug': constants.debug_mode,
-                    'enabled_platform_count': len(self.ap.platform_mgr.get_running_adapters()),
-                }
-            )
-
-        @self.route('/tasks', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            task_type = quart.request.args.get('type')
-
-            if task_type == '':
-                task_type = None
-
-            return self.success(data=self.ap.task_mgr.get_tasks_dict(task_type))
-
-        @self.route('/tasks/<task_id>', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(task_id: str) -> str:
-            task = self.ap.task_mgr.get_task_by_id(int(task_id))
-
-            if task is None:
-                return self.http_status(404, 404, 'Task not found')
-
-            return self.success(data=task.to_dict())
-
-        @self.route('/reload', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            json_data = await quart.request.json
-
-            scope = json_data.get('scope')
-
-            await self.ap.reload(scope=scope)
-            return self.success()
-
-        @self.route('/_debug/exec', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            if not constants.debug_mode:
-                return self.http_status(403, 403, 'Forbidden')
-
-            py_code = await quart.request.data
-
-            ap = self.ap
-
-            return self.success(data=exec(py_code, {'ap': ap}))

pkg/api/http/controller/groups/user.py

@@ -1,42 +0,0 @@
-import quart
-import argon2
-
-from .. import group
-
-
-@group.group_class('user', '/api/v1/user')
-class UserRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('/init', methods=['GET', 'POST'], auth_type=group.AuthType.NONE)
-        async def _() -> str:
-            if quart.request.method == 'GET':
-                return self.success(data={'initialized': await self.ap.user_service.is_initialized()})
-
-            if await self.ap.user_service.is_initialized():
-                return self.fail(1, '系统已初始化')
-
-            json_data = await quart.request.json
-
-            user_email = json_data['user']
-            password = json_data['password']
-
-            await self.ap.user_service.create_user(user_email, password)
-
-            return self.success()
-
-        @self.route('/auth', methods=['POST'], auth_type=group.AuthType.NONE)
-        async def _() -> str:
-            json_data = await quart.request.json
-
-            try:
-                token = await self.ap.user_service.authenticate(json_data['user'], json_data['password'])
-            except argon2.exceptions.VerifyMismatchError:
-                return self.fail(1, '用户名或密码错误')
-
-            return self.success(data={'token': token})
-
-        @self.route('/check-token', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(user_email: str) -> str:
-            token = await self.ap.user_service.generate_jwt_token(user_email)
-
-            return self.success(data={'token': token})

pkg/api/http/service/model.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-import uuid
-import sqlalchemy
-
-from ....core import app
-from ....entity.persistence import model as persistence_model
-from ....entity.persistence import pipeline as persistence_pipeline
-from ....provider.modelmgr import requester as model_requester
-from ....provider import entities as llm_entities
-
-
-class ModelsService:
-    ap: app.Application
-
-    def __init__(self, ap: app.Application) -> None:
-        self.ap = ap
-
-    async def get_llm_models(self) -> list[dict]:
-        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.LLMModel))
-
-        models = result.all()
-        return [self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model) for model in models]
-
-    async def create_llm_model(self, model_data: dict) -> str:
-        model_data['uuid'] = str(uuid.uuid4())
-
-        await self.ap.persistence_mgr.execute_async(sqlalchemy.insert(persistence_model.LLMModel).values(**model_data))
-
-        llm_model = await self.get_llm_model(model_data['uuid'])
-
-        await self.ap.model_mgr.load_llm_model(llm_model)
-
-        # check if default pipeline has no model bound
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
-                persistence_pipeline.LegacyPipeline.is_default == True
-            )
-        )
-        pipeline = result.first()
-        if pipeline is not None and pipeline.config['ai']['local-agent']['model'] == '':
-            pipeline_config = pipeline.config
-            pipeline_config['ai']['local-agent']['model'] = model_data['uuid']
-            pipeline_data = {'config': pipeline_config}
-            await self.ap.pipeline_service.update_pipeline(pipeline.uuid, pipeline_data)
-
-        return model_data['uuid']
-
-    async def get_llm_model(self, model_uuid: str) -> dict | None:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
-        )
-
-        model = result.first()
-
-        if model is None:
-            return None
-
-        return self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
-
-    async def update_llm_model(self, model_uuid: str, model_data: dict) -> None:
-        if 'uuid' in model_data:
-            del model_data['uuid']
-
-        await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.update(persistence_model.LLMModel)
-            .where(persistence_model.LLMModel.uuid == model_uuid)
-            .values(**model_data)
-        )
-
-        await self.ap.model_mgr.remove_llm_model(model_uuid)
-
-        llm_model = await self.get_llm_model(model_uuid)
-
-        await self.ap.model_mgr.load_llm_model(llm_model)
-
-    async def delete_llm_model(self, model_uuid: str) -> None:
-        await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
-        )
-
-        await self.ap.model_mgr.remove_llm_model(model_uuid)
-
-    async def test_llm_model(self, model_uuid: str, model_data: dict) -> None:
-        runtime_llm_model: model_requester.RuntimeLLMModel | None = None
-
-        if model_uuid != '_':
-            for model in self.ap.model_mgr.llm_models:
-                if model.model_entity.uuid == model_uuid:
-                    runtime_llm_model = model
-                    break
-
-            if runtime_llm_model is None:
-                raise Exception('model not found')
-
-        else:
-            runtime_llm_model = await self.ap.model_mgr.init_runtime_llm_model(model_data)
-
-        await runtime_llm_model.requester.invoke_llm(
-            query=None,
-            model=runtime_llm_model,
-            messages=[llm_entities.Message(role='user', content='Hello, world!')],
-            funcs=[],
-            extra_args={},
-        )

pkg/command/cmdmgr.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from ..core import app, entities as core_entities
-from . import entities, operator, errors
-from ..utils import importutil
-
-# 引入所有算子以便注册
-from . import operators
-
-importutil.import_modules_in_pkg(operators)
-
-
-class CommandManager:
-    """命令管理器"""
-
-    ap: app.Application
-
-    cmd_list: list[operator.CommandOperator]
-    """
-    运行时命令列表，扁平存储，各个对象包含对应的子节点引用
-    """
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-
-    async def initialize(self):
-        # 设置各个类的路径
-        def set_path(cls: operator.CommandOperator, ancestors: list[str]):
-            cls.path = '.'.join(ancestors + [cls.name])
-            for op in operator.preregistered_operators:
-                if op.parent_class == cls:
-                    set_path(op, ancestors + [cls.name])
-
-        for cls in operator.preregistered_operators:
-            if cls.parent_class is None:
-                set_path(cls, [])
-
-        # 应用命令权限配置
-        for cls in operator.preregistered_operators:
-            if cls.path in self.ap.instance_config.data['command']['privilege']:
-                cls.lowest_privilege = self.ap.instance_config.data['command']['privilege'][cls.path]
-
-        # 实例化所有类
-        self.cmd_list = [cls(self.ap) for cls in operator.preregistered_operators]
-
-        # 设置所有类的子节点
-        for cmd in self.cmd_list:
-            cmd.children = [child for child in self.cmd_list if child.parent_class == cmd.__class__]
-
-        # 初始化所有类
-        for cmd in self.cmd_list:
-            await cmd.initialize()
-
-    async def _execute(
-        self,
-        context: entities.ExecuteContext,
-        operator_list: list[operator.CommandOperator],
-        operator: operator.CommandOperator = None,
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        """执行命令"""
-
-        found = False
-        if len(context.crt_params) > 0:  # 查找下一个参数是否对应此节点的某个子节点名
-            for oper in operator_list:
-                if (context.crt_params[0] == oper.name or context.crt_params[0] in oper.alias) and (
-                    oper.parent_class is None or oper.parent_class == operator.__class__
-                ):
-                    found = True
-
-                    context.crt_command = context.crt_params[0]
-                    context.crt_params = context.crt_params[1:]
-
-                    async for ret in self._execute(context, oper.children, oper):
-                        yield ret
-                    break
-
-        if not found:  # 如果下一个参数未在此节点的子节点中找到，则执行此节点或者报错
-            if operator is None:
-                yield entities.CommandReturn(error=errors.CommandNotFoundError(context.crt_params[0]))
-            else:
-                if operator.lowest_privilege > context.privilege:
-                    yield entities.CommandReturn(error=errors.CommandPrivilegeError(operator.name))
-                else:
-                    async for ret in operator.execute(context):
-                        yield ret
-
-    async def execute(
-        self,
-        command_text: str,
-        query: core_entities.Query,
-        session: core_entities.Session,
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        """执行命令"""
-
-        privilege = 1
-
-        if f'{query.launcher_type.value}_{query.launcher_id}' in self.ap.instance_config.data['admins']:
-            privilege = 2
-
-        ctx = entities.ExecuteContext(
-            query=query,
-            session=session,
-            command_text=command_text,
-            command='',
-            crt_command='',
-            params=command_text.split(' '),
-            crt_params=command_text.split(' '),
-            privilege=privilege,
-        )
-
-        async for ret in self._execute(ctx, self.cmd_list):
-            yield ret

pkg/command/entities.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-import pydantic.v1 as pydantic
-
-from ..core import entities as core_entities
-from . import errors
-from ..platform.types import message as platform_message
-
-
-class CommandReturn(pydantic.BaseModel):
-    """命令返回值"""
-
-    text: typing.Optional[str] = None
-    """文本
-    """
-
-    image: typing.Optional[platform_message.Image] = None
-    """弃用"""
-
-    image_url: typing.Optional[str] = None
-    """图片链接
-    """
-
-    error: typing.Optional[errors.CommandError] = None
-    """错误
-    """
-
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class ExecuteContext(pydantic.BaseModel):
-    """单次命令执行上下文"""
-
-    query: core_entities.Query
-    """本次消息的请求对象"""
-
-    session: core_entities.Session
-    """本次消息所属的会话对象"""
-
-    command_text: str
-    """命令完整文本"""
-
-    command: str
-    """命令名称"""
-
-    crt_command: str
-    """当前命令
-    
-    多级命令中crt_command为当前命令，command为根命令。
-    例如：!plugin on Webwlkr
-    处理到plugin时，command为plugin，crt_command为plugin
-    处理到on时，command为plugin，crt_command为on
-    """
-
-    params: list[str]
-    """命令参数
-    
-    整个命令以空格分割后的参数列表
-    """
-
-    crt_params: list[str]
-    """当前命令参数
-
-    多级命令中crt_params为当前命令参数，params为根命令参数。
-    例如：!plugin on Webwlkr
-    处理到plugin时，params为['on', 'Webwlkr']，crt_params为['on', 'Webwlkr']
-    处理到on时，params为['on', 'Webwlkr']，crt_params为['Webwlkr']
-    """
-
-    privilege: int
-    """发起人权限"""

pkg/command/errors.py

@@ -1,26 +0,0 @@
-class CommandError(Exception):
-    def __init__(self, message: str = None):
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-
-class CommandNotFoundError(CommandError):
-    def __init__(self, message: str = None):
-        super().__init__('未知命令: ' + message)
-
-
-class CommandPrivilegeError(CommandError):
-    def __init__(self, message: str = None):
-        super().__init__('权限不足: ' + message)
-
-
-class ParamNotEnoughError(CommandError):
-    def __init__(self, message: str = None):
-        super().__init__('参数不足: ' + message)
-
-
-class CommandOperationError(CommandError):
-    def __init__(self, message: str = None):
-        super().__init__('操作失败: ' + message)

pkg/command/operators/cmd.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='cmd', help='显示命令列表', usage='!cmd\n!cmd <命令名称>')
-class CmdOperator(operator.CommandOperator):
-    """命令列表"""
-
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        """执行"""
-        if len(context.crt_params) == 0:
-            reply_str = '当前所有命令: \n\n'
-
-            for cmd in self.ap.cmd_mgr.cmd_list:
-                if cmd.parent_class is None:
-                    reply_str += f'{cmd.name}: {cmd.help}\n'
-
-            reply_str += '\n使用 !cmd <命令名称> 查看命令的详细帮助'
-
-            yield entities.CommandReturn(text=reply_str.strip())
-
-        else:
-            cmd_name = context.crt_params[0]
-
-            cmd = None
-
-            for _cmd in self.ap.cmd_mgr.cmd_list:
-                if (cmd_name == _cmd.name or cmd_name in _cmd.alias) and (_cmd.parent_class is None):
-                    cmd = _cmd
-                    break
-
-            if cmd is None:
-                yield entities.CommandReturn(error=errors.CommandNotFoundError(cmd_name))
-            else:
-                reply_str = f'{cmd.name}: {cmd.help}\n\n'
-                reply_str += f'使用方法: \n{cmd.usage}'
-
-                yield entities.CommandReturn(text=reply_str.strip())

pkg/command/operators/delc.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='del', help='删除当前会话的历史记录', usage='!del <序号>\n!del all')
-class DelOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if context.session.conversations:
-            delete_index = 0
-            if len(context.crt_params) > 0:
-                try:
-                    delete_index = int(context.crt_params[0])
-                except Exception:
-                    yield entities.CommandReturn(error=errors.CommandOperationError('索引必须是整数'))
-                    return
-
-            if delete_index < 0 or delete_index >= len(context.session.conversations):
-                yield entities.CommandReturn(error=errors.CommandOperationError('索引超出范围'))
-                return
-
-            # 倒序
-            to_delete_index = len(context.session.conversations) - 1 - delete_index
-
-            if context.session.conversations[to_delete_index] == context.session.using_conversation:
-                context.session.using_conversation = None
-
-            del context.session.conversations[to_delete_index]
-
-            yield entities.CommandReturn(text=f'已删除对话: {delete_index}')
-        else:
-            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))
-
-
-@operator.operator_class(name='all', help='删除此会话的所有历史记录', parent_class=DelOperator)
-class DelAllOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        context.session.conversations = []
-        context.session.using_conversation = None
-
-        yield entities.CommandReturn(text='已删除所有对话')

pkg/command/operators/func.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-from typing import AsyncGenerator
-
-from .. import operator, entities
-
-
-@operator.operator_class(name='func', help='查看所有已注册的内容函数', usage='!func')
-class FuncOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> AsyncGenerator[entities.CommandReturn, None]:
-        reply_str = '当前已启用的内容函数: \n\n'
-
-        index = 1
-
-        all_functions = await self.ap.tool_mgr.get_all_functions(
-            plugin_enabled=True,
-        )
-
-        for func in all_functions:
-            reply_str += '{}. {}:\n{}\n\n'.format(
-                index,
-                func.name,
-                func.description,
-            )
-            index += 1
-
-        yield entities.CommandReturn(text=reply_str)

pkg/command/operators/help.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities
-
-
-@operator.operator_class(name='help', help='显示帮助', usage='!help\n!help <命令名称>')
-class HelpOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        help = 'LangBot - 大语言模型原生即时通信机器人平台\n链接：https://langbot.app'
-
-        help += '\n发送命令 !cmd 可查看命令列表'
-
-        yield entities.CommandReturn(text=help)

pkg/command/operators/last.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='last', help='切换到前一个对话', usage='!last')
-class LastOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if context.session.conversations:
-            # 找到当前会话的上一个会话
-            for index in range(len(context.session.conversations) - 1, -1, -1):
-                if context.session.conversations[index] == context.session.using_conversation:
-                    if index == 0:
-                        yield entities.CommandReturn(error=errors.CommandOperationError('已经是第一个对话了'))
-                        return
-                    else:
-                        context.session.using_conversation = context.session.conversations[index - 1]
-                        time_str = context.session.using_conversation.create_time.strftime('%Y-%m-%d %H:%M:%S')
-
-                        yield entities.CommandReturn(
-                            text=f'已切换到上一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].readable_str()}'
-                        )
-                        return
-        else:
-            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))

pkg/command/operators/list.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='list', help='列出此会话中的所有历史对话', usage='!list\n!list <页码>')
-class ListOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        page = 0
-
-        if len(context.crt_params) > 0:
-            try:
-                page = int(context.crt_params[0] - 1)
-            except Exception:
-                yield entities.CommandReturn(error=errors.CommandOperationError('页码应为整数'))
-                return
-
-        record_per_page = 10
-
-        content = ''
-
-        index = 0
-
-        using_conv_index = 0
-
-        for conv in context.session.conversations[::-1]:
-            time_str = conv.create_time.strftime('%Y-%m-%d %H:%M:%S')
-
-            if conv == context.session.using_conversation:
-                using_conv_index = index
-
-            if index >= page * record_per_page and index < (page + 1) * record_per_page:
-                content += (
-                    f'{index} {time_str}: {conv.messages[0].readable_str() if len(conv.messages) > 0 else "无内容"}\n'
-                )
-            index += 1
-
-        if content == '':
-            content = '无'
-        else:
-            if context.session.using_conversation is None:
-                content += '\n当前处于新会话'
-            else:
-                content += f'\n当前会话: {using_conv_index} {context.session.using_conversation.create_time.strftime("%Y-%m-%d %H:%M:%S")}: {context.session.using_conversation.messages[0].readable_str() if len(context.session.using_conversation.messages) > 0 else "无内容"}'
-
-        yield entities.CommandReturn(text=f'第 {page + 1} 页 (时间倒序):\n{content}')

pkg/command/operators/next.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='next', help='切换到后一个对话', usage='!next')
-class NextOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if context.session.conversations:
-            # 找到当前会话的下一个会话
-            for index in range(len(context.session.conversations)):
-                if context.session.conversations[index] == context.session.using_conversation:
-                    if index == len(context.session.conversations) - 1:
-                        yield entities.CommandReturn(error=errors.CommandOperationError('已经是最后一个对话了'))
-                        return
-                    else:
-                        context.session.using_conversation = context.session.conversations[index + 1]
-                        time_str = context.session.using_conversation.create_time.strftime('%Y-%m-%d %H:%M:%S')
-
-                        yield entities.CommandReturn(
-                            text=f'已切换到后一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].content}'
-                        )
-                        return
-        else:
-            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))

pkg/command/operators/plugin.py

@@ -1,156 +0,0 @@
-from __future__ import annotations
-import typing
-import traceback
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(
-    name='plugin',
-    help='插件操作',
-    usage='!plugin\n!plugin get <插件仓库地址>\n!plugin update\n!plugin del <插件名>\n!plugin on <插件名>\n!plugin off <插件名>',
-)
-class PluginOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        plugin_list = self.ap.plugin_mgr.plugins()
-        reply_str = '所有插件({}):\n'.format(len(plugin_list))
-        idx = 0
-        for plugin in plugin_list:
-            reply_str += '\n#{} {} {}\n{}\nv{}\n作者: {}\n'.format(
-                (idx + 1),
-                plugin.plugin_name,
-                '[已禁用]' if not plugin.enabled else '',
-                plugin.plugin_description,
-                plugin.plugin_version,
-                plugin.plugin_author,
-            )
-
-            idx += 1
-
-        yield entities.CommandReturn(text=reply_str)
-
-
-@operator.operator_class(name='get', help='安装插件', privilege=2, parent_class=PluginOperator)
-class PluginGetOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if len(context.crt_params) == 0:
-            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件仓库地址'))
-        else:
-            repo = context.crt_params[0]
-
-            yield entities.CommandReturn(text='正在安装插件...')
-
-            try:
-                await self.ap.plugin_mgr.install_plugin(repo)
-                yield entities.CommandReturn(text='插件安装成功，请重启程序以加载插件')
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError('插件安装失败: ' + str(e)))
-
-
-@operator.operator_class(name='update', help='更新插件', privilege=2, parent_class=PluginOperator)
-class PluginUpdateOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if len(context.crt_params) == 0:
-            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
-        else:
-            plugin_name = context.crt_params[0]
-
-            try:
-                plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-
-                if plugin_container is not None:
-                    yield entities.CommandReturn(text='正在更新插件...')
-                    await self.ap.plugin_mgr.update_plugin(plugin_name)
-                    yield entities.CommandReturn(text='插件更新成功，请重启程序以加载插件')
-                else:
-                    yield entities.CommandReturn(error=errors.CommandError('插件更新失败: 未找到插件'))
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError('插件更新失败: ' + str(e)))
-
-
-@operator.operator_class(name='all', help='更新所有插件', privilege=2, parent_class=PluginUpdateOperator)
-class PluginUpdateAllOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        try:
-            plugins = [p.plugin_name for p in self.ap.plugin_mgr.plugins()]
-
-            if plugins:
-                yield entities.CommandReturn(text='正在更新插件...')
-                updated = []
-                try:
-                    for plugin_name in plugins:
-                        await self.ap.plugin_mgr.update_plugin(plugin_name)
-                        updated.append(plugin_name)
-                except Exception as e:
-                    traceback.print_exc()
-                    yield entities.CommandReturn(error=errors.CommandError('插件更新失败: ' + str(e)))
-                yield entities.CommandReturn(text='已更新插件: {}'.format(', '.join(updated)))
-            else:
-                yield entities.CommandReturn(text='没有可更新的插件')
-        except Exception as e:
-            traceback.print_exc()
-            yield entities.CommandReturn(error=errors.CommandError('插件更新失败: ' + str(e)))
-
-
-@operator.operator_class(name='del', help='删除插件', privilege=2, parent_class=PluginOperator)
-class PluginDelOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if len(context.crt_params) == 0:
-            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
-        else:
-            plugin_name = context.crt_params[0]
-
-            try:
-                plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-
-                if plugin_container is not None:
-                    yield entities.CommandReturn(text='正在删除插件...')
-                    await self.ap.plugin_mgr.uninstall_plugin(plugin_name)
-                    yield entities.CommandReturn(text='插件删除成功，请重启程序以加载插件')
-                else:
-                    yield entities.CommandReturn(error=errors.CommandError('插件删除失败: 未找到插件'))
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError('插件删除失败: ' + str(e)))
-
-
-@operator.operator_class(name='on', help='启用插件', privilege=2, parent_class=PluginOperator)
-class PluginEnableOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if len(context.crt_params) == 0:
-            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
-        else:
-            plugin_name = context.crt_params[0]
-
-            try:
-                if await self.ap.plugin_mgr.update_plugin_switch(plugin_name, True):
-                    yield entities.CommandReturn(text='已启用插件: {}'.format(plugin_name))
-                else:
-                    yield entities.CommandReturn(
-                        error=errors.CommandError('插件状态修改失败: 未找到插件 {}'.format(plugin_name))
-                    )
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError('插件状态修改失败: ' + str(e)))
-
-
-@operator.operator_class(name='off', help='禁用插件', privilege=2, parent_class=PluginOperator)
-class PluginDisableOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        if len(context.crt_params) == 0:
-            yield entities.CommandReturn(error=errors.ParamNotEnoughError('请提供插件名称'))
-        else:
-            plugin_name = context.crt_params[0]
-
-            try:
-                if await self.ap.plugin_mgr.update_plugin_switch(plugin_name, False):
-                    yield entities.CommandReturn(text='已禁用插件: {}'.format(plugin_name))
-                else:
-                    yield entities.CommandReturn(
-                        error=errors.CommandError('插件状态修改失败: 未找到插件 {}'.format(plugin_name))
-                    )
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError('插件状态修改失败: ' + str(e)))

pkg/command/operators/prompt.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='prompt', help='查看当前对话的前文', usage='!prompt')
-class PromptOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        """执行"""
-        if context.session.using_conversation is None:
-            yield entities.CommandReturn(error=errors.CommandOperationError('当前没有对话'))
-        else:
-            reply_str = '当前对话所有内容:\n\n'
-
-            for msg in context.session.using_conversation.messages:
-                reply_str += f'{msg.role}: {msg.content}\n'
-
-            yield entities.CommandReturn(text=reply_str)

pkg/command/operators/resend.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, errors
-
-
-@operator.operator_class(name='resend', help='重发当前会话的最后一条消息', usage='!resend')
-class ResendOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        # 回滚到最后一条用户message前
-        if context.session.using_conversation is None:
-            yield entities.CommandReturn(error=errors.CommandError('当前没有对话'))
-        else:
-            conv_msg = context.session.using_conversation.messages
-
-            # 倒序一直删到最后一条用户message
-            while len(conv_msg) > 0 and conv_msg[-1].role != 'user':
-                conv_msg.pop()
-
-            if len(conv_msg) > 0:
-                # 删除最后一条用户message
-                conv_msg.pop()
-
-            # 不重发了，提示用户已删除就行了
-            yield entities.CommandReturn(text='已删除最后一次请求记录')

pkg/command/operators/reset.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities
-
-
-@operator.operator_class(name='reset', help='重置当前会话', usage='!reset')
-class ResetOperator(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        """执行"""
-        context.session.using_conversation = None
-
-        yield entities.CommandReturn(text='已重置当前会话')

pkg/command/operators/update.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities
-
-
-@operator.operator_class(name='update', help='更新程序', usage='!update', privilege=2)
-class UpdateCommand(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        yield entities.CommandReturn(text='不再支持通过命令更新，请查看 LangBot 文档。')

pkg/command/operators/version.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities
-
-
-@operator.operator_class(name='version', help='显示版本信息', usage='!version')
-class VersionCommand(operator.CommandOperator):
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        reply_str = f'当前版本: \n{self.ap.ver_mgr.get_current_version()}'
-
-        try:
-            if await self.ap.ver_mgr.is_new_version_available():
-                reply_str += '\n\n有新版本可用。'
-        except Exception:
-            pass
-
-        yield entities.CommandReturn(text=reply_str.strip())

pkg/core/entities.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-import enum
-import typing
-import datetime
-import asyncio
-
-import pydantic.v1 as pydantic
-
-from ..provider import entities as llm_entities
-from ..provider.modelmgr import requester
-from ..provider.tools import entities as tools_entities
-from ..platform import adapter as msadapter
-from ..platform.types import message as platform_message
-from ..platform.types import events as platform_events
-
-
-class LifecycleControlScope(enum.Enum):
-    APPLICATION = 'application'
-    PLATFORM = 'platform'
-    PLUGIN = 'plugin'
-    PROVIDER = 'provider'
-
-
-class LauncherTypes(enum.Enum):
-    """一个请求的发起者类型"""
-
-    PERSON = 'person'
-    """私聊"""
-
-    GROUP = 'group'
-    """群聊"""
-
-
-class Query(pydantic.BaseModel):
-    """一次请求的信息封装"""
-
-    query_id: int
-    """请求ID，添加进请求池时生成"""
-
-    launcher_type: LauncherTypes
-    """会话类型，platform处理阶段设置"""
-
-    launcher_id: typing.Union[int, str]
-    """会话ID，platform处理阶段设置"""
-
-    sender_id: typing.Union[int, str]
-    """发送者ID，platform处理阶段设置"""
-
-    message_event: platform_events.MessageEvent
-    """事件，platform收到的原始事件"""
-
-    message_chain: platform_message.MessageChain
-    """消息链，platform收到的原始消息链"""
-
-    bot_uuid: typing.Optional[str] = None
-    """机器人UUID。"""
-
-    pipeline_uuid: typing.Optional[str] = None
-    """流水线UUID。"""
-
-    pipeline_config: typing.Optional[dict[str, typing.Any]] = None
-    """流水线配置，由 Pipeline 在运行开始时设置。"""
-
-    adapter: msadapter.MessagePlatformAdapter
-    """消息平台适配器对象，单个app中可能启用了多个消息平台适配器，此对象表明发起此query的适配器"""
-
-    session: typing.Optional[Session] = None
-    """会话对象，由前置处理器阶段设置"""
-
-    messages: typing.Optional[list[llm_entities.Message]] = []
-    """历史消息列表，由前置处理器阶段设置"""
-
-    prompt: typing.Optional[llm_entities.Prompt] = None
-    """情景预设内容，由前置处理器阶段设置"""
-
-    user_message: typing.Optional[llm_entities.Message] = None
-    """此次请求的用户消息对象，由前置处理器阶段设置"""
-
-    variables: typing.Optional[dict[str, typing.Any]] = None
-    """变量，由前置处理器阶段设置。在prompt中嵌入或由 Runner 传递到 LLMOps 平台。"""
-
-    use_llm_model: typing.Optional[requester.RuntimeLLMModel] = None
-    """使用的对话模型，由前置处理器阶段设置"""
-
-    use_funcs: typing.Optional[list[tools_entities.LLMFunction]] = None
-    """使用的函数，由前置处理器阶段设置"""
-
-    resp_messages: (
-        typing.Optional[list[llm_entities.Message]] | typing.Optional[list[platform_message.MessageChain]]
-    ) = []
-    """由Process阶段生成的回复消息对象列表"""
-
-    resp_message_chain: typing.Optional[list[platform_message.MessageChain]] = None
-    """回复消息链，从resp_messages包装而得"""
-
-    # ======= 内部保留 =======
-    current_stage: typing.Optional['pkg.pipeline.pipelinemgr.StageInstContainer'] = None
-    """当前所处阶段"""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    # ========== 插件可调用的 API（请求 API） ==========
-
-    def set_variable(self, key: str, value: typing.Any):
-        """设置变量"""
-        if self.variables is None:
-            self.variables = {}
-        self.variables[key] = value
-
-    def get_variable(self, key: str) -> typing.Any:
-        """获取变量"""
-        if self.variables is None:
-            return None
-        return self.variables.get(key)
-
-    def get_variables(self) -> dict[str, typing.Any]:
-        """获取所有变量"""
-        if self.variables is None:
-            return {}
-        return self.variables
-
-
-class Conversation(pydantic.BaseModel):
-    """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation"""
-
-    prompt: llm_entities.Prompt
-
-    messages: list[llm_entities.Message]
-
-    create_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
-
-    update_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
-
-    use_llm_model: typing.Optional[requester.RuntimeLLMModel] = None
-
-    use_funcs: typing.Optional[list[tools_entities.LLMFunction]]
-
-    uuid: typing.Optional[str] = None
-    """该对话的 uuid，在创建时不会自动生成。而是当使用 Dify API 等由外部管理对话信息的服务时，用于绑定外部的会话。具体如何使用，取决于 Runner。"""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class Session(pydantic.BaseModel):
-    """会话，一个 Session 对应一个 {launcher_type.value}_{launcher_id}"""
-
-    launcher_type: LauncherTypes
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Optional[typing.Union[int, str]] = 0
-
-    use_prompt_name: typing.Optional[str] = 'default'
-
-    using_conversation: typing.Optional[Conversation] = None
-
-    conversations: typing.Optional[list[Conversation]] = pydantic.Field(default_factory=list)
-
-    create_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
-
-    update_time: typing.Optional[datetime.datetime] = pydantic.Field(default_factory=datetime.datetime.now)
-
-    semaphore: typing.Optional[asyncio.Semaphore] = None
-    """当前会话的信号量，用于限制并发"""
-
-    class Config:
-        arbitrary_types_allowed = True

pkg/core/stages/load_config.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-import os
-
-from .. import stage, app
-from ..bootutils import config
-
-
-@stage.stage_class('LoadConfigStage')
-class LoadConfigStage(stage.BootingStage):
-    """加载配置文件阶段"""
-
-    async def run(self, ap: app.Application):
-        """启动"""
-
-        # ======= deprecated =======
-        if os.path.exists('data/config/command.json'):
-            ap.command_cfg = await config.load_json_config(
-                'data/config/command.json',
-                'templates/legacy/command.json',
-                completion=False,
-            )
-
-        if os.path.exists('data/config/pipeline.json'):
-            ap.pipeline_cfg = await config.load_json_config(
-                'data/config/pipeline.json',
-                'templates/legacy/pipeline.json',
-                completion=False,
-            )
-
-        if os.path.exists('data/config/platform.json'):
-            ap.platform_cfg = await config.load_json_config(
-                'data/config/platform.json',
-                'templates/legacy/platform.json',
-                completion=False,
-            )
-
-        if os.path.exists('data/config/provider.json'):
-            ap.provider_cfg = await config.load_json_config(
-                'data/config/provider.json',
-                'templates/legacy/provider.json',
-                completion=False,
-            )
-
-        if os.path.exists('data/config/system.json'):
-            ap.system_cfg = await config.load_json_config(
-                'data/config/system.json',
-                'templates/legacy/system.json',
-                completion=False,
-            )
-
-        # ======= deprecated =======
-
-        ap.instance_config = await config.load_yaml_config(
-            'data/config.yaml', 'templates/config.yaml', completion=False
-        )
-        await ap.instance_config.dump_config()
-
-        ap.sensitive_meta = await config.load_json_config(
-            'data/metadata/sensitive-words.json',
-            'templates/metadata/sensitive-words.json',
-        )
-        await ap.sensitive_meta.dump_config()
-
-        ap.pipeline_config_meta_trigger = await config.load_yaml_config(
-            'templates/metadata/pipeline/trigger.yaml',
-            'templates/metadata/pipeline/trigger.yaml',
-        )
-        ap.pipeline_config_meta_safety = await config.load_yaml_config(
-            'templates/metadata/pipeline/safety.yaml',
-            'templates/metadata/pipeline/safety.yaml',
-        )
-        ap.pipeline_config_meta_ai = await config.load_yaml_config(
-            'templates/metadata/pipeline/ai.yaml', 'templates/metadata/pipeline/ai.yaml'
-        )
-        ap.pipeline_config_meta_output = await config.load_yaml_config(
-            'templates/metadata/pipeline/output.yaml',
-            'templates/metadata/pipeline/output.yaml',
-        )

pkg/persistence/databases/sqlite.py

@@ -1,14 +0,0 @@
-from __future__ import annotations
-
-import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
-
-from .. import database
-
-
-@database.manager_class('sqlite')
-class SQLiteDatabaseManager(database.BaseDatabaseManager):
-    """SQLite 数据库管理类"""
-
-    async def initialize(self) -> None:
-        sqlite_path = 'data/langbot.db'
-        self.engine = sqlalchemy_asyncio.create_async_engine(f'sqlite+aiosqlite:///{sqlite_path}')

pkg/pipeline/cntfilter/filter.py

@@ -1,76 +0,0 @@
-# 内容过滤器的抽象类
-from __future__ import annotations
-import abc
-import typing
-
-from ...core import app, entities as core_entities
-from . import entities
-
-
-preregistered_filters: list[typing.Type[ContentFilter]] = []
-
-
-def filter_class(
-    name: str,
-) -> typing.Callable[[typing.Type[ContentFilter]], typing.Type[ContentFilter]]:
-    """内容过滤器类装饰器
-
-    Args:
-        name (str): 过滤器名称
-
-    Returns:
-        typing.Callable[[typing.Type[ContentFilter]], typing.Type[ContentFilter]]: 装饰器
-    """
-
-    def decorator(cls: typing.Type[ContentFilter]) -> typing.Type[ContentFilter]:
-        assert issubclass(cls, ContentFilter)
-
-        cls.name = name
-
-        preregistered_filters.append(cls)
-
-        return cls
-
-    return decorator
-
-
-class ContentFilter(metaclass=abc.ABCMeta):
-    """内容过滤器抽象类"""
-
-    name: str
-
-    ap: app.Application
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-
-    @property
-    def enable_stages(self):
-        """启用的阶段
-
-        默认为消息请求AI前后的两个阶段。
-
-        entity.EnableStage.PRE: 消息请求AI前，此时需要检查的内容是用户的输入消息。
-        entity.EnableStage.POST: 消息请求AI后，此时需要检查的内容是AI的回复消息。
-        """
-        return [entities.EnableStage.PRE, entities.EnableStage.POST]
-
-    async def initialize(self):
-        """初始化过滤器"""
-        pass
-
-    @abc.abstractmethod
-    async def process(self, query: core_entities.Query, message: str = None, image_url=None) -> entities.FilterResult:
-        """处理消息
-
-        分为前后阶段，具体取决于 enable_stages 的值。
-        对于内容过滤器来说，不需要考虑消息所处的阶段，只需要检查消息内容即可。
-
-        Args:
-            message (str): 需要检查的内容
-            image_url (str): 要检查的图片的 URL
-
-        Returns:
-            entities.FilterResult: 过滤结果，具体内容请查看 entities.FilterResult 类的文档
-        """
-        raise NotImplementedError

pkg/pipeline/longtext/strategies/forward.py

@@ -1,35 +0,0 @@
-# 转发消息组件
-from __future__ import annotations
-
-
-from .. import strategy as strategy_model
-from ....core import entities as core_entities
-from ....platform.types import message as platform_message
-
-
-ForwardMessageDiaplay = platform_message.ForwardMessageDiaplay
-Forward = platform_message.Forward
-
-
-@strategy_model.strategy_class('forward')
-class ForwardComponentStrategy(strategy_model.LongTextStrategy):
-    async def process(self, message: str, query: core_entities.Query) -> list[platform_message.MessageComponent]:
-        display = ForwardMessageDiaplay(
-            title='群聊的聊天记录',
-            brief='[聊天记录]',
-            source='聊天记录',
-            preview=['QQ用户: ' + message],
-            summary='查看1条转发消息',
-        )
-
-        node_list = [
-            platform_message.ForwardMessageNode(
-                sender_id=query.adapter.bot_account_id,
-                sender_name='QQ用户',
-                message_chain=platform_message.MessageChain([message]),
-            )
-        ]
-
-        forward = Forward(display=display, node_list=node_list)
-
-        return [forward]

pkg/pipeline/preproc/preproc.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-import datetime
-
-from .. import stage, entities
-from ...core import entities as core_entities
-from ...provider import entities as llm_entities
-from ...plugin import events
-from ...platform.types import message as platform_message
-
-
-@stage.stage_class('PreProcessor')
-class PreProcessor(stage.PipelineStage):
-    """请求预处理阶段
-
-    签出会话、prompt、上文、模型、内容函数。
-
-    改写：
-        - session
-        - prompt
-        - messages
-        - user_message
-        - use_model
-        - use_funcs
-    """
-
-    async def process(
-        self,
-        query: core_entities.Query,
-        stage_inst_name: str,
-    ) -> entities.StageProcessResult:
-        """处理"""
-        selected_runner = query.pipeline_config['ai']['runner']['runner']
-
-        session = await self.ap.sess_mgr.get_session(query)
-
-        # 非 local-agent 时，llm_model 为 None
-        llm_model = (
-            await self.ap.model_mgr.get_model_by_uuid(query.pipeline_config['ai']['local-agent']['model'])
-            if selected_runner == 'local-agent'
-            else None
-        )
-
-        conversation = await self.ap.sess_mgr.get_conversation(
-            query,
-            session,
-            query.pipeline_config['ai']['local-agent']['prompt'],
-        )
-
-        conversation.use_llm_model = llm_model
-
-        # 设置query
-        query.session = session
-        query.prompt = conversation.prompt.copy()
-        query.messages = conversation.messages.copy()
-
-        query.use_llm_model = llm_model
-
-        if selected_runner == 'local-agent':
-            query.use_funcs = (
-                conversation.use_funcs if query.use_llm_model.model_entity.abilities.__contains__('func_call') else None
-            )
-
-        query.variables = {
-            'session_id': f'{query.session.launcher_type.value}_{query.session.launcher_id}',
-            'conversation_id': conversation.uuid,
-            'msg_create_time': (
-                int(query.message_event.time) if query.message_event.time else int(datetime.datetime.now().timestamp())
-            ),
-        }
-
-        # Check if this model supports vision, if not, remove all images
-        # TODO this checking should be performed in runner, and in this stage, the image should be reserved
-        if selected_runner == 'local-agent' and not query.use_llm_model.model_entity.abilities.__contains__('vision'):
-            for msg in query.messages:
-                if isinstance(msg.content, list):
-                    for me in msg.content:
-                        if me.type == 'image_url':
-                            msg.content.remove(me)
-
-        content_list = []
-
-        plain_text = ''
-        qoute_msg = query.pipeline_config['trigger'].get('misc', '').get('combine-quote-message')
-
-        for me in query.message_chain:
-            if isinstance(me, platform_message.Plain):
-                content_list.append(llm_entities.ContentElement.from_text(me.text))
-                plain_text += me.text
-            elif isinstance(me, platform_message.Image):
-                if selected_runner != 'local-agent' or query.use_llm_model.model_entity.abilities.__contains__(
-                    'vision'
-                ):
-                    if me.base64 is not None:
-                        content_list.append(llm_entities.ContentElement.from_image_base64(me.base64))
-            elif isinstance(me, platform_message.Quote) and qoute_msg:
-                for msg in me.origin:
-                    if isinstance(msg, platform_message.Plain):
-                        content_list.append(llm_entities.ContentElement.from_text(msg.text))
-                    elif isinstance(msg, platform_message.Image):
-                        if selected_runner != 'local-agent' or query.use_llm_model.model_entity.abilities.__contains__(
-                            'vision'
-                        ):
-                            if msg.base64 is not None:
-                                content_list.append(llm_entities.ContentElement.from_image_base64(msg.base64))
-
-        query.variables['user_message_text'] = plain_text
-
-        query.user_message = llm_entities.Message(role='user', content=content_list)
-        # =========== 触发事件 PromptPreProcessing
-
-        event_ctx = await self.ap.plugin_mgr.emit_event(
-            event=events.PromptPreProcessing(
-                session_name=f'{query.session.launcher_type.value}_{query.session.launcher_id}',
-                default_prompt=query.prompt.messages,
-                prompt=query.messages,
-                query=query,
-            )
-        )
-
-        query.prompt.messages = event_ctx.event.default_prompt
-        query.messages = event_ctx.event.prompt
-
-        return entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)

pkg/pipeline/process/handlers/chat.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import typing
-import traceback
-
-
-from .. import handler
-from ... import entities
-from ....core import entities as core_entities
-from ....provider import runner as runner_module
-from ....plugin import events
-
-from ....platform.types import message as platform_message
-from ....utils import importutil
-from ....provider import runners
-
-importutil.import_modules_in_pkg(runners)
-
-
-class ChatMessageHandler(handler.MessageHandler):
-    async def handle(
-        self,
-        query: core_entities.Query,
-    ) -> typing.AsyncGenerator[entities.StageProcessResult, None]:
-        """处理"""
-        # 调API
-        #   生成器
-
-        # 触发插件事件
-        event_class = (
-            events.PersonNormalMessageReceived
-            if query.launcher_type == core_entities.LauncherTypes.PERSON
-            else events.GroupNormalMessageReceived
-        )
-
-        event_ctx = await self.ap.plugin_mgr.emit_event(
-            event=event_class(
-                launcher_type=query.launcher_type.value,
-                launcher_id=query.launcher_id,
-                sender_id=query.sender_id,
-                text_message=str(query.message_chain),
-                query=query,
-            )
-        )
-
-        if event_ctx.is_prevented_default():
-            if event_ctx.event.reply is not None:
-                mc = platform_message.MessageChain(event_ctx.event.reply)
-
-                query.resp_messages.append(mc)
-
-                yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-            else:
-                yield entities.StageProcessResult(result_type=entities.ResultType.INTERRUPT, new_query=query)
-        else:
-            if event_ctx.event.alter is not None:
-                # if isinstance(event_ctx.event, str):  # 现在暂时不考虑多模态alter
-                query.user_message.content = event_ctx.event.alter
-
-            text_length = 0
-
-            try:
-                for r in runner_module.preregistered_runners:
-                    if r.name == query.pipeline_config['ai']['runner']['runner']:
-                        runner = r(self.ap, query.pipeline_config)
-                        break
-                else:
-                    raise ValueError(f'未找到请求运行器: {query.pipeline_config["ai"]["runner"]["runner"]}')
-
-                async for result in runner.run(query):
-                    query.resp_messages.append(result)
-
-                    self.ap.logger.info(f'对话({query.query_id})响应: {self.cut_str(result.readable_str())}')
-
-                    if result.content is not None:
-                        text_length += len(result.content)
-
-                    yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-
-                query.session.using_conversation.messages.append(query.user_message)
-                query.session.using_conversation.messages.extend(query.resp_messages)
-            except Exception as e:
-                self.ap.logger.error(f'对话({query.query_id})请求失败: {type(e).__name__} {str(e)}')
-
-                hide_exception_info = query.pipeline_config['output']['misc']['hide-exception']
-
-                yield entities.StageProcessResult(
-                    result_type=entities.ResultType.INTERRUPT,
-                    new_query=query,
-                    user_notice='请求失败' if hide_exception_info else f'{e}',
-                    error_notice=f'{e}',
-                    debug_notice=traceback.format_exc(),
-                )
-            finally:
-                # TODO statistics
-                pass

pkg/pipeline/process/handlers/command.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-import typing
-
-
-from .. import handler
-from ... import entities
-from ....core import entities as core_entities
-from ....provider import entities as llm_entities
-from ....plugin import events
-from ....platform.types import message as platform_message
-
-
-class CommandHandler(handler.MessageHandler):
-    async def handle(
-        self,
-        query: core_entities.Query,
-    ) -> typing.AsyncGenerator[entities.StageProcessResult, None]:
-        """处理"""
-
-        command_text = str(query.message_chain).strip()[1:]
-
-        privilege = 1
-
-        if f'{query.launcher_type.value}_{query.launcher_id}' in self.ap.instance_config.data['admins']:
-            privilege = 2
-
-        spt = command_text.split(' ')
-
-        event_class = (
-            events.PersonCommandSent
-            if query.launcher_type == core_entities.LauncherTypes.PERSON
-            else events.GroupCommandSent
-        )
-
-        event_ctx = await self.ap.plugin_mgr.emit_event(
-            event=event_class(
-                launcher_type=query.launcher_type.value,
-                launcher_id=query.launcher_id,
-                sender_id=query.sender_id,
-                command=spt[0],
-                params=spt[1:] if len(spt) > 1 else [],
-                text_message=str(query.message_chain),
-                is_admin=(privilege == 2),
-                query=query,
-            )
-        )
-
-        if event_ctx.is_prevented_default():
-            if event_ctx.event.reply is not None:
-                mc = platform_message.MessageChain(event_ctx.event.reply)
-
-                query.resp_messages.append(mc)
-
-                yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-            else:
-                yield entities.StageProcessResult(result_type=entities.ResultType.INTERRUPT, new_query=query)
-
-        else:
-            if event_ctx.event.alter is not None:
-                query.message_chain = platform_message.MessageChain([platform_message.Plain(event_ctx.event.alter)])
-
-            session = await self.ap.sess_mgr.get_session(query)
-
-            async for ret in self.ap.cmd_mgr.execute(command_text=command_text, query=query, session=session):
-                if ret.error is not None:
-                    query.resp_messages.append(
-                        llm_entities.Message(
-                            role='command',
-                            content=str(ret.error),
-                        )
-                    )
-
-                    self.ap.logger.info(f'命令({query.query_id})报错: {self.cut_str(str(ret.error))}')
-
-                    yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-                elif ret.text is not None or ret.image_url is not None:
-                    content: list[llm_entities.ContentElement] = []
-
-                    if ret.text is not None:
-                        content.append(llm_entities.ContentElement.from_text(ret.text))
-
-                    if ret.image_url is not None:
-                        content.append(llm_entities.ContentElement.from_image_url(ret.image_url))
-
-                    query.resp_messages.append(
-                        llm_entities.Message(
-                            role='command',
-                            content=content,
-                        )
-                    )
-
-                    self.ap.logger.info(f'命令返回: {self.cut_str(str(content[0]))}')
-
-                    yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-                else:
-                    yield entities.StageProcessResult(result_type=entities.ResultType.INTERRUPT, new_query=query)

pkg/pipeline/respback/respback.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import random
-import asyncio
-
-
-from ...platform.types import events as platform_events
-from ...platform.types import message as platform_message
-
-from .. import stage, entities
-from ...core import entities as core_entities
-
-
-@stage.stage_class('SendResponseBackStage')
-class SendResponseBackStage(stage.PipelineStage):
-    """发送响应消息"""
-
-    async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
-        """处理"""
-
-        random_range = (
-            query.pipeline_config['output']['force-delay']['min'],
-            query.pipeline_config['output']['force-delay']['max'],
-        )
-
-        random_delay = random.uniform(*random_range)
-
-        self.ap.logger.debug('根据规则强制延迟回复: %s s', random_delay)
-
-        await asyncio.sleep(random_delay)
-
-        if query.pipeline_config['output']['misc']['at-sender'] and isinstance(
-            query.message_event, platform_events.GroupMessage
-        ):
-            query.resp_message_chain[-1].insert(0, platform_message.At(query.message_event.sender.id))
-
-        quote_origin = query.pipeline_config['output']['misc']['quote-origin']
-
-        await query.adapter.reply_message(
-            message_source=query.message_event,
-            message=query.resp_message_chain[-1],
-            quote_origin=quote_origin,
-        )
-
-        return entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)

pkg/pipeline/resprule/rules/atbot.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-
-from .. import rule as rule_model
-from .. import entities
-from ....core import entities as core_entities
-from ....platform.types import message as platform_message
-
-
-@rule_model.rule_class('at-bot')
-class AtBotRule(rule_model.GroupRespondRule):
-    async def match(
-        self,
-        message_text: str,
-        message_chain: platform_message.MessageChain,
-        rule_dict: dict,
-        query: core_entities.Query,
-    ) -> entities.RuleJudgeResult:
-        if message_chain.has(platform_message.At(query.adapter.bot_account_id)) and rule_dict['at']:
-            message_chain.remove(platform_message.At(query.adapter.bot_account_id))
-
-            if message_chain.has(
-                platform_message.At(query.adapter.bot_account_id)
-            ):  # 回复消息时会at两次，检查并删除重复的
-                message_chain.remove(platform_message.At(query.adapter.bot_account_id))
-
-            return entities.RuleJudgeResult(
-                matching=True,
-                replacement=message_chain,
-            )
-
-        return entities.RuleJudgeResult(matching=False, replacement=message_chain)

pkg/platform/adapter.py

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-# MessageSource的适配器
-import typing
-import abc
-
-
-from ..core import app
-from .types import message as platform_message
-from .types import events as platform_events
-from .logger import EventLogger
-
-
-class MessagePlatformAdapter(metaclass=abc.ABCMeta):
-    """消息平台适配器基类"""
-
-    name: str
-
-    bot_account_id: int
-    """机器人账号ID，需要在初始化时设置"""
-
-    config: dict
-
-    ap: app.Application
-
-    logger: EventLogger
-
-    def __init__(self, config: dict, ap: app.Application, logger: EventLogger):
-        """初始化适配器
-
-        Args:
-            config (dict): 对应的配置
-            ap (app.Application): 应用上下文
-        """
-        self.config = config
-        self.ap = ap
-        self.logger = logger
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        """主动发送消息
-
-        Args:
-            target_type (str): 目标类型，`person`或`group`
-            target_id (str): 目标ID
-            message (platform.types.MessageChain): 消息链
-        """
-        raise NotImplementedError
-
-    async def reply_message(
-        self,
-        message_source: platform_events.MessageEvent,
-        message: platform_message.MessageChain,
-        quote_origin: bool = False,
-    ):
-        """回复消息
-
-        Args:
-            message_source (platform.types.MessageEvent): 消息源事件
-            message (platform.types.MessageChain): 消息链
-            quote_origin (bool, optional): 是否引用原消息. Defaults to False.
-        """
-        raise NotImplementedError
-
-    async def is_muted(self, group_id: int) -> bool:
-        """获取账号是否在指定群被禁言"""
-        raise NotImplementedError
-
-    def register_listener(
-        self,
-        event_type: typing.Type[platform_message.Event],
-        callback: typing.Callable[[platform_message.Event, MessagePlatformAdapter], None],
-    ):
-        """注册事件监听器
-
-        Args:
-            event_type (typing.Type[platform.types.Event]): 事件类型
-            callback (typing.Callable[[platform.types.Event], None]): 回调函数，接收一个参数，为事件
-        """
-        raise NotImplementedError
-
-    def unregister_listener(
-        self,
-        event_type: typing.Type[platform_message.Event],
-        callback: typing.Callable[[platform_message.Event, MessagePlatformAdapter], None],
-    ):
-        """注销事件监听器
-
-        Args:
-            event_type (typing.Type[platform.types.Event]): 事件类型
-            callback (typing.Callable[[platform.types.Event], None]): 回调函数，接收一个参数，为事件
-        """
-        raise NotImplementedError
-
-    async def run_async(self):
-        """异步运行"""
-        raise NotImplementedError
-
-    async def kill(self) -> bool:
-        """关闭适配器
-
-        Returns:
-            bool: 是否成功关闭，热重载时若此函数返回False则不会重载MessageSource底层
-        """
-        raise NotImplementedError
-
-
-class MessageConverter:
-    """消息链转换器基类"""
-
-    @staticmethod
-    def yiri2target(message_chain: platform_message.MessageChain):
-        """将源平台消息链转换为目标平台消息链
-
-        Args:
-            message_chain (platform.types.MessageChain): 源平台消息链
-
-        Returns:
-            typing.Any: 目标平台消息链
-        """
-        raise NotImplementedError
-
-    @staticmethod
-    def target2yiri(message_chain: typing.Any) -> platform_message.MessageChain:
-        """将目标平台消息链转换为源平台消息链
-
-        Args:
-            message_chain (typing.Any): 目标平台消息链
-
-        Returns:
-            platform.types.MessageChain: 源平台消息链
-        """
-        raise NotImplementedError
-
-
-class EventConverter:
-    """事件转换器基类"""
-
-    @staticmethod
-    def yiri2target(event: typing.Type[platform_message.Event]):
-        """将源平台事件转换为目标平台事件
-
-        Args:
-            event (typing.Type[platform.types.Event]): 源平台事件
-
-        Returns:
-            typing.Any: 目标平台事件
-        """
-        raise NotImplementedError
-
-    @staticmethod
-    def target2yiri(event: typing.Any) -> platform_message.Event:
-        """将目标平台事件的调用参数转换为源平台的事件参数对象
-
-        Args:
-            event (typing.Any): 目标平台事件
-
-        Returns:
-            typing.Type[platform.types.Event]: 源平台事件
-        """
-        raise NotImplementedError

pkg/platform/adapter.yaml

@@ -1,14 +0,0 @@
-apiVersion: v1
-kind: ComponentTemplate
-metadata:
-  name: MessagePlatformAdapter
-  label:
-    en_US: Message Platform Adapter
-    zh_Hans: 消息平台适配器模板类
-spec:
-  type:
-    - python
-execution:
-  python:
-    path: ./adapter.py
-    attr: MessagePlatformAdapter

pkg/platform/sources/dingtalk.py

@@ -1,179 +0,0 @@
-import traceback
-import typing
-from libs.dingtalk_api.dingtalkevent import DingTalkEvent
-from pkg.platform.types import message as platform_message
-from pkg.platform.adapter import MessagePlatformAdapter
-from .. import adapter
-from ...core import app
-from ..types import events as platform_events
-from ..types import entities as platform_entities
-from libs.dingtalk_api.api import DingTalkClient
-import datetime
-from ..logger import EventLogger
-
-
-class DingTalkMessageConverter(adapter.MessageConverter):
-    @staticmethod
-    async def yiri2target(message_chain: platform_message.MessageChain):
-        content = ''
-        at = False
-        for msg in message_chain:
-            if type(msg) is platform_message.At:
-                at = True
-            if type(msg) is platform_message.Plain:
-                content += msg.text
-        return content,at
-
-    @staticmethod
-    async def target2yiri(event: DingTalkEvent, bot_name: str):
-        yiri_msg_list = []
-        yiri_msg_list.append(
-            platform_message.Source(id=event.incoming_message.message_id, time=datetime.datetime.now())
-        )
-
-        for atUser in event.incoming_message.at_users:
-            if atUser.dingtalk_id == event.incoming_message.chatbot_user_id:
-                yiri_msg_list.append(platform_message.At(target=bot_name))
-
-        if event.content:
-            text_content = event.content.replace('@' + bot_name, '')
-            yiri_msg_list.append(platform_message.Plain(text=text_content))
-        if event.picture:
-            yiri_msg_list.append(platform_message.Image(base64=event.picture))
-        if event.audio:
-            yiri_msg_list.append(platform_message.Voice(base64=event.audio))
-
-        chain = platform_message.MessageChain(yiri_msg_list)
-
-        return chain
-
-
-class DingTalkEventConverter(adapter.EventConverter):
-    @staticmethod
-    async def yiri2target(event: platform_events.MessageEvent):
-        return event.source_platform_object
-
-    @staticmethod
-    async def target2yiri(event: DingTalkEvent, bot_name: str):
-        message_chain = await DingTalkMessageConverter.target2yiri(event, bot_name)
-
-        if event.conversation == 'FriendMessage':
-            return platform_events.FriendMessage(
-                sender=platform_entities.Friend(
-                    id=event.incoming_message.sender_id,
-                    nickname=event.incoming_message.sender_nick,
-                    remark='',
-                ),
-                message_chain=message_chain,
-                time=event.incoming_message.create_at,
-                source_platform_object=event,
-            )
-        elif event.conversation == 'GroupMessage':
-            sender = platform_entities.GroupMember(
-                id=event.incoming_message.sender_id,
-                member_name=event.incoming_message.sender_nick,
-                permission='MEMBER',
-                group=platform_entities.Group(
-                    id=event.incoming_message.conversation_id,
-                    name=event.incoming_message.conversation_title,
-                    permission=platform_entities.Permission.Member,
-                ),
-                special_title='',
-                join_timestamp=0,
-                last_speak_timestamp=0,
-                mute_time_remaining=0,
-            )
-            time = event.incoming_message.create_at
-            return platform_events.GroupMessage(
-                sender=sender,
-                message_chain=message_chain,
-                time=time,
-                source_platform_object=event,
-            )
-
-
-class DingTalkAdapter(adapter.MessagePlatformAdapter):
-    bot: DingTalkClient
-    ap: app.Application
-    bot_account_id: str
-    message_converter: DingTalkMessageConverter = DingTalkMessageConverter()
-    event_converter: DingTalkEventConverter = DingTalkEventConverter()
-    config: dict
-
-    def __init__(self, config: dict, ap: app.Application, logger: EventLogger):
-        self.config = config
-        self.ap = ap
-        self.logger = logger
-        required_keys = [
-            'client_id',
-            'client_secret',
-            'robot_name',
-            'robot_code',
-        ]
-        missing_keys = [key for key in required_keys if key not in config]
-        if missing_keys:
-            raise Exception('钉钉缺少相关配置项，请查看文档或联系管理员')
-
-        self.bot_account_id = self.config['robot_name']
-
-        self.bot = DingTalkClient(
-            client_id=config['client_id'],
-            client_secret=config['client_secret'],
-            robot_name=config['robot_name'],
-            robot_code=config['robot_code'],
-            markdown_card=config['markdown_card'],
-            logger=self.logger,
-        )
-
-    async def reply_message(
-        self,
-        message_source: platform_events.MessageEvent,
-        message: platform_message.MessageChain,
-        quote_origin: bool = False,
-    ):
-        event = await DingTalkEventConverter.yiri2target(
-            message_source,
-        )
-        incoming_message = event.incoming_message
-
-        content,at = await DingTalkMessageConverter.yiri2target(message)
-        await self.bot.send_message(content, incoming_message,at)
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        content = await DingTalkMessageConverter.yiri2target(message)
-        if target_type == 'person':
-            await self.bot.send_proactive_message_to_one(target_id, content)
-        if target_type == 'group':
-            await self.bot.send_proactive_message_to_group(target_id, content)
-
-    def register_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ):
-        async def on_message(event: DingTalkEvent):
-            try:
-                return await callback(
-                    await self.event_converter.target2yiri(event, self.config['robot_name']),
-                    self,
-                )
-            except Exception as e:
-                await self.logger.error(f"Error in dingtalk callback: {traceback.format_exc()}")
-
-        if event_type == platform_events.FriendMessage:
-            self.bot.on_message('FriendMessage')(on_message)
-        elif event_type == platform_events.GroupMessage:
-            self.bot.on_message('GroupMessage')(on_message)
-
-    async def run_async(self):
-        await self.bot.start()
-
-    async def kill(self) -> bool:
-        return False
-
-    async def unregister_listener(
-        self,
-        event_type: type,
-        callback: typing.Callable[[platform_events.Event, MessagePlatformAdapter], None],
-    ):
-        return super().unregister_listener(event_type, callback)

pkg/platform/sources/discord.py

@@ -1,251 +0,0 @@
-from __future__ import annotations
-
-import discord
-
-import typing
-import re
-import base64
-import uuid
-import os
-import datetime
-
-import aiohttp
-
-from .. import adapter
-from ...core import app
-from ..types import message as platform_message
-from ..types import events as platform_events
-from ..types import entities as platform_entities
-from ..logger import EventLogger
-
-
-class DiscordMessageConverter(adapter.MessageConverter):
-    @staticmethod
-    async def yiri2target(
-        message_chain: platform_message.MessageChain,
-    ) -> typing.Tuple[str, typing.List[discord.File]]:
-        for ele in message_chain:
-            if isinstance(ele, platform_message.At):
-                message_chain.remove(ele)
-                break
-
-        text_string = ''
-        image_files = []
-
-        for ele in message_chain:
-            if isinstance(ele, platform_message.Image):
-                image_bytes = None
-
-                if ele.base64:
-                    image_bytes = base64.b64decode(ele.base64)
-                elif ele.url:
-                    async with aiohttp.ClientSession() as session:
-                        async with session.get(ele.url) as response:
-                            image_bytes = await response.read()
-                elif ele.path:
-                    with open(ele.path, 'rb') as f:
-                        image_bytes = f.read()
-
-                image_files.append(discord.File(fp=image_bytes, filename=f'{uuid.uuid4()}.png'))
-            elif isinstance(ele, platform_message.Plain):
-                text_string += ele.text
-            elif isinstance(ele, platform_message.Forward):
-                for node in ele.node_list:
-                    (
-                        text_string,
-                        image_files,
-                    ) = await DiscordMessageConverter.yiri2target(node.message_chain)
-                    text_string += text_string
-                    image_files.extend(image_files)
-
-        return text_string, image_files
-
-    @staticmethod
-    async def target2yiri(message: discord.Message) -> platform_message.MessageChain:
-        lb_msg_list = []
-
-        msg_create_time = datetime.datetime.fromtimestamp(int(message.created_at.timestamp()))
-
-        lb_msg_list.append(platform_message.Source(id=message.id, time=msg_create_time))
-
-        element_list = []
-
-        def text_element_recur(
-            text_ele: str,
-        ) -> list[platform_message.MessageComponent]:
-            if text_ele == '':
-                return []
-
-            # <@1234567890>
-            # @everyone
-            # @here
-            at_pattern = re.compile(r'(@everyone|@here|<@[\d]+>)')
-            at_matches = at_pattern.findall(text_ele)
-
-            if len(at_matches) > 0:
-                mid_at = at_matches[0]
-
-                text_split = text_ele.split(mid_at)
-
-                mid_at_component = []
-
-                if mid_at == '@everyone' or mid_at == '@here':
-                    mid_at_component.append(platform_message.AtAll())
-                else:
-                    mid_at_component.append(platform_message.At(target=mid_at[2:-1]))
-
-                return text_element_recur(text_split[0]) + mid_at_component + text_element_recur(text_split[1])
-            else:
-                return [platform_message.Plain(text=text_ele)]
-
-        element_list.extend(text_element_recur(message.content))
-
-        # attachments
-        for attachment in message.attachments:
-            async with aiohttp.ClientSession(trust_env=True) as session:
-                async with session.get(attachment.url) as response:
-                    image_data = await response.read()
-                    image_base64 = base64.b64encode(image_data).decode('utf-8')
-                    image_format = response.headers['Content-Type']
-                    element_list.append(platform_message.Image(base64=f'data:{image_format};base64,{image_base64}'))
-
-        return platform_message.MessageChain(element_list)
-
-
-class DiscordEventConverter(adapter.EventConverter):
-    @staticmethod
-    async def yiri2target(event: platform_events.Event) -> discord.Message:
-        pass
-
-    @staticmethod
-    async def target2yiri(event: discord.Message) -> platform_events.Event:
-        message_chain = await DiscordMessageConverter.target2yiri(event)
-
-        if isinstance(event.channel, discord.DMChannel):
-            return platform_events.FriendMessage(
-                sender=platform_entities.Friend(
-                    id=event.author.id,
-                    nickname=event.author.name,
-                    remark=event.channel.id,
-                ),
-                message_chain=message_chain,
-                time=event.created_at.timestamp(),
-                source_platform_object=event,
-            )
-        elif isinstance(event.channel, discord.TextChannel):
-            return platform_events.GroupMessage(
-                sender=platform_entities.GroupMember(
-                    id=event.author.id,
-                    member_name=event.author.name,
-                    permission=platform_entities.Permission.Member,
-                    group=platform_entities.Group(
-                        id=event.channel.id,
-                        name=event.channel.name,
-                        permission=platform_entities.Permission.Member,
-                    ),
-                    special_title='',
-                    join_timestamp=0,
-                    last_speak_timestamp=0,
-                    mute_time_remaining=0,
-                ),
-                message_chain=message_chain,
-                time=event.created_at.timestamp(),
-                source_platform_object=event,
-            )
-
-
-class DiscordAdapter(adapter.MessagePlatformAdapter):
-    bot: discord.Client
-
-    bot_account_id: str  # 用于在流水线中识别at是否是本bot，直接以bot_name作为标识
-
-    config: dict
-
-    ap: app.Application
-
-    message_converter: DiscordMessageConverter = DiscordMessageConverter()
-    event_converter: DiscordEventConverter = DiscordEventConverter()
-
-    listeners: typing.Dict[
-        typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ] = {}
-
-    def __init__(self, config: dict, ap: app.Application, logger: EventLogger):
-        self.config = config
-        self.ap = ap
-        self.logger = logger
-
-        self.bot_account_id = self.config['client_id']
-
-        adapter_self = self
-
-        class MyClient(discord.Client):
-            async def on_message(self: discord.Client, message: discord.Message):
-                if message.author.id == self.user.id or message.author.bot:
-                    return
-
-                lb_event = await adapter_self.event_converter.target2yiri(message)
-                await adapter_self.listeners[type(lb_event)](lb_event, adapter_self)
-
-        intents = discord.Intents.default()
-        intents.message_content = True
-
-        args = {}
-
-        if os.getenv('http_proxy'):
-            args['proxy'] = os.getenv('http_proxy')
-
-        self.bot = MyClient(intents=intents, **args)
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        pass
-
-    async def reply_message(
-        self,
-        message_source: platform_events.MessageEvent,
-        message: platform_message.MessageChain,
-        quote_origin: bool = False,
-    ):
-        msg_to_send, image_files = await self.message_converter.yiri2target(message)
-        assert isinstance(message_source.source_platform_object, discord.Message)
-
-        args = {
-            'content': msg_to_send,
-        }
-
-        if len(image_files) > 0:
-            args['files'] = image_files
-
-        if quote_origin:
-            args['reference'] = message_source.source_platform_object
-
-        if message.has(platform_message.At):
-            args['mention_author'] = True
-
-        await message_source.source_platform_object.channel.send(**args)
-
-    async def is_muted(self, group_id: int) -> bool:
-        return False
-
-    def register_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ):
-        self.listeners[event_type] = callback
-
-    def unregister_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ):
-        self.listeners.pop(event_type)
-
-    async def run_async(self):
-        async with self.bot:
-            await self.bot.start(self.config['token'], reconnect=True)
-
-    async def kill(self) -> bool:
-        await self.bot.close()
-        return True

pkg/platform/sources/lark.py

@@ -1,495 +0,0 @@
-from __future__ import annotations
-
-import lark_oapi
-from lark_oapi.api.im.v1 import CreateImageRequest, CreateImageRequestBody
-import traceback
-import typing
-import asyncio
-import re
-import base64
-import uuid
-import json
-import datetime
-import hashlib
-from Crypto.Cipher import AES
-
-import aiohttp
-import lark_oapi.ws.exception
-import quart
-from lark_oapi.api.im.v1 import *
-
-from .. import adapter
-from ...core import app
-from ..types import message as platform_message
-from ..types import events as platform_events
-from ..types import entities as platform_entities
-from ..logger import EventLogger
-
-
-class AESCipher(object):
-    def __init__(self, key):
-        self.bs = AES.block_size
-        self.key = hashlib.sha256(AESCipher.str_to_bytes(key)).digest()
-
-    @staticmethod
-    def str_to_bytes(data):
-        u_type = type(b''.decode('utf8'))
-        if isinstance(data, u_type):
-            return data.encode('utf8')
-        return data
-
-    @staticmethod
-    def _unpad(s):
-        return s[: -ord(s[len(s) - 1 :])]
-
-    def decrypt(self, enc):
-        iv = enc[: AES.block_size]
-        cipher = AES.new(self.key, AES.MODE_CBC, iv)
-        return self._unpad(cipher.decrypt(enc[AES.block_size :]))
-
-    def decrypt_string(self, enc):
-        enc = base64.b64decode(enc)
-        return self.decrypt(enc).decode('utf8')
-
-
-class LarkMessageConverter(adapter.MessageConverter):
-    @staticmethod
-    async def yiri2target(
-        message_chain: platform_message.MessageChain, api_client: lark_oapi.Client
-    ) -> typing.Tuple[list]:
-        message_elements = []
-        pending_paragraph = []
-        for msg in message_chain:
-            if isinstance(msg, platform_message.Plain):
-                # Ensure text is valid UTF-8
-                try:
-                    text = msg.text.encode('utf-8').decode('utf-8')
-                    pending_paragraph.append({'tag': 'md', 'text': text})
-                except UnicodeError:
-                    # If text is not valid UTF-8, try to decode with other encodings
-                    try:
-                        text = msg.text.encode('latin1').decode('utf-8')
-                        pending_paragraph.append({'tag': 'md', 'text': text})
-                    except UnicodeError:
-                        # If still fails, replace invalid characters
-                        text = msg.text.encode('utf-8', errors='replace').decode('utf-8')
-                        pending_paragraph.append({'tag': 'md', 'text': text})
-            elif isinstance(msg, platform_message.At):
-                pending_paragraph.append({'tag': 'at', 'user_id': msg.target, 'style': []})
-            elif isinstance(msg, platform_message.AtAll):
-                pending_paragraph.append({'tag': 'at', 'user_id': 'all', 'style': []})
-            elif isinstance(msg, platform_message.Image):
-                image_bytes = None
-
-                if msg.base64:
-                    try:
-                        # Remove data URL prefix if present
-                        if msg.base64.startswith('data:'):
-                            msg.base64 = msg.base64.split(',', 1)[1]
-                        image_bytes = base64.b64decode(msg.base64)
-                    except Exception:
-                        traceback.print_exc()
-                        continue
-                elif msg.url:
-                    try:
-                        async with aiohttp.ClientSession() as session:
-                            async with session.get(msg.url) as response:
-                                if response.status == 200:
-                                    image_bytes = await response.read()
-                                else:
-                                    traceback.print_exc()
-                                    continue
-                    except Exception:
-                        traceback.print_exc()
-                        continue
-                elif msg.path:
-                    try:
-                        with open(msg.path, 'rb') as f:
-                            image_bytes = f.read()
-                    except Exception:
-                        traceback.print_exc()
-                        continue
-
-                if image_bytes is None:
-                    continue
-
-                try:
-                    # Create a temporary file to store the image bytes
-                    import tempfile
-
-                    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-                        temp_file.write(image_bytes)
-                        temp_file.flush()
-
-                        # Create image request using the temporary file
-                        request = (
-                            CreateImageRequest.builder()
-                            .request_body(
-                                CreateImageRequestBody.builder()
-                                .image_type('message')
-                                .image(open(temp_file.name, 'rb'))
-                                .build()
-                            )
-                            .build()
-                        )
-
-                        response = await api_client.im.v1.image.acreate(request)
-
-                        if not response.success():
-                            raise Exception(
-                                f'client.im.v1.image.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}'
-                            )
-
-                        image_key = response.data.image_key
-
-                        message_elements.append(pending_paragraph)
-                        message_elements.append(
-                            [
-                                {
-                                    'tag': 'img',
-                                    'image_key': image_key,
-                                }
-                            ]
-                        )
-                        pending_paragraph = []
-                except Exception:
-                    traceback.print_exc()
-                    continue
-                finally:
-                    # Clean up the temporary file
-                    import os
-
-                    if 'temp_file' in locals():
-                        os.unlink(temp_file.name)
-            elif isinstance(msg, platform_message.Forward):
-                for node in msg.node_list:
-                    message_elements.extend(await LarkMessageConverter.yiri2target(node.message_chain, api_client))
-
-        if pending_paragraph:
-            message_elements.append(pending_paragraph)
-
-        return message_elements
-
-    @staticmethod
-    async def target2yiri(
-        message: lark_oapi.api.im.v1.model.event_message.EventMessage,
-        api_client: lark_oapi.Client,
-    ) -> platform_message.MessageChain:
-        message_content = json.loads(message.content)
-
-        lb_msg_list = []
-
-        msg_create_time = datetime.datetime.fromtimestamp(int(message.create_time) / 1000)
-
-        lb_msg_list.append(platform_message.Source(id=message.message_id, time=msg_create_time))
-
-        if message.message_type == 'text':
-            element_list = []
-
-            def text_element_recur(text_ele: dict) -> list[dict]:
-                if text_ele['text'] == '':
-                    return []
-
-                at_pattern = re.compile(r'@_user_[\d]+')
-                at_matches = at_pattern.findall(text_ele['text'])
-
-                name_mapping = {}
-                for mathc in at_matches:
-                    for mention in message.mentions:
-                        if mention.key == mathc:
-                            name_mapping[mathc] = mention.name
-                            break
-
-                if len(name_mapping.keys()) == 0:
-                    return [text_ele]
-
-                # 只处理第一个，剩下的递归处理
-                text_split = text_ele['text'].split(list(name_mapping.keys())[0])
-
-                new_list = []
-
-                left_text = text_split[0]
-                right_text = text_split[1]
-
-                new_list.extend(text_element_recur({'tag': 'text', 'text': left_text, 'style': []}))
-
-                new_list.append(
-                    {
-                        'tag': 'at',
-                        'user_id': list(name_mapping.keys())[0],
-                        'user_name': name_mapping[list(name_mapping.keys())[0]],
-                        'style': [],
-                    }
-                )
-
-                new_list.extend(text_element_recur({'tag': 'text', 'text': right_text, 'style': []}))
-
-                return new_list
-
-            element_list = text_element_recur({'tag': 'text', 'text': message_content['text'], 'style': []})
-
-            message_content = {'title': '', 'content': element_list}
-
-        elif message.message_type == 'post':
-            new_list = []
-
-            for ele in message_content['content']:
-                if type(ele) is dict:
-                    new_list.append(ele)
-                elif type(ele) is list:
-                    new_list.extend(ele)
-
-            message_content['content'] = new_list
-        elif message.message_type == 'image':
-            message_content['content'] = [{'tag': 'img', 'image_key': message_content['image_key'], 'style': []}]
-
-        for ele in message_content['content']:
-            if ele['tag'] == 'text':
-                lb_msg_list.append(platform_message.Plain(text=ele['text']))
-            elif ele['tag'] == 'at':
-                lb_msg_list.append(platform_message.At(target=ele['user_name']))
-            elif ele['tag'] == 'img':
-                image_key = ele['image_key']
-
-                request: GetMessageResourceRequest = (
-                    GetMessageResourceRequest.builder()
-                    .message_id(message.message_id)
-                    .file_key(image_key)
-                    .type('image')
-                    .build()
-                )
-
-                response: GetMessageResourceResponse = await api_client.im.v1.message_resource.aget(request)
-
-                if not response.success():
-                    raise Exception(
-                        f'client.im.v1.message_resource.get failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}'
-                    )
-
-                image_bytes = response.file.read()
-                image_base64 = base64.b64encode(image_bytes).decode()
-
-                image_format = response.raw.headers['content-type']
-
-                lb_msg_list.append(platform_message.Image(base64=f'data:{image_format};base64,{image_base64}'))
-
-        return platform_message.MessageChain(lb_msg_list)
-
-
-class LarkEventConverter(adapter.EventConverter):
-    @staticmethod
-    async def yiri2target(
-        event: platform_events.MessageEvent,
-    ) -> lark_oapi.im.v1.P2ImMessageReceiveV1:
-        pass
-
-    @staticmethod
-    async def target2yiri(
-        event: lark_oapi.im.v1.P2ImMessageReceiveV1, api_client: lark_oapi.Client
-    ) -> platform_events.Event:
-        message_chain = await LarkMessageConverter.target2yiri(event.event.message, api_client)
-
-        if event.event.message.chat_type == 'p2p':
-            return platform_events.FriendMessage(
-                sender=platform_entities.Friend(
-                    id=event.event.sender.sender_id.open_id,
-                    nickname=event.event.sender.sender_id.union_id,
-                    remark='',
-                ),
-                message_chain=message_chain,
-                time=event.event.message.create_time,
-            )
-        elif event.event.message.chat_type == 'group':
-            return platform_events.GroupMessage(
-                sender=platform_entities.GroupMember(
-                    id=event.event.sender.sender_id.open_id,
-                    member_name=event.event.sender.sender_id.union_id,
-                    permission=platform_entities.Permission.Member,
-                    group=platform_entities.Group(
-                        id=event.event.message.chat_id,
-                        name='',
-                        permission=platform_entities.Permission.Member,
-                    ),
-                    special_title='',
-                    join_timestamp=0,
-                    last_speak_timestamp=0,
-                    mute_time_remaining=0,
-                ),
-                message_chain=message_chain,
-                time=event.event.message.create_time,
-            )
-
-
-class LarkAdapter(adapter.MessagePlatformAdapter):
-    bot: lark_oapi.ws.Client
-    api_client: lark_oapi.Client
-
-    bot_account_id: str  # 用于在流水线中识别at是否是本bot，直接以bot_name作为标识
-    lark_tenant_key: str  # 飞书企业key
-
-    message_converter: LarkMessageConverter = LarkMessageConverter()
-    event_converter: LarkEventConverter = LarkEventConverter()
-
-    listeners: typing.Dict[
-        typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ]
-
-    config: dict
-    quart_app: quart.Quart
-    ap: app.Application
-
-    def __init__(self, config: dict, ap: app.Application, logger: EventLogger):
-        self.config = config
-        self.ap = ap
-        self.logger = logger
-        self.quart_app = quart.Quart(__name__)
-        self.listeners = {}
-
-        @self.quart_app.route('/lark/callback', methods=['POST'])
-        async def lark_callback():
-            try:
-                data = await quart.request.json
-
-                self.ap.logger.debug(f'Lark callback event: {data}')
-
-                if 'encrypt' in data:
-                    cipher = AESCipher(self.config['encrypt-key'])
-                    data = cipher.decrypt_string(data['encrypt'])
-                    data = json.loads(data)
-
-                type = data.get('type')
-                if type is None:
-                    context = EventContext(data)
-                    type = context.header.event_type
-
-                if 'url_verification' == type:
-                    # todo 验证verification token
-                    return {'challenge': data.get('challenge')}
-                context = EventContext(data)
-                type = context.header.event_type
-                p2v1 = P2ImMessageReceiveV1()
-                p2v1.header = context.header
-                event = P2ImMessageReceiveV1Data()
-                event.message = EventMessage(context.event['message'])
-                event.sender = EventSender(context.event['sender'])
-                p2v1.event = event
-                p2v1.schema = context.schema
-                if 'im.message.receive_v1' == type:
-                    try:
-                        event = await self.event_converter.target2yiri(p2v1, self.api_client)
-                    except Exception as e:
-                        await self.logger.error(f"Error in lark callback: {traceback.format_exc()}")
-
-                    if event.__class__ in self.listeners:
-                        await self.listeners[event.__class__](event, self)
-
-                return {'code': 200, 'message': 'ok'}
-            except Exception as e:
-                await self.logger.error(f"Error in lark callback: {traceback.format_exc()}")
-                return {'code': 500, 'message': 'error'}
-
-        async def on_message(event: lark_oapi.im.v1.P2ImMessageReceiveV1):
-            lb_event = await self.event_converter.target2yiri(event, self.api_client)
-
-            await self.listeners[type(lb_event)](lb_event, self)
-
-        def sync_on_message(event: lark_oapi.im.v1.P2ImMessageReceiveV1):
-            asyncio.create_task(on_message(event))
-
-        event_handler = (
-            lark_oapi.EventDispatcherHandler.builder('', '').register_p2_im_message_receive_v1(sync_on_message).build()
-        )
-
-        self.bot_account_id = config['bot_name']
-
-        self.bot = lark_oapi.ws.Client(config['app_id'], config['app_secret'], event_handler=event_handler)
-        self.api_client = lark_oapi.Client.builder().app_id(config['app_id']).app_secret(config['app_secret']).build()
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        pass
-
-    async def reply_message(
-        self,
-        message_source: platform_events.MessageEvent,
-        message: platform_message.MessageChain,
-        quote_origin: bool = False,
-    ):
-        # 不再需要了，因为message_id已经被包含到message_chain中
-        # lark_event = await self.event_converter.yiri2target(message_source)
-        lark_message = await self.message_converter.yiri2target(message, self.api_client)
-
-        final_content = {
-            'zh_Hans': {
-                'title': '',
-                'content': lark_message,
-            },
-        }
-
-        request: ReplyMessageRequest = (
-            ReplyMessageRequest.builder()
-            .message_id(message_source.message_chain.message_id)
-            .request_body(
-                ReplyMessageRequestBody.builder()
-                .content(json.dumps(final_content))
-                .msg_type('post')
-                .reply_in_thread(False)
-                .uuid(str(uuid.uuid4()))
-                .build()
-            )
-            .build()
-        )
-
-        response: ReplyMessageResponse = await self.api_client.im.v1.message.areply(request)
-
-        if not response.success():
-            raise Exception(
-                f'client.im.v1.message.reply failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}'
-            )
-
-    async def is_muted(self, group_id: int) -> bool:
-        return False
-
-    def register_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ):
-        self.listeners[event_type] = callback
-
-    def unregister_listener(
-        self,
-        event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
-    ):
-        self.listeners.pop(event_type)
-
-    async def run_async(self):
-        port = self.config['port']
-        enable_webhook = self.config['enable-webhook']
-
-        if not enable_webhook:
-            try:
-                await self.bot._connect()
-            except lark_oapi.ws.exception.ClientException as e:
-                raise e
-            except Exception as e:
-                await self.bot._disconnect()
-                if self.bot._auto_reconnect:
-                    await self.bot._reconnect()
-                else:
-                    raise e
-        else:
-
-            async def shutdown_trigger_placeholder():
-                while True:
-                    await asyncio.sleep(1)
-
-            await self.quart_app.run_task(
-                host='0.0.0.0',
-                port=port,
-                shutdown_trigger=shutdown_trigger_placeholder,
-            )
-
-    async def kill(self) -> bool:
-        return False

pkg/platform/types/__init__.py

@@ -1,3 +0,0 @@
-from .entities import *
-from .events import *
-from .message import *

pkg/platform/types/base.py

@@ -1,107 +0,0 @@
-from typing import Dict, List, Type
-
-import pydantic.v1.main as pdm
-from pydantic.v1 import BaseModel
-
-
-class PlatformMetaclass(pdm.ModelMetaclass):
-    """此类是平台中使用的 pydantic 模型的元类的基类。"""
-
-
-def to_camel(name: str) -> str:
-    """将下划线命名风格转换为小驼峰命名。"""
-    if name[:2] == '__':  # 不处理双下划线开头的特殊命名。
-        return name
-    name_parts = name.split('_')
-    return ''.join(name_parts[:1] + [x.title() for x in name_parts[1:]])
-
-
-class PlatformBaseModel(BaseModel, metaclass=PlatformMetaclass):
-    """模型基类。
-
-    启用了三项配置：
-    1. 允许解析时传入额外的值，并将额外值保存在模型中。
-    2. 允许通过别名访问字段。
-    3. 自动生成小驼峰风格的别名。
-    """
-
-    def __init__(self, *args, **kwargs):
-        """"""
-        super().__init__(*args, **kwargs)
-
-    def __repr__(self) -> str:
-        return (
-            self.__class__.__name__ + '(' + ', '.join((f'{k}={repr(v)}' for k, v in self.__dict__.items() if v)) + ')'
-        )
-
-    class Config:
-        extra = 'allow'
-        allow_population_by_field_name = True
-        alias_generator = to_camel
-
-
-class PlatformIndexedMetaclass(PlatformMetaclass):
-    """可以通过子类名获取子类的类的元类。"""
-
-    __indexedbases__: List[Type['PlatformIndexedModel']] = []
-    __indexedmodel__ = None
-
-    def __new__(cls, name, bases, attrs, **kwargs):
-        new_cls = super().__new__(cls, name, bases, attrs, **kwargs)
-        # 第一类：PlatformIndexedModel
-        if name == 'PlatformIndexedModel':
-            cls.__indexedmodel__ = new_cls
-            new_cls.__indexes__ = {}
-            return new_cls
-        # 第二类：PlatformIndexedModel 的直接子类，这些是可以通过子类名获取子类的类。
-        if cls.__indexedmodel__ in bases:
-            cls.__indexedbases__.append(new_cls)
-            new_cls.__indexes__ = {}
-            return new_cls
-        # 第三类：PlatformIndexedModel 的直接子类的子类，这些添加到直接子类的索引中。
-        for base in cls.__indexedbases__:
-            if issubclass(new_cls, base):
-                base.__indexes__[name] = new_cls
-                return new_cls
-
-    def __getitem__(cls, name):
-        return cls.get_subtype(name)
-
-
-class PlatformIndexedModel(PlatformBaseModel, metaclass=PlatformIndexedMetaclass):
-    """可以通过子类名获取子类的类。"""
-
-    __indexes__: Dict[str, Type['PlatformIndexedModel']]
-
-    @classmethod
-    def get_subtype(cls, name: str) -> Type['PlatformIndexedModel']:
-        """根据类名称，获取相应的子类类型。
-
-        Args:
-            name: 类名称。
-
-        Returns:
-            Type['PlatformIndexedModel']: 子类类型。
-        """
-        try:
-            type_ = cls.__indexes__.get(name)
-            if not (type_ and issubclass(type_, cls)):
-                raise ValueError(f'`{name}` 不是 `{cls.__name__}` 的子类！')
-            return type_
-        except AttributeError:
-            raise ValueError(f'`{name}` 不是 `{cls.__name__}` 的子类！') from None
-
-    @classmethod
-    def parse_subtype(cls, obj: dict) -> 'PlatformIndexedModel':
-        """通过字典，构造对应的模型对象。
-
-        Args:
-            obj: 一个字典，包含了模型对象的属性。
-
-        Returns:
-            PlatformIndexedModel: 构造的对象。
-        """
-        if cls in PlatformIndexedModel.__subclasses__():
-            ModelType = cls.get_subtype(obj['type'])
-            return ModelType.parse_obj(obj)
-        return super().parse_obj(obj)

pkg/platform/types/entities.py

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-此模块提供实体和配置项模型。
-"""
-
-import abc
-from datetime import datetime
-from enum import Enum
-import typing
-
-import pydantic.v1 as pydantic
-
-
-class Entity(pydantic.BaseModel):
-    """实体，表示一个用户或群。"""
-
-    id: int
-    """ID。"""
-
-    @abc.abstractmethod
-    def get_name(self) -> str:
-        """名称。"""
-
-
-class Friend(Entity):
-    """私聊对象。"""
-
-    id: typing.Union[int, str]
-    """ID。"""
-    nickname: typing.Optional[str]
-    """昵称。"""
-    remark: typing.Optional[str]
-    """备注。"""
-
-    def get_name(self) -> str:
-        return self.nickname or self.remark or ''
-
-
-class Permission(str, Enum):
-    """群成员身份权限。"""
-
-    Member = 'MEMBER'
-    """成员。"""
-    Administrator = 'ADMINISTRATOR'
-    """管理员。"""
-    Owner = 'OWNER'
-    """群主。"""
-
-    def __repr__(self) -> str:
-        return repr(self.value)
-
-
-class Group(Entity):
-    """群。"""
-
-    id: typing.Union[int, str]
-    """群号。"""
-    name: str
-    """群名称。"""
-    permission: Permission
-    """Bot 在群中的权限。"""
-
-    def get_name(self) -> str:
-        return self.name
-
-
-class GroupMember(Entity):
-    """群成员。"""
-
-    id: typing.Union[int, str]
-    """群员 ID。"""
-    member_name: str
-    """群员名称。"""
-    permission: Permission
-    """在群中的权限。"""
-    group: Group
-    """群。"""
-    special_title: str = ''
-    """群头衔。"""
-    join_timestamp: datetime = datetime.utcfromtimestamp(0)
-    """加入群的时间。"""
-    last_speak_timestamp: datetime = datetime.utcfromtimestamp(0)
-    """最后一次发言的时间。"""
-    mute_time_remaining: int = 0
-    """禁言剩余时间。"""
-
-    def get_name(self) -> str:
-        return self.member_name

pkg/platform/types/events.py

@@ -1,106 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-此模块提供事件模型。
-"""
-
-import typing
-
-import pydantic.v1 as pydantic
-
-from . import entities as platform_entities
-from . import message as platform_message
-
-
-class Event(pydantic.BaseModel):
-    """事件基类。
-
-    Args:
-        type: 事件名。
-    """
-
-    type: str
-    """事件名。"""
-
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + '('
-            + ', '.join((f'{k}={repr(v)}' for k, v in self.__dict__.items() if k != 'type' and v))
-            + ')'
-        )
-
-    @classmethod
-    def parse_subtype(cls, obj: dict) -> 'Event':
-        try:
-            return typing.cast(Event, super().parse_subtype(obj))
-        except ValueError:
-            return Event(type=obj['type'])
-
-    @classmethod
-    def get_subtype(cls, name: str) -> typing.Type['Event']:
-        try:
-            return typing.cast(typing.Type[Event], super().get_subtype(name))
-        except ValueError:
-            return Event
-
-
-###############################
-# Message Event
-class MessageEvent(Event):
-    """消息事件。
-
-    Args:
-        type: 事件名。
-        message_chain: 消息内容。
-    """
-
-    type: str
-    """事件名。"""
-    message_chain: platform_message.MessageChain
-    """消息内容。"""
-
-    time: float | None = None
-    """消息发送时间戳。"""
-
-    source_platform_object: typing.Optional[typing.Any] = None
-    """原消息平台对象。
-    供消息平台适配器开发者使用，如果回复用户时需要使用原消息事件对象的信息，
-    那么可以将其存到这个字段以供之后取出使用。"""
-
-
-class FriendMessage(MessageEvent):
-    """私聊消息。
-
-    Args:
-        type: 事件名。
-        sender: 发送消息的好友。
-        message_chain: 消息内容。
-    """
-
-    type: str = 'FriendMessage'
-    """事件名。"""
-    sender: platform_entities.Friend
-    """发送消息的好友。"""
-    message_chain: platform_message.MessageChain
-    """消息内容。"""
-
-
-class GroupMessage(MessageEvent):
-    """群消息。
-
-    Args:
-        type: 事件名。
-        sender: 发送消息的群成员。
-        message_chain: 消息内容。
-    """
-
-    type: str = 'GroupMessage'
-    """事件名。"""
-    sender: platform_entities.GroupMember
-    """发送消息的群成员。"""
-    message_chain: platform_message.MessageChain
-    """消息内容。"""
-
-    @property
-    def group(self) -> platform_entities.Group:
-        return self.sender.group

pkg/platform/types/message.py

@@ -1,924 +0,0 @@
-import itertools
-import logging
-import typing
-from datetime import datetime
-from pathlib import Path
-import base64
-
-import aiofiles
-import httpx
-import pydantic.v1 as pydantic
-
-from . import entities as platform_entities
-from .base import PlatformBaseModel, PlatformIndexedMetaclass, PlatformIndexedModel
-
-logger = logging.getLogger(__name__)
-
-
-class MessageComponentMetaclass(PlatformIndexedMetaclass):
-    """消息组件元类。"""
-
-    __message_component__ = None
-
-    def __new__(cls, name, bases, attrs, **kwargs):
-        new_cls = super().__new__(cls, name, bases, attrs, **kwargs)
-        if name == 'MessageComponent':
-            cls.__message_component__ = new_cls
-
-        if not cls.__message_component__:
-            return new_cls
-
-        for base in bases:
-            if issubclass(base, cls.__message_component__):
-                # 获取字段名
-                if hasattr(new_cls, '__fields__'):
-                    # 忽略 type 字段
-                    new_cls.__parameter_names__ = list(new_cls.__fields__)[1:]
-                else:
-                    new_cls.__parameter_names__ = []
-                break
-
-        return new_cls
-
-
-class MessageComponent(PlatformIndexedModel, metaclass=MessageComponentMetaclass):
-    """消息组件。"""
-
-    type: str
-    """消息组件类型。"""
-
-    def __str__(self):
-        return ''
-
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + '('
-            + ', '.join((f'{k}={repr(v)}' for k, v in self.__dict__.items() if k != 'type' and v))
-            + ')'
-        )
-
-    def __init__(self, *args, **kwargs):
-        # 解析参数列表，将位置参数转化为具名参数
-        parameter_names = self.__parameter_names__
-        if len(args) > len(parameter_names):
-            raise TypeError(f'`{self.type}`需要{len(parameter_names)}个参数，但传入了{len(args)}个。')
-        for name, value in zip(parameter_names, args):
-            if name in kwargs:
-                raise TypeError(f'在 `{self.type}` 中，具名参数 `{name}` 与位置参数重复。')
-            kwargs[name] = value
-
-        super().__init__(**kwargs)
-
-
-TMessageComponent = typing.TypeVar('TMessageComponent', bound=MessageComponent)
-
-
-class MessageChain(PlatformBaseModel):
-    """消息链。
-
-    一个构造消息链的例子：
-    ```py
-    message_chain = MessageChain([
-        AtAll(),
-        Plain("Hello World!"),
-    ])
-    ```
-
-    `Plain` 可以省略。
-    ```py
-    message_chain = MessageChain([
-        AtAll(),
-        "Hello World!",
-    ])
-    ```
-
-    在调用 API 时，参数中需要 MessageChain 的，也可以使用 `List[MessageComponent]` 代替。
-    例如，以下两种写法是等价的：
-    ```py
-    await bot.send_friend_message(12345678, [
-        Plain("Hello World!")
-    ])
-    ```
-    ```py
-    await bot.send_friend_message(12345678, MessageChain([
-        Plain("Hello World!")
-    ]))
-    ```
-
-    可以使用 `in` 运算检查消息链中：
-    1. 是否有某个消息组件。
-    2. 是否有某个类型的消息组件。
-
-    ```py
-    if AtAll in message_chain:
-        print('AtAll')
-
-    if At(bot.qq) in message_chain:
-        print('At Me')
-    ```
-
-    """
-
-    __root__: typing.List[MessageComponent]
-
-    @staticmethod
-    def _parse_message_chain(msg_chain: typing.Iterable):
-        result = []
-        for msg in msg_chain:
-            if isinstance(msg, dict):
-                result.append(MessageComponent.parse_subtype(msg))
-            elif isinstance(msg, MessageComponent):
-                result.append(msg)
-            elif isinstance(msg, str):
-                result.append(Plain(msg))
-            else:
-                raise TypeError(f'消息链中元素需为 dict 或 str 或 MessageComponent，当前类型：{type(msg)}')
-        return result
-
-    @pydantic.validator('__root__', always=True, pre=True)
-    def _parse_component(cls, msg_chain):
-        if isinstance(msg_chain, (str, MessageComponent)):
-            msg_chain = [msg_chain]
-        if not msg_chain:
-            msg_chain = []
-        return cls._parse_message_chain(msg_chain)
-
-    @classmethod
-    def parse_obj(cls, msg_chain: typing.Iterable):
-        """通过列表形式的消息链，构造对应的 `MessageChain` 对象。
-
-        Args:
-            msg_chain: 列表形式的消息链。
-        """
-        result = cls._parse_message_chain(msg_chain)
-        return cls(__root__=result)
-
-    def __init__(self, __root__: typing.Iterable[MessageComponent] = None):
-        super().__init__(__root__=__root__)
-
-    def __str__(self):
-        return ''.join(str(component) for component in self.__root__)
-
-    def __repr__(self):
-        return f'{self.__class__.__name__}({self.__root__!r})'
-
-    def __iter__(self):
-        yield from self.__root__
-
-    def get_first(self, t: typing.Type[TMessageComponent]) -> typing.Optional[TMessageComponent]:
-        """获取消息链中第一个符合类型的消息组件。"""
-        for component in self:
-            if isinstance(component, t):
-                return component
-        return None
-
-    @typing.overload
-    def __getitem__(self, index: int) -> MessageComponent: ...
-
-    @typing.overload
-    def __getitem__(self, index: slice) -> typing.List[MessageComponent]: ...
-
-    @typing.overload
-    def __getitem__(self, index: typing.Type[TMessageComponent]) -> typing.List[TMessageComponent]: ...
-
-    @typing.overload
-    def __getitem__(
-        self, index: typing.Tuple[typing.Type[TMessageComponent], int]
-    ) -> typing.List[TMessageComponent]: ...
-
-    def __getitem__(
-        self,
-        index: typing.Union[
-            int,
-            slice,
-            typing.Type[TMessageComponent],
-            typing.Tuple[typing.Type[TMessageComponent], int],
-        ],
-    ) -> typing.Union[MessageComponent, typing.List[MessageComponent], typing.List[TMessageComponent]]:
-        return self.get(index)
-
-    def __setitem__(
-        self,
-        key: typing.Union[int, slice],
-        value: typing.Union[MessageComponent, str, typing.Iterable[typing.Union[MessageComponent, str]]],
-    ):
-        if isinstance(value, str):
-            value = Plain(value)
-        if isinstance(value, typing.Iterable):
-            value = (Plain(c) if isinstance(c, str) else c for c in value)
-        self.__root__[key] = value  # type: ignore
-
-    def __delitem__(self, key: typing.Union[int, slice]):
-        del self.__root__[key]
-
-    def __reversed__(self) -> typing.Iterable[MessageComponent]:
-        return reversed(self.__root__)
-
-    def has(
-        self,
-        sub: typing.Union[MessageComponent, typing.Type[MessageComponent], 'MessageChain', str],
-    ) -> bool:
-        """判断消息链中：
-        1. 是否有某个消息组件。
-        2. 是否有某个类型的消息组件。
-
-        Args:
-            sub (`Union[MessageComponent, Type[MessageComponent], 'MessageChain', str]`):
-                若为 `MessageComponent`，则判断该组件是否在消息链中。
-                若为 `Type[MessageComponent]`，则判断该组件类型是否在消息链中。
-
-        Returns:
-            bool: 是否找到。
-        """
-        if isinstance(sub, type):  # 检测消息链中是否有某种类型的对象
-            for i in self:
-                if type(i) is sub:
-                    return True
-            return False
-        if isinstance(sub, MessageComponent):  # 检查消息链中是否有某个组件
-            for i in self:
-                if i == sub:
-                    return True
-            return False
-        raise TypeError(f'类型不匹配，当前类型：{type(sub)}')
-
-    def __contains__(self, sub) -> bool:
-        return self.has(sub)
-
-    def __ge__(self, other):
-        return other in self
-
-    def __len__(self) -> int:
-        return len(self.__root__)
-
-    def __add__(self, other: typing.Union['MessageChain', MessageComponent, str]) -> 'MessageChain':
-        if isinstance(other, MessageChain):
-            return self.__class__(self.__root__ + other.__root__)
-        if isinstance(other, str):
-            return self.__class__(self.__root__ + [Plain(other)])
-        if isinstance(other, MessageComponent):
-            return self.__class__(self.__root__ + [other])
-        return NotImplemented
-
-    def __radd__(self, other: typing.Union[MessageComponent, str]) -> 'MessageChain':
-        if isinstance(other, MessageComponent):
-            return self.__class__([other] + self.__root__)
-        if isinstance(other, str):
-            return self.__class__([typing.cast(MessageComponent, Plain(other))] + self.__root__)
-        return NotImplemented
-
-    def __mul__(self, other: int):
-        if isinstance(other, int):
-            return self.__class__(self.__root__ * other)
-        return NotImplemented
-
-    def __rmul__(self, other: int):
-        return self.__mul__(other)
-
-    def __iadd__(self, other: typing.Iterable[typing.Union[MessageComponent, str]]):
-        self.extend(other)
-
-    def __imul__(self, other: int):
-        if isinstance(other, int):
-            self.__root__ *= other
-        return NotImplemented
-
-    def index(
-        self,
-        x: typing.Union[MessageComponent, typing.Type[MessageComponent]],
-        i: int = 0,
-        j: int = -1,
-    ) -> int:
-        """返回 x 在消息链中首次出现项的索引号（索引号在 i 或其后且在 j 之前）。
-
-        Args:
-            x (`Union[MessageComponent, Type[MessageComponent]]`):
-                要查找的消息元素或消息元素类型。
-            i: 从哪个位置开始查找。
-            j: 查找到哪个位置结束。
-
-        Returns:
-            int: 如果找到，则返回索引号。
-
-        Raises:
-            ValueError: 没有找到。
-            TypeError: 类型不匹配。
-        """
-        if isinstance(x, type):
-            l = len(self)
-            if i < 0:
-                i += l
-            if i < 0:
-                i = 0
-            if j < 0:
-                j += l
-            if j > l:
-                j = l
-            for index in range(i, j):
-                if type(self[index]) is x:
-                    return index
-            raise ValueError('消息链中不存在该类型的组件。')
-        if isinstance(x, MessageComponent):
-            return self.__root__.index(x, i, j)
-        raise TypeError(f'类型不匹配，当前类型：{type(x)}')
-
-    def count(self, x: typing.Union[MessageComponent, typing.Type[MessageComponent]]) -> int:
-        """返回消息链中 x 出现的次数。
-
-        Args:
-            x (`Union[MessageComponent, Type[MessageComponent]]`):
-                要查找的消息元素或消息元素类型。
-
-        Returns:
-            int: 次数。
-        """
-        if isinstance(x, type):
-            return sum(1 for i in self if type(i) is x)
-        if isinstance(x, MessageComponent):
-            return self.__root__.count(x)
-        raise TypeError(f'类型不匹配，当前类型：{type(x)}')
-
-    def extend(self, x: typing.Iterable[typing.Union[MessageComponent, str]]):
-        """将另一个消息链中的元素添加到消息链末尾。
-
-        Args:
-            x: 另一个消息链，也可为消息元素或字符串元素的序列。
-        """
-        self.__root__.extend(Plain(c) if isinstance(c, str) else c for c in x)
-
-    def append(self, x: typing.Union[MessageComponent, str]):
-        """将一个消息元素或字符串元素添加到消息链末尾。
-
-        Args:
-            x: 消息元素或字符串元素。
-        """
-        self.__root__.append(Plain(x) if isinstance(x, str) else x)
-
-    def insert(self, i: int, x: typing.Union[MessageComponent, str]):
-        """将一个消息元素或字符串添加到消息链中指定位置。
-
-        Args:
-            i: 插入位置。
-            x: 消息元素或字符串元素。
-        """
-        self.__root__.insert(i, Plain(x) if isinstance(x, str) else x)
-
-    def pop(self, i: int = -1) -> MessageComponent:
-        """从消息链中移除并返回指定位置的元素。
-
-        Args:
-            i: 移除位置。默认为末尾。
-
-        Returns:
-            MessageComponent: 移除的元素。
-        """
-        return self.__root__.pop(i)
-
-    def remove(self, x: typing.Union[MessageComponent, typing.Type[MessageComponent]]):
-        """从消息链中移除指定元素或指定类型的一个元素。
-
-        Args:
-            x: 指定的元素或元素类型。
-        """
-        if isinstance(x, type):
-            self.pop(self.index(x))
-        if isinstance(x, MessageComponent):
-            self.__root__.remove(x)
-
-    def exclude(
-        self,
-        x: typing.Union[MessageComponent, typing.Type[MessageComponent]],
-        count: int = -1,
-    ) -> 'MessageChain':
-        """返回移除指定元素或指定类型的元素后剩余的消息链。
-
-        Args:
-            x: 指定的元素或元素类型。
-            count: 至多移除的数量。默认为全部移除。
-
-        Returns:
-            MessageChain: 剩余的消息链。
-        """
-
-        def _exclude():
-            nonlocal count
-            x_is_type = isinstance(x, type)
-            for c in self:
-                if count > 0 and ((x_is_type and type(c) is x) or c == x):
-                    count -= 1
-                    continue
-                yield c
-
-        return self.__class__(_exclude())
-
-    def reverse(self):
-        """将消息链原地翻转。"""
-        self.__root__.reverse()
-
-    @classmethod
-    def join(cls, *args: typing.Iterable[typing.Union[str, MessageComponent]]):
-        return cls(Plain(c) if isinstance(c, str) else c for c in itertools.chain(*args))
-
-    @property
-    def source(self) -> typing.Optional['Source']:
-        """获取消息链中的 `Source` 对象。"""
-        return self.get_first(Source)
-
-    @property
-    def message_id(self) -> int:
-        """获取消息链的 message_id，若无法获取，返回 -1。"""
-        source = self.source
-        return source.id if source else -1
-
-
-TMessage = typing.Union[
-    MessageChain,
-    typing.Iterable[typing.Union[MessageComponent, str]],
-    MessageComponent,
-    str,
-]
-"""可以转化为 MessageChain 的类型。"""
-
-
-class Source(MessageComponent):
-    """源。包含消息的基本信息。"""
-
-    type: str = 'Source'
-    """消息组件类型。"""
-    id: typing.Union[int, str]
-    """消息的识别号，用于引用回复（Source 类型永远为 MessageChain 的第一个元素）。"""
-    time: datetime
-    """消息时间。"""
-
-
-class Plain(MessageComponent):
-    """纯文本。"""
-
-    type: str = 'Plain'
-    """消息组件类型。"""
-    text: str
-    """文字消息。"""
-
-    def __str__(self):
-        return self.text
-
-    def __repr__(self):
-        return f'Plain({self.text!r})'
-
-
-class Quote(MessageComponent):
-    """引用。"""
-
-    type: str = 'Quote'
-    """消息组件类型。"""
-    id: typing.Optional[int] = None
-    """被引用回复的原消息的 message_id。"""
-    group_id: typing.Optional[typing.Union[int, str]] = None
-    """被引用回复的原消息所接收的群号，当为好友消息时为0。"""
-    sender_id: typing.Optional[typing.Union[int, str]] = None
-    """被引用回复的原消息的发送者的ID。"""
-    target_id: typing.Optional[typing.Union[int, str]] = None
-    """被引用回复的原消息的接收者者的ID或群ID。"""
-    origin: MessageChain
-    """被引用回复的原消息的消息链对象。"""
-
-    @pydantic.validator('origin', always=True, pre=True)
-    def origin_formater(cls, v):
-        return MessageChain.parse_obj(v)
-
-
-class At(MessageComponent):
-    """At某人。"""
-
-    type: str = 'At'
-    """消息组件类型。"""
-    target: typing.Union[int, str]
-    """群员 ID。"""
-    display: typing.Optional[str] = None
-    """At时显示的文字，发送消息时无效，自动使用群名片。"""
-
-    def __eq__(self, other):
-        return isinstance(other, At) and self.target == other.target
-
-    def __str__(self):
-        return f'@{self.display or self.target}'
-
-
-class AtAll(MessageComponent):
-    """At全体。"""
-
-    type: str = 'AtAll'
-    """消息组件类型。"""
-
-    def __str__(self):
-        return '@全体成员'
-
-
-class Image(MessageComponent):
-    """图片。"""
-
-    type: str = 'Image'
-    """消息组件类型。"""
-    image_id: typing.Optional[str] = None
-    """图片的 image_id，不为空时将忽略 url 属性。"""
-    url: typing.Optional[pydantic.HttpUrl] = None
-    """图片的 URL，发送时可作网络图片的链接；接收时为图片的链接，可用于图片下载。"""
-    path: typing.Union[str, Path, None] = None
-    """图片的路径，发送本地图片。"""
-    base64: typing.Optional[str] = None
-    """图片的 Base64 编码。"""
-
-    def __eq__(self, other):
-        return isinstance(other, Image) and self.type == other.type and self.uuid == other.uuid
-
-    def __str__(self):
-        return '[图片]'
-
-    @pydantic.validator('path')
-    def validate_path(cls, path: typing.Union[str, Path, None]):
-        """修复 path 参数的行为，使之相对于 LangBot 的启动路径。"""
-        if path:
-            try:
-                return str(Path(path).resolve(strict=True))
-            except FileNotFoundError:
-                raise ValueError(f'无效路径：{path}')
-        else:
-            return path
-
-    @property
-    def uuid(self):
-        image_id = self.image_id
-        if image_id[0] == '{':  # 群图片
-            image_id = image_id[1:37]
-        elif image_id[0] == '/':  # 好友图片
-            image_id = image_id[1:]
-        return image_id
-
-    async def get_bytes(self) -> typing.Tuple[bytes, str]:
-        """获取图片的 bytes 和 mime type"""
-        if self.url:
-            async with httpx.AsyncClient() as client:
-                response = await client.get(self.url)
-                response.raise_for_status()
-                return response.content, response.headers.get('Content-Type')
-        elif self.base64:
-            mime_type = 'image/jpeg'
-
-            split_index = self.base64.find(';base64,')
-            if split_index == -1:
-                raise ValueError('Invalid base64 string')
-
-            mime_type = self.base64[5:split_index]
-            base64_data = self.base64[split_index + 8 :]
-
-            return base64.b64decode(base64_data), mime_type
-        elif self.path:
-            async with aiofiles.open(self.path, 'rb') as f:
-                return await f.read(), 'image/jpeg'
-        else:
-            raise ValueError('Can not get bytes from image')
-
-    @classmethod
-    async def from_local(
-        cls,
-        filename: typing.Union[str, Path, None] = None,
-        content: typing.Optional[bytes] = None,
-    ) -> 'Image':
-        """从本地文件路径加载图片，以 base64 的形式传递。
-
-        Args:
-            filename: 从本地文件路径加载图片，与 `content` 二选一。
-            content: 从本地文件内容加载图片，与 `filename` 二选一。
-
-        Returns:
-            Image: 图片对象。
-        """
-        if content:
-            pass
-        elif filename:
-            path = Path(filename)
-            import aiofiles
-
-            async with aiofiles.open(path, 'rb') as f:
-                content = await f.read()
-        else:
-            raise ValueError('请指定图片路径或图片内容！')
-        import base64
-
-        img = cls(base64=base64.b64encode(content).decode())
-        return img
-
-    @classmethod
-    def from_unsafe_path(cls, path: typing.Union[str, Path]) -> 'Image':
-        """从不安全的路径加载图片。
-
-        Args:
-            path: 从不安全的路径加载图片。
-
-        Returns:
-            Image: 图片对象。
-        """
-        return cls.construct(path=str(path))
-
-
-class Unknown(MessageComponent):
-    """未知。"""
-
-    type: str = 'Unknown'
-    """消息组件类型。"""
-    text: str
-    """文本。"""
-
-    def __str__(self):
-        return f'Unknown Message: {self.text}'
-
-
-class Voice(MessageComponent):
-    """语音。"""
-
-    type: str = 'Voice'
-    """消息组件类型。"""
-    voice_id: typing.Optional[str] = None
-    """语音的 voice_id，不为空时将忽略 url 属性。"""
-    url: typing.Optional[str] = None
-    """语音的 URL，发送时可作网络语音的链接；接收时为语音文件的链接，可用于语音下载。"""
-    path: typing.Optional[str] = None
-    """语音的路径，发送本地语音。"""
-    base64: typing.Optional[str] = None
-    """语音的 Base64 编码。"""
-    length: typing.Optional[int] = None
-    """语音的长度，单位为秒。"""
-
-    @pydantic.validator('path')
-    def validate_path(cls, path: typing.Optional[str]):
-        """修复 path 参数的行为，使之相对于 LangBot 的启动路径。"""
-        if path:
-            try:
-                return str(Path(path).resolve(strict=True))
-            except FileNotFoundError:
-                raise ValueError(f'无效路径：{path}')
-        else:
-            return path
-
-    def __str__(self):
-        return '[语音]'
-
-    async def download(
-        self,
-        filename: typing.Union[str, Path, None] = None,
-        directory: typing.Union[str, Path, None] = None,
-    ):
-        """下载语音到本地。
-
-        Args:
-            filename: 下载到本地的文件路径。与 `directory` 二选一。
-            directory: 下载到本地的文件夹路径。与 `filename` 二选一。
-        """
-        if not self.url:
-            logger.warning(f'语音 `{self.voice_id}` 无 url 参数，下载失败。')
-            return
-
-        import httpx
-
-        async with httpx.AsyncClient() as client:
-            response = await client.get(self.url)
-            response.raise_for_status()
-            content = response.content
-
-            if filename:
-                path = Path(filename)
-                path.parent.mkdir(parents=True, exist_ok=True)
-            elif directory:
-                path = Path(directory)
-                path.mkdir(parents=True, exist_ok=True)
-                path = path / f'{self.voice_id}.silk'
-            else:
-                raise ValueError('请指定文件路径或文件夹路径！')
-
-            import aiofiles
-
-            async with aiofiles.open(path, 'wb') as f:
-                await f.write(content)
-
-    @classmethod
-    async def from_local(
-        cls,
-        filename: typing.Union[str, Path, None] = None,
-        content: typing.Optional[bytes] = None,
-    ) -> 'Voice':
-        """从本地文件路径加载语音，以 base64 的形式传递。
-
-        Args:
-            filename: 从本地文件路径加载语音，与 `content` 二选一。
-            content: 从本地文件内容加载语音，与 `filename` 二选一。
-        """
-        if content:
-            pass
-        if filename:
-            path = Path(filename)
-            import aiofiles
-
-            async with aiofiles.open(path, 'rb') as f:
-                content = await f.read()
-        else:
-            raise ValueError('请指定语音路径或语音内容！')
-        import base64
-
-        img = cls(base64=base64.b64encode(content).decode())
-        return img
-
-
-class ForwardMessageNode(pydantic.BaseModel):
-    """合并转发中的一条消息。"""
-
-    sender_id: typing.Optional[typing.Union[int, str]] = None
-    """发送人ID。"""
-    sender_name: typing.Optional[str] = None
-    """显示名称。"""
-    message_chain: typing.Optional[MessageChain] = None
-    """消息内容。"""
-    message_id: typing.Optional[int] = None
-    """消息的 message_id。"""
-    time: typing.Optional[datetime] = None
-    """发送时间。"""
-
-    @pydantic.validator('message_chain', check_fields=False)
-    def _validate_message_chain(cls, value: typing.Union[MessageChain, list]):
-        if isinstance(value, list):
-            return MessageChain.parse_obj(value)
-        return value
-
-    @classmethod
-    def create(
-        cls,
-        sender: typing.Union[platform_entities.Friend, platform_entities.GroupMember],
-        message: MessageChain,
-    ) -> 'ForwardMessageNode':
-        """从消息链生成转发消息。
-
-        Args:
-            sender: 发送人。
-            message: 消息内容。
-
-        Returns:
-            ForwardMessageNode: 生成的一条消息。
-        """
-        return ForwardMessageNode(sender_id=sender.id, sender_name=sender.get_name(), message_chain=message)
-
-
-class ForwardMessageDiaplay(pydantic.BaseModel):
-    title: str = '群聊的聊天记录'
-    brief: str = '[聊天记录]'
-    source: str = '聊天记录'
-    preview: typing.List[str] = []
-    summary: str = '查看x条转发消息'
-
-
-class Forward(MessageComponent):
-    """合并转发。"""
-
-    type: str = 'Forward'
-    """消息组件类型。"""
-    display: ForwardMessageDiaplay
-    """显示信息"""
-    node_list: typing.List[ForwardMessageNode]
-    """转发消息节点列表。"""
-
-    def __init__(self, *args, **kwargs):
-        if len(args) == 1:
-            self.node_list = args[0]
-            super().__init__(**kwargs)
-        super().__init__(*args, **kwargs)
-
-    def __str__(self):
-        return '[聊天记录]'
-
-
-class File(MessageComponent):
-    """文件。"""
-
-    type: str = 'File'
-    """消息组件类型。"""
-    id: str
-    """文件识别 ID。"""
-    name: str
-    """文件名称。"""
-    size: int
-    """文件大小。"""
-
-    def __str__(self):
-        return f'[文件]{self.name}'
-
-
-# ================ 个人微信专用组件 ================
-
-
-class WeChatMiniPrograms(MessageComponent):
-    """小程序。个人微信专用组件。"""
-
-    type: str = 'WeChatMiniPrograms'
-    """小程序id"""
-    mini_app_id: str
-    """小程序归属用户id"""
-    user_name: str
-    """小程序名称"""
-    display_name: typing.Optional[str] = ''
-    """打开地址"""
-    page_path: typing.Optional[str] = ''
-    """小程序标题"""
-    title: typing.Optional[str] = ''
-    """首页图片"""
-    image_url: typing.Optional[str] = ''
-
-
-class WeChatForwardMiniPrograms(MessageComponent):
-    """转发小程序。个人微信专用组件。"""
-
-    type: str = 'WeChatForwardMiniPrograms'
-    """xml数据"""
-    xml_data: str
-    """首页图片"""
-    image_url: typing.Optional[str] = None
-
-    def __str__(self):
-        return self.xml_data
-
-
-class WeChatEmoji(MessageComponent):
-    """emoji表情。个人微信专用组件。"""
-
-    type: str = 'WeChatEmoji'
-    """emojimd5"""
-    emoji_md5: str
-    """emoji大小"""
-    emoji_size: int
-
-
-class WeChatLink(MessageComponent):
-    """发送链接。个人微信专用组件。"""
-
-    type: str = 'WeChatLink'
-    """标题"""
-    link_title: str = ''
-    """链接描述"""
-    link_desc: str = ''
-    """链接地址"""
-    link_url: str = ''
-    """链接略缩图"""
-    link_thumb_url: str = ''
-
-
-class WeChatForwardLink(MessageComponent):
-    """转发链接。个人微信专用组件。"""
-
-    type: str = 'WeChatForwardLink'
-    """xml数据"""
-    xml_data: str
-
-    def __str__(self):
-        return self.xml_data
-
-
-class WeChatForwardImage(MessageComponent):
-    """转发图片。个人微信专用组件。"""
-
-    type: str = 'WeChatForwardImage'
-    """xml数据"""
-    xml_data: str
-
-    def __str__(self):
-        return self.xml_data
-
-
-class WeChatForwardFile(MessageComponent):
-    """转发文件。个人微信专用组件。"""
-
-    type: str = 'WeChatForwardFile'
-    """xml数据"""
-    xml_data: str
-
-    def __str__(self):
-        return self.xml_data
-
-
-class WeChatAppMsg(MessageComponent):
-    """通用appmsg发送。个人微信专用组件。"""
-
-    type: str = 'WeChatAppMsg'
-    """xml数据"""
-    app_msg: str
-
-    def __str__(self):
-        return self.app_msg
-
-
-class WeChatForwardQuote(MessageComponent):
-    """转发引用消息。个人微信专用组件。"""
-
-    type: str = 'WeChatForwardQuote'
-    """xml数据"""
-    app_msg: str
-
-    def __str__(self):
-        return self.app_msg

pkg/plugin/context.py

@@ -1,388 +0,0 @@
-from __future__ import annotations
-
-import typing
-import abc
-import pydantic.v1 as pydantic
-import enum
-
-from . import events
-from ..provider.tools import entities as tools_entities
-from ..core import app
-from ..discover import engine as discover_engine
-from ..platform.types import message as platform_message
-from ..platform import adapter as platform_adapter
-
-
-def register(
-    name: str, description: str, version: str, author: str
-) -> typing.Callable[[typing.Type[BasePlugin]], typing.Type[BasePlugin]]:
-    """注册插件类
-
-    使用示例：
-
-    @register(
-        name="插件名称",
-        description="插件描述",
-        version="插件版本",
-        author="插件作者"
-    )
-    class MyPlugin(BasePlugin):
-        pass
-    """
-    pass
-
-
-def handler(
-    event: typing.Type[events.BaseEventModel],
-) -> typing.Callable[[typing.Callable], typing.Callable]:
-    """注册事件监听器
-
-    使用示例：
-
-    class MyPlugin(BasePlugin):
-
-        @handler(NormalMessageResponded)
-        async def on_normal_message_responded(self, ctx: EventContext):
-            pass
-    """
-    pass
-
-
-def llm_func(
-    name: str = None,
-) -> typing.Callable:
-    """注册内容函数
-
-    使用示例：
-
-    class MyPlugin(BasePlugin):
-
-        @llm_func("access_the_web_page")
-        async def _(self, query, url: str, brief_len: int):
-            \"""Call this function to search about the question before you answer any questions.
-            - Do not search through google.com at any time.
-            - If you need to search somthing, visit https://www.sogou.com/web?query=<something>.
-            - If user ask you to open a url (start with http:// or https://), visit it directly.
-            - Summary the plain content result by yourself, DO NOT directly output anything in the result you got.
-
-            Args:
-                url(str): url to visit
-                brief_len(int): max length of the plain text content, recommend 1024-4096, prefer 4096
-
-            Returns:
-                str: plain text content of the web page or error message(starts with 'error:')
-            \"""
-    """
-    pass
-
-
-class BasePlugin(metaclass=abc.ABCMeta):
-    """插件基类"""
-
-    host: APIHost
-    """API宿主"""
-
-    ap: app.Application
-    """应用程序对象"""
-
-    config: dict
-    """插件配置"""
-
-    def __init__(self, host: APIHost):
-        """初始化阶段被调用"""
-        self.host = host
-        self.config = {}
-
-    async def initialize(self):
-        """初始化阶段被调用"""
-        pass
-
-    async def destroy(self):
-        """释放/禁用插件时被调用"""
-        pass
-
-    def __del__(self):
-        """释放/禁用插件时被调用"""
-        pass
-
-
-class APIHost:
-    """LangBot API 宿主"""
-
-    ap: app.Application
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-
-    async def initialize(self):
-        pass
-
-    # ========== 插件可调用的 API（主程序API） ==========
-
-    def get_platform_adapters(self) -> list[platform_adapter.MessagePlatformAdapter]:
-        """获取已启用的消息平台适配器列表
-
-        Returns:
-            list[platform.adapter.MessageSourceAdapter]: 已启用的消息平台适配器列表
-        """
-        return self.ap.platform_mgr.get_running_adapters()
-
-    async def send_active_message(
-        self,
-        adapter: platform_adapter.MessagePlatformAdapter,
-        target_type: str,
-        target_id: str,
-        message: platform_message.MessageChain,
-    ):
-        """发送主动消息
-
-        Args:
-            adapter (platform.adapter.MessageSourceAdapter): 消息平台适配器对象，调用 host.get_platform_adapters() 获取并取用其中某个
-            target_type (str): 目标类型，`person`或`group`
-            target_id (str): 目标ID
-            message (platform.types.MessageChain): 消息链
-        """
-        await adapter.send_message(
-            target_type=target_type,
-            target_id=target_id,
-            message=message,
-        )
-
-    def require_ver(
-        self,
-        ge: str,
-        le: str = 'v999.999.999',
-    ) -> bool:
-        """插件版本要求装饰器
-
-        Args:
-            ge (str): 最低版本要求
-            le (str, optional): 最高版本要求
-
-        Returns:
-            bool: 是否满足要求, False时为无法获取版本号，True时为满足要求，报错为不满足要求
-        """
-        langbot_version = ''
-
-        try:
-            langbot_version = self.ap.ver_mgr.get_current_version()  # 从updater模块获取版本号
-        except Exception:
-            return False
-
-        if self.ap.ver_mgr.compare_version_str(langbot_version, ge) < 0 or (
-            self.ap.ver_mgr.compare_version_str(langbot_version, le) > 0
-        ):
-            raise Exception(
-                'LangBot 版本不满足要求，某些功能（可能是由插件提供的）无法正常使用。（要求版本：{}-{}，但当前版本：{}）'.format(
-                    ge, le, langbot_version
-                )
-            )
-
-        return True
-
-
-class EventContext:
-    """事件上下文, 保存此次事件运行的信息"""
-
-    eid = 0
-    """事件编号"""
-
-    host: APIHost = None
-    """API宿主"""
-
-    event: events.BaseEventModel = None
-    """此次事件的对象，具体类型为handler注册时指定监听的类型，可查看events.py中的定义"""
-
-    __prevent_default__ = False
-    """是否阻止默认行为"""
-
-    __prevent_postorder__ = False
-    """是否阻止后续插件的执行"""
-
-    __return_value__ = {}
-    """ 返回值 
-    示例:
-    {
-        "example": [
-            'value1',
-            'value2',
-            3,
-            4,
-            {
-                'key1': 'value1',
-            },
-            ['value1', 'value2']
-        ]
-    }
-    """
-
-    # ========== 插件可调用的 API ==========
-
-    def add_return(self, key: str, ret):
-        """添加返回值"""
-        if key not in self.__return_value__:
-            self.__return_value__[key] = []
-        self.__return_value__[key].append(ret)
-
-    async def reply(self, message_chain: platform_message.MessageChain):
-        """回复此次消息请求
-
-        Args:
-            message_chain (platform.types.MessageChain): 源平台的消息链，若用户使用的不是源平台适配器，程序也能自动转换为目标平台消息链
-        """
-        # TODO 添加 at_sender 和 quote_origin 参数
-        await self.event.query.adapter.reply_message(
-            message_source=self.event.query.message_event, message=message_chain
-        )
-
-    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
-        """主动发送消息
-
-        Args:
-            target_type (str): 目标类型，`person`或`group`
-            target_id (str): 目标ID
-            message (platform.types.MessageChain): 源平台的消息链，若用户使用的不是源平台适配器，程序也能自动转换为目标平台消息链
-        """
-        await self.event.query.adapter.send_message(target_type=target_type, target_id=target_id, message=message)
-
-    def prevent_postorder(self):
-        """阻止后续插件执行"""
-        self.__prevent_postorder__ = True
-
-    def prevent_default(self):
-        """阻止默认行为"""
-        self.__prevent_default__ = True
-
-    # ========== 以下是内部保留方法，插件不应调用 ==========
-
-    def get_return(self, key: str) -> list:
-        """获取key的所有返回值"""
-        if key in self.__return_value__:
-            return self.__return_value__[key]
-        return None
-
-    def get_return_value(self, key: str):
-        """获取key的首个返回值"""
-        if key in self.__return_value__:
-            return self.__return_value__[key][0]
-        return None
-
-    def is_prevented_default(self):
-        """是否阻止默认行为"""
-        return self.__prevent_default__
-
-    def is_prevented_postorder(self):
-        """是否阻止后序插件执行"""
-        return self.__prevent_postorder__
-
-    def __init__(self, host: APIHost, event: events.BaseEventModel):
-        self.eid = EventContext.eid
-        self.host = host
-        self.event = event
-        self.__prevent_default__ = False
-        self.__prevent_postorder__ = False
-        self.__return_value__ = {}
-        EventContext.eid += 1
-
-
-class RuntimeContainerStatus(enum.Enum):
-    """插件容器状态"""
-
-    MOUNTED = 'mounted'
-    """已加载进内存，所有位于运行时记录中的 RuntimeContainer 至少是这个状态"""
-
-    INITIALIZED = 'initialized'
-    """已初始化"""
-
-
-class RuntimeContainer(pydantic.BaseModel):
-    """运行时的插件容器
-
-    运行期间存储单个插件的信息
-    """
-
-    plugin_name: str
-    """插件名称"""
-
-    plugin_label: discover_engine.I18nString
-    """插件标签"""
-
-    plugin_description: discover_engine.I18nString
-    """插件描述"""
-
-    plugin_version: str
-    """插件版本"""
-
-    plugin_author: str
-    """插件作者"""
-
-    plugin_repository: str
-    """插件源码地址"""
-
-    main_file: str
-    """插件主文件路径"""
-
-    pkg_path: str
-    """插件包路径"""
-
-    plugin_class: typing.Type[BasePlugin] = None
-    """插件类"""
-
-    enabled: typing.Optional[bool] = True
-    """是否启用"""
-
-    priority: typing.Optional[int] = 0
-    """优先级"""
-
-    config_schema: typing.Optional[list[dict]] = []
-    """插件配置模板"""
-
-    plugin_config: typing.Optional[dict] = {}
-    """插件配置"""
-
-    plugin_inst: typing.Optional[BasePlugin] = None
-    """插件实例"""
-
-    event_handlers: dict[
-        typing.Type[events.BaseEventModel],
-        typing.Callable[[BasePlugin, EventContext], typing.Awaitable[None]],
-    ] = {}
-    """事件处理器"""
-
-    tools: list[tools_entities.LLMFunction] = []
-    """内容函数"""
-
-    status: RuntimeContainerStatus = RuntimeContainerStatus.MOUNTED
-    """插件状态"""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    def model_dump(self, *args, **kwargs):
-        return {
-            'name': self.plugin_name,
-            'label': self.plugin_label.to_dict(),
-            'description': self.plugin_description.to_dict(),
-            'version': self.plugin_version,
-            'author': self.plugin_author,
-            'repository': self.plugin_repository,
-            'main_file': self.main_file,
-            'pkg_path': self.pkg_path,
-            'enabled': self.enabled,
-            'priority': self.priority,
-            'config_schema': self.config_schema,
-            'event_handlers': {
-                event_name.__name__: handler.__name__ for event_name, handler in self.event_handlers.items()
-            },
-            'tools': [
-                {
-                    'name': function.name,
-                    'human_desc': function.human_desc,
-                    'description': function.description,
-                    'parameters': function.parameters,
-                    'func': function.func.__name__,
-                }
-                for function in self.tools
-            ],
-            'status': self.status.value,
-        }

pkg/plugin/errors.py

@@ -1,21 +0,0 @@
-from __future__ import annotations
-
-
-class PluginSystemError(Exception):
-    message: str
-
-    def __init__(self, message: str):
-        self.message = message
-
-    def __str__(self):
-        return self.message
-
-
-class PluginNotFoundError(PluginSystemError):
-    def __init__(self, message: str):
-        super().__init__(f'未找到插件: {message}')
-
-
-class PluginInstallerError(PluginSystemError):
-    def __init__(self, message: str):
-        super().__init__(f'安装器操作错误: {message}')

pkg/plugin/events.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-import pydantic.v1 as pydantic
-
-from ..core import entities as core_entities
-from ..provider import entities as llm_entities
-from ..platform.types import message as platform_message
-
-
-class BaseEventModel(pydantic.BaseModel):
-    """事件模型基类"""
-
-    query: typing.Union[core_entities.Query, None]
-    """此次请求的query对象，非请求过程的事件时为None"""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class PersonMessageReceived(BaseEventModel):
-    """收到任何私聊消息时"""
-
-    launcher_type: str
-    """发起对象类型(group/person)"""
-
-    launcher_id: typing.Union[int, str]
-    """发起对象ID(群号/QQ号)"""
-
-    sender_id: typing.Union[int, str]
-    """发送者ID(QQ号)"""
-
-    message_chain: platform_message.MessageChain
-
-
-class GroupMessageReceived(BaseEventModel):
-    """收到任何群聊消息时"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    message_chain: platform_message.MessageChain
-
-
-class PersonNormalMessageReceived(BaseEventModel):
-    """判断为应该处理的私聊普通消息时触发"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    text_message: str
-
-    alter: typing.Optional[str] = None
-    """修改后的消息文本"""
-
-    reply: typing.Optional[list] = None
-    """回复消息组件列表"""
-
-
-class PersonCommandSent(BaseEventModel):
-    """判断为应该处理的私聊命令时触发"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    command: str
-
-    params: list[str]
-
-    text_message: str
-
-    is_admin: bool
-
-    alter: typing.Optional[str] = None
-    """修改后的完整命令文本"""
-
-    reply: typing.Optional[list] = None
-    """回复消息组件列表"""
-
-
-class GroupNormalMessageReceived(BaseEventModel):
-    """判断为应该处理的群聊普通消息时触发"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    text_message: str
-
-    alter: typing.Optional[str] = None
-    """修改后的消息文本"""
-
-    reply: typing.Optional[list] = None
-    """回复消息组件列表"""
-
-
-class GroupCommandSent(BaseEventModel):
-    """判断为应该处理的群聊命令时触发"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    command: str
-
-    params: list[str]
-
-    text_message: str
-
-    is_admin: bool
-
-    alter: typing.Optional[str] = None
-    """修改后的完整命令文本"""
-
-    reply: typing.Optional[list] = None
-    """回复消息组件列表"""
-
-
-class NormalMessageResponded(BaseEventModel):
-    """回复普通消息时触发"""
-
-    launcher_type: str
-
-    launcher_id: typing.Union[int, str]
-
-    sender_id: typing.Union[int, str]
-
-    session: core_entities.Session
-    """会话对象"""
-
-    prefix: str
-    """回复消息的前缀"""
-
-    response_text: str
-    """回复消息的文本"""
-
-    finish_reason: str
-    """响应结束原因"""
-
-    funcs_called: list[str]
-    """调用的函数列表"""
-
-    reply: typing.Optional[list] = None
-    """回复消息组件列表"""
-
-
-class PromptPreProcessing(BaseEventModel):
-    """会话中的Prompt预处理时触发"""
-
-    session_name: str
-
-    default_prompt: list[llm_entities.Message]
-    """此对话的情景预设，可修改"""
-
-    prompt: list[llm_entities.Message]
-    """此对话现有消息记录，可修改"""

pkg/plugin/host.py

@@ -1,9 +0,0 @@
-# 此模块已过时
-# 请从 pkg.plugin.context 引入 BasePlugin, EventContext 和 APIHost
-# 最早将于 v3.4 移除此模块
-
-from .events import *
-
-
-def emit(*args, **kwargs):
-    print('插件调用了已弃用的函数 pkg.plugin.host.emit()')

pkg/plugin/installer.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import abc
-
-from ..core import app, taskmgr
-
-
-class PluginInstaller(metaclass=abc.ABCMeta):
-    """插件安装器抽象类"""
-
-    ap: app.Application
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-
-    async def initialize(self):
-        pass
-
-    @abc.abstractmethod
-    async def install_plugin(
-        self,
-        plugin_source: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """安装插件"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    async def uninstall_plugin(
-        self,
-        plugin_name: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """卸载插件"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    async def update_plugin(
-        self,
-        plugin_name: str,
-        plugin_source: str = None,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """更新插件"""
-        raise NotImplementedError

pkg/plugin/installers/github.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import re
-import os
-import zipfile
-import ssl
-import certifi
-
-import aiohttp
-import aiofiles
-import aiofiles.os as aiofiles_os
-import aioshutil
-
-from .. import installer, errors
-from ...utils import pkgmgr
-from ...core import taskmgr
-
-
-class GitHubRepoInstaller(installer.PluginInstaller):
-    """GitHub仓库插件安装器"""
-
-    def get_github_plugin_repo_label(self, repo_url: str) -> list[str]:
-        """获取username, repo"""
-        repo = re.findall(
-            r'(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)',
-            repo_url,
-        )
-        if len(repo) > 0:
-            return repo[0].split('/')
-        else:
-            return None
-
-    async def download_plugin_source_code(
-        self,
-        repo_url: str,
-        target_path: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ) -> str:
-        """下载插件源码（全异步）"""
-        repo = self.get_github_plugin_repo_label(repo_url)
-        if repo is None:
-            raise errors.PluginInstallerError('仅支持GitHub仓库地址')
-
-        target_path += repo[1]
-        self.ap.logger.debug('正在下载源码...')
-        task_context.trace('下载源码...', 'download-plugin-source-code')
-
-        zipball_url = f'https://api.github.com/repos/{"/".join(repo)}/zipball/HEAD'
-        zip_resp: bytes = None
-
-        # 创建自定义SSL上下文，使用certifi提供的根证书
-        ssl_context = ssl.create_default_context(cafile=certifi.where())
-
-        async with aiohttp.ClientSession(trust_env=True) as session:
-            async with session.get(
-                url=zipball_url,
-                timeout=aiohttp.ClientTimeout(total=300),
-                ssl=ssl_context,  # 使用自定义SSL上下文来验证证书
-            ) as resp:
-                if resp.status != 200:
-                    raise errors.PluginInstallerError(f'下载源码失败: {await resp.text()}')
-                zip_resp = await resp.read()
-
-        if await aiofiles_os.path.exists('temp/' + target_path):
-            await aioshutil.rmtree('temp/' + target_path)
-
-        if await aiofiles_os.path.exists(target_path):
-            await aioshutil.rmtree(target_path)
-
-        await aiofiles_os.makedirs('temp/' + target_path)
-
-        async with aiofiles.open('temp/' + target_path + '/source.zip', 'wb') as f:
-            await f.write(zip_resp)
-
-        self.ap.logger.debug('解压中...')
-        task_context.trace('解压中...', 'unzip-plugin-source-code')
-
-        with zipfile.ZipFile('temp/' + target_path + '/source.zip', 'r') as zip_ref:
-            zip_ref.extractall('temp/' + target_path)
-        await aiofiles_os.remove('temp/' + target_path + '/source.zip')
-
-        import glob
-
-        unzip_dir = glob.glob('temp/' + target_path + '/*')[0]
-        await aioshutil.copytree(unzip_dir, target_path + '/')
-        await aioshutil.rmtree(unzip_dir)
-
-        self.ap.logger.debug('源码下载完成。')
-        return repo[1]
-
-    async def install_requirements(self, path: str):
-        if os.path.exists(path + '/requirements.txt'):
-            pkgmgr.install_requirements(path + '/requirements.txt')
-
-    async def install_plugin(
-        self,
-        plugin_source: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """安装插件"""
-        task_context.trace('下载插件源码...', 'install-plugin')
-        repo_label = await self.download_plugin_source_code(plugin_source, 'plugins/', task_context)
-        task_context.trace('安装插件依赖...', 'install-plugin')
-        await self.install_requirements('plugins/' + repo_label)
-        task_context.trace('完成.', 'install-plugin')
-
-        # Caution: in the v4.0, plugin without manifest will not be able to be updated
-        # await self.ap.plugin_mgr.setting.record_installed_plugin_source(
-        #     "plugins/" + repo_label + '/', plugin_source
-        # )
-
-    async def uninstall_plugin(
-        self,
-        plugin_name: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """卸载插件"""
-        plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-        if plugin_container is None:
-            raise errors.PluginInstallerError('插件不存在或未成功加载')
-        else:
-            task_context.trace('删除插件目录...', 'uninstall-plugin')
-            await aioshutil.rmtree(plugin_container.pkg_path)
-            task_context.trace('完成, 重新加载以生效.', 'uninstall-plugin')
-
-    async def update_plugin(
-        self,
-        plugin_name: str,
-        plugin_source: str = None,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """更新插件"""
-        task_context.trace('更新插件...', 'update-plugin')
-        plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-        if plugin_container is None:
-            raise errors.PluginInstallerError('插件不存在或未成功加载')
-        else:
-            if plugin_container.plugin_repository:
-                plugin_source = plugin_container.plugin_repository
-                task_context.trace('转交安装任务.', 'update-plugin')
-                await self.install_plugin(plugin_source, task_context)
-            else:
-                raise errors.PluginInstallerError('插件无源码信息，无法更新')

pkg/plugin/loader.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-import abc
-
-from ..core import app
-from . import context
-
-
-class PluginLoader(metaclass=abc.ABCMeta):
-    """插件加载器抽象类"""
-
-    ap: app.Application
-
-    plugins: list[context.RuntimeContainer]
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-        self.plugins = []
-
-    async def initialize(self):
-        pass
-
-    @abc.abstractmethod
-    async def load_plugins(self):
-        pass

pkg/plugin/loaders/classic.py

@@ -1,198 +0,0 @@
-from __future__ import annotations
-
-import typing
-import pkgutil
-import importlib
-import traceback
-
-from .. import loader, events, context, models
-from ...core import entities as core_entities
-from ...provider.tools import entities as tools_entities
-from ...utils import funcschema
-from ...discover import engine as discover_engine
-
-
-class PluginLoader(loader.PluginLoader):
-    """加载 plugins/ 目录下的插件"""
-
-    _current_pkg_path = ''
-
-    _current_module_path = ''
-
-    _current_container: context.RuntimeContainer = None
-
-    plugins: list[context.RuntimeContainer] = []
-
-    def __init__(self, ap):
-        self.ap = ap
-        self.plugins = []
-        self._current_pkg_path = ''
-        self._current_module_path = ''
-        self._current_container = None
-
-    async def initialize(self):
-        """初始化"""
-
-    def register(
-        self, name: str, description: str, version: str, author: str
-    ) -> typing.Callable[[typing.Type[context.BasePlugin]], typing.Type[context.BasePlugin]]:
-        self.ap.logger.debug(f'注册插件 {name} {version} by {author}')
-        container = context.RuntimeContainer(
-            plugin_name=name,
-            plugin_label=discover_engine.I18nString(en_US=name, zh_Hans=name),
-            plugin_description=discover_engine.I18nString(en_US=description, zh_Hans=description),
-            plugin_version=version,
-            plugin_author=author,
-            plugin_repository='',
-            pkg_path=self._current_pkg_path,
-            main_file=self._current_module_path,
-            event_handlers={},
-            tools=[],
-        )
-
-        self._current_container = container
-
-        def wrapper(cls: context.BasePlugin) -> typing.Type[context.BasePlugin]:
-            container.plugin_class = cls
-            return cls
-
-        return wrapper
-
-    # 过时
-    # 最早将于 v3.4 版本移除
-    def on(self, event: typing.Type[events.BaseEventModel]) -> typing.Callable[[typing.Callable], typing.Callable]:
-        """注册过时的事件处理器"""
-        self.ap.logger.debug(f'注册事件处理器 {event.__name__}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            async def handler(plugin: context.BasePlugin, ctx: context.EventContext) -> None:
-                args = {
-                    'host': ctx.host,
-                    'event': ctx,
-                }
-
-                # 把 ctx.event 所有的属性都放到 args 里
-                # for k, v in ctx.event.dict().items():
-                #     args[k] = v
-                for attr_name in ctx.event.__dict__.keys():
-                    args[attr_name] = getattr(ctx.event, attr_name)
-
-                func(plugin, **args)
-
-            self._current_container.event_handlers[event] = handler
-
-            return func
-
-        return wrapper
-
-    # 过时
-    # 最早将于 v3.4 版本移除
-    def func(
-        self,
-        name: str = None,
-    ) -> typing.Callable:
-        """注册过时的内容函数"""
-        self.ap.logger.debug(f'注册内容函数 {name}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            function_schema = funcschema.get_func_schema(func)
-            function_name = self._current_container.plugin_name + '-' + (func.__name__ if name is None else name)
-
-            async def handler(plugin: context.BasePlugin, query: core_entities.Query, *args, **kwargs):
-                return func(*args, **kwargs)
-
-            llm_function = tools_entities.LLMFunction(
-                name=function_name,
-                human_desc='',
-                description=function_schema['description'],
-                parameters=function_schema['parameters'],
-                func=handler,
-            )
-
-            self._current_container.tools.append(llm_function)
-
-            return func
-
-        return wrapper
-
-    def handler(self, event: typing.Type[events.BaseEventModel]) -> typing.Callable[[typing.Callable], typing.Callable]:
-        """注册事件处理器"""
-        self.ap.logger.debug(f'注册事件处理器 {event.__name__}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            if (
-                self._current_container is None
-            ):  # None indicates this plugin is registered through manifest, so ignore it here
-                return func
-
-            self._current_container.event_handlers[event] = func
-
-            return func
-
-        return wrapper
-
-    def llm_func(
-        self,
-        name: str = None,
-    ) -> typing.Callable:
-        """注册内容函数"""
-        self.ap.logger.debug(f'注册内容函数 {name}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            if (
-                self._current_container is None
-            ):  # None indicates this plugin is registered through manifest, so ignore it here
-                return func
-
-            function_schema = funcschema.get_func_schema(func)
-            function_name = self._current_container.plugin_name + '-' + (func.__name__ if name is None else name)
-
-            llm_function = tools_entities.LLMFunction(
-                name=function_name,
-                human_desc='',
-                description=function_schema['description'],
-                parameters=function_schema['parameters'],
-                func=func,
-            )
-
-            self._current_container.tools.append(llm_function)
-
-            return func
-
-        return wrapper
-
-    async def _walk_plugin_path(self, module, prefix='', path_prefix=''):
-        """遍历插件路径"""
-        for item in pkgutil.iter_modules(module.__path__):
-            if item.ispkg:
-                await self._walk_plugin_path(
-                    __import__(module.__name__ + '.' + item.name, fromlist=['']),
-                    prefix + item.name + '.',
-                    path_prefix + item.name + '/',
-                )
-            else:
-                try:
-                    self._current_pkg_path = 'plugins/' + path_prefix
-                    self._current_module_path = 'plugins/' + path_prefix + item.name + '.py'
-
-                    self._current_container = None
-
-                    importlib.import_module(module.__name__ + '.' + item.name)
-
-                    if self._current_container is not None:
-                        self.plugins.append(self._current_container)
-                        self.ap.logger.debug(f'插件 {self._current_container} 已加载')
-                except Exception:
-                    self.ap.logger.error(f'加载插件模块 {prefix + item.name} 时发生错误')
-                    traceback.print_exc()
-
-    async def load_plugins(self):
-        """加载插件"""
-        setattr(models, 'register', self.register)
-        setattr(models, 'on', self.on)
-        setattr(models, 'func', self.func)
-
-        setattr(context, 'register', self.register)
-        setattr(context, 'handler', self.handler)
-        setattr(context, 'llm_func', self.llm_func)
-        await self._walk_plugin_path(__import__('plugins', fromlist=['']))

pkg/plugin/loaders/manifest.py

@@ -1,96 +0,0 @@
-from __future__ import annotations
-
-import typing
-import os
-import traceback
-
-from ...core import app
-from .. import context, events
-from .. import loader
-from ...utils import funcschema
-from ...provider.tools import entities as tools_entities
-
-
-class PluginManifestLoader(loader.PluginLoader):
-    """通过插件清单发现插件"""
-
-    _current_container: context.RuntimeContainer = None
-
-    def __init__(self, ap: app.Application):
-        super().__init__(ap)
-
-    def handler(self, event: typing.Type[events.BaseEventModel]) -> typing.Callable[[typing.Callable], typing.Callable]:
-        """注册事件处理器"""
-        self.ap.logger.debug(f'注册事件处理器 {event.__name__}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            self._current_container.event_handlers[event] = func
-
-            return func
-
-        return wrapper
-
-    def llm_func(
-        self,
-        name: str = None,
-    ) -> typing.Callable:
-        """注册内容函数"""
-        self.ap.logger.debug(f'注册内容函数 {name}')
-
-        def wrapper(func: typing.Callable) -> typing.Callable:
-            function_schema = funcschema.get_func_schema(func)
-            function_name = self._current_container.plugin_name + '-' + (func.__name__ if name is None else name)
-
-            llm_function = tools_entities.LLMFunction(
-                name=function_name,
-                human_desc='',
-                description=function_schema['description'],
-                parameters=function_schema['parameters'],
-                func=func,
-            )
-
-            self._current_container.tools.append(llm_function)
-
-            return func
-
-        return wrapper
-
-    async def load_plugins(self):
-        """加载插件"""
-        setattr(context, 'handler', self.handler)
-        setattr(context, 'llm_func', self.llm_func)
-
-        plugin_manifests = self.ap.discover.get_components_by_kind('Plugin')
-
-        for plugin_manifest in plugin_manifests:
-            try:
-                config_schema = plugin_manifest.spec['config'] if 'config' in plugin_manifest.spec else []
-
-                current_plugin_container = context.RuntimeContainer(
-                    plugin_name=plugin_manifest.metadata.name,
-                    plugin_label=plugin_manifest.metadata.label,
-                    plugin_description=plugin_manifest.metadata.description,
-                    plugin_version=plugin_manifest.metadata.version,
-                    plugin_author=plugin_manifest.metadata.author,
-                    plugin_repository=plugin_manifest.metadata.repository,
-                    main_file=os.path.join(plugin_manifest.rel_dir, plugin_manifest.execution.python.path),
-                    pkg_path=plugin_manifest.rel_dir,
-                    config_schema=config_schema,
-                    event_handlers={},
-                    tools=[],
-                )
-
-                self._current_container = current_plugin_container
-
-                # extract the plugin class
-                # this step will load the plugin module,
-                # so the event handlers and tools will be registered
-                plugin_class = plugin_manifest.get_python_component_class()
-                current_plugin_container.plugin_class = plugin_class
-
-                # TODO load component extensions
-
-                self.plugins.append(current_plugin_container)
-            except Exception:
-                self.ap.logger.error(f'加载插件 {plugin_manifest.metadata.name} 时发生错误')
-                traceback.print_exc()

pkg/plugin/manager.py

@@ -1,308 +0,0 @@
-from __future__ import annotations
-
-import traceback
-
-import sqlalchemy
-
-from ..core import app, taskmgr
-from . import context, loader, events, installer, models
-from .loaders import classic, manifest
-from .installers import github
-from ..entity.persistence import plugin as persistence_plugin
-
-
-class PluginManager:
-    """插件管理器"""
-
-    ap: app.Application
-
-    loaders: list[loader.PluginLoader]
-
-    installer: installer.PluginInstaller
-
-    api_host: context.APIHost
-
-    plugin_containers: list[context.RuntimeContainer]
-
-    def plugins(
-        self,
-        enabled: bool = None,
-        status: context.RuntimeContainerStatus = None,
-    ) -> list[context.RuntimeContainer]:
-        """获取插件列表"""
-        plugins = self.plugin_containers
-
-        if enabled is not None:
-            plugins = [plugin for plugin in plugins if plugin.enabled == enabled]
-
-        if status is not None:
-            plugins = [plugin for plugin in plugins if plugin.status == status]
-
-        return plugins
-
-    def get_plugin(
-        self,
-        author: str,
-        plugin_name: str,
-    ) -> context.RuntimeContainer:
-        """通过作者和插件名获取插件"""
-        for plugin in self.plugins():
-            if plugin.plugin_author == author and plugin.plugin_name == plugin_name:
-                return plugin
-        return None
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-        self.loaders = [
-            classic.PluginLoader(ap),
-            manifest.PluginManifestLoader(ap),
-        ]
-        self.installer = github.GitHubRepoInstaller(ap)
-        self.api_host = context.APIHost(ap)
-        self.plugin_containers = []
-
-    async def initialize(self):
-        for loader in self.loaders:
-            await loader.initialize()
-        await self.installer.initialize()
-        await self.api_host.initialize()
-
-        setattr(models, 'require_ver', self.api_host.require_ver)
-
-    async def load_plugins(self):
-        self.ap.logger.info('Loading all plugins...')
-
-        for loader in self.loaders:
-            await loader.load_plugins()
-            self.plugin_containers.extend(loader.plugins)
-
-        await self.load_plugin_settings(self.plugin_containers)
-
-        # 按优先级倒序
-        self.plugin_containers.sort(key=lambda x: x.priority, reverse=False)
-
-        self.ap.logger.debug(f'优先级排序后的插件列表 {self.plugin_containers}')
-
-    async def load_plugin_settings(self, plugin_containers: list[context.RuntimeContainer]):
-        for plugin_container in plugin_containers:
-            result = await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.select(persistence_plugin.PluginSetting)
-                .where(persistence_plugin.PluginSetting.plugin_author == plugin_container.plugin_author)
-                .where(persistence_plugin.PluginSetting.plugin_name == plugin_container.plugin_name)
-            )
-
-            setting = result.first()
-
-            if setting is None:
-                new_setting_data = {
-                    'plugin_author': plugin_container.plugin_author,
-                    'plugin_name': plugin_container.plugin_name,
-                    'enabled': plugin_container.enabled,
-                    'priority': plugin_container.priority,
-                    'config': plugin_container.plugin_config,
-                }
-
-                await self.ap.persistence_mgr.execute_async(
-                    sqlalchemy.insert(persistence_plugin.PluginSetting).values(**new_setting_data)
-                )
-                continue
-            else:
-                plugin_container.enabled = setting.enabled
-                plugin_container.priority = setting.priority
-                plugin_container.plugin_config = setting.config
-
-    async def dump_plugin_container_setting(self, plugin_container: context.RuntimeContainer):
-        """保存单个插件容器的设置到数据库"""
-        await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.update(persistence_plugin.PluginSetting)
-            .where(persistence_plugin.PluginSetting.plugin_author == plugin_container.plugin_author)
-            .where(persistence_plugin.PluginSetting.plugin_name == plugin_container.plugin_name)
-            .values(
-                enabled=plugin_container.enabled,
-                priority=plugin_container.priority,
-                config=plugin_container.plugin_config,
-            )
-        )
-
-    async def initialize_plugin(self, plugin: context.RuntimeContainer):
-        self.ap.logger.debug(f'初始化插件 {plugin.plugin_name}')
-        plugin.plugin_inst = plugin.plugin_class(self.api_host)
-        plugin.plugin_inst.config = plugin.plugin_config
-        plugin.plugin_inst.ap = self.ap
-        plugin.plugin_inst.host = self.api_host
-        await plugin.plugin_inst.initialize()
-        plugin.status = context.RuntimeContainerStatus.INITIALIZED
-
-    async def initialize_plugins(self):
-        for plugin in self.plugins():
-            if not plugin.enabled:
-                self.ap.logger.debug(f'插件 {plugin.plugin_name} 未启用，跳过初始化')
-                continue
-            try:
-                await self.initialize_plugin(plugin)
-            except Exception as e:
-                self.ap.logger.error(f'插件 {plugin.plugin_name} 初始化失败: {e}')
-                self.ap.logger.exception(e)
-                continue
-
-    async def destroy_plugin(self, plugin: context.RuntimeContainer):
-        if plugin.status != context.RuntimeContainerStatus.INITIALIZED:
-            return
-
-        self.ap.logger.debug(f'释放插件 {plugin.plugin_name}')
-        plugin.plugin_inst.__del__()
-        await plugin.plugin_inst.destroy()
-        plugin.plugin_inst = None
-        plugin.status = context.RuntimeContainerStatus.MOUNTED
-
-    async def destroy_plugins(self):
-        for plugin in self.plugins():
-            if plugin.status != context.RuntimeContainerStatus.INITIALIZED:
-                self.ap.logger.debug(f'插件 {plugin.plugin_name} 未初始化，跳过释放')
-                continue
-
-            try:
-                await self.destroy_plugin(plugin)
-            except Exception as e:
-                self.ap.logger.error(f'插件 {plugin.plugin_name} 释放失败: {e}')
-                self.ap.logger.exception(e)
-                continue
-
-    async def install_plugin(
-        self,
-        plugin_source: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """安装插件"""
-        await self.installer.install_plugin(plugin_source, task_context)
-
-        # TODO statistics
-
-        task_context.trace('重载插件..', 'reload-plugin')
-        await self.ap.reload(scope='plugin')
-
-    async def uninstall_plugin(
-        self,
-        plugin_name: str,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """卸载插件"""
-
-        plugin_container = self.get_plugin_by_name(plugin_name)
-
-        if plugin_container is None:
-            raise ValueError(f'插件 {plugin_name} 不存在')
-
-        await self.destroy_plugin(plugin_container)
-        await self.installer.uninstall_plugin(plugin_name, task_context)
-
-        # TODO statistics
-
-        task_context.trace('重载插件..', 'reload-plugin')
-        await self.ap.reload(scope='plugin')
-
-    async def update_plugin(
-        self,
-        plugin_name: str,
-        plugin_source: str = None,
-        task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
-    ):
-        """更新插件"""
-        await self.installer.update_plugin(plugin_name, plugin_source, task_context)
-
-        # TODO statistics
-
-        task_context.trace('重载插件..', 'reload-plugin')
-        await self.ap.reload(scope='plugin')
-
-    def get_plugin_by_name(self, plugin_name: str) -> context.RuntimeContainer:
-        """通过插件名获取插件"""
-        for plugin in self.plugins():
-            if plugin.plugin_name == plugin_name:
-                return plugin
-        return None
-
-    async def emit_event(self, event: events.BaseEventModel) -> context.EventContext:
-        """触发事件"""
-
-        ctx = context.EventContext(host=self.api_host, event=event)
-
-        emitted_plugins: list[context.RuntimeContainer] = []
-
-        for plugin in self.plugins(enabled=True, status=context.RuntimeContainerStatus.INITIALIZED):
-            if event.__class__ in plugin.event_handlers:
-                self.ap.logger.debug(f'插件 {plugin.plugin_name} 处理事件 {event.__class__.__name__}')
-
-                is_prevented_default_before_call = ctx.is_prevented_default()
-
-                try:
-                    await plugin.event_handlers[event.__class__](plugin.plugin_inst, ctx)
-                except Exception as e:
-                    self.ap.logger.error(
-                        f'插件 {plugin.plugin_name} 处理事件 {event.__class__.__name__} 时发生错误: {e}'
-                    )
-                    self.ap.logger.debug(f'Traceback: {traceback.format_exc()}')
-
-                emitted_plugins.append(plugin)
-
-                if not is_prevented_default_before_call and ctx.is_prevented_default():
-                    self.ap.logger.debug(f'插件 {plugin.plugin_name} 阻止了默认行为执行')
-
-                if ctx.is_prevented_postorder():
-                    self.ap.logger.debug(f'插件 {plugin.plugin_name} 阻止了后序插件的执行')
-                    break
-
-        for key in ctx.__return_value__.keys():
-            if hasattr(ctx.event, key):
-                setattr(ctx.event, key, ctx.__return_value__[key][0])
-
-        self.ap.logger.debug(f'事件 {event.__class__.__name__}({ctx.eid}) 处理完成，返回值 {ctx.__return_value__}')
-
-        # TODO statistics
-
-        return ctx
-
-    async def update_plugin_switch(self, plugin_name: str, new_status: bool):
-        if self.get_plugin_by_name(plugin_name) is not None:
-            for plugin in self.plugins():
-                if plugin.plugin_name == plugin_name:
-                    if plugin.enabled == new_status:
-                        return False
-
-                    # 初始化/释放插件
-                    if new_status:
-                        await self.initialize_plugin(plugin)
-                    else:
-                        await self.destroy_plugin(plugin)
-
-                    plugin.enabled = new_status
-
-                    await self.dump_plugin_container_setting(plugin)
-
-                    break
-
-            return True
-        else:
-            return False
-
-    async def reorder_plugins(self, plugins: list[dict]):
-        for plugin in plugins:
-            plugin_name = plugin.get('name')
-            plugin_priority = plugin.get('priority')
-
-            for plugin in self.plugin_containers:
-                if plugin.plugin_name == plugin_name:
-                    plugin.priority = plugin_priority
-                    break
-
-        self.plugin_containers.sort(key=lambda x: x.priority, reverse=False)
-
-        for plugin in self.plugin_containers:
-            await self.dump_plugin_container_setting(plugin)
-
-    async def set_plugin_config(self, plugin_container: context.RuntimeContainer, new_config: dict):
-        plugin_container.plugin_config = new_config
-
-        plugin_container.plugin_inst.config = new_config
-
-        await self.dump_plugin_container_setting(plugin_container)

pkg/plugin/models.py

@@ -1,28 +0,0 @@
-# 此模块已过时，请引入 pkg.plugin.context 中的 register, handler 和 llm_func 来注册插件、事件处理函数和内容函数
-# 各个事件模型请从 pkg.plugin.events 引入
-# 最早将于 v3.4 移除此模块
-
-from __future__ import annotations
-
-import typing
-
-from .context import BasePlugin as Plugin
-from .events import *
-
-
-def register(
-    name: str, description: str, version: str, author
-) -> typing.Callable[[typing.Type[Plugin]], typing.Type[Plugin]]:
-    pass
-
-
-def on(
-    event: typing.Type[BaseEventModel],
-) -> typing.Callable[[typing.Callable], typing.Callable]:
-    pass
-
-
-def func(
-    name: str = None,
-) -> typing.Callable:
-    pass

pkg/provider/entities.py

@@ -1,135 +0,0 @@
-from __future__ import annotations
-
-import typing
-import pydantic.v1 as pydantic
-
-from pkg.provider import entities
-
-
-from ..platform.types import message as platform_message
-
-
-class FunctionCall(pydantic.BaseModel):
-    name: str
-
-    arguments: str
-
-
-class ToolCall(pydantic.BaseModel):
-    id: str
-
-    type: str
-
-    function: FunctionCall
-
-
-class ImageURLContentObject(pydantic.BaseModel):
-    url: str
-
-    def __str__(self):
-        return self.url[:128] + ('...' if len(self.url) > 128 else '')
-
-
-class ContentElement(pydantic.BaseModel):
-    type: str
-    """内容类型"""
-
-    text: typing.Optional[str] = None
-
-    image_url: typing.Optional[ImageURLContentObject] = None
-
-    image_base64: typing.Optional[str] = None
-
-    def __str__(self):
-        if self.type == 'text':
-            return self.text
-        elif self.type == 'image_url':
-            return f'[图片]({self.image_url})'
-        else:
-            return '未知内容'
-
-    @classmethod
-    def from_text(cls, text: str):
-        return cls(type='text', text=text)
-
-    @classmethod
-    def from_image_url(cls, image_url: str):
-        return cls(type='image_url', image_url=ImageURLContentObject(url=image_url))
-
-    @classmethod
-    def from_image_base64(cls, image_base64: str):
-        return cls(type='image_base64', image_base64=image_base64)
-
-
-class Message(pydantic.BaseModel):
-    """消息"""
-
-    role: str  # user, system, assistant, tool, command, plugin
-    """消息的角色"""
-
-    name: typing.Optional[str] = None
-    """名称，仅函数调用返回时设置"""
-
-    content: typing.Optional[list[ContentElement]] | typing.Optional[str] = None
-    """内容"""
-
-    tool_calls: typing.Optional[list[ToolCall]] = None
-    """工具调用"""
-
-    tool_call_id: typing.Optional[str] = None
-
-    def readable_str(self) -> str:
-        if self.content is not None:
-            return str(self.role) + ': ' + str(self.get_content_platform_message_chain())
-        elif self.tool_calls is not None:
-            return f'调用工具: {self.tool_calls[0].id}'
-        else:
-            return '未知消息'
-
-    def get_content_platform_message_chain(self, prefix_text: str = '') -> platform_message.MessageChain | None:
-        """将内容转换为平台消息 MessageChain 对象
-
-        Args:
-            prefix_text (str): 首个文字组件的前缀文本
-        """
-
-        if self.content is None:
-            return None
-        elif isinstance(self.content, str):
-            return platform_message.MessageChain([platform_message.Plain(prefix_text + self.content)])
-        elif isinstance(self.content, list):
-            mc = []
-            for ce in self.content:
-                if ce.type == 'text':
-                    mc.append(platform_message.Plain(ce.text))
-                elif ce.type == 'image_url':
-                    if ce.image_url.url.startswith('http'):
-                        mc.append(platform_message.Image(url=ce.image_url.url))
-                    else:  # base64
-                        b64_str = ce.image_url.url
-
-                        if b64_str.startswith('data:'):
-                            b64_str = b64_str.split(',')[1]
-
-                        mc.append(platform_message.Image(base64=b64_str))
-
-            # 找第一个文字组件
-            if prefix_text:
-                for i, c in enumerate(mc):
-                    if isinstance(c, platform_message.Plain):
-                        mc[i] = platform_message.Plain(prefix_text + c.text)
-                        break
-                else:
-                    mc.insert(0, platform_message.Plain(prefix_text))
-
-            return platform_message.MessageChain(mc)
-
-
-class Prompt(pydantic.BaseModel):
-    """供AI使用的Prompt"""
-
-    name: str
-    """名称"""
-
-    messages: list[entities.Message]
-    """消息列表"""

pkg/provider/modelmgr/modelmgr.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-import sqlalchemy
-
-from . import entities, requester
-from ...core import app
-from ...discover import engine
-from . import token
-from ...entity.persistence import model as persistence_model
-
-FETCH_MODEL_LIST_URL = 'https://api.qchatgpt.rockchin.top/api/v2/fetch/model_list'
-
-
-class ModelManager:
-    """模型管理器"""
-
-    model_list: list[entities.LLMModelInfo]  # deprecated
-
-    requesters: dict[str, requester.LLMAPIRequester]  # deprecated
-
-    token_mgrs: dict[str, token.TokenManager]  # deprecated
-
-    # ====== 4.0 ======
-
-    ap: app.Application
-
-    llm_models: list[requester.RuntimeLLMModel]
-
-    requester_components: list[engine.Component]
-
-    requester_dict: dict[str, type[requester.LLMAPIRequester]]  # cache
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-        self.model_list = []
-        self.requesters = {}
-        self.token_mgrs = {}
-        self.llm_models = []
-        self.requester_components = []
-        self.requester_dict = {}
-
-    async def initialize(self):
-        self.requester_components = self.ap.discover.get_components_by_kind('LLMAPIRequester')
-
-        # forge requester class dict
-        requester_dict: dict[str, type[requester.LLMAPIRequester]] = {}
-        for component in self.requester_components:
-            requester_dict[component.metadata.name] = component.get_python_component_class()
-
-        self.requester_dict = requester_dict
-
-        await self.load_models_from_db()
-
-    async def load_models_from_db(self):
-        """从数据库加载模型"""
-        self.ap.logger.info('Loading models from db...')
-
-        self.llm_models = []
-
-        # llm models
-        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.LLMModel))
-
-        llm_models = result.all()
-
-        # load models
-        for llm_model in llm_models:
-            await self.load_llm_model(llm_model)
-
-    async def init_runtime_llm_model(
-        self,
-        model_info: persistence_model.LLMModel | sqlalchemy.Row[persistence_model.LLMModel] | dict,
-    ):
-        """初始化运行时模型"""
-        if isinstance(model_info, sqlalchemy.Row):
-            model_info = persistence_model.LLMModel(**model_info._mapping)
-        elif isinstance(model_info, dict):
-            model_info = persistence_model.LLMModel(**model_info)
-
-        requester_inst = self.requester_dict[model_info.requester](ap=self.ap, config=model_info.requester_config)
-
-        await requester_inst.initialize()
-
-        runtime_llm_model = requester.RuntimeLLMModel(
-            model_entity=model_info,
-            token_mgr=token.TokenManager(
-                name=model_info.uuid,
-                tokens=model_info.api_keys,
-            ),
-            requester=requester_inst,
-        )
-
-        return runtime_llm_model
-
-    async def load_llm_model(
-        self,
-        model_info: persistence_model.LLMModel | sqlalchemy.Row[persistence_model.LLMModel] | dict,
-    ):
-        """加载模型"""
-        runtime_llm_model = await self.init_runtime_llm_model(model_info)
-        self.llm_models.append(runtime_llm_model)
-
-    async def get_model_by_name(self, name: str) -> entities.LLMModelInfo:  # deprecated
-        """通过名称获取模型"""
-        for model in self.model_list:
-            if model.name == name:
-                return model
-        raise ValueError(f'无法确定模型 {name} 的信息')
-
-    async def get_model_by_uuid(self, uuid: str) -> entities.LLMModelInfo:
-        """通过uuid获取模型"""
-        for model in self.llm_models:
-            if model.model_entity.uuid == uuid:
-                return model
-        raise ValueError(f'model {uuid} not found')
-
-    async def remove_llm_model(self, model_uuid: str):
-        """移除模型"""
-        for model in self.llm_models:
-            if model.model_entity.uuid == model_uuid:
-                self.llm_models.remove(model)
-                return
-
-    def get_available_requesters_info(self) -> list[dict]:
-        """获取所有可用的请求器"""
-        return [component.to_plain_dict() for component in self.requester_components]
-
-    def get_available_requester_info_by_name(self, name: str) -> dict | None:
-        """通过名称获取请求器信息"""
-        for component in self.requester_components:
-            if component.metadata.name == name:
-                return component.to_plain_dict()
-        return None
-
-    def get_available_requester_manifest_by_name(self, name: str) -> engine.Component | None:
-        """通过名称获取请求器清单"""
-        for component in self.requester_components:
-            if component.metadata.name == name:
-                return component
-        return None

pkg/provider/modelmgr/requester.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import abc
-import typing
-
-from ...core import app
-from ...core import entities as core_entities
-from .. import entities as llm_entities
-from ..tools import entities as tools_entities
-from ...entity.persistence import model as persistence_model
-from . import token
-
-
-class RuntimeLLMModel:
-    """运行时模型"""
-
-    model_entity: persistence_model.LLMModel
-    """模型数据"""
-
-    token_mgr: token.TokenManager
-    """api key管理器"""
-
-    requester: LLMAPIRequester
-    """请求器实例"""
-
-    def __init__(
-        self,
-        model_entity: persistence_model.LLMModel,
-        token_mgr: token.TokenManager,
-        requester: LLMAPIRequester,
-    ):
-        self.model_entity = model_entity
-        self.token_mgr = token_mgr
-        self.requester = requester
-
-
-class LLMAPIRequester(metaclass=abc.ABCMeta):
-    """LLM API请求器"""
-
-    name: str = None
-
-    ap: app.Application
-
-    default_config: dict[str, typing.Any] = {}
-
-    requester_cfg: dict[str, typing.Any] = {}
-
-    def __init__(self, ap: app.Application, config: dict[str, typing.Any]):
-        self.ap = ap
-        self.requester_cfg = {**self.default_config}
-        self.requester_cfg.update(config)
-
-    async def initialize(self):
-        pass
-
-    @abc.abstractmethod
-    async def invoke_llm(
-        self,
-        query: core_entities.Query,
-        model: RuntimeLLMModel,
-        messages: typing.List[llm_entities.Message],
-        funcs: typing.List[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        """调用API
-
-        Args:
-            model (RuntimeLLMModel): 使用的模型信息
-            messages (typing.List[llm_entities.Message]): 消息对象列表
-            funcs (typing.List[tools_entities.LLMFunction], optional): 使用的工具函数列表. Defaults to None.
-            extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
-
-        Returns:
-            llm_entities.Message: 返回消息对象
-        """
-        pass

pkg/provider/modelmgr/requesters/anthropicmsgs.py

@@ -1,178 +0,0 @@
-from __future__ import annotations
-
-import typing
-import json
-import platform
-import socket
-import anthropic
-import httpx
-
-from .. import errors, requester
-
-from ....core import entities as core_entities
-from ... import entities as llm_entities
-from ...tools import entities as tools_entities
-from ....utils import image
-
-
-class AnthropicMessages(requester.LLMAPIRequester):
-    """Anthropic Messages API 请求器"""
-
-    client: anthropic.AsyncAnthropic
-
-    default_config: dict[str, typing.Any] = {
-        'base_url': 'https://api.anthropic.com/v1',
-        'timeout': 120,
-    }
-
-    async def initialize(self):
-        # 兼容 Windows 缺失 TCP_KEEPINTVL 和 TCP_KEEPCNT 的问题
-        if platform.system() == 'Windows':
-            if not hasattr(socket, 'TCP_KEEPINTVL'):
-                socket.TCP_KEEPINTVL = 0
-            if not hasattr(socket, 'TCP_KEEPCNT'):
-                socket.TCP_KEEPCNT = 0
-        httpx_client = anthropic._base_client.AsyncHttpxClientWrapper(
-            base_url=self.requester_cfg['base_url'],
-            # cast to a valid type because mypy doesn't understand our type narrowing
-            timeout=typing.cast(httpx.Timeout, self.requester_cfg['timeout']),
-            limits=anthropic._constants.DEFAULT_CONNECTION_LIMITS,
-            follow_redirects=True,
-            trust_env=True,
-        )
-
-        self.client = anthropic.AsyncAnthropic(
-            api_key='',
-            http_client=httpx_client,
-        )
-
-    async def invoke_llm(
-        self,
-        query: core_entities.Query,
-        model: requester.RuntimeLLMModel,
-        messages: typing.List[llm_entities.Message],
-        funcs: typing.List[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        self.client.api_key = model.token_mgr.get_token()
-
-        args = extra_args.copy()
-        args['model'] = model.model_entity.name
-
-        # 处理消息
-
-        # system
-        system_role_message = None
-
-        for i, m in enumerate(messages):
-            if m.role == 'system':
-                system_role_message = m
-
-                break
-
-        if system_role_message:
-            messages.pop(i)
-
-        if isinstance(system_role_message, llm_entities.Message) and isinstance(system_role_message.content, str):
-            args['system'] = system_role_message.content
-
-        req_messages = []
-
-        for m in messages:
-            if m.role == 'tool':
-                tool_call_id = m.tool_call_id
-
-                req_messages.append(
-                    {
-                        'role': 'user',
-                        'content': [
-                            {
-                                'type': 'tool_result',
-                                'tool_use_id': tool_call_id,
-                                'content': m.content,
-                            }
-                        ],
-                    }
-                )
-
-                continue
-
-            msg_dict = m.dict(exclude_none=True)
-
-            if isinstance(m.content, str) and m.content.strip() != '':
-                msg_dict['content'] = [{'type': 'text', 'text': m.content}]
-            elif isinstance(m.content, list):
-                for i, ce in enumerate(m.content):
-                    if ce.type == 'image_base64':
-                        image_b64, image_format = await image.extract_b64_and_format(ce.image_base64)
-
-                        alter_image_ele = {
-                            'type': 'image',
-                            'source': {
-                                'type': 'base64',
-                                'media_type': f'image/{image_format}',
-                                'data': image_b64,
-                            },
-                        }
-                        msg_dict['content'][i] = alter_image_ele
-
-            if m.tool_calls:
-                for tool_call in m.tool_calls:
-                    msg_dict['content'].append(
-                        {
-                            'type': 'tool_use',
-                            'id': tool_call.id,
-                            'name': tool_call.function.name,
-                            'input': json.loads(tool_call.function.arguments),
-                        }
-                    )
-
-                del msg_dict['tool_calls']
-
-            req_messages.append(msg_dict)
-
-        args['messages'] = req_messages
-
-        if funcs:
-            tools = await self.ap.tool_mgr.generate_tools_for_anthropic(funcs)
-
-            if tools:
-                args['tools'] = tools
-
-        try:
-            # print(json.dumps(args, indent=4, ensure_ascii=False))
-            resp = await self.client.messages.create(**args)
-
-            args = {
-                'content': '',
-                'role': resp.role,
-            }
-
-            assert type(resp) is anthropic.types.message.Message
-
-            for block in resp.content:
-                if block.type == 'thinking':
-                    args['content'] = '<think>' + block.thinking + '</think>\n' + args['content']
-                elif block.type == 'text':
-                    args['content'] += block.text
-                elif block.type == 'tool_use':
-                    assert type(block) is anthropic.types.tool_use_block.ToolUseBlock
-                    tool_call = llm_entities.ToolCall(
-                        id=block.id,
-                        type='function',
-                        function=llm_entities.FunctionCall(name=block.name, arguments=json.dumps(block.input)),
-                    )
-                    if 'tool_calls' not in args:
-                        args['tool_calls'] = []
-                    args['tool_calls'].append(tool_call)
-
-            return llm_entities.Message(**args)
-        except anthropic.AuthenticationError as e:
-            raise errors.RequesterError(f'api-key 无效: {e.message}')
-        except anthropic.BadRequestError as e:
-            raise errors.RequesterError(str(e.message))
-        except anthropic.NotFoundError as e:
-            if 'model: ' in str(e):
-                raise errors.RequesterError(f'模型无效: {e.message}')
-            else:
-                raise errors.RequesterError(f'请求地址无效: {e.message}')

pkg/provider/modelmgr/requesters/anthropicmsgs.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: anthropic-messages
-  label:
-    en_US: Anthropic
-    zh_Hans: Anthropic
-  icon: anthropic.svg
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://api.anthropic.com/v1"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./anthropicmsgs.py
-    attr: AnthropicMessages

pkg/provider/modelmgr/requesters/bailianchatcmpl.py

@@ -1,17 +0,0 @@
-from __future__ import annotations
-
-import typing
-import openai
-
-from . import modelscopechatcmpl
-
-
-class BailianChatCompletions(modelscopechatcmpl.ModelScopeChatCompletions):
-    """阿里云百炼大模型平台 ChatCompletion API 请求器"""
-
-    client: openai.AsyncClient
-
-    default_config: dict[str, typing.Any] = {
-        'base_url': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        'timeout': 120,
-    }

pkg/provider/modelmgr/requesters/bailianchatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: bailian-chat-completions
-  label:
-    en_US: Aliyun Bailian
-    zh_Hans: 阿里云百炼
-  icon: bailian.png
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://dashscope.aliyuncs.com/compatible-mode/v1"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./bailianchatcmpl.py
-    attr: BailianChatCompletions

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import typing
-
-import openai
-import openai.types.chat.chat_completion as chat_completion
-import httpx
-
-from .. import errors, requester
-from ....core import entities as core_entities
-from ... import entities as llm_entities
-from ...tools import entities as tools_entities
-
-
-class OpenAIChatCompletions(requester.LLMAPIRequester):
-    """OpenAI ChatCompletion API 请求器"""
-
-    client: openai.AsyncClient
-
-    default_config: dict[str, typing.Any] = {
-        'base_url': 'https://api.openai.com/v1',
-        'timeout': 120,
-    }
-
-    async def initialize(self):
-        self.client = openai.AsyncClient(
-            api_key='',
-            base_url=self.requester_cfg['base_url'].replace(' ', ''),
-            timeout=self.requester_cfg['timeout'],
-            http_client=httpx.AsyncClient(trust_env=True, timeout=self.requester_cfg['timeout']),
-        )
-
-    async def _req(
-        self,
-        args: dict,
-        extra_body: dict = {},
-    ) -> chat_completion.ChatCompletion:
-        return await self.client.chat.completions.create(**args, extra_body=extra_body)
-
-    async def _make_msg(
-        self,
-        chat_completion: chat_completion.ChatCompletion,
-    ) -> llm_entities.Message:
-        chatcmpl_message = chat_completion.choices[0].message.model_dump()
-
-        # 确保 role 字段存在且不为 None
-        if 'role' not in chatcmpl_message or chatcmpl_message['role'] is None:
-            chatcmpl_message['role'] = 'assistant'
-
-        reasoning_content = chatcmpl_message['reasoning_content'] if 'reasoning_content' in chatcmpl_message else None
-
-        # deepseek的reasoner模型
-        if reasoning_content is not None:
-            chatcmpl_message['content'] = '<think>\n' + reasoning_content + '\n</think>\n' + chatcmpl_message['content']
-
-        message = llm_entities.Message(**chatcmpl_message)
-
-        return message
-
-    async def _closure(
-        self,
-        query: core_entities.Query,
-        req_messages: list[dict],
-        use_model: requester.RuntimeLLMModel,
-        use_funcs: list[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        self.client.api_key = use_model.token_mgr.get_token()
-
-        args = {}
-        args['model'] = use_model.model_entity.name
-
-        if use_funcs:
-            tools = await self.ap.tool_mgr.generate_tools_for_openai(use_funcs)
-
-            if tools:
-                args['tools'] = tools
-
-        # 设置此次请求中的messages
-        messages = req_messages.copy()
-
-        # 检查vision
-        for msg in messages:
-            if 'content' in msg and isinstance(msg['content'], list):
-                for me in msg['content']:
-                    if me['type'] == 'image_base64':
-                        me['image_url'] = {'url': me['image_base64']}
-                        me['type'] = 'image_url'
-                        del me['image_base64']
-
-        args['messages'] = messages
-
-        # 发送请求
-        resp = await self._req(args, extra_body=extra_args)
-
-        # 处理请求结果
-        message = await self._make_msg(resp)
-
-        return message
-
-    async def invoke_llm(
-        self,
-        query: core_entities.Query,
-        model: requester.RuntimeLLMModel,
-        messages: typing.List[llm_entities.Message],
-        funcs: typing.List[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        req_messages = []  # req_messages 仅用于类内，外部同步由 query.messages 进行
-        for m in messages:
-            msg_dict = m.dict(exclude_none=True)
-            content = msg_dict.get('content')
-            if isinstance(content, list):
-                # 检查 content 列表中是否每个部分都是文本
-                if all(isinstance(part, dict) and part.get('type') == 'text' for part in content):
-                    # 将所有文本部分合并为一个字符串
-                    msg_dict['content'] = '\n'.join(part['text'] for part in content)
-            req_messages.append(msg_dict)
-
-        try:
-            return await self._closure(
-                query=query,
-                req_messages=req_messages,
-                use_model=model,
-                use_funcs=funcs,
-                extra_args=extra_args,
-            )
-        except asyncio.TimeoutError:
-            raise errors.RequesterError('请求超时')
-        except openai.BadRequestError as e:
-            if 'context_length_exceeded' in e.message:
-                raise errors.RequesterError(f'上文过长，请重置会话: {e.message}')
-            else:
-                raise errors.RequesterError(f'请求参数错误: {e.message}')
-        except openai.AuthenticationError as e:
-            raise errors.RequesterError(f'无效的 api-key: {e.message}')
-        except openai.NotFoundError as e:
-            raise errors.RequesterError(f'请求路径错误: {e.message}')
-        except openai.RateLimitError as e:
-            raise errors.RequesterError(f'请求过于频繁或余额不足: {e.message}')
-        except openai.APIError as e:
-            raise errors.RequesterError(f'请求错误: {e.message}')

pkg/provider/modelmgr/requesters/chatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: openai-chat-completions
-  label:
-    en_US: OpenAI
-    zh_Hans: OpenAI
-  icon: openai.svg
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://api.openai.com/v1"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./chatcmpl.py
-    attr: OpenAIChatCompletions

pkg/provider/modelmgr/requesters/deepseekchatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: deepseek-chat-completions
-  label:
-    en_US: DeepSeek
-    zh_Hans: 深度求索
-  icon: deepseek.svg
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://api.deepseek.com"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./deepseekchatcmpl.py
-    attr: DeepseekChatCompletions

pkg/provider/modelmgr/requesters/geminichatcmpl.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import typing
-import google.genai
-from google.genai import types
-
-from .. import errors, requester
-from ....core import entities as core_entities
-from ... import entities as llm_entities
-from ...tools import entities as tools_entities
-
-
-class GeminiChatCompletions(requester.LLMAPIRequester):
-    """Google Gemini API 请求器"""
-
-    default_config: dict[str, typing.Any] = {
-        'base_url': 'https://generativelanguage.googleapis.com',
-        'timeout': 120,
-    }
-
-    async def initialize(self):
-        """初始化 Gemini API 客户端"""
-        pass
-
-    async def invoke_llm(
-        self,
-        query: core_entities.Query,
-        model: requester.RuntimeLLMModel,
-        messages: typing.List[llm_entities.Message],
-        funcs: typing.List[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        """调用 Gemini API 生成回复"""
-        try:
-            self.client = google.genai.Client(
-                api_key=model.token_mgr.get_token(),
-                http_options=types.HttpOptions(api_version='v1alpha'),
-            )
-            contents = []
-
-            system_content = None
-
-            for message in messages:
-                role = message.role
-                parts = []
-
-                if isinstance(message.content, str):
-                    parts.append(types.Part.from_text(text=message.content))
-                elif isinstance(message.content, list):
-                    for content in message.content:
-                        if content.type == 'text':
-                            parts.append(types.Part.from_text(text=content.text))
-                        # elif content.type == 'image_url':
-                        #     parts.append(types.Part.from_image_url(url=content.image_url))
-
-                if role == 'system':
-                    system_content = parts
-                else:
-                    content = types.Content(role=role, parts=parts)
-                    contents.append(content)
-
-            response = self.client.models.generate_content(
-                model=model.model_entity.name,
-                contents=contents,
-                config=types.GenerateContentConfig(
-                    system_instruction=system_content,
-                    **extra_args,
-                ),
-            )
-
-            return llm_entities.Message(
-                role='assistant',
-                content=response.candidates[0].content.parts[0].text,
-            )
-
-        except Exception as e:
-            error_message = str(e).lower()
-            if 'invalid api key' in error_message:
-                raise errors.RequesterError(f'无效的 API 密钥: {str(e)}')
-            elif 'not found' in error_message:
-                raise errors.RequesterError(f'请求路径错误或模型无效: {str(e)}')
-            elif any(keyword in error_message for keyword in ['rate limit', 'quota', 'permission denied']):
-                raise errors.RequesterError(f'请求过于频繁或余额不足: {str(e)}')
-            elif 'timeout' in error_message:
-                raise errors.RequesterError(f'请求超时: {str(e)}')
-            else:
-                raise errors.RequesterError(f'Gemini API 请求错误: {str(e)}')

pkg/provider/modelmgr/requesters/geminichatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: gemini-chat-completions
-  label:
-    en_US: Google Gemini
-    zh_Hans: Google Gemini
-  icon: gemini.svg
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://generativelanguage.googleapis.com"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./geminichatcmpl.py
-    attr: GeminiChatCompletions

pkg/provider/modelmgr/requesters/giteeaichatcmpl.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-
-import typing
-
-from . import chatcmpl
-from .. import requester
-from ....core import entities as core_entities
-from ... import entities as llm_entities
-from ...tools import entities as tools_entities
-
-
-class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
-    """Gitee AI ChatCompletions API 请求器"""
-
-    default_config: dict[str, typing.Any] = {
-        'base_url': 'https://ai.gitee.com/v1',
-        'timeout': 120,
-    }
-
-    async def _closure(
-        self,
-        query: core_entities.Query,
-        req_messages: list[dict],
-        use_model: requester.RuntimeLLMModel,
-        use_funcs: list[tools_entities.LLMFunction] = None,
-        extra_args: dict[str, typing.Any] = {},
-    ) -> llm_entities.Message:
-        self.client.api_key = use_model.token_mgr.get_token()
-
-        args = {}
-        args['model'] = use_model.model_entity.name
-
-        if use_funcs:
-            tools = await self.ap.tool_mgr.generate_tools_for_openai(use_funcs)
-
-            if tools:
-                args['tools'] = tools
-
-        # gitee 不支持多模态，把content都转换成纯文字
-        for m in req_messages:
-            if 'content' in m and isinstance(m['content'], list):
-                m['content'] = ' '.join([c['text'] for c in m['content']])
-
-        args['messages'] = req_messages
-
-        resp = await self._req(args, extra_body=extra_args)
-
-        message = await self._make_msg(resp)
-
-        return message

pkg/provider/modelmgr/requesters/giteeaichatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: gitee-ai-chat-completions
-  label:
-    en_US: Gitee AI
-    zh_Hans: Gitee AI
-  icon: giteeai.svg
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "https://ai.gitee.com/v1"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./giteeaichatcmpl.py
-    attr: GiteeAIChatCompletions

pkg/provider/modelmgr/requesters/lmstudiochatcmpl.yaml

@@ -1,28 +0,0 @@
-apiVersion: v1
-kind: LLMAPIRequester
-metadata:
-  name: lmstudio-chat-completions
-  label:
-    en_US: LM Studio
-    zh_Hans: LM Studio
-  icon: lmstudio.webp
-spec:
-  config:
-    - name: base_url
-      label:
-        en_US: Base URL
-        zh_Hans: 基础 URL
-      type: string
-      required: true
-      default: "http://127.0.0.1:1234/v1"
-    - name: timeout
-      label:
-        en_US: Timeout
-        zh_Hans: 超时时间
-      type: integer
-      required: true
-      default: 120
-execution:
-  python:
-    path: ./lmstudiochatcmpl.py
-    attr: LmStudioChatCompletions