merge: merge master into feat/unified_webhook

Resolved conflicts by keeping current branch changes for webhook feature files:
- src/langbot/libs/wecom_ai_bot_api/api.py
- src/langbot/libs/wecom_ai_bot_api/wecombotevent.py
- src/langbot/pkg/api/http/controller/groups/webhooks.py
- src/langbot/pkg/platform/sources/officialaccount.py
- src/langbot/pkg/platform/sources/qqofficial.py
- src/langbot/pkg/platform/sources/wecom.py
- src/langbot/pkg/platform/sources/wecombot.py

Merged master branch changes including:
- Project restructure: moved files from pkg/ and libs/ to src/langbot/
- New features: API key auth, MCP resources, pipeline extensions
- Documentation updates: AGENTS.md, CLAUDE.md, API docs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,29 +1,13 @@
 name: 漏洞反馈
-description: 报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭。由于自己操作不当/不甚了解所用技术栈引起的网络连接问题恕无法解决，请勿提 issue。容器间网络连接问题，参考文档 https://docs.langbot.app/deploy/network-details.html  
+description: 【供中文用户】报错或漏洞请使用这个模板创建，不使用此模板创建的异常、漏洞相关issue将被直接关闭。由于自己操作不当/不甚了解所用技术栈引起的网络连接问题恕无法解决，请勿提 issue。容器间网络连接问题，参考文档 https://docs.langbot.app/zh/workshop/network-details.html  
 title: "[Bug]: "
 labels: ["bug?"]
 body:
-  - type: dropdown
-    attributes:
-      label: 消息平台适配器
-      description: "接入的消息平台类型"
-      options:
-        - 其他（或暂未使用）
-        - Nakuru（go-cqhttp）
-        - aiocqhttp（使用 OneBot 协议接入的）
-        - qq-botpy（QQ官方API WebSocket）
-        - qqofficial（QQ官方API Webhook）
-        - lark（飞书）
-        - wecom（企业微信）
-        - gewechat（个人微信）
-        - discord
-    validations:
-      required: true
   - type: input
     attributes:
       label: 运行环境
       description: LangBot 版本、操作系统、系统架构、**Python版本**、**主机地理位置**
-      placeholder: 例如：v3.3.0、CentOS x64 Python 3.10.3、Docker 的系统直接写 Docker 就行
+      placeholder: 例如：v3.3.0、CentOS x64 Python 3.10.3、Docker
     validations:
       required: true
   - type: textarea
@@ -35,12 +19,12 @@ body:
   - type: textarea
     attributes:
       label: 复现步骤
-      description: 如何重现这个问题，越详细越好；请贴上所有相关的配置文件和元数据文件（注意隐去敏感信息）
+      description: 提供越多信息，我们会越快解决问题，建议多提供配置截图；**如果你不认真填写（只一两句话概括），我们会很生气并且立即关闭 issue 或两年后才回复你**
     validations:
-      required: true
+      required: false
   - type: textarea
     attributes:
       label: 启用的插件
-      description: 有些情况可能和插件功能有关，建议提供插件启用情况。可以使用`!plugin`命令查看已启用的插件
+      description: 有些情况可能和插件功能有关，建议提供插件启用情况。
     validations:
       required: false

.github/ISSUE_TEMPLATE/bug-report_en.yml

@@ -0,0 +1,30 @@
+name: Bug report
+description: Report bugs or vulnerabilities using this template. For container network connection issues, refer to the documentation https://docs.langbot.app/en/workshop/network-details.html
+title: "[Bug]: "
+labels: ["bug?"]
+body:
+  - type: input
+    attributes:
+      label: Runtime environment
+      description: LangBot version, operating system, system architecture, **Python version**, **host location**
+      placeholder: "For example: v3.3.0, CentOS x64 Python 3.10.3, Docker"
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Exception
+      description: Describe the exception in detail, what happened and when it happened. **Please include log information.** 
+    validations:
+      required: true
+  - 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. 【注意】请务必认真填写此部分，若不提供完整信息（如只有一两句话的概括），我们将不会回复！
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Enabled plugins
+      description: Some cases may be related to plugin functionality, so please provide the plugin enablement status.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -1,7 +1,7 @@
 name: 需求建议
 title: "[Feature]: "
-labels: ["改进"]
-description: "新功能或现有功能优化请使用这个模板；不符合类别的issue将被直接关闭"
+labels: []
+description: "【供中文用户】新功能或现有功能优化请使用这个模板；不符合类别的issue将被直接关闭"
 body:
   - type: dropdown
     attributes:

.github/ISSUE_TEMPLATE/feature-request_en.yml

@@ -0,0 +1,21 @@
+name: Feature request
+title: "[Feature]: "
+labels: []
+description: "New features or existing feature improvements should use this template; issues that do not match will be closed directly"
+body:
+  - type: dropdown
+    attributes:
+      label: This is a?
+      description: New feature request or existing feature improvement
+      options:
+        - New feature
+        - Existing feature improvement
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Detailed description
+      description: Detailed description, the more detailed the better
+    validations:
+      required: true
+      

.github/ISSUE_TEMPLATE/submit-plugin.yml

@@ -1,7 +1,7 @@
 name: 提交新插件
 title: "[Plugin]: 请求登记新插件"
 labels: ["独立插件"]
-description: "本模板供且仅供提交新插件使用"
+description: "【供中文用户】本模板供且仅供提交新插件使用"
 body:
   - type: input
     attributes:

.github/ISSUE_TEMPLATE/submit-plugin_en.yml

@@ -0,0 +1,24 @@
+name: Submit a new plugin
+title: "[Plugin]: Request to register a new plugin"
+labels: ["Independent Plugin"]
+description: "This template is only for submitting new plugins"
+body:
+  - type: input
+    attributes:
+      label: Plugin name
+      description: Fill in the name of the plugin
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Plugin code repository address
+      description: Only support Github
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Plugin description
+      description: The description of the plugin
+    validations:
+      required: true
+      

.github/pull_request_template.md

@@ -1,20 +1,32 @@
-## 概述
+## 概述 / Overview
 
-实现/解决/优化的内容: 
+> 请在此部分填写你实现/解决/优化的内容:  
+> Summary of what you implemented/solved/optimized:
+> 
 
-## 检查清单
+### 更改前后对比截图 / Screenshots
 
-### PR 作者完成
+> 请在此部分粘贴更改前后对比截图（可以是界面截图、控制台输出、对话截图等）:  
+> Please paste the screenshots of changes before and after here (can be interface screenshots, console output, conversation screenshots, etc.):
+> 
+> 修改前 / Before:
+> 
+> 修改后 / After:
+> 
 
-*请在方括号间写`x`以打勾
+## 检查清单 / Checklist
 
-- [ ] 阅读仓库[贡献指引](https://github.com/RockChinQ/LangBot/blob/master/CONTRIBUTING.md)了吗？
-- [ ] 与项目所有者沟通过了吗？
-- [ ] 我确定已自行测试所作的更改，确保功能符合预期。
+### PR 作者完成 / For PR author
 
-### 项目所有者完成
+*请在方括号间写`x`以打勾 / Please tick the box with `x`*
 
-- [ ] 相关 issues 链接了吗？
-- [ ] 配置项写好了吗？迁移写好了吗？生效了吗？
-- [ ] 依赖写到 requirements.txt 和 core/bootutils/deps.py 了吗
-- [ ] 文档编写了吗？
+- [ ] 阅读仓库[贡献指引](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.
+
+### 项目维护者完成 / For project maintainer
+
+- [ ] 相关 issues 链接了吗？ / Have you linked the related issues?
+- [ ] 配置项写好了吗？迁移写好了吗？生效了吗？ / Have you written the configuration items? Have you written the migration? Has it taken effect?
+- [ ] 依赖加到 pyproject.toml 和 core/bootutils/deps.py 了吗 / Have you added the dependencies to pyproject.toml and core/bootutils/deps.py?
+- [ ] 文档编写了吗？ / Have you written the documentation?

.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/build-release-artifacts.yaml

@@ -46,7 +46,7 @@ jobs:
           npm run build
       - name: Package Output
         run: |
-          cp -r /tmp/langbot_build_web/web/dist ./web
+          cp -r /tmp/langbot_build_web/web/out ./web
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:

.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,13 +22,14 @@ tips.py
 venv*
 bin/
 .vscode
-test_*
+/test_*
 venv/
 hugchat.json
 qcapi
 claude.json
 bard.json
 /*yaml
+!.pre-commit-config.yaml
 !components.yaml
 !/docker-compose.yaml
 data/labels/instance_id.json
@@ -38,5 +39,17 @@ botpy.log*
 /poc
 /libs/wecom_api/test.py
 /venv
-/jp-tyo-churros-05.rockchin.top
-test.py
+test.py
+/web_ui
+.venv/
+uv.lock
+/test
+plugins.bak
+coverage.xml
+.coverage
+src/langbot/web/
+
+# Build artifacts
+/dist
+/build
+*.egg-info

.pre-commit-config.yaml

@@ -0,0 +1,27 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    # Ruff version.
+    rev: v0.11.7
+    hooks:
+      # Run the linter of backend.
+      - id: ruff
+        args: [--fix]
+      # Run the formatter of backend.
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.1.0
+    hooks:
+      - id: prettier
+        types_or: [javascript, jsx, ts, tsx, css, scss]
+        additional_dependencies:
+          - prettier@3.1.0
+
+  - repo: local
+    hooks:
+      - id: lint-staged
+        name: lint-staged
+        entry: cd web && pnpm lint-staged
+        language: system
+        types: [javascript, jsx, ts, tsx]
+        pass_filenames: false

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

CONTRIBUTING.md

@@ -5,22 +5,27 @@
 ### 贡献形式
 
 - 提交PR，解决issues中提到的bug或期待的功能
-- 提交PR，实现您设想的功能（请先提出issue与作者沟通）
-- 优化代码架构，使各个模块的组织更加整洁优雅
-- 在issues中提出发现的bug或者期待的功能
+- 提交PR，实现您设想的功能（请先提出issue与项目维护者沟通）
 - 为本项目在其他社交平台撰写文章、制作视频等
 - 为本项目的衍生项目作出贡献，或开发插件增加功能
 
-### 如何开始
+### 沟通语言规范
 
-- 加入本项目交流群，一同探讨项目相关事务
-- 解决本项目或衍生项目的issues中亟待解决的问题
-- 阅读并完善本项目文档
-- 在各个社交媒体撰写本项目教程等
+- 在 PR 和 Commit Message 中请使用全英文
+- 对于中文用户，issue 中可以使用中文
 
-### 代码规范
+<hr/>
 
-- 代码中的注解`务必`符合Google风格的规范
-- 模块顶部的引入代码请遵循`系统模块`、`第三方库模块`、`自定义模块`的顺序进行引入
-- `不要`直接引入模块的特定属性，而是引入这个模块，再通过`xxx.yyy`的形式使用属性
-- 任何作用域的字段`必须`先声明后使用，并在声明处注明类型提示
+## Guidelines
+
+### Contribution
+
+- Submit PRs to solve bugs or features in the issues
+- Submit PRs to implement your ideas (Please create an issue first and communicate with the project maintainer)
+- Write articles or make videos about this project on other social platforms
+- Contribute to the development of derivative projects, or develop plugins to add features
+
+### Spoken Language
+
+- Use English in PRs and Commit Messages
+- For English users, you can use English in issues

Dockerfile

@@ -6,17 +6,18 @@ COPY web ./web
 
 RUN cd web && npm install && npm run build
 
-FROM python:3.10.13-slim
+FROM python:3.12.7-slim
 
 WORKDIR /app
 
 COPY . .
 
-COPY --from=node /app/web/dist ./web/dist
+COPY --from=node /app/web/out ./web/out
 
 RUN apt update \
     && apt install gcc -y \
-    && python -m pip install -r requirements.txt \
+    && python -m pip install --no-cache-dir uv \
+    && uv sync \
     && touch /.dockerenv
 
-CMD [ "python", "main.py" ]
+CMD [ "uv", "run", "main.py" ]

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,60 +1,61 @@
 
 <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://docs.langbot.app">项目主页</a> ｜
-<a href="https://docs.langbot.app/insight/intro.html">功能介绍</a> ｜
-<a href="https://docs.langbot.app/insight/guide.html">部署文档</a> ｜
-<a href="https://docs.langbot.app/usage/faq.html">常见问题</a> ｜
-<a href="https://docs.langbot.app/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">
-😎高稳定、🧩支持扩展、🦄多模态 - 大模型原生即时通信机器人平台🤖  
-</div>
-
-<br/>
+<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)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
- ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=%E4%BD%BF%E7%94%A8%E9%87%8F%EF%BC%887%E6%97%A5%EF%BC%89)
+[![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)
 
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+<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>
 
-## ✨ 特性
-
-- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、个人微信、飞书、Discord、Telegram 等平台。
-- 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
-- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；适配 Anthropic [MCP 协议](https://modelcontextprotocol.io/)；目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
-- 😻 [New] Web 管理面板：支持通过浏览器管理 LangBot 实例，具体支持功能，查看[文档](https://docs.langbot.app/webui/intro.html)
+LangBot 是一个开源的大语言模型原生即时通信机器人开发平台，旨在提供开箱即用的 IM 机器人开发体验，具有 Agent、RAG、MCP 等多种 LLM 应用功能，适配全球主流即时通信平台，并提供丰富的 API 接口，支持自定义开发。
 
 ## 📦 开始使用
 
-> [!IMPORTANT]
->
-> 在您开始任何方式部署之前，请务必阅读[新手指引](https://docs.langbot.app/insight/guide.html)。
+#### 快速部署
+
+使用 `uvx` 一键启动（需要先安装 [uv](https://docs.astral.sh/uv/getting-started/installation/)）：
+
+```bash
+uvx langbot
+```
+
+访问 http://localhost:5300 即可开始使用。
 
 #### Docker Compose 部署
 
-适合熟悉 Docker 的用户，查看文档[Docker 部署](https://docs.langbot.app/deploy/langbot/docker.html)。
+```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/deploy/langbot/one-click/bt.html)使用。
+已上架宝塔面板，若您已安装宝塔面板，可以根据[文档](https://docs.langbot.app/zh/deploy/langbot/one-click/bt.html)使用。
 
 #### Zeabur 云部署
 
@@ -68,17 +69,31 @@
 
 #### 手动部署
 
-直接使用发行版运行，查看文档[手动部署](https://docs.langbot.app/deploy/langbot/manual.html)。
+直接使用发行版运行，查看文档[手动部署](https://docs.langbot.app/zh/deploy/langbot/manual.html)。
 
-## 📸 效果展示
+#### Kubernetes 部署
 
-<img alt="回复效果（带有联网插件）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+参考 [Kubernetes 部署](./docker/README_K8S.md) 文档。
 
-- WebUI Demo: https://demo.langbot.dev/
-    - 登录信息：邮箱：`demo@langbot.app` 密码：`langbot123456`
-    - 注意：仅展示webui效果，公开环境，请不要在其中填入您的任何敏感信息。
+## 😎 保持更新
 
-## 🔌 组件兼容性
+点击仓库右上角 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 效果，公开环境，请不要在其中填入您的任何敏感信息。
 
 ### 消息平台
 
@@ -87,17 +102,16 @@
 | QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
 | QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
-| 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
+| 企微对外客服 | ✅ |  |
+| 企微智能机器人 | ✅ |  |
+| 个人微信 | ✅ |  |
 | 微信公众号 | ✅ |  |
 | 飞书 | ✅ |  |
 | 钉钉 | ✅ |  |
 | Discord | ✅ |  |
 | Telegram | ✅ |  |
 | Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: 正在开发中
+| LINE | ✅ |  |
 
 ### 大模型能力
 
@@ -109,14 +123,23 @@
 | [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
 
@@ -134,15 +157,14 @@
 
 ## 😘 社区贡献
 
-感谢以下[代码贡献者](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>
 
-以及 LangBot 核心团队成员：
+<!--
+## For Code Agents
 
-- [RockChinQ](https://github.com/RockChinQ)
-- [the-lazy-me](https://github.com/the-lazy-me)
-- [wangcham](https://github.com/wangcham)
-- [KaedeSAMA](https://github.com/KaedeSAMA)
+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,64 +1,61 @@
 <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>
-
-<a href="https://docs.langbot.app">Home</a> ｜
-<a href="https://docs.langbot.app/insight/intro.html">Features</a> ｜
-<a href="https://docs.langbot.app/insight/guide.html">Deployment</a> ｜
-<a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
-<a href="https://docs.langbot.app/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/>
-
+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)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
- ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=Usage(7days))
+[![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">
 
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+<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/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.
-- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Integrate Anthropic [MCP protocol](https://modelcontextprotocol.io/); Currently has dozens of [plugins](https://docs.langbot.app/plugin/plugin-intro.html)
-- 😻 [New] Web UI: Support management LangBot instance through the browser, for details, see [documentation](https://docs.langbot.app/webui/intro.html)
+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
 
-> [!IMPORTANT]
->
-> - Before you start deploying in any way, please read the [New User Guide](https://docs.langbot.app/insight/guide.html).  
-> - All documentation is in Chinese, we will provide i18n version in the near future.
+#### 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
 
-Suitable for users familiar with Docker, see the [Docker Deployment](https://docs.langbot.app/deploy/langbot/docker.html) documentation.
+```bash
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
+docker compose up -d
+```
+
+Visit http://localhost:5300 to start using it.
+
+Detailed documentation [Docker Deployment](https://docs.langbot.app/en/deploy/langbot/docker.html).
 
 #### One-click Deployment on BTPanel
 
-LangBot has been listed on the BTPanel, if you have installed the BTPanel, you can use the [document](https://docs.langbot.app/deploy/langbot/one-click/bt.html) to use it.
+LangBot has been listed on the BTPanel, if you have installed the BTPanel, you can use the [document](https://docs.langbot.app/en/deploy/langbot/one-click/bt.html) to use it.
 
 #### Zeabur Cloud Deployment
 
 Community contributed Zeabur template.
 
-[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/en-US/templates/ZKTBDH)
 
 #### Railway Cloud Deployment
 
@@ -66,35 +63,48 @@ Community contributed Zeabur template.
 
 #### Other Deployment Methods
 
-Directly use the released version to run, see the [Manual Deployment](https://docs.langbot.app/deploy/langbot/manual.html) documentation.
+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="Reply Effect (with Internet Plugin)" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+Refer to the [Kubernetes Deployment](./docker/README_K8S.md) documentation.
 
-- 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.
+## 😎 Stay Ahead
 
-## 🔌 Component Compatibility
+Click the Star and Watch button in the upper right corner of the repository to get the latest updates.
+
+![star gif](https://docs.langbot.app/star.gif)
+
+## ✨ Features
+
+- 💬 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.
+
+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 |
 | --- | --- | --- |
-| Personal QQ | ✅ |  |
-| QQ Official API | ✅ |  |
-| WeCom | ✅ |  |
-| Personal WeChat | ✅ | Use [Gewechat](https://github.com/Devo919/Gewechat) to access |
-| Lark | ✅ |  |
-| DingTalk | ✅ |  |
 | Discord | ✅ |  |
 | Telegram | ✅ |  |
 | Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: In development
+| LINE | ✅ |  |
+| Personal QQ | ✅ |  |
+| QQ Official API | ✅ |  |
+| WeCom | ✅ |  |
+| WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
+| Personal WeChat | ✅ |  |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
 
 ### LLMs
 
@@ -106,26 +116,26 @@ 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 |
 | [GiteeAI](https://ai.gitee.com/) | ✅ | LLM interface gateway(MaaS) |
 | [SiliconFlow](https://siliconflow.cn/) | ✅ | LLM gateway(MaaS) |
 | [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLM gateway(MaaS), LLMOps platform |
 | [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | LLM gateway(MaaS), LLMOps platform |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | LLM gateway(MaaS) |
 | [MCP](https://modelcontextprotocol.io/) | ✅ | Support tool access through MCP protocol |
 
 ## 🤝 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>
-
-And the core team members of LangBot:
-
-- [RockChinQ](https://github.com/RockChinQ)
-- [the-lazy-me](https://github.com/the-lazy-me)
-- [wangcham](https://github.com/wangcham)
-- [KaedeSAMA](https://github.com/KaedeSAMA)

README_JP.md

@@ -1,63 +1,61 @@
 <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>
-
-<a href="https://docs.langbot.app">ホーム</a> ｜
-<a href="https://docs.langbot.app/insight/intro.html">機能</a> ｜
-<a href="https://docs.langbot.app/insight/guide.html">デプロイ</a> ｜
-<a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
-<a href="https://docs.langbot.app/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/>
+[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)
-[![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
- ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=Usage(7days))
+[![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">
 
-[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+<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/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/)；豊富なエコシステム、現在数十の[プラグイン](https://docs.langbot.app/plugin/plugin-intro.html)が存在。
-- 😻 [新機能] Web UI: ブラウザを通じてLangBotインスタンスを管理することをサポート。詳細は[ドキュメント](https://docs.langbot.app/webui/intro.html)を参照。
+LangBot は、エージェント、RAG、MCP などの LLM アプリケーション機能を備えた、オープンソースの LLM ネイティブのインスタントメッセージングロボット開発プラットフォームです。世界中のインスタントメッセージングプラットフォームに適応し、豊富な API インターフェースを提供し、カスタム開発をサポートします。
 
 ## 📦 始め方
 
-> [!IMPORTANT]
->
-> - どのデプロイ方法を始める前に、必ず[新規ユーザーガイド](https://docs.langbot.app/insight/guide.html)をお読みください。  
-> - すべてのドキュメントは中国語で提供されています。近い将来、i18nバージョンを提供する予定です。
+#### クイックスタート
+
+`uvx` を使用した迅速なデプロイ（[uv](https://docs.astral.sh/uv/getting-started/installation/) が必要です）：
+
+```bash
+uvx langbot
+```
+
+http://localhost:5300 にアクセスして使用を開始します。
 
 #### Docker Compose デプロイ
 
-Dockerに慣れているユーザーに適しています。[Dockerデプロイ](https://docs.langbot.app/deploy/langbot/docker.html)のドキュメントを参照してください。
+```bash
+git clone https://github.com/langbot-app/LangBot
+cd LangBot/docker
+docker compose up -d
+```
 
-#### BTPanelでのワンクリックデプロイ
+http://localhost:5300 にアクセスして使用を開始します。
 
-LangBotはBTPanelにリストされています。BTPanelをインストールしている場合は、[ドキュメント](https://docs.langbot.app/deploy/langbot/one-click/bt.html)を使用して使用できます。
+詳細なドキュメントは[Dockerデプロイ](https://docs.langbot.app/en/deploy/langbot/docker.html)を参照してください。
+
+#### Panelでのワンクリックデプロイ
+
+LangBotはBTPanelにリストされています。BTPanelをインストールしている場合は、[ドキュメント](https://docs.langbot.app/en/deploy/langbot/one-click/bt.html)を使用して使用できます。
 
 #### Zeaburクラウドデプロイ
 
 コミュニティが提供するZeaburテンプレート。
 
-[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/en-US/templates/ZKTBDH)
 
 #### Railwayクラウドデプロイ
 
@@ -65,35 +63,48 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 
 #### その他のデプロイ方法
 
-リリースバージョンを直接使用して実行します。[手動デプロイ](https://docs.langbot.app/deploy/langbot/manual.html)のドキュメントを参照してください。
+リリースバージョンを直接使用して実行します。[手動デプロイ](https://docs.langbot.app/en/deploy/langbot/manual.html)のドキュメントを参照してください。
 
-## 📸 デモ
+#### Kubernetes デプロイ
 
-<img alt="返信効果（インターネットプラグイン付き）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+[Kubernetes デプロイ](./docker/README_K8S.md) ドキュメントを参照してください。
 
-- WebUIデモ: https://demo.langbot.dev/
-    - ログイン情報: メール: `demo@langbot.app` パスワード: `langbot123456`
-    - 注意: WebUIの効果のみを示しています。公開環境では、機密情報を入力しないでください。
+## 😎 最新情報を入手
 
-## 🔌 コンポーネントの互換性
+リポジトリの右上にある Star と Watch ボタンをクリックして、最新の更新を取得してください。
+
+![star gif](https://docs.langbot.app/star.gif)
+
+## ✨ 機能
+
+- 💬 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 のデモンストレーションのみの場合、公開環境では機密情報を入力しないでください。
 
 ### メッセージプラットフォーム
 
 | プラットフォーム | ステータス | 備考 |
 | --- | --- | --- |
-| 個人QQ | ✅ |  |
-| QQ公式API | ✅ |  |
-| WeCom | ✅ |  |
-| 個人WeChat | ✅ | [Gewechat](https://github.com/Devo919/Gewechat)を使用して接続 |
-| Lark | ✅ |  |
-| DingTalk | ✅ |  |
 | Discord | ✅ |  |
 | Telegram | ✅ |  |
 | Slack | ✅ |  |
-| LINE | 🚧 |  |
-| WhatsApp | 🚧 |  |
-
-🚧: 開発中
+| LINE | ✅ |  |
+| 個人QQ | ✅ |  |
+| QQ公式API | ✅ |  |
+| WeCom | ✅ |  |
+| WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
+| 個人WeChat | ✅ | |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
 
 ### LLMs
 
@@ -105,6 +116,12 @@ 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実行プラットフォーム |
 | [LMStudio](https://lmstudio.ai/) | ✅ | ローカルLLM実行プラットフォーム |
@@ -112,19 +129,13 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 | [SiliconFlow](https://siliconflow.cn/) | ✅ | LLMゲートウェイ(MaaS) |
 | [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
 | [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
+| [ModelScope](https://modelscope.cn/docs/model-service/API-Inference/intro) | ✅ | LLMゲートウェイ(MaaS) |
 | [MCP](https://modelcontextprotocol.io/) | ✅ | MCPプロトコルをサポート |
 
 ## 🤝 コミュニティ貢献
 
-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>
-
-LangBot の核心チームメンバー:
-
-- [RockChinQ](https://github.com/RockChinQ)
-- [the-lazy-me](https://github.com/the-lazy-me)
-- [wangcham](https://github.com/wangcham)
-- [KaedeSAMA](https://github.com/KaedeSAMA)

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/__init__.py

@@ -1,2 +0,0 @@
-from .v1 import client
-from .v1 import errors

libs/dify_service_api/test.py

@@ -1,44 +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/dify_service_api/v1/client.py

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-import httpx
-import typing
-import json
-
-from .errors import DifyAPIError
-
-
-class AsyncDifyServiceClient:
-    """Dify Service API 客户端"""
-
-    api_key: str
-    base_url: str
-    
-    def __init__(
-        self,
-        api_key: str,
-        base_url: str = "https://api.dify.ai/v1",
-    ) -> None:
-        self.api_key = api_key
-        self.base_url = base_url
-
-    async def chat_messages(
-        self,
-        inputs: dict[str, typing.Any],
-        query: str,
-        user: str,
-        response_mode: str = "streaming",  # 当前不支持 blocking
-        conversation_id: str = "",
-        files: list[dict[str, typing.Any]] = [],
-        timeout: float = 30.0,
-    ) -> typing.AsyncGenerator[dict[str, typing.Any], None]:
-        """发送消息"""
-        if response_mode != "streaming":
-            raise DifyAPIError("当前仅支持 streaming 模式")
-        
-        async with httpx.AsyncClient(
-            base_url=self.base_url,
-            trust_env=True,
-            timeout=timeout,
-        ) as client:
-            async with client.stream(
-                "POST",
-                "/chat-messages",
-                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
-                json={
-                    "inputs": inputs,
-                    "query": query,
-                    "user": user,
-                    "response_mode": response_mode,
-                    "conversation_id": conversation_id,
-                    "files": files,
-                },
-            ) as r:
-                async for chunk in r.aiter_lines():
-                    if r.status_code != 200:
-                        raise DifyAPIError(f"{r.status_code} {chunk}")
-                    if chunk.strip() == "":
-                        continue
-                    if chunk.startswith("data:"):
-                        yield json.loads(chunk[5:])
-        
-    async def workflow_run(
-        self,
-        inputs: dict[str, typing.Any],
-        user: str,
-        response_mode: str = "streaming",  # 当前不支持 blocking
-        files: list[dict[str, typing.Any]] = [],
-        timeout: float = 30.0,
-    ) -> typing.AsyncGenerator[dict[str, typing.Any], None]:
-        """运行工作流"""
-        if response_mode != "streaming":
-            raise DifyAPIError("当前仅支持 streaming 模式")
-        
-        async with httpx.AsyncClient(
-            base_url=self.base_url,
-            trust_env=True,
-            timeout=timeout,
-        ) as client:
-
-            async with client.stream(
-                "POST",
-                "/workflows/run",
-                headers={"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"},
-                json={
-                    "inputs": inputs,
-                    "user": user,
-                    "response_mode": response_mode,
-                    "files": files,
-                },
-            ) as r:
-                async for chunk in r.aiter_lines():
-                    if r.status_code != 200:
-                        raise DifyAPIError(f"{r.status_code} {chunk}")
-                    if chunk.strip() == "":
-                        continue
-                    if chunk.startswith("data:"):
-                        yield json.loads(chunk[5:])
-
-    async def upload_file(
-        self,
-        file: httpx._types.FileTypes,
-        user: str,
-        timeout: float = 30.0,
-    ) -> str:
-        """上传文件"""
-        async with httpx.AsyncClient(
-            base_url=self.base_url,
-            trust_env=True,
-            timeout=timeout,
-        ) as client:
-            # multipart/form-data
-            response = await client.post(
-                "/files/upload",
-                headers={"Authorization": f"Bearer {self.api_key}"},
-                files={
-                    "file": file,
-                    "user": (None, user),
-                },
-            )
-
-            if response.status_code != 201:
-                raise DifyAPIError(f"{response.status_code} {response.text}")
-
-            return response.json()

libs/dingtalk_api/api.py

@@ -1,255 +0,0 @@
-import base64
-import json
-import time
-from typing import Callable
-import dingtalk_stream
-from .EchoHandler import EchoTextHandler
-from .dingtalkevent import DingTalkEvent
-import httpx
-import traceback
-
-
-class DingTalkClient:
-    def __init__(self, client_id: str, client_secret: str,robot_name:str,robot_code:str,markdown_card:bool):
-        """初始化 WebSocket 连接并自动启动"""
-        self.credential = dingtalk_stream.Credential(client_id, client_secret)
-        self.client = dingtalk_stream.DingTalkStreamClient(self.credential)
-        self.key = client_id
-        self.secret = client_secret
-        # 在 DingTalkClient 中传入自己作为参数，避免循环导入
-        self.EchoTextHandler = EchoTextHandler(self)
-        self.client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self.EchoTextHandler)
-        self._message_handlers = {
-            "example":[],
-        }
-        self.access_token = ''
-        self.robot_name = robot_name
-        self.robot_code = robot_code
-        self.access_token_expiry_time = ''
-        self.markdown_card = markdown_card
-
-
-
-    async def get_access_token(self):
-        url = "https://api.dingtalk.com/v1.0/oauth2/accessToken"
-        headers = {
-            "Content-Type": "application/json"
-        }
-        data = {
-            "appKey": self.key,
-            "appSecret": self.secret
-        }
-        async with httpx.AsyncClient() as client:
-            try:
-                response = await client.post(url,json=data,headers=headers)
-                if response.status_code == 200:
-                    response_data = response.json()
-                    self.access_token = response_data.get("accessToken")
-                    expires_in = int(response_data.get("expireIn",7200))
-                    self.access_token_expiry_time = time.time() + expires_in - 60
-            except Exception as e:
-                raise Exception(e)
-
-
-    async def is_token_expired(self):
-        """检查token是否过期"""
-        if self.access_token_expiry_time is None:
-            return True
-        return time.time() > self.access_token_expiry_time
-            
-    async def check_access_token(self):
-        if not self.access_token or await self.is_token_expired():
-            return False
-        return bool(self.access_token and self.access_token.strip())
-
-    async def download_image(self,download_code:str):
-        if not await self.check_access_token():
-            await self.get_access_token()
-        url = 'https://api.dingtalk.com/v1.0/robot/messageFiles/download'
-        params = {
-            "downloadCode":download_code,
-            "robotCode":self.robot_code
-        }
-        headers ={
-            "x-acs-dingtalk-access-token": self.access_token
-        }
-        async with httpx.AsyncClient() as client:
-            response = await client.post(url, headers=headers, json=params)
-            if response.status_code == 200:
-                result = response.json()
-                download_url = result.get("downloadUrl")
-            else:
-                raise Exception(f"Error: {response.status_code}, {response.text}")
-
-        if download_url:
-            return await self.download_url_to_base64(download_url)
-
-    async def download_url_to_base64(self,download_url):
-        async with httpx.AsyncClient() as client:
-            response = await client.get(download_url)
-            
-            if response.status_code == 200:
-                
-                file_bytes = response.content
-                base64_str = base64.b64encode(file_bytes).decode('utf-8')  # 返回字符串格式
-                return base64_str
-            else:
-                raise Exception("获取文件失败")
-            
-    async def get_audio_url(self,download_code:str):
-        if not await self.check_access_token():
-            await self.get_access_token()
-        url = 'https://api.dingtalk.com/v1.0/robot/messageFiles/download'
-        params = {
-            "downloadCode":download_code,
-            "robotCode":self.robot_code
-        }
-        headers ={
-            "x-acs-dingtalk-access-token": self.access_token
-        }
-        async with httpx.AsyncClient() as client:
-            response = await client.post(url, headers=headers, json=params)
-            if response.status_code == 200:
-                result = response.json()
-                download_url = result.get("downloadUrl")
-                if download_url:
-                    return await self.download_url_to_base64(download_url)
-                else:
-                    raise Exception("获取音频失败")
-            else:
-                raise Exception(f"Error: {response.status_code}, {response.text}")
-                
-    async def update_incoming_message(self, message):
-        """异步更新 DingTalkClient 中的 incoming_message"""
-        message_data = await self.get_message(message)
-        if message_data:
-            event = DingTalkEvent.from_payload(message_data)
-            if event:
-                await self._handle_message(event)
-        
-
-    async def send_message(self,content:str,incoming_message):
-        if self.markdown_card:
-            self.EchoTextHandler.reply_markdown(title=self.robot_name+'的回答',text=content,incoming_message=incoming_message)
-        else:
-            self.EchoTextHandler.reply_text(content,incoming_message)
-    
-
-    async def get_incoming_message(self):
-        """获取收到的消息"""
-        return await self.EchoTextHandler.get_incoming_message()
-
-
-
-    def on_message(self, msg_type: str):
-        def decorator(func: Callable[[DingTalkEvent], None]):
-            if msg_type not in self._message_handlers:
-                self._message_handlers[msg_type] = []
-            self._message_handlers[msg_type].append(func)
-            return func
-        return decorator
-
-    async def _handle_message(self, event: DingTalkEvent):
-        """
-        处理消息事件。
-        """
-        msg_type = event.conversation
-        if msg_type in self._message_handlers:
-            for handler in self._message_handlers[msg_type]:
-                await handler(event)
-
-
-    async def get_message(self,incoming_message:dingtalk_stream.chatbot.ChatbotMessage):
-        try:
-            
-            # print(json.dumps(incoming_message.to_dict(), indent=4, ensure_ascii=False))
-            message_data = {
-                "IncomingMessage":incoming_message,
-            }
-            if str(incoming_message.conversation_type) == '1':
-                message_data["conversation_type"] = 'FriendMessage'
-            elif str(incoming_message.conversation_type) == '2':
-                message_data["conversation_type"] = 'GroupMessage'
-
-            
-            if incoming_message.message_type == 'richText':
-            
-                data = incoming_message.rich_text_content.to_dict()
-                for item in data['richText']:
-                    if 'text' in item:
-                        message_data["Content"] = item['text']
-                    if incoming_message.get_image_list()[0]:
-                        message_data["Picture"] = await self.download_image(incoming_message.get_image_list()[0])
-                message_data["Type"] = 'text'
-            
-            elif incoming_message.message_type == 'text':
-                message_data['Content'] = incoming_message.get_text_list()[0]
-
-                message_data["Type"] = 'text'
-            elif incoming_message.message_type == 'picture':
-                message_data['Picture'] = await self.download_image(incoming_message.get_image_list()[0])
-                
-                message_data['Type'] = 'image'
-            elif incoming_message.message_type == 'audio':
-                message_data['Audio'] = await self.get_audio_url(incoming_message.to_dict()['content']['downloadCode'])
-
-                message_data['Type'] = 'audio'
-
-            copy_message_data = message_data.copy()
-            del copy_message_data['IncomingMessage']
-            # print("message_data:", json.dumps(copy_message_data, indent=4, ensure_ascii=False))
-        except Exception:
-            traceback.print_exc()
-            
-        return message_data
-
-    async def send_proactive_message_to_one(self,target_id:str,content:str):
-        if not await self.check_access_token():
-            await self.get_access_token()
-
-        url = 'https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend'
-
-        headers ={
-            "x-acs-dingtalk-access-token":self.access_token,
-            "Content-Type":"application/json",
-        }
-
-        data ={
-            "robotCode":self.robot_code,
-            "userIds":[target_id],
-            "msgKey": "sampleText",
-            "msgParam": json.dumps({"content":content}),
-        }
-        try:
-            async with httpx.AsyncClient() as client:
-                response  = await client.post(url,headers=headers,json=data)
-        except Exception:
-            traceback.print_exc()
-
-
-    async def send_proactive_message_to_group(self,target_id:str,content:str):
-        if not await self.check_access_token():
-            await self.get_access_token()
-
-        url = 'https://api.dingtalk.com/v1.0/robot/groupMessages/send'
-
-        headers ={
-            "x-acs-dingtalk-access-token":self.access_token,
-            "Content-Type":"application/json",
-        }
-
-        data ={
-            "robotCode":self.robot_code,
-            "openConversationId":target_id,
-            "msgKey": "sampleText",
-            "msgParam": json.dumps({"content":content}),
-        }
-        try:
-            async with httpx.AsyncClient() as client:
-                response  = await client.post(url,headers=headers,json=data)
-        except Exception:
-            traceback.print_exc()
-    
-    async def start(self):
-        """启动 WebSocket 连接，监听消息"""
-        await self.client.start() 

libs/qq_official_api/api.py

@@ -1,274 +0,0 @@
-import time
-from quart import request
-import base64
-import binascii
-import httpx
-from quart import Quart
-import xml.etree.ElementTree as ET
-from typing import Callable, Dict, Any
-from pkg.platform.types import events as platform_events, message as platform_message
-import aiofiles
-from .qqofficialevent import QQOfficialEvent
-import json
-import hmac
-import base64
-import hashlib
-import traceback
-from cryptography.hazmat.primitives.asymmetric import ed25519
-from .qqofficialevent import QQOfficialEvent
-
-def handle_validation(body: dict, bot_secret: str):
-    
-    # bot正确的secert是32位的，此处仅为了适配演示demo
-    while len(bot_secret) < 32:
-        bot_secret = bot_secret * 2
-    bot_secret = bot_secret[:32]
-    # 实际使用场景中以上三行内容可清除
-
-    seed_bytes = bot_secret.encode()
-
-    signing_key = ed25519.Ed25519PrivateKey.from_private_bytes(seed_bytes)
-
-    msg = body['d']['event_ts'] + body['d']['plain_token']
-    msg_bytes = msg.encode()
-
-    signature = signing_key.sign(msg_bytes)
-
-    signature_hex = signature.hex()
-
-    response = {
-        "plain_token": body['d']['plain_token'],
-        "signature": signature_hex
-    }
-
-    return response
-
-class QQOfficialClient:
-    def __init__(self, secret: str, token: str, app_id: str):
-        self.app = Quart(__name__)
-        self.app.add_url_rule(
-            "/callback/command",
-            "handle_callback",
-            self.handle_callback_request,
-            methods=["GET", "POST"],
-        )
-        self.secret = secret
-        self.token = token
-        self.app_id = app_id
-        self._message_handlers = {
-        }
-        self.base_url = "https://api.sgroup.qq.com"
-        self.access_token = ""
-        self.access_token_expiry_time = None
-
-    async def check_access_token(self):
-        """检查access_token是否存在"""
-        if not self.access_token or await self.is_token_expired():
-            return False
-        return bool(self.access_token and self.access_token.strip())
-    
-    async def get_access_token(self):
-        """获取access_token"""
-        url = "https://bots.qq.com/app/getAppAccessToken"
-        async with httpx.AsyncClient() as client:
-            params = {
-                "appId":self.app_id,
-                "clientSecret":self.secret,
-            }
-            headers = {
-                "content-type":"application/json",
-            }
-            try:
-                response = await client.post(url,json=params,headers=headers)
-                if response.status_code == 200:
-                    response_data = response.json()
-                access_token = response_data.get("access_token")
-                expires_in = int(response_data.get("expires_in",7200))
-                self.access_token_expiry_time = time.time() + expires_in - 60
-                if access_token:
-                    self.access_token = access_token
-            except Exception as e:
-                raise Exception(f"获取access_token失败: {e}")
-
-
-    async def handle_callback_request(self):
-        """处理回调请求"""
-        try:
-            # 读取请求数据
-            body = await request.get_data()
-            payload = json.loads(body)
-
-            
-            # 验证是否为回调验证请求
-            if payload.get("op") == 13:
-                # 生成签名
-                response = handle_validation(payload, self.secret)
-
-                return response
-
-            if payload.get("op") == 0:
-                    message_data = await self.get_message(payload)
-                    if message_data:
-                        event = QQOfficialEvent.from_payload(message_data)
-                        await self._handle_message(event)
-            
-            return {"code": 0, "message": "success"}
-
-        except Exception as e:
-            traceback.print_exc()
-            return {"error": str(e)}, 400
-
-    
-
-    async def run_task(self, host: str, port: int, *args, **kwargs):
-        """启动 Quart 应用"""
-        await self.app.run_task(host=host, port=port, *args, **kwargs)
-
-    def on_message(self, msg_type: str):
-        """注册消息类型处理器"""
-
-        def decorator(func: Callable[[platform_events.Event], None]):
-            if msg_type not in self._message_handlers:
-                self._message_handlers[msg_type] = []
-            self._message_handlers[msg_type].append(func)
-            return func
-
-        return decorator
-
-    async def _handle_message(self, event:QQOfficialEvent):
-        """处理消息事件"""
-        msg_type = event.t
-        if msg_type in self._message_handlers:
-            for handler in self._message_handlers[msg_type]:
-                await handler(event)
-
-
-    async def get_message(self,msg:dict) -> Dict[str,Any]:
-        """获取消息"""
-        message_data = {
-            "t":  msg.get("t",{}),
-            "user_openid": msg.get("d",{}).get("author",{}).get("user_openid",{}),
-            "timestamp": msg.get("d",{}).get("timestamp",{}),
-            "d_author_id": msg.get("d",{}).get("author",{}).get("id",{}),
-            "content": msg.get("d",{}).get("content",{}),
-            "d_id": msg.get("d",{}).get("id",{}),
-            "id": msg.get("id",{}),
-            "channel_id": msg.get("d",{}).get("channel_id",{}),
-            "username": msg.get("d",{}).get("author",{}).get("username",{}),
-            "guild_id": msg.get("d",{}).get("guild_id",{}),
-            "member_openid": msg.get("d",{}).get("author",{}).get("openid",{}),
-            "group_openid": msg.get("d",{}).get("group_openid",{})
-        }
-        attachments = msg.get("d", {}).get("attachments", [])
-        image_attachments = [attachment['url'] for attachment in attachments if await self.is_image(attachment)]
-        image_attachments_type = [attachment['content_type'] for attachment in attachments if await self.is_image(attachment)]
-        if image_attachments:
-            message_data["image_attachments"] = image_attachments[0]
-            message_data["content_type"] = image_attachments_type[0]
-        else:
-            
-            message_data["image_attachments"] = None
-        
-        return message_data
-    
-
-    async def is_image(self,attachment:dict) -> bool:
-        """判断是否为图片附件"""
-        content_type = attachment.get("content_type","")
-        return content_type.startswith("image/")
-    
-    
-    async def send_private_text_msg(self,user_openid:str,content:str,msg_id:str):
-        """发送私聊消息"""
-        if not await self.check_access_token():
-             await self.get_access_token()
-
-        url = self.base_url + "/v2/users/" + user_openid + "/messages"
-        async with httpx.AsyncClient() as client:
-            headers = {
-                "Authorization": f"QQBot {self.access_token}",
-                "Content-Type": "application/json",
-            }
-            data = {
-                "content": content,
-                "msg_type": 0,
-                "msg_id": msg_id,
-            }
-            response = await client.post(url,headers=headers,json=data)
-            if response.status_code == 200:
-                return
-            else:
-                raise ValueError(response)
-    
-
-    async def send_group_text_msg(self,group_openid:str,content:str,msg_id:str):
-        """发送群聊消息"""
-        if not await self.check_access_token():
-            await self.get_access_token()
-
-        url = self.base_url + "/v2/groups/" + group_openid + "/messages"
-        async with httpx.AsyncClient() as client:
-            headers = {
-                "Authorization": f"QQBot {self.access_token}",
-                "Content-Type": "application/json",
-            }
-            data = {
-                "content": content,
-                "msg_type": 0,
-                "msg_id": msg_id,
-            }
-            response = await client.post(url,headers=headers,json=data)
-            if response.status_code == 200:
-                return
-            else:
-                raise Exception(response.read().decode())
-
-    async def send_channle_group_text_msg(self,channel_id:str,content:str,msg_id:str):
-        """发送频道群聊消息"""
-        if not await self.check_access_token():
-             await self.get_access_token()
-
-        url = self.base_url + "/channels/" + channel_id + "/messages"
-        async with httpx.AsyncClient() as client:
-            headers = {
-                "Authorization": f"QQBot {self.access_token}",
-                "Content-Type": "application/json",
-            }
-            params = {
-                "content": content,
-                "msg_type": 0,
-                "msg_id": msg_id,
-            }
-            response = await client.post(url,headers=headers,json=params)
-            if response.status_code == 200:
-                return True
-            else:
-                raise Exception(response)
-
-    async def send_channle_private_text_msg(self,guild_id:str,content:str,msg_id:str):
-        """发送频道私聊消息"""
-        if not await self.check_access_token():
-             await self.get_access_token()
-
-        url = self.base_url + "/dms/" + guild_id + "/messages"
-        async with httpx.AsyncClient() as client:
-            headers = {
-                "Authorization": f"QQBot {self.access_token}",
-                "Content-Type": "application/json",
-            }
-            params = {
-                "content": content,
-                "msg_type": 0,
-                "msg_id": msg_id,
-            }
-            response = await client.post(url,headers=headers,json=params)
-            if response.status_code == 200:
-                return True
-            else:
-                raise Exception(response)
-
-    async def is_token_expired(self):
-        """检查token是否过期"""
-        if self.access_token_expiry_time is None:
-            return True
-        return time.time() > self.access_token_expiry_time

libs/slack_api/api.py

@@ -1,111 +0,0 @@
-import json
-from quart import Quart, jsonify,request
-from slack_sdk.web.async_client import AsyncWebClient
-from .slackevent import SlackEvent
-from typing import Callable, Dict, Any
-from pkg.platform.types import events as platform_events, message as platform_message
-
-class SlackClient():
-    
-      def __init__(self,bot_token:str,signing_secret:str):
-
-            self.bot_token = bot_token
-            self.signing_secret = signing_secret
-            self.app = Quart(__name__)
-            self.client = AsyncWebClient(self.bot_token)
-            self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
-            self._message_handlers = {
-            "example":[],
-            }
-            self.bot_user_id = None # 避免机器人回复自己的消息
-
-      async def handle_callback_request(self):
-            try:
-                  body = await request.get_data()
-                  data = json.loads(body)
-                  if 'type' in data:
-                        if data['type'] == 'url_verification':
-                              return data['challenge']
-                  
-                  bot_user_id = data.get("event",{}).get("bot_id","")
-
-                  if self.bot_user_id and bot_user_id == self.bot_user_id:
-                        return jsonify({'status': 'ok'})
-                  
-                  
-                  # 处理私信
-                  if data and data.get("event", {}).get("channel_type") in ["im"]:
-                        event = SlackEvent.from_payload(data)
-                        await self._handle_message(event)
-                        return jsonify({'status': 'ok'})
-                  
-                  #处理群聊
-                  if data.get("event",{}).get("type") == 'app_mention':
-                             data.setdefault("event", {})["channel_type"] = "channel"
-                             event = SlackEvent.from_payload(data)
-                             await self._handle_message(event)
-                             return jsonify({'status':'ok'})
-
-                  return jsonify({'status': 'ok'})
-            
-            except Exception as e:
-                 raise(e)
-            
-
-
-      async def _handle_message(self, event: SlackEvent):
-        """
-        处理消息事件。
-        """
-        msg_type = event.type
-        if msg_type in self._message_handlers:
-            for handler in self._message_handlers[msg_type]:
-                await handler(event)
-
-      def on_message(self, msg_type: str):
-        """注册消息类型处理器"""
-        def decorator(func: Callable[[platform_events.Event], None]):
-            if msg_type not in self._message_handlers:
-                self._message_handlers[msg_type] = []
-            self._message_handlers[msg_type].append(func)
-            return func
-        return decorator
-
-      async def send_message_to_channel(self,text:str,channel_id:str):
-            try:
-                  response = await self.client.chat_postMessage(
-                        channel=channel_id,
-                        text=text
-                  )
-                  if self.bot_user_id is None and response.get("ok"):
-                        self.bot_user_id = response["message"]["bot_id"]
-                  return 
-            except Exception as e:
-                  raise e
-
-      async def send_message_to_one(self,text:str,user_id:str):
-            try:
-                  response = await self.client.chat_postMessage(
-                        channel = '@'+user_id,
-                        text= text
-                  )
-                  if self.bot_user_id is None and response.get("ok"):
-                        self.bot_user_id = response["message"]["bot_id"]
-                  
-                  return 
-            except Exception as e:
-                  raise e
-
-      async def run_task(self, host: str, port: int, *args, **kwargs):
-            """
-            启动 Quart 应用。
-            """
-            await self.app.run_task(host=host, port=port, *args, **kwargs)
-
-
-
-
-
-            
-
-

libs/slack_api/slackevent.py

@@ -1,91 +0,0 @@
-from typing import Dict, Any, Optional
-
-class SlackEvent(dict):
-    @staticmethod
-    def from_payload(payload: Dict[str, Any]) -> Optional["SlackEvent"]:
-        try:
-            event = SlackEvent(payload)
-            return event
-        except KeyError:
-            return None
-    
-    @property
-    def text(self) -> str:
-        
-        if self.get("event", {}).get("channel_type") == "im":
-                blocks = self.get("event", {}).get("blocks", [])
-                if not blocks:
-                    return ""
-
-                elements = blocks[0].get("elements", [])
-                if not elements:
-                    return "" 
-
-                elements = elements[0].get("elements", [])
-                text = ""
-
-                for el in elements:
-                    if el.get("type") == "text":
-                        text += el.get("text", "")
-                    elif el.get("type") == "link":
-                        text += el.get("url", "")
-
-                return text 
-
-                
-        if self.get("event",{}).get("channel_type") == 'channel': 
-            message_text = ""
-            for block in self.get("event", {}).get("blocks", []):
-                if block.get("type") == "rich_text":
-                    for element in block.get("elements", []):
-                        if element.get("type") == "rich_text_section":
-                            parts = []
-                            for el in element.get("elements", []):
-                                if el.get("type") == "text":
-                                    parts.append(el["text"])
-                                elif el.get("type") == "link":
-                                    parts.append(el["url"])
-                            message_text = "".join(parts)
-                            
-            return message_text
-
-
-    
-    @property
-    def user_id(self) -> Optional[str]:
-        return self.get("event", {}).get("user","")
-    
-    @property
-    def channel_id(self) -> Optional[str]:
-        return self.get("event", {}).get("channel","")
-    
-    @property
-    def type(self) -> str:
-        """ message对应私聊，app_mention对应频道at """
-        return self.get("event", {}).get("channel_type", "")
-    
-    @property
-    def message_id(self) -> str:
-        return self.get("event_id","")
-    
-    @property
-    def pic_url(self) -> str:
-        """提取 Slack 事件中的图片 URL"""
-        files = self.get("event", {}).get("files", [])
-        if files:
-            return files[0].get("url_private", "")
-        return None
-        
-    
-    @property
-    def sender_name(self) -> str:
-        return self.get("event", {}).get("user","")
-    
-    def __getattr__(self, key: str) -> Optional[Any]:
-        return self.get(key)
-
-    def __setattr__(self, key: str, value: Any) -> None:
-        self[key] = value
-
-    def __repr__(self) -> str:
-        return f"<SlackEvent {super().__repr__()}>"

main.py

@@ -1,87 +1,3 @@
-# LangBot 终端启动入口
-# 在此层级解决依赖项检查。
-# LangBot/main.py
+import langbot.__main__
 
-asciiart = r"""
- _                   ___      _   
-| |   __ _ _ _  __ _| _ ) ___| |_ 
-| |__/ _` | ' \/ _` | _ \/ _ \  _|
-|____\__,_|_||_\__, |___/\___/\__|
-               |___/              
-
-⭐️开源地址: https://github.com/RockChinQ/LangBot
-📖文档地址: https://docs.langbot.app
-"""
-
-
-import asyncio
-
-
-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("以下依赖包未安装，将自动安装，请完成后重启程序：")
-        for dep in missing_deps:
-            print("-", dep)
-        await deps.install_deps(missing_deps)
-        print("已自动安装缺失的依赖包，请重启程序。")
-        sys.exit(0)
-
-    # 检查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("以下文件不存在，已自动生成：")
-        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("按任意键退出...")
-        exit(1)
-
-    # 检查本目录是否有main.py，且包含LangBot字符串
-    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("按任意键退出...")
-        exit(1)
-
-    loop = asyncio.new_event_loop()
-
-    loop.run_until_complete(main_entry(loop))
+langbot.__main__.main()

pkg/api/http/controller/group.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-import abc
-import typing
-import enum
-import quart
-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)
-
-                        # 检查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 as e:  # 自动 500
-                    return self.http_status(500, -2, str(e))
-                
-            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/plugins.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-
-import traceback
-
-import quart
-
-from .....core import app, 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=['DELETE'], 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.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('/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=f'plugin-install-github',
-                label=f'安装插件 ...{short_source_str}',
-                context=ctx
-            )
-
-            return self.success(data={
-                'task_id': wrapper.id
-            })

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

@@ -1,62 +0,0 @@
-import quart
-
-from .....core import app
-from .. import group
-
-
-@group.group_class('settings', '/api/v1/settings')
-class SettingsRouterGroup(group.RouterGroup):
-    
-    async def initialize(self) -> None:
-        
-        @self.route('', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _() -> str:
-            return self.success(
-                data={
-                    "managers": [
-                        {
-                            "name": m.name,
-                            "description": m.description,
-                        }
-                        for m in self.ap.settings_mgr.get_manager_list()
-                    ]
-                }
-            )
-        
-        @self.route('/<manager_name>', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(manager_name: str) -> str:
-
-            manager = self.ap.settings_mgr.get_manager(manager_name)
-
-            if manager is None:
-                return self.fail(1, '配置管理器不存在')
-
-            return self.success(
-                data={
-                    "manager": {
-                        "name": manager.name,
-                        "description": manager.description,
-                        "schema": manager.schema,
-                        "file": manager.file.config_file_name,
-                        "data": manager.data,
-                        "doc_link": manager.doc_link
-                    }
-                }
-            )
-        
-        @self.route('/<manager_name>/data', methods=['PUT'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(manager_name: str) -> str:
-            data = await quart.request.json
-            manager = self.ap.settings_mgr.get_manager(manager_name)
-
-            if manager is None:
-                return self.fail(code=1, msg='配置管理器不存在')
-
-            # manager.data = data['data']
-            for k, v in data['data'].items():
-                manager.data[k] = v
-
-            await manager.dump_config()
-            return self.success(data={
-                "data": manager.data
-            })

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

@@ -1,63 +0,0 @@
-import quart
-import asyncio
-
-from .....core import app, taskmgr
-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.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,47 +0,0 @@
-import quart
-import sqlalchemy
-import argon2
-
-from .. import group
-from .....persistence.entities import user
-
-
-@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'])
-        async def _() -> str:
-            return self.success()

pkg/api/http/controller/main.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import os
-
-import quart
-import quart_cors
-
-from ....core import app, entities as core_entities
-from .groups import logs, system, settings, plugins, stats, user
-from . import group
-
-
-class HTTPController:
-
-    ap: app.Application
-
-    quart_app: quart.Quart
-
-    def __init__(self, ap: app.Application) -> None:
-        self.ap = ap
-        self.quart_app = quart.Quart(__name__)
-        quart_cors.cors(self.quart_app, allow_origin="*")
-
-    async def initialize(self) -> None:
-        await self.register_routes()
-
-    async def run(self) -> None:
-        if self.ap.system_cfg.data["http-api"]["enable"]:
-
-            async def shutdown_trigger_placeholder():
-                while True:
-                    await asyncio.sleep(1)
-
-            async def exception_handler(*args, **kwargs):
-                try:
-                    await self.quart_app.run_task(
-                        *args, **kwargs
-                    )
-                except Exception as e:
-                    self.ap.logger.error(f"启动 HTTP 服务失败： {e}")
-
-            self.ap.task_mgr.create_task(
-                exception_handler(
-                    host=self.ap.system_cfg.data["http-api"]["host"],
-                    port=self.ap.system_cfg.data["http-api"]["port"],
-                    shutdown_trigger=shutdown_trigger_placeholder,
-                ),
-                name="http-api-quart",
-                scopes=[core_entities.LifecycleControlScope.APPLICATION],
-            )
-
-            # await asyncio.sleep(5)
-
-    async def register_routes(self) -> None:
-
-        @self.quart_app.route("/healthz")
-        async def healthz():
-            return {"code": 0, "msg": "ok"}
-
-        for g in group.preregistered_groups:
-            ginst = g(self.ap, self.quart_app)
-            await ginst.initialize()
-
-        frontend_path = "web/dist"
-
-        @self.quart_app.route("/")
-        async def index():
-            return await quart.send_from_directory(
-                frontend_path,
-                "index.html",
-                mimetype="text/html"
-            )
-
-        @self.quart_app.route("/<path:path>")
-        async def static_file(path: str):
-
-            mimetype = None
-
-            if path.endswith(".html"):
-                mimetype = "text/html"
-            elif path.endswith(".js"):
-                mimetype = "application/javascript"
-            elif path.endswith(".css"):
-                mimetype = "text/css"
-            elif path.endswith(".png"):
-                mimetype = "image/png"
-            elif path.endswith(".jpg"):
-                mimetype = "image/jpeg"
-            elif path.endswith(".jpeg"):
-                mimetype = "image/jpeg"
-            elif path.endswith(".gif"):
-                mimetype = "image/gif"
-            elif path.endswith(".svg"):
-                mimetype = "image/svg+xml"
-            elif path.endswith(".ico"):
-                mimetype = "image/x-icon"
-            elif path.endswith(".json"):
-                mimetype = "application/json"
-            elif path.endswith(".txt"):
-                mimetype = "text/plain"
-
-            return await quart.send_from_directory(
-                frontend_path,
-                path,
-                mimetype=mimetype
-            )

pkg/api/http/service/user.py

@@ -1,73 +0,0 @@
-from __future__ import annotations
-
-import sqlalchemy
-import argon2
-import jwt
-import datetime
-
-from ....core import app
-from ....persistence.entities import user
-from ....utils import constants
-
-
-class UserService:
-
-    ap: app.Application
-
-    def __init__(self, ap: app.Application) -> None:
-        self.ap = ap
-
-    async def is_initialized(self) -> bool:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(user.User).limit(1)
-        )
-
-        result_list = result.all()
-        return result_list is not None and len(result_list) > 0
-    
-    async def create_user(self, user_email: str, password: str) -> None:
-        ph = argon2.PasswordHasher()
-
-        hashed_password = ph.hash(password)
-
-        await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.insert(user.User).values(
-                user=user_email,
-                password=hashed_password
-            )
-        )
-
-    async def authenticate(self, user_email: str, password: str) -> str | None:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(user.User).where(user.User.user == user_email)
-        )
-
-        result_list = result.all()
-
-        if result_list is None or len(result_list) == 0:
-            raise ValueError('用户不存在')
-
-        user_obj = result_list[0]
-
-        ph = argon2.PasswordHasher()
-
-        ph.verify(user_obj.password, password)
-
-        return await self.generate_jwt_token(user_email)
-
-    async def generate_jwt_token(self, user_email: str) -> str:
-        jwt_secret = self.ap.instance_secret_meta.data['jwt_secret']
-        jwt_expire = self.ap.system_cfg.data['http-api']['jwt-expire']
-
-        payload = {
-            'user': user_email,
-            'iss': 'LangBot-'+constants.edition,
-            'exp': datetime.datetime.now() + datetime.timedelta(seconds=jwt_expire)
-        }
-
-        return jwt.encode(payload, jwt_secret, algorithm='HS256')
-    
-    async def verify_jwt_token(self, token: str) -> str:
-        jwt_secret = self.ap.instance_secret_meta.data['jwt_secret']
-
-        return jwt.decode(token, jwt_secret, algorithms=['HS256'])['user']

pkg/audit/__init__.py

@@ -1,3 +0,0 @@
-"""
-审计相关操作
-"""

pkg/audit/center/apigroup.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-import abc
-import uuid
-import json
-import logging
-import asyncio
-
-import aiohttp
-import requests
-
-from ...core import app, entities as core_entities
-
-
-class APIGroup(metaclass=abc.ABCMeta):
-    """API 组抽象类"""
-
-    _basic_info: dict = None
-    _runtime_info: dict = None
-
-    prefix = None
-
-    ap: app.Application
-
-    def __init__(self, prefix: str, ap: app.Application):
-        self.prefix = prefix
-        self.ap = ap
-
-    async def _do(
-        self,
-        method: str,
-        path: str,
-        data: dict = None,
-        params: dict = None,
-        headers: dict = {},
-        **kwargs,
-    ):
-        """
-        执行请求
-        """
-        self._runtime_info["account_id"] = "-1"
-
-        url = self.prefix + path
-        data = json.dumps(data)
-        headers["Content-Type"] = "application/json"
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.request(
-                    method, url, data=data, params=params, headers=headers, **kwargs
-                ) as resp:
-                    self.ap.logger.debug("data: %s", data)
-                    self.ap.logger.debug("ret: %s", await resp.text())
-
-        except Exception as e:
-            self.ap.logger.debug(f"上报失败: {e}")
-
-    async def do(
-        self,
-        method: str,
-        path: str,
-        data: dict = None,
-        params: dict = None,
-        headers: dict = {},
-        **kwargs,
-    ) -> asyncio.Task:
-        """执行请求"""
-
-        return self.ap.task_mgr.create_task(
-            self._do(method, path, data, params, headers, **kwargs),
-            kind="telemetry-operation",
-            name=f"{method} {path}",
-            scopes=[core_entities.LifecycleControlScope.APPLICATION],
-        ).task
-
-    def gen_rid(self):
-        """生成一个请求 ID"""
-        return str(uuid.uuid4())
-
-    def basic_info(self):
-        """获取基本信息"""
-        basic_info = APIGroup._basic_info.copy()
-        basic_info["rid"] = self.gen_rid()
-        return basic_info
-
-    def runtime_info(self):
-        """获取运行时信息"""
-        return APIGroup._runtime_info

pkg/audit/center/groups/main.py

@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-from .. import apigroup
-from ....core import app
-
-
-class V2MainDataAPI(apigroup.APIGroup):
-    """主程序相关 数据API"""
-
-    def __init__(self, prefix: str, ap: app.Application):
-        self.ap = ap
-        super().__init__(prefix+"/main", ap)
-
-    async def do(self, *args, **kwargs):
-        if not self.ap.system_cfg.data['report-usage']:
-            return None
-        return await super().do(*args, **kwargs)
-
-    async def post_update_record(
-        self,
-        spent_seconds: int,
-        infer_reason: str,
-        old_version: str,
-        new_version: str,
-    ):
-        """提交更新记录"""
-        return await self.do(
-            "POST",
-            "/update",
-            data={
-                "basic": self.basic_info(),
-                "update_info": {
-                    "spent_seconds": spent_seconds,
-                    "infer_reason": infer_reason,
-                    "old_version": old_version,
-                    "new_version": new_version,
-                }
-            }
-        )
-    
-    async def post_announcement_showed(
-        self,
-        ids: list[int],
-    ):
-        """提交公告已阅"""
-        return await self.do(
-            "POST",
-            "/announcement",
-            data={
-                "basic": self.basic_info(),
-                "announcement_info": {
-                    "ids": ids,
-                }
-            }
-        )

pkg/audit/center/groups/plugin.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-from ....core import app
-from .. import apigroup
-
-
-class V2PluginDataAPI(apigroup.APIGroup):
-    """插件数据相关 API"""
-
-    def __init__(self, prefix: str, ap: app.Application):
-        self.ap = ap
-        super().__init__(prefix+"/plugin", ap)
-
-    async def do(self, *args, **kwargs):
-        if not self.ap.system_cfg.data['report-usage']:
-            return None
-        return await super().do(*args, **kwargs)
-
-    async def post_install_record(
-        self,
-        plugin: dict
-    ):
-        """提交插件安装记录"""
-        return await self.do(
-            "POST",
-            "/install",
-            data={
-                "basic": self.basic_info(),
-                "plugin": plugin,
-            }
-        )
-
-    async def post_remove_record(
-        self,
-        plugin: dict
-    ):
-        """提交插件卸载记录"""
-        return await self.do(
-            "POST",
-            "/remove",
-            data={
-                "basic": self.basic_info(),
-                "plugin": plugin,
-            }
-        )
-
-    async def post_update_record(
-        self,
-        plugin: dict,
-        old_version: str,
-        new_version: str,
-    ):
-        """提交插件更新记录"""
-        return await self.do(
-            "POST",
-            "/update",
-            data={
-                "basic": self.basic_info(),
-                "plugin": plugin,
-                "update_info": {
-                    "old_version": old_version,
-                    "new_version": new_version,
-                }
-            }
-        )

pkg/audit/center/groups/usage.py

@@ -1,88 +0,0 @@
-from __future__ import annotations
-
-from .. import apigroup
-from ....core import app
-
-
-class V2UsageDataAPI(apigroup.APIGroup):
-    """使用量数据相关 API"""
-
-    def __init__(self, prefix: str, ap: app.Application):
-        self.ap = ap
-        super().__init__(prefix+"/usage", ap)
-
-    async def do(self, *args, **kwargs):
-        if not self.ap.system_cfg.data['report-usage']:
-            return None
-        return await super().do(*args, **kwargs)
-
-    async def post_query_record(
-        self,
-        session_type: str,
-        session_id: str,
-        query_ability_provider: str,
-        usage: int,
-        model_name: str,
-        response_seconds: int,
-        retry_times: int,
-    ):
-        """提交请求记录"""
-        return await self.do(
-            "POST",
-            "/query",
-            data={
-                "basic": self.basic_info(),
-                "runtime": self.runtime_info(),
-                "session_info": {
-                    "type": session_type,
-                    "id": session_id,
-                },
-                "query_info": {
-                    "ability_provider": query_ability_provider,
-                    "usage": usage,
-                    "model_name": model_name,
-                    "response_seconds": response_seconds,
-                    "retry_times": retry_times,
-                }
-            }
-        )
-    
-    async def post_event_record(
-        self,
-        plugins: list[dict],
-        event_name: str,
-    ):
-        """提交事件触发记录"""
-        return await self.do(
-            "POST",
-            "/event",
-            data={
-                "basic": self.basic_info(),
-                "runtime": self.runtime_info(),
-                "plugins": plugins,
-                "event_info": {
-                    "name": event_name,
-                }
-            }
-        )
-    
-    async def post_function_record(
-        self,
-        plugin: dict,
-        function_name: str,
-        function_description: str,
-    ):
-        """提交内容函数使用记录"""
-        return await self.do(
-            "POST",
-            "/function",
-            data={
-                "basic": self.basic_info(),
-                "plugin": plugin,
-                "function_info": {
-                    "name": function_name,
-                    "description": function_description,
-                }
-            }
-        )
-    

pkg/audit/center/v2.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from . import apigroup
-from .groups import main
-from .groups import usage
-from .groups import plugin
-from ...core import app
-
-
-class V2CenterAPI:
-    """中央服务器 v2 API 交互类"""
-    
-    main: main.V2MainDataAPI = None
-    """主 API 组"""
-
-    usage: usage.V2UsageDataAPI = None
-    """使用量 API 组"""
-
-    plugin: plugin.V2PluginDataAPI = None
-    """插件 API 组"""
-
-    def __init__(self, ap: app.Application, backend_url: str, basic_info: dict = None, runtime_info: dict = None):
-        """初始化"""
-
-        logging.debug("basic_info: %s, runtime_info: %s", basic_info, runtime_info)
-        
-        apigroup.APIGroup._basic_info = basic_info
-        apigroup.APIGroup._runtime_info = runtime_info
-
-        self.main = main.V2MainDataAPI(backend_url, ap)
-        self.usage = usage.V2UsageDataAPI(backend_url, ap)
-        self.plugin = plugin.V2PluginDataAPI(backend_url, ap)
-

pkg/audit/identifier.py

@@ -1,85 +0,0 @@
-# 实例 识别码 控制
-
-import os
-import uuid
-import json
-import time
-
-
-identifier = {
-    'host_id': '',
-    'instance_id': '',
-    'host_create_ts': 0,
-    'instance_create_ts': 0,
-}
-
-HOST_ID_FILE = os.path.expanduser('~/.langbot/host_id.json')
-INSTANCE_ID_FILE = 'data/labels/instance_id.json'
-
-def init():
-    global identifier
-
-    if not os.path.exists(os.path.expanduser('~/.langbot')):
-        os.mkdir(os.path.expanduser('~/.langbot'))
-
-    if not os.path.exists(HOST_ID_FILE):
-        new_host_id = 'host_'+str(uuid.uuid4())
-        new_host_create_ts = int(time.time())
-
-        with open(HOST_ID_FILE, 'w') as f:
-            json.dump({
-                'host_id': new_host_id,
-                'host_create_ts': new_host_create_ts
-            }, f)
-
-        identifier['host_id'] = new_host_id
-        identifier['host_create_ts'] = new_host_create_ts
-    else:
-        loaded_host_id = ''
-        loaded_host_create_ts = 0
-
-        with open(HOST_ID_FILE, 'r') as f:
-            file_content = json.load(f)
-            loaded_host_id = file_content['host_id']
-            loaded_host_create_ts = file_content['host_create_ts']
-
-        identifier['host_id'] = loaded_host_id
-        identifier['host_create_ts'] = loaded_host_create_ts
-
-    # 检查实例 id
-    if os.path.exists(INSTANCE_ID_FILE):
-        instance_id = {}
-        with open(INSTANCE_ID_FILE, 'r') as f:
-            instance_id = json.load(f)
-        
-        if instance_id['host_id'] != identifier['host_id']: # 如果实例 id 不是当前主机的，删除
-            os.remove(INSTANCE_ID_FILE)
-
-    if not os.path.exists(INSTANCE_ID_FILE):
-        new_instance_id = 'instance_'+str(uuid.uuid4())
-        new_instance_create_ts = int(time.time())
-
-        with open(INSTANCE_ID_FILE, 'w') as f:
-            json.dump({
-                'host_id': identifier['host_id'],
-                'instance_id': new_instance_id,
-                'instance_create_ts': new_instance_create_ts
-            }, f)
-
-        identifier['instance_id'] = new_instance_id
-        identifier['instance_create_ts'] = new_instance_create_ts
-    else:
-        loaded_instance_id = ''
-        loaded_instance_create_ts = 0
-
-        with open(INSTANCE_ID_FILE, 'r') as f:
-            file_content = json.load(f)
-            loaded_instance_id = file_content['instance_id']
-            loaded_instance_create_ts = file_content['instance_create_ts']
-
-        identifier['instance_id'] = loaded_instance_id
-        identifier['instance_create_ts'] = loaded_instance_create_ts
-
-def print_out():
-    global identifier
-    print(identifier)

pkg/command/cmdmgr.py

@@ -1,129 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from ..core import app, entities as core_entities
-from ..provider import entities as llm_entities
-from . import entities, operator, errors
-from ..config import manager as cfg_mgr
-
-# 引入所有算子以便注册
-from .operators import func, plugin, default, reset, list as list_cmd, last, next, delc, resend, prompt, cmd, help, version, update, ollama, model
-
-
-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.command_cfg.data['privilege']:
-                cls.lowest_privilege = self.ap.command_cfg.data['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.system_cfg.data['admin-sessions']:
-            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,76 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-import pydantic.v1 as pydantic
-
-from ..core import app, entities as core_entities
-from . import errors, operator
-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,33 +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,50 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, 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/default.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import typing
-import traceback
-
-from .. import operator, entities, cmdmgr, errors
-
-
-@operator.operator_class(
-    name="default",
-    help="操作情景预设",
-    usage='!default\n!default set <指定情景预设为默认>'
-)
-class DefaultOperator(operator.CommandOperator):
-
-    async def execute(
-        self,
-        context: entities.ExecuteContext
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        
-        reply_str = "当前所有情景预设: \n\n"
-
-        for prompt in self.ap.prompt_mgr.get_all_prompts():
-
-            content = ""
-            for msg in prompt.messages:
-                content += f"  {msg.readable_str()}\n"
-
-            reply_str += f"名称: {prompt.name}\n内容: \n{content}\n\n"
-
-        reply_str += f"当前会话使用的是: {context.session.use_prompt_name}"
-
-        yield entities.CommandReturn(text=reply_str.strip())
-
-
-@operator.operator_class(
-    name="set",
-    help="设置当前会话默认情景预设",
-    parent_class=DefaultOperator
-)
-class DefaultSetOperator(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:
-            prompt_name = context.crt_params[0]
-    
-            try:
-                prompt = await self.ap.prompt_mgr.get_prompt_by_prefix(prompt_name)
-                if prompt is None:
-                    yield entities.CommandReturn(error=errors.CommandError("设置当前会话默认情景预设失败: 未找到情景预设 {}".format(prompt_name)))
-                else:
-                    context.session.use_prompt_name = prompt.name
-                    yield entities.CommandReturn(text=f"已设置当前会话默认情景预设为 {prompt_name}, !reset 后生效")
-            except Exception as e:
-                traceback.print_exc()
-                yield entities.CommandReturn(error=errors.CommandError("设置当前会话默认情景预设失败: "+str(e)))

pkg/command/operators/delc.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import typing
-import datetime
-
-from .. import operator, entities, cmdmgr, 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:
-                    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,29 +0,0 @@
-from __future__ import annotations
-from typing import AsyncGenerator
-
-from .. import operator, entities, cmdmgr
-from ...plugin import context as plugin_context
-
-
-@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,23 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, errors
-
-
-@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 = self.ap.system_cfg.data['help-message']
-
-        help += '\n发送命令 !cmd 可查看命令列表'
-
-        yield entities.CommandReturn(text=help)

pkg/command/operators/last.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import typing
-import datetime
-
-
-from .. import operator, entities, cmdmgr, 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,56 +0,0 @@
-from __future__ import annotations
-
-import typing
-import datetime
-
-from .. import operator, entities, cmdmgr, 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:
-                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/model.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, errors
-
-@operator.operator_class(
-    name="model",
-    help='显示和切换模型列表',
-    usage='!model\n!model show <模型名>\n!model set <模型名>',
-    privilege=2
-)
-class ModelOperator(operator.CommandOperator):
-    """Model命令"""
-    
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        content = '模型列表:\n'
-
-        model_list = self.ap.model_mgr.model_list
-
-        for model in model_list:
-            content += f"\n名称: {model.name}\n"
-            content += f"请求器: {model.requester.name}\n"
-
-        content += f"\n当前对话使用模型: {context.query.use_model.name}\n"
-        content += f"新对话默认使用模型: {self.ap.provider_cfg.data.get('model')}\n"
-
-        yield entities.CommandReturn(text=content.strip())
-
-
-@operator.operator_class(
-    name="show",
-    help='显示模型详情',
-    privilege=2,
-    parent_class=ModelOperator
-)
-class ModelShowOperator(operator.CommandOperator):
-    """Model Show命令"""
-    
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        model_name = context.crt_params[0]
-
-        model = None
-        for _model in self.ap.model_mgr.model_list:
-            if model_name == _model.name:
-                model = _model
-                break
-
-        if model is None:
-            yield entities.CommandReturn(error=errors.CommandError(f"未找到模型 {model_name}"))
-        else:
-            content = f"模型详情\n"
-            content += f"名称: {model.name}\n"
-            if model.model_name is not None:
-                content += f"请求模型名称: {model.model_name}\n"
-            content += f"请求器: {model.requester.name}\n"
-            content += f"密钥组: {model.token_mgr.provider}\n"
-            content += f"支持视觉: {model.vision_supported}\n"
-            content += f"支持工具: {model.tool_call_supported}\n"
-
-            yield entities.CommandReturn(text=content.strip())
-
-@operator.operator_class(
-    name="set",
-    help='设置默认使用模型',
-    privilege=2,
-    parent_class=ModelOperator
-)
-class ModelSetOperator(operator.CommandOperator):
-    """Model Set命令"""
-    
-    async def execute(self, context: entities.ExecuteContext) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        model_name = context.crt_params[0]
-
-        model = None
-        for _model in self.ap.model_mgr.model_list:
-            if model_name == _model.name:
-                model = _model
-                break
-
-        if model is None:
-            yield entities.CommandReturn(error=errors.CommandError(f"未找到模型 {model_name}"))
-        else:
-            self.ap.provider_cfg.data['model'] = model_name
-            await self.ap.provider_cfg.dump_config()
-            yield entities.CommandReturn(text=f"已设置当前使用模型为 {model_name}，重置会话以生效")

pkg/command/operators/next.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import typing
-import datetime
-
-from .. import operator, entities, cmdmgr, 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/ollama.py

@@ -1,121 +0,0 @@
-from __future__ import annotations
-
-import json
-import typing
-import traceback
-
-import ollama
-from .. import operator, entities, errors
-
-
-@operator.operator_class(
-    name="ollama",
-    help="ollama平台操作",
-    usage="!ollama\n!ollama show <模型名>\n!ollama pull <模型名>\n!ollama del <模型名>"
-)
-class OllamaOperator(operator.CommandOperator):
-    async def execute(
-            self, context: entities.ExecuteContext
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        try:
-            content: str = '模型列表:\n'
-            model_list: list = ollama.list().get('models', [])
-            for model in model_list:
-                content += f"名称: {model['name']}\n"
-                content += f"修改时间: {model['modified_at']}\n"
-                content += f"大小: {bytes_to_mb(model['size'])}MB\n\n"
-            yield entities.CommandReturn(text=f"{content.strip()}")
-        except ollama.ResponseError as e:
-            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型列表，请确认 Ollama 服务正常"))
-
-
-def bytes_to_mb(num_bytes):
-    mb: float = num_bytes / 1024 / 1024
-    return format(mb, '.2f')
-
-
-@operator.operator_class(
-    name="show",
-    help="ollama模型详情",
-    privilege=2,
-    parent_class=OllamaOperator
-)
-class OllamaShowOperator(operator.CommandOperator):
-    async def execute(
-            self, context: entities.ExecuteContext
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        content: str = '模型详情:\n'
-        try:
-            show: dict = ollama.show(model=context.crt_params[0])
-            model_info: dict = show.get('model_info', {})
-            ignore_show: str = 'too long to show...'
-
-            for key in ['license', 'modelfile']:
-                show[key] = ignore_show
-
-            for key in ['tokenizer.chat_template.rag', 'tokenizer.chat_template.tool_use']:
-                model_info[key] = ignore_show
-
-            content += json.dumps(show, indent=4)
-            yield entities.CommandReturn(text=content.strip())
-        except ollama.ResponseError as e:
-            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型详情，请确认 Ollama 服务正常"))
-
-@operator.operator_class(
-    name="pull",
-    help="ollama模型拉取",
-    privilege=2,
-    parent_class=OllamaOperator
-)
-class OllamaPullOperator(operator.CommandOperator):
-    async def execute(
-            self, context: entities.ExecuteContext
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        try:
-            model_list: list = ollama.list().get('models', [])
-            if context.crt_params[0] in [model['name'] for model in model_list]:
-                yield entities.CommandReturn(text="模型已存在")
-                return
-        except ollama.ResponseError as e:
-            yield entities.CommandReturn(error=errors.CommandError(f"无法获取模型列表，请确认 Ollama 服务正常"))
-            return
-
-        on_progress: bool = False
-        progress_count: int = 0
-        try:
-            for resp in ollama.pull(model=context.crt_params[0], stream=True):
-                total: typing.Any = resp.get('total')
-                if not on_progress:
-                    if total is not None:
-                        on_progress = True
-                    yield entities.CommandReturn(text=resp.get('status'))
-                else:
-                    if total is None:
-                        on_progress = False
-
-                    completed: typing.Any = resp.get('completed')
-                    if isinstance(completed, int) and isinstance(total, int):
-                        percentage_completed = (completed / total) * 100
-                        if percentage_completed > progress_count:
-                            progress_count += 10
-                            yield entities.CommandReturn(
-                                text=f"下载进度: {completed}/{total} ({percentage_completed:.2f}%)")
-        except ollama.ResponseError as e:
-            yield entities.CommandReturn(text=f"拉取失败: {e.error}")
-
-
-@operator.operator_class(
-    name="del",
-    help="ollama模型删除",
-    privilege=2,
-    parent_class=OllamaOperator
-)
-class OllamaDelOperator(operator.CommandOperator):
-    async def execute(
-            self, context: entities.ExecuteContext
-    ) -> typing.AsyncGenerator[entities.CommandReturn, None]:
-        try:
-            ret: str = ollama.delete(model=context.crt_params[0])['status']
-        except ollama.ResponseError as e:
-            ret = f"{e.error}"
-        yield entities.CommandReturn(text=ret)

pkg/command/operators/plugin.py

@@ -1,219 +0,0 @@
-from __future__ import annotations
-import typing
-import traceback
-
-from .. import operator, entities, cmdmgr, errors
-from ...core import app
-
-
-@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)
-
-            # TODO 从元数据调远程地址
-
-            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,29 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, 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,34 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, 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,23 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, entities, cmdmgr, errors
-
-
-@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,30 +0,0 @@
-from __future__ import annotations
-
-import typing
-import traceback
-
-from .. import operator, entities, cmdmgr, errors
-
-
-@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]:
-       
-        try:
-            yield entities.CommandReturn(text="正在进行更新...")
-            if await self.ap.ver_mgr.update_all():
-                yield entities.CommandReturn(text="更新完成，请重启程序以应用更新")
-            else:
-                yield entities.CommandReturn(text="当前已是最新版本")
-        except Exception as e:
-            traceback.print_exc()
-            yield entities.CommandReturn(error=errors.CommandError("更新失败: "+str(e)))

pkg/command/operators/version.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator, cmdmgr, entities, errors
-
-
-@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:
-            pass
-
-        yield entities.CommandReturn(text=reply_str.strip())

pkg/config/impls/json.py

@@ -1,59 +0,0 @@
-import os
-import shutil
-import json
-
-from .. import model as file_model
-
-
-class JSONConfigFile(file_model.ConfigFile):
-    """JSON配置文件"""
-
-    def __init__(
-        self, config_file_name: str, template_file_name: str = None, template_data: dict = None
-    ) -> None:
-        self.config_file_name = config_file_name
-        self.template_file_name = template_file_name
-        self.template_data = template_data
-
-    def exists(self) -> bool:
-        return os.path.exists(self.config_file_name)
-
-    async def create(self):
-        if self.template_file_name is not None:
-            shutil.copyfile(self.template_file_name, self.config_file_name)
-        elif self.template_data is not None:
-            with open(self.config_file_name, "w", encoding="utf-8") as f:
-                json.dump(self.template_data, f, indent=4, ensure_ascii=False)
-        else:
-            raise ValueError("template_file_name or template_data must be provided")
-
-    async def load(self, completion: bool=True) -> dict:
-
-        if not self.exists():
-            await self.create()
-
-        if self.template_file_name is not None:
-            with open(self.template_file_name, "r", encoding="utf-8") as f:
-                self.template_data = json.load(f)
-
-        with open(self.config_file_name, "r", encoding="utf-8") as f:
-            try:
-                cfg = json.load(f)
-            except json.JSONDecodeError as e:
-                raise Exception(f"配置文件 {self.config_file_name} 语法错误: {e}")
-
-        if completion:
-
-            for key in self.template_data:
-                if key not in cfg:
-                    cfg[key] = self.template_data[key]
-
-        return cfg
-
-    async def save(self, cfg: dict):
-        with open(self.config_file_name, "w", encoding="utf-8") as f:
-            json.dump(cfg, f, indent=4, ensure_ascii=False)
-
-    def save_sync(self, cfg: dict):
-        with open(self.config_file_name, "w", encoding="utf-8") as f:
-            json.dump(cfg, f, indent=4, ensure_ascii=False)

pkg/config/impls/yaml.py

@@ -1,59 +0,0 @@
-import os
-import shutil
-import yaml
-
-from .. import model as file_model
-
-
-class YAMLConfigFile(file_model.ConfigFile):
-    """YAML配置文件"""
-
-    def __init__(
-        self, config_file_name: str, template_file_name: str = None, template_data: dict = None
-    ) -> None:
-        self.config_file_name = config_file_name
-        self.template_file_name = template_file_name
-        self.template_data = template_data
-
-    def exists(self) -> bool:
-        return os.path.exists(self.config_file_name)
-
-    async def create(self):
-        if self.template_file_name is not None:
-            shutil.copyfile(self.template_file_name, self.config_file_name)
-        elif self.template_data is not None:
-            with open(self.config_file_name, "w", encoding="utf-8") as f:
-                yaml.dump(self.template_data, f, indent=4, allow_unicode=True)
-        else:
-            raise ValueError("template_file_name or template_data must be provided")
-
-    async def load(self, completion: bool=True) -> dict:
-
-        if not self.exists():
-            await self.create()
-
-        if self.template_file_name is not None:
-            with open(self.template_file_name, "r", encoding="utf-8") as f:
-                self.template_data = yaml.load(f, Loader=yaml.FullLoader)
-
-        with open(self.config_file_name, "r", encoding="utf-8") as f:
-            try:
-                cfg = yaml.load(f, Loader=yaml.FullLoader)
-            except yaml.YAMLError as e:
-                raise Exception(f"配置文件 {self.config_file_name} 语法错误: {e}")
-
-        if completion:
-
-            for key in self.template_data:
-                if key not in cfg:
-                    cfg[key] = self.template_data[key]
-
-        return cfg
-
-    async def save(self, cfg: dict):
-        with open(self.config_file_name, "w", encoding="utf-8") as f:
-            yaml.dump(cfg, f, indent=4, allow_unicode=True)
-
-    def save_sync(self, cfg: dict):
-        with open(self.config_file_name, "w", encoding="utf-8") as f:
-            yaml.dump(cfg, f, indent=4, allow_unicode=True)

pkg/config/manager.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-from . import model as file_model
-from .impls import pymodule, json as json_file, yaml as yaml_file
-
-
-class ConfigManager:
-    """配置文件管理器"""
-    
-    name: str = None
-    """配置管理器名"""
-
-    description: str = None
-    """配置管理器描述"""
-
-    schema: dict = None
-    """配置文件 schema
-    需要符合 JSON Schema Draft 7 规范
-    """
-
-    file: file_model.ConfigFile = None
-    """配置文件实例"""
-
-    data: dict = None
-    """配置数据"""
-
-    doc_link: str = None
-    """配置文件文档链接"""
-
-    def __init__(self, cfg_file: file_model.ConfigFile) -> None:
-        self.file = cfg_file
-        self.data = {}
-
-    async def load_config(self, completion: bool=True):
-        self.data = await self.file.load(completion=completion)
-
-    async def dump_config(self):
-        await self.file.save(self.data)
-
-    def dump_config_sync(self):
-        self.file.save_sync(self.data)
-
-
-async def load_python_module_config(config_name: str, template_name: str, completion: bool=True) -> ConfigManager:
-    """加载Python模块配置文件
-    
-    Args:
-        config_name (str): 配置文件名
-        template_name (str): 模板文件名
-        completion (bool): 是否自动补全内存中的配置文件
-
-    Returns:
-        ConfigManager: 配置文件管理器
-    """
-    cfg_inst = pymodule.PythonModuleConfigFile(
-        config_name,
-        template_name
-    )
-
-    cfg_mgr = ConfigManager(cfg_inst)
-    await cfg_mgr.load_config(completion=completion)
-
-    return cfg_mgr
-
-
-async def load_json_config(config_name: str, template_name: str=None, template_data: dict=None, completion: bool=True) -> ConfigManager:
-    """加载JSON配置文件
-    
-    Args:
-        config_name (str): 配置文件名
-        template_name (str): 模板文件名
-        template_data (dict): 模板数据
-        completion (bool): 是否自动补全内存中的配置文件
-    """
-    cfg_inst = json_file.JSONConfigFile(
-        config_name,
-        template_name,
-        template_data
-    )
-
-    cfg_mgr = ConfigManager(cfg_inst)
-    await cfg_mgr.load_config(completion=completion)
-
-    return cfg_mgr
-
-
-async def load_yaml_config(config_name: str, template_name: str=None, template_data: dict=None, completion: bool=True) -> ConfigManager:
-    """加载YAML配置文件
-    
-    Args:
-        config_name (str): 配置文件名
-        template_name (str): 模板文件名
-        template_data (dict): 模板数据
-        completion (bool): 是否自动补全内存中的配置文件
-
-    Returns:
-        ConfigManager: 配置文件管理器
-    """
-    cfg_inst = yaml_file.YAMLConfigFile(
-        config_name,
-        template_name,
-        template_data
-    )
-
-    cfg_mgr = ConfigManager(cfg_inst)
-    await cfg_mgr.load_config(completion=completion)
-
-    return cfg_mgr

pkg/config/settings.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-from . import manager as config_manager
-from ..core import app
-
-
-class SettingsManager:
-    """设置管理器
-    保存、管理多个配置文件管理器
-    """
-
-    ap: app.Application
-
-    managers: list[config_manager.ConfigManager] = []
-    """配置文件管理器列表"""
-
-    def __init__(self, ap: app.Application) -> None:
-        self.ap = ap
-        self.managers = []
-
-    async def initialize(self) -> None:
-        pass
-
-    def register_manager(
-        self,
-        name: str,
-        description: str,
-        manager: config_manager.ConfigManager,
-        schema: dict=None,
-        doc_link: str=None,
-    ) -> None:
-        """注册配置管理器
-        
-        Args:
-            name (str): 配置管理器名
-            description (str): 配置管理器描述
-            manager (ConfigManager): 配置管理器
-            schema (dict): 配置文件 schema，符合 JSON Schema Draft 7 规范
-        """
-
-        for m in self.managers:
-            if m.name == name:
-                raise ValueError(f'配置管理器名 {name} 已存在')
-
-        manager.name = name
-        manager.description = description
-        manager.schema = schema
-        manager.doc_link = doc_link
-        self.managers.append(manager)
-
-    def get_manager(self, name: str) -> config_manager.ConfigManager | None:
-        """获取配置管理器
-        
-        Args:
-            name (str): 配置管理器名
-        
-        Returns:
-            ConfigManager: 配置管理器
-        """
-
-        for m in self.managers:
-            if m.name == name:
-                return m
-
-        return None
-    
-    def get_manager_list(self) -> list[config_manager.ConfigManager]:
-        """获取配置管理器列表
-        
-        Returns:
-            list[ConfigManager]: 配置管理器列表
-        """
-
-        return self.managers
-    

pkg/core/app.py

@@ -1,231 +0,0 @@
-from __future__ import annotations
-
-import logging
-import asyncio
-import threading
-import traceback
-import enum
-import sys
-import os
-
-from ..platform import manager as im_mgr
-from ..provider.session import sessionmgr as llm_session_mgr
-from ..provider.modelmgr import modelmgr as llm_model_mgr
-from ..provider.sysprompt import sysprompt as llm_prompt_mgr
-from ..provider.tools import toolmgr as llm_tool_mgr
-from ..provider import runnermgr
-from ..config import manager as config_mgr
-from ..config import settings as settings_mgr
-from ..audit.center import v2 as center_mgr
-from ..command import cmdmgr
-from ..plugin import manager as plugin_mgr
-from ..pipeline import pool
-from ..pipeline import controller, stagemgr
-from ..utils import version as version_mgr, proxy as proxy_mgr, announce as announce_mgr
-from ..persistence import mgr as persistencemgr
-from ..api.http.controller import main as http_controller
-from ..api.http.service import user as user_service
-from ..discover import engine as discover_engine
-from ..utils import logcache, ip
-from . import taskmgr
-from . import entities as core_entities
-from .bootutils import config
-
-
-class Application:
-    """运行时应用对象和上下文"""
-
-    event_loop: asyncio.AbstractEventLoop = None
-
-    # asyncio_tasks: list[asyncio.Task] = []
-    task_mgr: taskmgr.AsyncTaskManager = None
-
-    discover: discover_engine.ComponentDiscoveryEngine = None
-
-    platform_mgr: im_mgr.PlatformManager = None
-
-    cmd_mgr: cmdmgr.CommandManager = None
-
-    sess_mgr: llm_session_mgr.SessionManager = None
-
-    model_mgr: llm_model_mgr.ModelManager = None
-
-    prompt_mgr: llm_prompt_mgr.PromptManager = None
-
-    tool_mgr: llm_tool_mgr.ToolManager = None
-
-    runner_mgr: runnermgr.RunnerManager = None
-
-    settings_mgr: settings_mgr.SettingsManager = None
-
-    # ======= 配置管理器 =======
-
-    command_cfg: config_mgr.ConfigManager = None
-
-    pipeline_cfg: config_mgr.ConfigManager = None
-
-    platform_cfg: config_mgr.ConfigManager = None
-
-    provider_cfg: config_mgr.ConfigManager = None
-
-    system_cfg: config_mgr.ConfigManager = None
-
-    # ======= 元数据配置管理器 =======
-
-    sensitive_meta: config_mgr.ConfigManager = None
-
-    adapter_qq_botpy_meta: config_mgr.ConfigManager = None
-
-    plugin_setting_meta: config_mgr.ConfigManager = None
-
-    llm_models_meta: config_mgr.ConfigManager = None
-
-    instance_secret_meta: config_mgr.ConfigManager = None
-
-    # =========================
-
-    ctr_mgr: center_mgr.V2CenterAPI = None
-
-    plugin_mgr: plugin_mgr.PluginManager = None
-
-    query_pool: pool.QueryPool = None
-
-    ctrl: controller.Controller = None
-
-    stage_mgr: stagemgr.StageManager = None
-
-    ver_mgr: version_mgr.VersionManager = None
-
-    ann_mgr: announce_mgr.AnnouncementManager = None
-
-    proxy_mgr: proxy_mgr.ProxyManager = None
-
-    logger: logging.Logger = None
-
-    persistence_mgr: persistencemgr.PersistenceManager = None
-
-    http_ctrl: http_controller.HTTPController = None
-
-    log_cache: logcache.LogCache = None
-
-    # ========= HTTP Services =========
-
-    user_service: user_service.UserService = None
-
-    def __init__(self):
-        pass
-
-    async def initialize(self):
-        pass
-
-    async def run(self):
-        try:
-            await self.plugin_mgr.initialize_plugins()
-            # 后续可能会允许动态重启其他任务
-            # 故为了防止程序在非 Ctrl-C 情况下退出，这里创建一个不会结束的协程
-            async def never_ending():
-                while True:
-                    await asyncio.sleep(1)
-
-            self.task_mgr.create_task(self.platform_mgr.run(), name="platform-manager", scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM])
-            self.task_mgr.create_task(self.ctrl.run(), name="query-controller", scopes=[core_entities.LifecycleControlScope.APPLICATION])
-            self.task_mgr.create_task(self.http_ctrl.run(), name="http-api-controller", scopes=[core_entities.LifecycleControlScope.APPLICATION])
-            self.task_mgr.create_task(never_ending(), name="never-ending-task", scopes=[core_entities.LifecycleControlScope.APPLICATION])
-
-            await self.print_web_access_info()
-            await self.task_mgr.wait_all()
-        except asyncio.CancelledError:
-            pass
-        except Exception as e:
-            self.logger.error(f"应用运行致命异常: {e}")
-            self.logger.debug(f"Traceback: {traceback.format_exc()}")
-
-    async def print_web_access_info(self):
-        """打印访问 webui 的提示"""
-
-        if not os.path.exists(os.path.join(".", "web/dist")):
-            self.logger.warning("WebUI 文件缺失，请根据文档获取：https://docs.langbot.app/webui/intro.html")
-            return
-
-        host_ip = "127.0.0.1"
-
-        public_ip = await ip.get_myip()
-
-        port = self.system_cfg.data['http-api']['port']
-
-        tips = f"""
-=======================================
-✨ 您可通过以下方式访问管理面板
-
-🏠 本地地址：http://{host_ip}:{port}/
-🌐 公网地址：http://{public_ip}:{port}/
-
-📌 如果您在容器中运行此程序，请确保容器的 {port} 端口已对外暴露
-🔗 若要使用公网地址访问，请阅读以下须知
-   1. 公网地址仅供参考，请以您的主机公网 IP 为准；
-   2. 要使用公网地址访问，请确保您的主机具有公网 IP，并且系统防火墙已放行 {port} 端口；
-
-🤯 WebUI 仍处于 Beta 测试阶段，如有问题或建议请反馈到 https://github.com/RockChinQ/LangBot/issues
-=======================================
-""".strip()
-        for line in tips.split("\n"):
-            self.logger.info(line)
-
-    async def reload(
-        self,
-        scope: core_entities.LifecycleControlScope,
-    ):
-        match scope:
-            case core_entities.LifecycleControlScope.PLATFORM.value:
-                self.logger.info("执行热重载 scope="+scope)
-                await self.platform_mgr.shutdown()
-
-                self.platform_mgr = im_mgr.PlatformManager(self)
-
-                await self.platform_mgr.initialize()
-
-                self.task_mgr.create_task(self.platform_mgr.run(), name="platform-manager", scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM])
-            case core_entities.LifecycleControlScope.PLUGIN.value:
-                self.logger.info("执行热重载 scope="+scope)
-                await self.plugin_mgr.destroy_plugins()
-
-                # 删除 sys.module 中所有的 plugins/* 下的模块
-                for mod in list(sys.modules.keys()):
-                    if mod.startswith("plugins."):
-                        del sys.modules[mod]
-
-                self.plugin_mgr = plugin_mgr.PluginManager(self)
-                await self.plugin_mgr.initialize()
-
-                await self.plugin_mgr.initialize_plugins()
-
-                await self.plugin_mgr.load_plugins()
-                await self.plugin_mgr.initialize_plugins()
-            case core_entities.LifecycleControlScope.PROVIDER.value:
-                self.logger.info("执行热重载 scope="+scope)
-
-                await self.tool_mgr.shutdown()
-
-                latest_llm_model_config = await config.load_json_config("data/metadata/llm-models.json", "templates/metadata/llm-models.json")
-                self.llm_models_meta = latest_llm_model_config
-                llm_model_mgr_inst = llm_model_mgr.ModelManager(self)
-                await llm_model_mgr_inst.initialize()
-                self.model_mgr = llm_model_mgr_inst
-
-                llm_session_mgr_inst = llm_session_mgr.SessionManager(self)
-                await llm_session_mgr_inst.initialize()
-                self.sess_mgr = llm_session_mgr_inst
-
-                llm_prompt_mgr_inst = llm_prompt_mgr.PromptManager(self)
-                await llm_prompt_mgr_inst.initialize()
-                self.prompt_mgr = llm_prompt_mgr_inst
-
-                llm_tool_mgr_inst = llm_tool_mgr.ToolManager(self)
-                await llm_tool_mgr_inst.initialize()
-                self.tool_mgr = llm_tool_mgr_inst
-
-                runner_mgr_inst = runnermgr.RunnerManager(self)
-                await runner_mgr_inst.initialize()
-                self.runner_mgr = runner_mgr_inst
-            case _:
-                pass

pkg/core/bootutils/deps.py

@@ -1,57 +0,0 @@
-import pip
-
-# 检查依赖，防止用户未安装
-# 左边为引入名称，右边为依赖名称
-required_deps = {
-    "requests": "requests",
-    "openai": "openai",
-    "anthropic": "anthropic",
-    "colorlog": "colorlog",
-    "aiocqhttp": "aiocqhttp",
-    "botpy": "qq-botpy-rc",
-    "PIL": "pillow",
-    "nakuru": "nakuru-project-idk",
-    "tiktoken": "tiktoken",
-    "yaml": "pyyaml",
-    "aiohttp": "aiohttp",
-    "psutil": "psutil",
-    "async_lru": "async-lru",
-    "ollama": "ollama",
-    "quart": "quart",
-    "quart_cors": "quart-cors",
-    "sqlalchemy": "sqlalchemy[asyncio]",
-    "aiosqlite": "aiosqlite",
-    "aiofiles": "aiofiles",
-    "aioshutil": "aioshutil",
-    "argon2": "argon2-cffi",
-    "jwt": "pyjwt",
-    "Crypto": "pycryptodome",
-    "lark_oapi": "lark-oapi",
-    "discord": "discord.py",
-    "cryptography": "cryptography",
-    "gewechat_client": "gewechat-client",
-    "dingtalk_stream": "dingtalk_stream",
-    "dashscope": "dashscope",
-    "telegram": "python-telegram-bot",
-    "certifi": "certifi",
-    "mcp": "mcp",
-    "telegramify_markdown":"telegramify-markdown",
-}
-
-
-async def check_deps() -> list[str]:
-    global required_deps
-
-    missing_deps = []
-    for dep in required_deps:
-        try:
-            __import__(dep)
-        except ImportError:
-            missing_deps.append(dep)
-    return missing_deps
-
-async def install_deps(deps: list[str]):
-    global required_deps
-    
-    for dep in deps:
-        pip.main(["install", required_deps[dep]])

pkg/core/bootutils/files.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import os
-import shutil
-import sys
-
-
-required_files = {
-    "plugins/__init__.py": "templates/__init__.py",
-    "plugins/plugins.json": "templates/plugin-settings.json",
-    "data/config/command.json": "templates/command.json",
-    "data/config/pipeline.json": "templates/pipeline.json",
-    "data/config/platform.json": "templates/platform.json",
-    "data/config/provider.json": "templates/provider.json",
-    "data/config/system.json": "templates/system.json",
-    "data/scenario/default.json": "templates/scenario-template.json",
-}
-
-required_paths = [
-    "temp",
-    "data",
-    "data/metadata",
-    "data/prompts",
-    "data/scenario",
-    "data/logs",
-    "data/config",
-    "data/labels",
-    "plugins"
-]
-
-async def generate_files() -> list[str]:
-    global required_files, required_paths
-
-    for required_paths in required_paths:
-        if not os.path.exists(required_paths):
-            os.mkdir(required_paths)
-
-    generated_files = []
-    for file in required_files:
-        if not os.path.exists(file):
-            shutil.copyfile(required_files[file], file)
-            generated_files.append(file)
-
-    return generated_files

pkg/core/entities.py

@@ -1,159 +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 entities
-from ..provider.sysprompt import entities as sysprompt_entities
-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
-from ..platform.types import entities as platform_entities
-
-
-
-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收到的原始消息链"""
-
-    adapter: msadapter.MessagePlatformAdapter
-    """消息平台适配器对象，单个app中可能启用了多个消息平台适配器，此对象表明发起此query的适配器"""
-
-    session: typing.Optional[Session] = None
-    """会话对象，由前置处理器阶段设置"""
-
-    messages: typing.Optional[list[llm_entities.Message]] = []
-    """历史消息列表，由前置处理器阶段设置"""
-
-    prompt: typing.Optional[sysprompt_entities.Prompt] = None
-    """情景预设内容，由前置处理器阶段设置"""
-
-    user_message: typing.Optional[llm_entities.Message] = None
-    """此次请求的用户消息对象，由前置处理器阶段设置"""
-
-    variables: typing.Optional[dict[str, typing.Any]] = None
-    """变量，由前置处理器阶段设置。在prompt中嵌入或由 Runner 传递到 LLMOps 平台。"""
-
-    use_model: typing.Optional[entities.LLMModelInfo] = 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: "pkg.pipeline.stagemgr.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: sysprompt_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_model: entities.LLMModelInfo
-
-    use_funcs: typing.Optional[list[tools_entities.LLMFunction]]
-
-    uuid: typing.Optional[str] = None
-    """该对话的 uuid，在创建时不会自动生成。而是当使用 Dify API 等由外部管理对话信息的服务时，用于绑定外部的会话。具体如何使用，取决于 Runner。"""
-
-
-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/migrations/m001_sensitive_word_migration.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import os
-import sys
-
-from .. import migration
-
-
-@migration.migration_class("sensitive-word-migration", 1)
-class SensitiveWordMigration(migration.Migration):
-    """敏感词迁移
-    """
-
-    async def need_migrate(self) -> bool:
-        """判断当前环境是否需要运行此迁移
-        """
-        return os.path.exists("data/config/sensitive-words.json") and not os.path.exists("data/metadata/sensitive-words.json")
-
-    async def run(self):
-        """执行迁移
-        """
-        # 移动文件
-        os.rename("data/config/sensitive-words.json", "data/metadata/sensitive-words.json")
-
-        # 重新加载配置
-        await self.ap.sensitive_meta.load_config()

pkg/core/migrations/m008_ad_fixwin_config_migrate.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from .. import migration
-
-
-@migration.migration_class("ad-fixwin-cfg-migration", 8)
-class AdFixwinConfigMigration(migration.Migration):
-    """迁移"""
-
-    async def need_migrate(self) -> bool:
-        """判断当前环境是否需要运行此迁移"""
-        return isinstance(
-            self.ap.pipeline_cfg.data["rate-limit"]["fixwin"]["default"],
-            int
-        )
-
-    async def run(self):
-        """执行迁移"""
-        
-        for session_name in self.ap.pipeline_cfg.data["rate-limit"]["fixwin"]:
-
-            temp_dict = {
-                "window-size": 60,
-                "limit": self.ap.pipeline_cfg.data["rate-limit"]["fixwin"][session_name]
-            }
-            
-            self.ap.pipeline_cfg.data["rate-limit"]["fixwin"][session_name] = temp_dict
-
-        await self.ap.pipeline_cfg.dump_config()

pkg/core/migrations/m029_dashscope_app_api_config.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from .. import migration
-
-
-@migration.migration_class("dashscope-app-api-config", 29)
-class DashscopeAppAPICfgMigration(migration.Migration):
-    """迁移"""
-
-    async def need_migrate(self) -> bool:
-        """判断当前环境是否需要运行此迁移"""
-        return 'dashscope-app-api' not in self.ap.provider_cfg.data
-
-    async def run(self):
-        """执行迁移"""
-        self.ap.provider_cfg.data['dashscope-app-api'] = {
-            "app-type": "agent",
-            "api-key": "sk-1234567890",
-            "agent": {
-                "app-id": "Your_app_id",
-                "references_quote": "参考资料来自:"
-            },
-            "workflow": {
-                "app-id": "Your_app_id",
-                "references_quote": "参考资料来自:",
-                "biz_params": {  
-                    "city": "北京",
-                    "date": "2023-08-10"
-                }
-            }
-        }
-
-        await self.ap.provider_cfg.dump_config()

pkg/core/notes/n002_selection_mode_on_windows.py

@@ -1,21 +0,0 @@
-from __future__ import annotations
-
-import typing
-import os
-import sys
-import logging
-
-from .. import note, app
-
-
-@note.note_class("SelectionModeOnWindows", 2)
-class SelectionModeOnWindows(note.LaunchNote):
-    """Windows 上的选择模式提示信息
-    """
-
-    async def need_show(self) -> bool:
-        return os.name == 'nt'
-
-    async def yield_note(self) -> typing.AsyncGenerator[typing.Tuple[str, int], None]:
-
-        yield """您正在使用 Windows 系统，若窗口左上角显示处于”选择“模式，程序将被暂停运行，此时请右键窗口中空白区域退出选择模式。""", logging.INFO

pkg/core/stages/build_app.py

@@ -1,127 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-from .. import stage, app
-from ...utils import version, proxy, announce, platform
-from ...audit.center import v2 as center_v2
-from ...audit import identifier
-from ...pipeline import pool, controller, stagemgr
-from ...plugin import manager as plugin_mgr
-from ...command import cmdmgr
-from ...provider.session import sessionmgr as llm_session_mgr
-from ...provider.modelmgr import modelmgr as llm_model_mgr
-from ...provider.sysprompt import sysprompt as llm_prompt_mgr
-from ...provider.tools import toolmgr as llm_tool_mgr
-from ...provider import runnermgr
-from ...platform import manager as im_mgr
-from ...persistence import mgr as persistencemgr
-from ...api.http.controller import main as http_controller
-from ...api.http.service import user as user_service
-from ...discover import engine as discover_engine
-from ...utils import logcache
-from .. import taskmgr
-
-
-@stage.stage_class("BuildAppStage")
-class BuildAppStage(stage.BootingStage):
-    """构建应用阶段
-    """
-
-    async def run(self, ap: app.Application):
-        """构建app对象的各个组件对象并初始化
-        """
-        ap.task_mgr = taskmgr.AsyncTaskManager(ap)
-
-        discover = discover_engine.ComponentDiscoveryEngine(ap)
-        discover.discover_blueprint(
-            "components.yaml"
-        )
-        ap.discover = discover
-
-        proxy_mgr = proxy.ProxyManager(ap)
-        await proxy_mgr.initialize()
-        ap.proxy_mgr = proxy_mgr
-        
-        ver_mgr = version.VersionManager(ap)
-        await ver_mgr.initialize()
-        ap.ver_mgr = ver_mgr
-
-        center_v2_api = center_v2.V2CenterAPI(
-            ap,
-            backend_url=ap.system_cfg.data["qcg-center-url"],
-            basic_info={
-                "host_id": identifier.identifier["host_id"],
-                "instance_id": identifier.identifier["instance_id"],
-                "semantic_version": ver_mgr.get_current_version(),
-                "platform": platform.get_platform(),
-            },
-            runtime_info={
-                "admin_id": "{}".format(ap.system_cfg.data["admin-sessions"]),
-                "msg_source": str([
-                    adapter_cfg['adapter'] if 'adapter' in adapter_cfg else 'unknown'
-                    for adapter_cfg in ap.platform_cfg.data['platform-adapters'] if adapter_cfg['enable']
-                ]),
-            },
-        )
-        ap.ctr_mgr = center_v2_api
-
-        # 发送公告
-        ann_mgr = announce.AnnouncementManager(ap)
-        ap.ann_mgr = ann_mgr
-
-        ap.query_pool = pool.QueryPool()
-
-        log_cache = logcache.LogCache()
-        ap.log_cache = log_cache
-
-        persistence_mgr_inst = persistencemgr.PersistenceManager(ap)
-        await persistence_mgr_inst.initialize()
-        ap.persistence_mgr = persistence_mgr_inst
-
-        plugin_mgr_inst = plugin_mgr.PluginManager(ap)
-        await plugin_mgr_inst.initialize()
-        ap.plugin_mgr = plugin_mgr_inst
-        await plugin_mgr_inst.load_plugins()
-
-        cmd_mgr_inst = cmdmgr.CommandManager(ap)
-        await cmd_mgr_inst.initialize()
-        ap.cmd_mgr = cmd_mgr_inst
-
-        llm_model_mgr_inst = llm_model_mgr.ModelManager(ap)
-        await llm_model_mgr_inst.initialize()
-        ap.model_mgr = llm_model_mgr_inst
-
-        llm_session_mgr_inst = llm_session_mgr.SessionManager(ap)
-        await llm_session_mgr_inst.initialize()
-        ap.sess_mgr = llm_session_mgr_inst
-
-        llm_prompt_mgr_inst = llm_prompt_mgr.PromptManager(ap)
-        await llm_prompt_mgr_inst.initialize()
-        ap.prompt_mgr = llm_prompt_mgr_inst
-
-        llm_tool_mgr_inst = llm_tool_mgr.ToolManager(ap)
-        await llm_tool_mgr_inst.initialize()
-        ap.tool_mgr = llm_tool_mgr_inst
-
-        runner_mgr_inst = runnermgr.RunnerManager(ap)
-        await runner_mgr_inst.initialize()
-        ap.runner_mgr = runner_mgr_inst
-
-        im_mgr_inst = im_mgr.PlatformManager(ap=ap)
-        await im_mgr_inst.initialize()
-        ap.platform_mgr = im_mgr_inst
-
-        stage_mgr = stagemgr.StageManager(ap)
-        await stage_mgr.initialize()
-        ap.stage_mgr = stage_mgr
-
-        http_ctrl = http_controller.HTTPController(ap)
-        await http_ctrl.initialize()
-        ap.http_ctrl = http_ctrl
-
-        user_service_inst = user_service.UserService(ap)
-        ap.user_service = user_service_inst
-
-        ctrl = controller.Controller(ap)
-        ap.ctrl = ctrl

pkg/core/stages/load_config.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import secrets
-
-from .. import stage, app
-from ..bootutils import config
-from ...config import settings as settings_mgr
-from ...utils import schema
-
-
-@stage.stage_class("LoadConfigStage")
-class LoadConfigStage(stage.BootingStage):
-    """加载配置文件阶段
-    """
-
-    async def run(self, ap: app.Application):
-        """启动
-        """
-        
-        ap.settings_mgr = settings_mgr.SettingsManager(ap)
-        await ap.settings_mgr.initialize()
-
-        ap.command_cfg = await config.load_json_config("data/config/command.json", "templates/command.json", completion=False)
-        ap.pipeline_cfg = await config.load_json_config("data/config/pipeline.json", "templates/pipeline.json", completion=False)
-        ap.platform_cfg = await config.load_json_config("data/config/platform.json", "templates/platform.json", completion=False)
-        ap.provider_cfg = await config.load_json_config("data/config/provider.json", "templates/provider.json", completion=False)
-        ap.system_cfg = await config.load_json_config("data/config/system.json", "templates/system.json", completion=False)
-
-        ap.settings_mgr.register_manager(
-            name="command.json",
-            description="命令配置",
-            manager=ap.command_cfg,
-            schema=schema.CONFIG_COMMAND_SCHEMA,
-            doc_link="https://docs.langbot.app/config/function/command.html"
-        )
-
-        ap.settings_mgr.register_manager(
-            name="pipeline.json",
-            description="消息处理流水线配置",
-            manager=ap.pipeline_cfg,
-            schema=schema.CONFIG_PIPELINE_SCHEMA,
-            doc_link="https://docs.langbot.app/config/function/pipeline.html"
-        )
-
-        ap.settings_mgr.register_manager(
-            name="platform.json",
-            description="消息平台配置",
-            manager=ap.platform_cfg,
-            schema=schema.CONFIG_PLATFORM_SCHEMA,
-            doc_link="https://docs.langbot.app/config/function/platform.html"
-        )
-
-        ap.settings_mgr.register_manager(
-            name="provider.json",
-            description="大模型能力配置",
-            manager=ap.provider_cfg,
-            schema=schema.CONFIG_PROVIDER_SCHEMA,
-            doc_link="https://docs.langbot.app/config/function/provider.html"
-        )
-
-        ap.settings_mgr.register_manager(
-            name="system.json",
-            description="系统配置",
-            manager=ap.system_cfg,
-            schema=schema.CONFIG_SYSTEM_SCHEMA,
-            doc_link="https://docs.langbot.app/config/function/system.html"
-        )
-
-        ap.plugin_setting_meta = await config.load_json_config("plugins/plugins.json", "templates/plugin-settings.json")
-        await ap.plugin_setting_meta.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.adapter_qq_botpy_meta = await config.load_json_config("data/metadata/adapter-qq-botpy.json", "templates/metadata/adapter-qq-botpy.json")
-        await ap.adapter_qq_botpy_meta.dump_config()
-
-        ap.llm_models_meta = await config.load_json_config("data/metadata/llm-models.json", "templates/metadata/llm-models.json")
-        await ap.llm_models_meta.dump_config()
-
-        ap.instance_secret_meta = await config.load_json_config("data/metadata/instance-secret.json", template_data={
-            'jwt_secret': secrets.token_hex(16)
-        })
-        await ap.instance_secret_meta.dump_config()

pkg/core/stages/migrate.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-import importlib
-
-from .. import stage, app
-from .. import migration
-from ..migrations import m001_sensitive_word_migration, m002_openai_config_migration, m003_anthropic_requester_cfg_completion, m004_moonshot_cfg_completion
-from ..migrations import m005_deepseek_cfg_completion, m006_vision_config, m007_qcg_center_url, m008_ad_fixwin_config_migrate, m009_msg_truncator_cfg
-from ..migrations import m010_ollama_requester_config, m011_command_prefix_config, m012_runner_config, m013_http_api_config, m014_force_delay_config
-from ..migrations import m015_gitee_ai_config, m016_dify_service_api, m017_dify_api_timeout_params, m018_xai_config, m019_zhipuai_config
-from ..migrations import m020_wecom_config, m021_lark_config, m022_lmstudio_config, m023_siliconflow_config, m024_discord_config, m025_gewechat_config
-from ..migrations import m026_qqofficial_config, m027_wx_official_account_config, m028_aliyun_requester_config
-from ..migrations import m029_dashscope_app_api_config, m030_lark_config_cmpl, m031_dingtalk_config, m032_volcark_config
-from ..migrations import m033_dify_thinking_config, m034_gewechat_file_url_config, m035_wxoa_mode, m036_wxoa_loading_message
-from ..migrations import m037_mcp_config, m038_tg_dingtalk_markdown
-
-
-@stage.stage_class("MigrationStage")
-class MigrationStage(stage.BootingStage):
-    """迁移阶段
-    """
-
-    async def run(self, ap: app.Application):
-        """启动
-        """
-
-        migrations = migration.preregistered_migrations
-
-        # 按照迁移号排序
-        migrations.sort(key=lambda x: x.number)
-
-        for migration_cls in migrations:
-            migration_instance = migration_cls(ap)
-
-            if await migration_instance.need_migrate():
-                await migration_instance.run()
-                print(f'已执行迁移 {migration_instance.name}')

pkg/core/stages/show_notes.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from .. import stage, app, note
-from ..notes import n001_classic_msgs, n002_selection_mode_on_windows, n003_print_version
-
-
-@stage.stage_class("ShowNotesStage")
-class ShowNotesStage(stage.BootingStage):
-    """显示启动信息阶段
-    """
-
-    async def run(self, ap: app.Application):
-
-        # 排序
-        note.preregistered_notes.sort(key=lambda x: x.number)
-
-        for note_cls in note.preregistered_notes:
-            try:
-                note_inst = note_cls(ap)
-                if await note_inst.need_show():
-                    async for ret in note_inst.yield_note():
-                        if not ret:
-                            continue
-                        msg, level = ret
-                        if msg:
-                            ap.logger.log(level, msg)
-            except Exception as e:
-                continue

pkg/discover/engine.py

@@ -1,200 +0,0 @@
-from __future__ import annotations
-
-import typing
-import importlib
-import os
-import inspect
-
-import yaml
-import pydantic
-
-from ..core import app
-
-
-class I18nString(pydantic.BaseModel):
-    """国际化字符串"""
-
-    en_US: str
-    """英文"""
-
-    zh_CN: typing.Optional[str] = None
-    """中文"""
-
-    ja_JP: typing.Optional[str] = None
-    """日文"""
-
-
-class Metadata(pydantic.BaseModel):
-    """元数据"""
-
-    name: str
-    """名称"""
-
-    label: I18nString
-    """标签"""
-
-    description: typing.Optional[I18nString] = None
-    """描述"""
-
-    icon: typing.Optional[str] = None
-    """图标"""
-
-
-class PythonExecution(pydantic.BaseModel):
-    """Python执行"""
-
-    path: str
-    """路径"""
-
-    attr: str
-    """属性"""
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        if self.path.startswith('./'):
-            self.path = self.path[2:]
-
-
-class Execution(pydantic.BaseModel):
-    """执行"""
-
-    python: PythonExecution
-    """Python执行"""
-
-
-class Component(pydantic.BaseModel):
-    """组件清单"""
-
-    owner: str
-    """组件所属"""
-
-    manifest: typing.Dict[str, typing.Any]
-    """组件清单内容"""
-
-    rel_path: str
-    """组件清单相对main.py的路径"""
-
-    _metadata: Metadata
-    """组件元数据"""
-
-    _spec: typing.Dict[str, typing.Any]
-    """组件规格"""
-
-    _execution: Execution
-    """组件执行"""
-
-    def __init__(self, owner: str, manifest: typing.Dict[str, typing.Any], rel_path: str):
-        super().__init__(
-            owner=owner,
-            manifest=manifest,
-            rel_path=rel_path
-        )
-        self._metadata = Metadata(**manifest['metadata'])
-        self._spec = manifest['spec']
-        self._execution = Execution(**manifest['execution']) if 'execution' in manifest else None
-
-    @property
-    def kind(self) -> str:
-        """组件类型"""
-        return self.manifest['kind']
-    
-    @property
-    def metadata(self) -> Metadata:
-        """组件元数据"""
-        return self._metadata
-    
-    @property
-    def spec(self) -> typing.Dict[str, typing.Any]:
-        """组件规格"""
-        return self._spec
-    
-    @property
-    def execution(self) -> Execution:
-        """组件执行"""
-        return self._execution
-    
-    def get_python_component_class(self) -> typing.Type[typing.Any]:
-        """获取Python组件类"""
-        parent_path = os.path.dirname(self.rel_path)
-        module_path = os.path.join(parent_path, self.execution.python.path)
-        if module_path.endswith('.py'):
-            module_path = module_path[:-3]
-        module_path = module_path.replace('/', '.').replace('\\', '.')
-        module = importlib.import_module(module_path)
-        return getattr(module, self.execution.python.attr)
-
-
-class ComponentDiscoveryEngine:
-    """组件发现引擎"""
-
-    ap: app.Application
-    """应用实例"""
-
-    components: typing.Dict[str, typing.List[Component]] = {}
-    """组件列表"""
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-
-    def load_component_manifest(self, path: str, owner: str = 'builtin', no_save: bool = False) -> Component:
-        """加载组件清单"""
-        with open(path, 'r', encoding='utf-8') as f:
-            manifest = yaml.safe_load(f)
-            comp = Component(
-                owner=owner,
-                manifest=manifest,
-                rel_path=path
-            )
-            if not no_save:
-                if comp.kind not in self.components:
-                    self.components[comp.kind] = []
-                self.components[comp.kind].append(comp)
-            return comp
-        
-    def load_component_manifests_in_dir(self, path: str, owner: str = 'builtin', no_save: bool = False) -> typing.List[Component]:
-        """加载目录中的组件清单"""
-        components: typing.List[Component] = []
-        for file in os.listdir(path):
-            if file.endswith('.yaml') or file.endswith('.yml'):
-                components.append(self.load_component_manifest(os.path.join(path, file), owner, no_save))
-        return components
-    
-    def load_blueprint_comp_group(self, group: dict, owner: str = 'builtin', no_save: bool = False) -> typing.List[Component]:
-        """加载蓝图组件组"""
-        components: typing.List[Component] = []
-        if 'fromFiles' in group:
-            for file in group['fromFiles']:
-                components.append(self.load_component_manifest(file, owner, no_save))
-        if 'fromDirs' in group:
-            for dir in group['fromDirs']:
-                path = dir['path']
-                # depth = dir['depth']
-                components.extend(self.load_component_manifests_in_dir(path, owner, no_save))
-        return components
-
-    def discover_blueprint(self, blueprint_manifest_path: str, owner: str = 'builtin'):
-        """发现蓝图"""
-        blueprint_manifest = self.load_component_manifest(blueprint_manifest_path, owner, no_save=True)
-        assert blueprint_manifest.kind == 'Blueprint', '`Kind` must be `Blueprint`'
-        components: typing.Dict[str, typing.List[Component]] = {}
-
-        # load ComponentTemplate first
-        if 'ComponentTemplate' in blueprint_manifest.spec['components']:
-            components['ComponentTemplate'] = self.load_blueprint_comp_group(blueprint_manifest.spec['components']['ComponentTemplate'], owner)
-
-        for name, component in blueprint_manifest.spec['components'].items():
-            if name == 'ComponentTemplate':
-                continue
-            components[name] = self.load_blueprint_comp_group(component, owner)
-        
-        self.ap.logger.debug(f'Components: {components}')
-
-        return blueprint_manifest, components
-
-
-    def get_components_by_kind(self, kind: str) -> typing.List[Component]:
-        """获取指定类型的组件"""
-        if kind not in self.components:
-            raise ValueError(f'No components found for kind: {kind}')
-        return self.components[kind]

pkg/persistence/databases/sqlite.py

@@ -1,13 +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:
-        self.engine = sqlalchemy_asyncio.create_async_engine(f"sqlite+aiosqlite:///{self.ap.system_cfg.data['persistence']['sqlite']['path']}")

pkg/persistence/mgr.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import datetime
-
-import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
-import sqlalchemy
-
-from . import database
-from .entities import user, base
-from ..core import app
-from .databases import sqlite
-
-
-class PersistenceManager:
-    """持久化模块管理器"""
-
-    ap: app.Application
-
-    db: database.BaseDatabaseManager
-    """数据库管理器"""
-
-    meta: sqlalchemy.MetaData
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-        self.meta = base.Base.metadata
-
-    async def initialize(self):
-        
-        for manager in database.preregistered_managers:
-            self.db = manager(self.ap)
-            await self.db.initialize()
-
-        await self.create_tables()
-
-    async def create_tables(self):
-        # TODO: 对扩展友好
-        
-        # 日志
-        async with self.get_db_engine().connect() as conn:
-            await conn.run_sync(self.meta.create_all)
-
-            await conn.commit()
-
-    async def execute_async(
-        self,
-        *args,
-        **kwargs
-    ) -> sqlalchemy.engine.cursor.CursorResult:
-        async with self.get_db_engine().connect() as conn:
-            result = await conn.execute(*args, **kwargs)
-            await conn.commit()
-            return result
-
-    def get_db_engine(self) -> sqlalchemy_asyncio.AsyncEngine:
-        return self.db.get_engine()

pkg/pipeline/bansess/bansess.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-import re
-
-from .. import stage, entities, stagemgr
-from ...core import entities as core_entities
-from ...config import manager as cfg_mgr
-
-
-@stage.stage_class('BanSessionCheckStage')
-class BanSessionCheckStage(stage.PipelineStage):
-    """访问控制处理阶段
-    
-    仅检查query中群号或个人号是否在访问控制列表中。
-    """
-
-    async def initialize(self):
-        pass
-
-    async def process(
-        self,
-        query: core_entities.Query,
-        stage_inst_name: str
-    ) -> entities.StageProcessResult:
-        
-        found = False
-
-        mode = self.ap.pipeline_cfg.data['access-control']['mode']
-
-        sess_list = self.ap.pipeline_cfg.data['access-control'][mode]
-
-        if (query.launcher_type.value == 'group' and 'group_*' in sess_list) \
-            or (query.launcher_type.value == 'person' and 'person_*' in sess_list):
-            found = True
-        else:
-            for sess in sess_list:
-                if sess == f"{query.launcher_type.value}_{query.launcher_id}":
-                    found = True
-                    break
-            
-        ctn = False
-
-        if mode == 'whitelist':
-            ctn = found
-        else:
-            ctn = not found
-
-        return entities.StageProcessResult(
-            result_type=entities.ResultType.CONTINUE if ctn else entities.ResultType.INTERRUPT,
-            new_query=query,
-            console_notice=f'根据访问控制忽略消息: {query.launcher_type.value}_{query.launcher_id}' if not ctn else ''
-        )

pkg/pipeline/cntfilter/filter.py

@@ -1,80 +0,0 @@
-# 内容过滤器的抽象类
-from __future__ import annotations
-import abc
-import typing
-
-from ...core import app
-from . import entities
-from ...provider import entities as llm_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, 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/controller.py

@@ -1,197 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import typing
-import traceback
-
-from ..core import app, entities
-from . import entities as pipeline_entities
-from ..plugin import events
-from ..platform.types import message as platform_message
-
-
-class Controller:
-    """总控制器
-    """
-    ap: app.Application
-
-    semaphore: asyncio.Semaphore = None
-    """请求并发控制信号量"""
-
-    def __init__(self, ap: app.Application):
-        self.ap = ap
-        self.semaphore = asyncio.Semaphore(self.ap.system_cfg.data['pipeline-concurrency'])
-
-    async def consumer(self):
-        """事件处理循环
-        """
-        try:
-            while True:
-                selected_query: entities.Query = None
-
-                # 取请求
-                async with self.ap.query_pool:
-                    queries: list[entities.Query] = self.ap.query_pool.queries
-
-                    for query in queries:
-                        session = await self.ap.sess_mgr.get_session(query)
-                        self.ap.logger.debug(f"Checking query {query} session {session}")
-
-                        if not session.semaphore.locked():
-                            selected_query = query
-                            await session.semaphore.acquire()
-
-                            break
-
-                    if selected_query:  # 找到了
-                        queries.remove(selected_query)
-                    else:  # 没找到 说明：没有请求 或者 所有query对应的session都已达到并发上限
-                        await self.ap.query_pool.condition.wait()
-                        continue
-
-                if selected_query:
-                    async def _process_query(selected_query):
-                        async with self.semaphore:  # 总并发上限
-                            await self.process_query(selected_query)
-                        
-                        async with self.ap.query_pool:
-                            (await self.ap.sess_mgr.get_session(selected_query)).semaphore.release()
-                            # 通知其他协程，有新的请求可以处理了
-                            self.ap.query_pool.condition.notify_all()
-                    self.ap.task_mgr.create_task(
-                        _process_query(selected_query),
-                        kind="query",
-                        name=f"query-{selected_query.query_id}",
-                        scopes=[entities.LifecycleControlScope.APPLICATION, entities.LifecycleControlScope.PLATFORM],
-                    )
-
-        except Exception as e:
-            # traceback.print_exc()
-            self.ap.logger.error(f"控制器循环出错: {e}")
-            self.ap.logger.error(f"Traceback: {traceback.format_exc()}")
-
-    async def _check_output(self, query: entities.Query, result: pipeline_entities.StageProcessResult):
-        """检查输出
-        """
-        if result.user_notice:
-            # 处理str类型
-
-            if isinstance(result.user_notice, str):
-                result.user_notice = platform_message.MessageChain(
-                    platform_message.Plain(result.user_notice)
-                )
-            elif isinstance(result.user_notice, list):
-                result.user_notice = platform_message.MessageChain(
-                    *result.user_notice
-                )
-
-            await self.ap.platform_mgr.send(
-                query.message_event,
-                result.user_notice,
-                query.adapter
-            )
-        if result.debug_notice:
-            self.ap.logger.debug(result.debug_notice)
-        if result.console_notice:
-            self.ap.logger.info(result.console_notice)
-        if result.error_notice:
-            self.ap.logger.error(result.error_notice)
-
-    async def _execute_from_stage(
-        self,
-        stage_index: int,
-        query: entities.Query,
-    ):
-        """从指定阶段开始执行，实现了责任链模式和基于生成器的阶段分叉功能。
-
-        如何看懂这里为什么这么写？
-        去问 GPT-4:
-            Q1: 现在有一个责任链，其中有多个stage，query对象在其中传递，stage.process可能返回Result也有可能返回typing.AsyncGenerator[Result, None]，
-                如果返回的是生成器，需要挨个生成result，检查是否result中是否要求继续，如果要求继续就进行下一个stage。如果此次生成器产生的result处理完了，就继续生成下一个result，
-                调用后续的stage，直到该生成器全部生成完。责任链中可能有多个stage会返回生成器
-            Q2: 不是这样的，你可能理解有误。如果我们责任链上有这些Stage：
-
-                A B C D E F G
-
-                如果所有的stage都返回Result，且所有Result都要求继续，那么执行顺序是：
-
-                A B C D E F G
-
-                现在假设C返回的是AsyncGenerator，那么执行顺序是：
-
-                A B C D E F G C D E F G C D E F G ...
-            Q3: 但是如果不止一个stage会返回生成器呢？
-        """
-        i = stage_index
-
-        while i < len(self.ap.stage_mgr.stage_containers):
-            stage_container = self.ap.stage_mgr.stage_containers[i]
-
-            query.current_stage = stage_container  # 标记到 Query 对象里
-            
-            result = stage_container.inst.process(query, stage_container.inst_name)
-
-            if isinstance(result, typing.Coroutine):
-                result = await result
-
-            if isinstance(result, pipeline_entities.StageProcessResult):  # 直接返回结果
-                self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} res {result}")
-                await self._check_output(query, result)
-
-                if result.result_type == pipeline_entities.ResultType.INTERRUPT:
-                    self.ap.logger.debug(f"Stage {stage_container.inst_name} interrupted query {query}")
-                    break
-                elif result.result_type == pipeline_entities.ResultType.CONTINUE:
-                    query = result.new_query
-            elif isinstance(result, typing.AsyncGenerator):  # 生成器
-                self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} gen")
-
-                async for sub_result in result:
-                    self.ap.logger.debug(f"Stage {stage_container.inst_name} processed query {query} res {sub_result}")
-                    await self._check_output(query, sub_result)
-
-                    if sub_result.result_type == pipeline_entities.ResultType.INTERRUPT:
-                        self.ap.logger.debug(f"Stage {stage_container.inst_name} interrupted query {query}")
-                        break
-                    elif sub_result.result_type == pipeline_entities.ResultType.CONTINUE:
-                        query = sub_result.new_query
-                        await self._execute_from_stage(i + 1, query)
-                break
-
-            i += 1
-
-    async def process_query(self, query: entities.Query):
-        """处理请求
-        """
-        try:
-
-            # ======== 触发 MessageReceived 事件 ========
-            event_type = events.PersonMessageReceived if query.launcher_type == entities.LauncherTypes.PERSON else events.GroupMessageReceived
-
-            event_ctx = await self.ap.plugin_mgr.emit_event(
-                event=event_type(
-                    launcher_type=query.launcher_type.value,
-                    launcher_id=query.launcher_id,
-                    sender_id=query.sender_id,
-                    message_chain=query.message_chain,
-                    query=query
-                )
-            )
-
-            if event_ctx.is_prevented_default():
-                return
-            
-            self.ap.logger.debug(f"Processing query {query}")
-
-            await self._execute_from_stage(0, query)
-        except Exception as e:
-            inst_name = query.current_stage.inst_name if query.current_stage else 'unknown'
-            self.ap.logger.error(f"处理请求时出错 query_id={query.query_id} stage={inst_name} : {e}")
-            self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
-        finally:
-            self.ap.logger.debug(f"Query {query} processed")
-
-    async def run(self):
-        """运行控制器
-        """
-        await self.consumer()

pkg/pipeline/longtext/longtext.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-import os
-import traceback
-
-from PIL import Image, ImageDraw, ImageFont
-
-from ...core import app
-from . import strategy
-from .strategies import image, forward
-from .. import stage, entities, stagemgr
-from ...core import entities as core_entities
-from ...config import manager as cfg_mgr
-from ...platform.types import message as platform_message
-
-
-@stage.stage_class("LongTextProcessStage")
-class LongTextProcessStage(stage.PipelineStage):
-    """长消息处理阶段
-
-    改写：
-        - resp_message_chain
-    """
-
-    strategy_impl: strategy.LongTextStrategy
-
-    async def initialize(self):
-        config = self.ap.platform_cfg.data['long-text-process']
-        if config['strategy'] == 'image':
-            use_font = config['font-path']
-            try:
-                # 检查是否存在
-                if not os.path.exists(use_font):
-                    # 若是windows系统，使用微软雅黑
-                    if os.name == "nt":
-                        use_font = "C:/Windows/Fonts/msyh.ttc"
-                        if not os.path.exists(use_font):
-                            self.ap.logger.warn("未找到字体文件，且无法使用Windows自带字体，更换为转发消息组件以发送长消息，您可以在配置文件中调整相关设置。")
-                            config['blob_message_strategy'] = "forward"
-                        else:
-                            self.ap.logger.info("使用Windows自带字体：" + use_font)
-                            config['font-path'] = use_font
-                    else:
-                        self.ap.logger.warn("未找到字体文件，且无法使用系统自带字体，更换为转发消息组件以发送长消息，您可以在配置文件中调整相关设置。")
-
-                        self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
-            except:
-                traceback.print_exc()
-                self.ap.logger.error("加载字体文件失败({})，更换为转发消息组件以发送长消息，您可以在配置文件中调整相关设置。".format(use_font))
-
-                self.ap.platform_cfg.data['long-text-process']['strategy'] = "forward"
-
-        for strategy_cls in strategy.preregistered_strategies:
-            if strategy_cls.name == config['strategy']:
-                self.strategy_impl = strategy_cls(self.ap)
-                break
-        else:
-            raise ValueError(f"未找到名为 {config['strategy']} 的长消息处理策略")
-
-        await self.strategy_impl.initialize()
-    
-    async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
-        # 检查是否包含非 Plain 组件
-        contains_non_plain = False
-
-        for msg in query.resp_message_chain[-1]:
-            if not isinstance(msg, platform_message.Plain):
-                contains_non_plain = True
-                break
-        
-        if contains_non_plain:
-            self.ap.logger.debug("消息中包含非 Plain 组件，跳过长消息处理。")
-        elif len(str(query.resp_message_chain[-1])) > self.ap.platform_cfg.data['long-text-process']['threshold']:
-            query.resp_message_chain[-1] = platform_message.MessageChain(await self.strategy_impl.process(str(query.resp_message_chain[-1]), query))
-
-        return entities.StageProcessResult(
-            result_type=entities.ResultType.CONTINUE,
-            new_query=query
-        )

pkg/pipeline/longtext/strategies/forward.py

@@ -1,41 +0,0 @@
-# 转发消息组件
-from __future__ import annotations
-import typing
-
-import pydantic.v1 as pydantic
-
-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/msgtrun/msgtrun.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from .. import stage, entities, stagemgr
-from ...core import entities as core_entities
-from . import truncator
-from .truncators import round
-
-
-@stage.stage_class("ConversationMessageTruncator")
-class ConversationMessageTruncator(stage.PipelineStage):
-    """会话消息截断器
-
-    用于截断会话消息链，以适应平台消息长度限制。
-    """
-    trun: truncator.Truncator
-
-    async def initialize(self):
-        use_method = self.ap.pipeline_cfg.data['msg-truncate']['method']
-
-        for trun in truncator.preregistered_truncators:
-            if trun.name == use_method:
-                self.trun = trun(self.ap)
-                break
-        else:
-            raise ValueError(f"未知的截断器: {use_method}")
-
-    async def process(self, query: core_entities.Query, stage_inst_name: str) -> entities.StageProcessResult:
-        """处理
-        """
-        query = await self.trun.truncate(query)
-
-        return entities.StageProcessResult(
-            result_type=entities.ResultType.CONTINUE,
-            new_query=query
-        )

pkg/pipeline/preproc/preproc.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-import datetime
-
-from .. import stage, entities, stagemgr
-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:
-        """处理
-        """
-        session = await self.ap.sess_mgr.get_session(query)
-
-        conversation = await self.ap.sess_mgr.get_conversation(session)
-
-        # 设置query
-        query.session = session
-        query.prompt = conversation.prompt.copy()
-        query.messages = conversation.messages.copy()
-
-        query.use_model = conversation.use_model
-
-        query.use_funcs = conversation.use_funcs if query.use_model.tool_call_supported 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()),
-        }
-
-        # 检查vision是否启用，没启用就删除所有图片
-        if not self.ap.provider_cfg.data['enable-vision'] or (self.ap.provider_cfg.data['runner'] == 'local-agent' and not query.use_model.vision_supported):
-            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 = ""
-
-        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 self.ap.provider_cfg.data['enable-vision'] and (self.ap.provider_cfg.data['runner'] != 'local-agent' or query.use_model.vision_supported):
-                    if me.base64 is not None:
-                        content_list.append(
-                            llm_entities.ContentElement.from_image_base64(me.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
-        )