chore: bump version 4.4.0

* fix: mcp session cannot be enabled

* fix: error message

* perf: ui

* perf: ui

---------

Co-authored-by: Junyan Qin <rockchinq@gmail.com>

.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

.gitignore

@@ -22,7 +22,7 @@ tips.py
 venv*
 bin/
 .vscode
-test_*
+/test_*
 venv/
 hugchat.json
 qcapi
@@ -43,4 +43,7 @@ test.py
 /web_ui
 .venv/
 uv.lock
-/test
+/test
+plugins.bak
+coverage.xml
+.coverage

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

@@ -35,7 +35,7 @@ LangBot 是一个开源的大语言模型原生即时通信机器人开发平台
 
 ```bash
 git clone https://github.com/langbot-app/LangBot
-cd LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -89,6 +89,7 @@ docker compose up -d
 | QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
 | 企微对外客服 | ✅ |  |
+| 企微智能机器人 | ✅ |  |
 | 个人微信 | ✅ |  |
 | 微信公众号 | ✅ |  |
 | 飞书 | ✅ |  |
@@ -96,6 +97,7 @@ docker compose up -d
 | Discord | ✅ |  |
 | Telegram | ✅ |  |
 | Slack | ✅ |  |
+| LINE | ✅ |  |
 
 ### 大模型能力
 
@@ -107,9 +109,9 @@ docker compose up -d
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
+| [胜算云](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | 全球大模型都可调用（友情推荐） |
 | [优云智算](https://www.compshare.cn/?ytag=GPU_YY-gh_langbot) | ✅ | 大模型和 GPU 资源平台 |
 | [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 资源平台 |
-| [胜算云](https://www.shengsuanyun.com/?from=CH_KYIPP758) | ✅ | 大模型和 GPU 资源平台 |
 | [302.AI](https://share.302.ai/SuTG99) | ✅ | 大模型聚合平台 |
 | [Google Gemini](https://aistudio.google.com/prompts/new_chat) | ✅ | |
 | [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
@@ -117,10 +119,12 @@ docker compose up -d
 | [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
 

README_EN.md

@@ -29,7 +29,7 @@ LangBot is an open-source LLM native instant messaging robot development platfor
 
 ```bash
 git clone https://github.com/langbot-app/LangBot
-cd LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -79,16 +79,18 @@ Or visit the demo environment: https://demo.langbot.dev/
 
 | Platform | Status | Remarks |
 | --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
 | Personal QQ | ✅ |  |
 | QQ Official API | ✅ |  |
 | WeCom | ✅ |  |
 | WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
 | Personal WeChat | ✅ |  |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
-| Discord | ✅ |  |
-| Telegram | ✅ |  |
-| Slack | ✅ |  |
 
 ### LLMs
 

README_JP.md

@@ -29,7 +29,7 @@ LangBot は、エージェント、RAG、MCP などの LLM アプリケーショ
 
 ```bash
 git clone https://github.com/langbot-app/LangBot
-cd LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -79,16 +79,18 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 
 | プラットフォーム | ステータス | 備考 |
 | --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
 | 個人QQ | ✅ |  |
 | QQ公式API | ✅ |  |
 | WeCom | ✅ |  |
 | WeComCS | ✅ |  |
+| WeCom AI Bot | ✅ |  |
 | 個人WeChat | ✅ | |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
-| Discord | ✅ |  |
-| Telegram | ✅ |  |
-| Slack | ✅ |  |
 
 ### LLMs
 

README_TW.md

@@ -31,7 +31,7 @@ LangBot 是一個開源的大語言模型原生即時通訊機器人開發平台
 
 ```bash
 git clone https://github.com/langbot-app/LangBot
-cd LangBot
+cd LangBot/docker
 docker compose up -d
 ```
 
@@ -81,16 +81,18 @@ docker compose up -d
 
 | 平台 | 狀態 | 備註 |
 | --- | --- | --- |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | ✅ |  |
 | QQ 個人號 | ✅ | QQ 個人號私聊、群聊 |
 | QQ 官方機器人 | ✅ | QQ 官方機器人，支援頻道、私聊、群聊 |
 | 微信 | ✅ |  |
 | 企微對外客服 | ✅ |  |
+| 企微智能機器人 | ✅ |  |
 | 微信公眾號 | ✅ |  |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
-| Discord | ✅ |  |
-| Telegram | ✅ |  |
-| Slack | ✅ |  |
 
 ### 大模型能力
 

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.

codecov.yml

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

libs/coze_server_api/client.py

@@ -0,0 +1,192 @@
+import json
+import asyncio
+import aiohttp
+import io
+from typing import Dict, List, Any, AsyncGenerator
+import os
+from pathlib import Path
+
+
+
+
+class AsyncCozeAPIClient:
+    def __init__(self, api_key: str, api_base: str = "https://api.coze.cn"):
+        self.api_key = api_key
+        self.api_base = api_base
+        self.session = None
+
+    async def __aenter__(self):
+        """支持异步上下文管理器"""
+        await self.coze_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """退出时自动关闭会话"""
+        await self.close()
+
+
+
+    async def coze_session(self):
+        """确保HTTP session存在"""
+        if self.session is None:
+            connector = aiohttp.TCPConnector(
+                ssl=False if self.api_base.startswith("http://") else True,
+                limit=100,
+                limit_per_host=30,
+                keepalive_timeout=30,
+                enable_cleanup_closed=True,
+            )
+            timeout = aiohttp.ClientTimeout(
+                total=120,  # 默认超时时间
+                connect=30,
+                sock_read=120,
+            )
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Accept": "text/event-stream",
+            }
+            self.session = aiohttp.ClientSession(
+                headers=headers, timeout=timeout, connector=connector
+            )
+        return self.session
+
+    async def close(self):
+        """显式关闭会话"""
+        if self.session and not self.session.closed:
+            await self.session.close()
+            self.session = None
+
+    async def upload(
+        self,
+        file,
+    ) -> str:
+        # 处理 Path 对象
+        if isinstance(file, Path):
+            if not file.exists():
+                raise ValueError(f"File not found: {file}")
+            with open(file, "rb") as f:
+                file = f.read()
+
+        # 处理文件路径字符串
+        elif isinstance(file, str):
+            if not os.path.isfile(file):
+                raise ValueError(f"File not found: {file}")
+            with open(file, "rb") as f:
+                file = f.read()
+
+        # 处理文件对象
+        elif hasattr(file, 'read'):
+            file = file.read()
+
+        session = await self.coze_session()
+        url = f"{self.api_base}/v1/files/upload"
+
+        try:
+            file_io = io.BytesIO(file)
+            async with session.post(
+                url,
+                data={
+                    "file": file_io,
+                },
+                timeout=aiohttp.ClientTimeout(total=60),
+            ) as response:
+                if response.status == 401:
+                    raise Exception("Coze API 认证失败，请检查 API Key 是否正确")
+
+                response_text = await response.text()
+
+
+                if response.status != 200:
+                    raise Exception(
+                        f"文件上传失败，状态码: {response.status}, 响应: {response_text}"
+                    )
+                try:
+                    result = await response.json()
+                except json.JSONDecodeError:
+                    raise Exception(f"文件上传响应解析失败: {response_text}")
+
+                if result.get("code") != 0:
+                    raise Exception(f"文件上传失败: {result.get('msg', '未知错误')}")
+
+                file_id = result["data"]["id"]
+                return file_id
+
+        except asyncio.TimeoutError:
+            raise Exception("文件上传超时")
+        except Exception as e:
+            raise Exception(f"文件上传失败: {str(e)}")
+
+
+    async def chat_messages(
+        self,
+        bot_id: str,
+        user_id: str,
+        additional_messages: List[Dict] | None = None,
+        conversation_id: str | None = None,
+        auto_save_history: bool = True,
+        stream: bool = True,
+        timeout: float = 120,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """发送聊天消息并返回流式响应
+
+        Args:
+            bot_id: Bot ID
+            user_id: 用户ID
+            additional_messages: 额外消息列表
+            conversation_id: 会话ID
+            auto_save_history: 是否自动保存历史
+            stream: 是否流式响应
+            timeout: 超时时间
+        """
+        session = await self.coze_session()
+        url = f"{self.api_base}/v3/chat"
+
+        payload = {
+            "bot_id": bot_id,
+            "user_id": user_id,
+            "stream": stream,
+            "auto_save_history": auto_save_history,
+        }
+
+        if additional_messages:
+            payload["additional_messages"] = additional_messages
+
+        params = {}
+        if conversation_id:
+            params["conversation_id"] = conversation_id
+
+
+        try:
+            async with session.post(
+                url,
+                json=payload,
+                params=params,
+                timeout=aiohttp.ClientTimeout(total=timeout),
+            ) as response:
+                if response.status == 401:
+                    raise Exception("Coze API 认证失败，请检查 API Key 是否正确")
+
+                if response.status != 200:
+                    raise Exception(f"Coze API 流式请求失败，状态码: {response.status}")
+
+
+                async for chunk in response.content:
+                    chunk = chunk.decode("utf-8")
+                    if chunk != '\n':
+                        if chunk.startswith("event:"):
+                            chunk_type = chunk.replace("event:", "", 1).strip()
+                        elif chunk.startswith("data:"):
+                            chunk_data = chunk.replace("data:", "", 1).strip()
+                    else:
+                        yield {"event": chunk_type, "data": json.loads(chunk_data)}
+
+        except asyncio.TimeoutError:
+            raise Exception(f"Coze API 流式请求超时 ({timeout}秒)")
+        except Exception as e:
+            raise Exception(f"Coze API 流式请求失败: {str(e)}")
+
+
+
+
+
+

libs/dingtalk_api/api.py

@@ -110,6 +110,24 @@ class DingTalkClient:
             else:
                 raise Exception(f'Error: {response.status_code}, {response.text}')
 
+    async def get_file_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 download_url
+                else:
+                    await self.logger.error(f'failed to get file: {response.json()}')
+            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)
@@ -189,6 +207,17 @@ class DingTalkClient:
                 message_data['Audio'] = await self.get_audio_url(incoming_message.to_dict()['content']['downloadCode'])
 
                 message_data['Type'] = 'audio'
+            elif incoming_message.message_type == 'file':
+                down_list = incoming_message.get_down_list()
+                if len(down_list) >= 2:
+                    message_data['File'] = await self.get_file_url(down_list[0])
+                    message_data['Name'] = down_list[1]
+                else:
+                    if self.logger:
+                        await self.logger.error(f'get_down_list() returned fewer than 2 elements: {down_list}')
+                    message_data['File'] = None
+                    message_data['Name'] = None
+                message_data['Type'] = 'file'
 
             copy_message_data = message_data.copy()
             del copy_message_data['IncomingMessage']

libs/dingtalk_api/dingtalkevent.py

@@ -31,6 +31,15 @@ class DingTalkEvent(dict):
     def audio(self):
         return self.get('Audio', '')
 
+    @property
+    def file(self):
+        return self.get('File', '')
+
+    @property
+    def name(self):
+        return self.get('Name', '')
+
+
     @property
     def conversation(self):
         return self.get('conversation_type', '')

libs/wecom_ai_bot_api/WXBizMsgCrypt3.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+"""对企业微信发送给企业后台的消息加解密示例代码.
+@copyright: Copyright (c) 1998-2014 Tencent Inc.
+
+"""
+
+# ------------------------------------------------------------------------
+import logging
+import base64
+import random
+import hashlib
+import time
+import struct
+from Crypto.Cipher import AES
+import xml.etree.cElementTree as ET
+import socket
+from libs.wecom_ai_bot_api import ierror
+
+
+"""
+Crypto.Cipher包已不再维护，开发者可以通过以下命令下载安装最新版的加解密工具包
+    pip install pycryptodome
+"""
+
+
+class FormatException(Exception):
+    pass
+
+
+def throw_exception(message, exception_class=FormatException):
+    """my define raise exception function"""
+    raise exception_class(message)
+
+
+class SHA1:
+    """计算企业微信的消息签名接口"""
+
+    def getSHA1(self, token, timestamp, nonce, encrypt):
+        """用SHA1算法生成安全签名
+        @param token:  票据
+        @param timestamp: 时间戳
+        @param encrypt: 密文
+        @param nonce: 随机字符串
+        @return: 安全签名
+        """
+        try:
+            sortlist = [token, timestamp, nonce, encrypt]
+            sortlist.sort()
+            sha = hashlib.sha1()
+            sha.update(''.join(sortlist).encode())
+            return ierror.WXBizMsgCrypt_OK, sha.hexdigest()
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ComputeSignature_Error, None
+
+
+class XMLParse:
+    """提供提取消息格式中的密文及生成回复消息格式的接口"""
+
+    # xml消息模板
+    AES_TEXT_RESPONSE_TEMPLATE = """<xml>
+<Encrypt><![CDATA[%(msg_encrypt)s]]></Encrypt>
+<MsgSignature><![CDATA[%(msg_signaturet)s]]></MsgSignature>
+<TimeStamp>%(timestamp)s</TimeStamp>
+<Nonce><![CDATA[%(nonce)s]]></Nonce>
+</xml>"""
+
+    def extract(self, xmltext):
+        """提取出xml数据包中的加密消息
+        @param xmltext: 待提取的xml字符串
+        @return: 提取出的加密消息字符串
+        """
+        try:
+            xml_tree = ET.fromstring(xmltext)
+            encrypt = xml_tree.find('Encrypt')
+            return ierror.WXBizMsgCrypt_OK, encrypt.text
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ParseXml_Error, None
+
+    def generate(self, encrypt, signature, timestamp, nonce):
+        """生成xml消息
+        @param encrypt: 加密后的消息密文
+        @param signature: 安全签名
+        @param timestamp: 时间戳
+        @param nonce: 随机字符串
+        @return: 生成的xml字符串
+        """
+        resp_dict = {
+            'msg_encrypt': encrypt,
+            'msg_signaturet': signature,
+            'timestamp': timestamp,
+            'nonce': nonce,
+        }
+        resp_xml = self.AES_TEXT_RESPONSE_TEMPLATE % resp_dict
+        return resp_xml
+
+
+class PKCS7Encoder:
+    """提供基于PKCS7算法的加解密接口"""
+
+    block_size = 32
+
+    def encode(self, text):
+        """对需要加密的明文进行填充补位
+        @param text: 需要进行填充补位操作的明文
+        @return: 补齐明文字符串
+        """
+        text_length = len(text)
+        # 计算需要填充的位数
+        amount_to_pad = self.block_size - (text_length % self.block_size)
+        if amount_to_pad == 0:
+            amount_to_pad = self.block_size
+        # 获得补位所用的字符
+        pad = chr(amount_to_pad)
+        return text + (pad * amount_to_pad).encode()
+
+    def decode(self, decrypted):
+        """删除解密后明文的补位字符
+        @param decrypted: 解密后的明文
+        @return: 删除补位字符后的明文
+        """
+        pad = ord(decrypted[-1])
+        if pad < 1 or pad > 32:
+            pad = 0
+        return decrypted[:-pad]
+
+
+class Prpcrypt(object):
+    """提供接收和推送给企业微信消息的加解密接口"""
+
+    def __init__(self, key):
+        # self.key = base64.b64decode(key+"=")
+        self.key = key
+        # 设置加解密模式为AES的CBC模式
+        self.mode = AES.MODE_CBC
+
+    def encrypt(self, text, receiveid):
+        """对明文进行加密
+        @param text: 需要加密的明文
+        @return: 加密得到的字符串
+        """
+        # 16位随机字符串添加到明文开头
+        text = text.encode()
+        text = self.get_random_str() + struct.pack('I', socket.htonl(len(text))) + text + receiveid.encode()
+
+        # 使用自定义的填充方式对明文进行补位填充
+        pkcs7 = PKCS7Encoder()
+        text = pkcs7.encode(text)
+        # 加密
+        cryptor = AES.new(self.key, self.mode, self.key[:16])
+        try:
+            ciphertext = cryptor.encrypt(text)
+            # 使用BASE64对加密后的字符串进行编码
+            return ierror.WXBizMsgCrypt_OK, base64.b64encode(ciphertext)
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_EncryptAES_Error, None
+
+    def decrypt(self, text, receiveid):
+        """对解密后的明文进行补位删除
+        @param text: 密文
+        @return: 删除填充补位后的明文
+        """
+        try:
+            cryptor = AES.new(self.key, self.mode, self.key[:16])
+            # 使用BASE64对密文进行解码，然后AES-CBC解密
+            plain_text = cryptor.decrypt(base64.b64decode(text))
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_DecryptAES_Error, None
+        try:
+            pad = plain_text[-1]
+            # 去掉补位字符串
+            # pkcs7 = PKCS7Encoder()
+            # plain_text = pkcs7.encode(plain_text)
+            # 去除16位随机字符串
+            content = plain_text[16:-pad]
+            xml_len = socket.ntohl(struct.unpack('I', content[:4])[0])
+            xml_content = content[4 : xml_len + 4]
+            from_receiveid = content[xml_len + 4 :]
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_IllegalBuffer, None
+
+        if from_receiveid.decode('utf8') != receiveid:
+            return ierror.WXBizMsgCrypt_ValidateCorpid_Error, None
+        return 0, xml_content
+
+    def get_random_str(self):
+        """随机生成16位字符串
+        @return: 16位字符串
+        """
+        return str(random.randint(1000000000000000, 9999999999999999)).encode()
+
+
+class WXBizMsgCrypt(object):
+    # 构造函数
+    def __init__(self, sToken, sEncodingAESKey, sReceiveId):
+        try:
+            self.key = base64.b64decode(sEncodingAESKey + '=')
+            assert len(self.key) == 32
+        except Exception:
+            throw_exception('[error]: EncodingAESKey unvalid !', FormatException)
+            # return ierror.WXBizMsgCrypt_IllegalAesKey,None
+        self.m_sToken = sToken
+        self.m_sReceiveId = sReceiveId
+
+        # 验证URL
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sEchoStr: 随机串，对应URL参数的echostr
+        # @param sReplyEchoStr: 解密之后的echostr，当return返回0时有效
+        # @return：成功0，失败返回对应的错误码
+
+    def VerifyURL(self, sMsgSignature, sTimeStamp, sNonce, sEchoStr):
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, sEchoStr)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, sReplyEchoStr = pc.decrypt(sEchoStr, self.m_sReceiveId)
+        return ret, sReplyEchoStr
+
+    def EncryptMsg(self, sReplyMsg, sNonce, timestamp=None):
+        # 将企业回复用户的消息加密打包
+        # @param sReplyMsg: 企业号待回复用户的消息，xml格式的字符串
+        # @param sTimeStamp: 时间戳，可以自己生成，也可以用URL参数的timestamp,如为None则自动用当前时间
+        # @param sNonce: 随机串，可以自己生成，也可以用URL参数的nonce
+        # sEncryptMsg: 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串,
+        # return：成功0，sEncryptMsg,失败返回对应的错误码None
+        pc = Prpcrypt(self.key)
+        ret, encrypt = pc.encrypt(sReplyMsg, self.m_sReceiveId)
+        encrypt = encrypt.decode('utf8')
+        if ret != 0:
+            return ret, None
+        if timestamp is None:
+            timestamp = str(int(time.time()))
+        # 生成安全签名
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, timestamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        xmlParse = XMLParse()
+        return ret, xmlParse.generate(encrypt, signature, timestamp, sNonce)
+
+    def DecryptMsg(self, sPostData, sMsgSignature, sTimeStamp, sNonce):
+        # 检验消息的真实性，并且获取解密后的明文
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sPostData: 密文，对应POST请求的数据
+        #  xml_content: 解密后的原文，当return返回0时有效
+        # @return: 成功0，失败返回对应的错误码
+        # 验证安全签名
+        xmlParse = XMLParse()
+        ret, encrypt = xmlParse.extract(sPostData)
+        if ret != 0:
+            return ret, None
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, xml_content = pc.decrypt(encrypt, self.m_sReceiveId)
+        return ret, xml_content

libs/wecom_ai_bot_api/api.py

@@ -0,0 +1,578 @@
+import asyncio
+import base64
+import json
+import time
+import traceback
+import uuid
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+from urllib.parse import unquote
+
+import httpx
+from Crypto.Cipher import AES
+from quart import Quart, request, Response, jsonify
+
+from libs.wecom_ai_bot_api import wecombotevent
+from libs.wecom_ai_bot_api.WXBizMsgCrypt3 import WXBizMsgCrypt
+from pkg.platform.logger import EventLogger
+
+
+@dataclass
+class StreamChunk:
+    """描述单次推送给企业微信的流式片段。"""
+
+    # 需要返回给企业微信的文本内容
+    content: str
+
+    # 标记是否为最终片段，对应企业微信协议里的 finish 字段
+    is_final: bool = False
+
+    # 预留额外元信息，未来支持多模态扩展时可使用
+    meta: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class StreamSession:
+    """维护一次企业微信流式会话的上下文。"""
+
+    # 企业微信要求的 stream_id，用于标识后续刷新请求
+    stream_id: str
+
+    # 原始消息的 msgid，便于与流水线消息对应
+    msg_id: str
+
+    # 群聊会话标识（单聊时为空）
+    chat_id: Optional[str]
+
+    # 触发消息的发送者
+    user_id: Optional[str]
+
+    # 会话创建时间
+    created_at: float = field(default_factory=time.time)
+
+    # 最近一次被访问的时间，cleanup 依据该值判断过期
+    last_access: float = field(default_factory=time.time)
+
+    # 将流水线增量结果缓存到队列，刷新请求逐条消费
+    queue: asyncio.Queue = field(default_factory=asyncio.Queue)
+
+    # 是否已经完成（收到最终片段）
+    finished: bool = False
+
+    # 缓存最近一次片段，处理重试或超时兜底
+    last_chunk: Optional[StreamChunk] = None
+
+
+class StreamSessionManager:
+    """管理 stream 会话的生命周期，并负责队列的生产消费。"""
+
+    def __init__(self, logger: EventLogger, ttl: int = 60) -> None:
+        self.logger = logger
+
+        self.ttl = ttl  # 超时时间（秒），超过该时间未被访问的会话会被清理由 cleanup
+        self._sessions: dict[str, StreamSession] = {}  # stream_id -> StreamSession 映射
+        self._msg_index: dict[str, str] = {}  # msgid -> stream_id 映射，便于流水线根据消息 ID 找到会话
+
+    def get_stream_id_by_msg(self, msg_id: str) -> Optional[str]:
+        if not msg_id:
+            return None
+        return self._msg_index.get(msg_id)
+
+    def get_session(self, stream_id: str) -> Optional[StreamSession]:
+        return self._sessions.get(stream_id)
+
+    def create_or_get(self, msg_json: dict[str, Any]) -> tuple[StreamSession, bool]:
+        """根据企业微信回调创建或获取会话。
+
+        Args:
+            msg_json: 企业微信解密后的回调 JSON。
+
+        Returns:
+            Tuple[StreamSession, bool]: `StreamSession` 为会话实例，`bool` 指示是否为新建会话。
+
+        Example:
+            在首次回调中调用，得到 `is_new=True` 后再触发流水线。
+        """
+        msg_id = msg_json.get('msgid', '')
+        if msg_id and msg_id in self._msg_index:
+            stream_id = self._msg_index[msg_id]
+            session = self._sessions.get(stream_id)
+            if session:
+                session.last_access = time.time()
+                return session, False
+
+        stream_id = str(uuid.uuid4())
+        session = StreamSession(
+            stream_id=stream_id,
+            msg_id=msg_id,
+            chat_id=msg_json.get('chatid'),
+            user_id=msg_json.get('from', {}).get('userid'),
+        )
+
+        if msg_id:
+            self._msg_index[msg_id] = stream_id
+        self._sessions[stream_id] = session
+        return session, True
+
+    async def publish(self, stream_id: str, chunk: StreamChunk) -> bool:
+        """向 stream 队列写入新的增量片段。
+
+        Args:
+            stream_id: 企业微信分配的流式会话 ID。
+            chunk: 待发送的增量片段。
+
+        Returns:
+            bool: 当流式队列存在并成功入队时返回 True。
+
+        Example:
+            在收到模型增量后调用 `await manager.publish('sid', StreamChunk('hello'))`。
+        """
+        session = self._sessions.get(stream_id)
+        if not session:
+            return False
+
+        session.last_access = time.time()
+        session.last_chunk = chunk
+
+        try:
+            session.queue.put_nowait(chunk)
+        except asyncio.QueueFull:
+            # 默认无界队列，此处兜底防御
+            await session.queue.put(chunk)
+
+        if chunk.is_final:
+            session.finished = True
+
+        return True
+
+    async def consume(self, stream_id: str, timeout: float = 0.5) -> Optional[StreamChunk]:
+        """从队列中取出一个片段，若超时返回 None。
+
+        Args:
+            stream_id: 企业微信流式会话 ID。
+            timeout: 取片段的最长等待时间（秒）。
+
+        Returns:
+            Optional[StreamChunk]: 成功时返回片段，超时或会话不存在时返回 None。
+
+        Example:
+            企业微信刷新到达时调用，若队列有数据则立即返回 `StreamChunk`。
+        """
+        session = self._sessions.get(stream_id)
+        if not session:
+            return None
+
+        session.last_access = time.time()
+
+        try:
+            chunk = await asyncio.wait_for(session.queue.get(), timeout)
+            session.last_access = time.time()
+            if chunk.is_final:
+                session.finished = True
+            return chunk
+        except asyncio.TimeoutError:
+            if session.finished and session.last_chunk:
+                return session.last_chunk
+            return None
+
+    def mark_finished(self, stream_id: str) -> None:
+        session = self._sessions.get(stream_id)
+        if session:
+            session.finished = True
+            session.last_access = time.time()
+
+    def cleanup(self) -> None:
+        """定期清理过期会话，防止队列与映射无上限累积。"""
+        now = time.time()
+        expired: list[str] = []
+        for stream_id, session in self._sessions.items():
+            if now - session.last_access > self.ttl:
+                expired.append(stream_id)
+
+        for stream_id in expired:
+            session = self._sessions.pop(stream_id, None)
+            if not session:
+                continue
+            msg_id = session.msg_id
+            if msg_id and self._msg_index.get(msg_id) == stream_id:
+                self._msg_index.pop(msg_id, None)
+
+
+class WecomBotClient:
+    def __init__(self, Token: str, EnCodingAESKey: str, Corpid: str, logger: EventLogger):
+        """企业微信智能机器人客户端。
+
+        Args:
+            Token: 企业微信回调验证使用的 token。
+            EnCodingAESKey: 企业微信消息加解密密钥。
+            Corpid: 企业 ID。
+            logger: 日志记录器。
+
+        Example:
+            >>> client = WecomBotClient(Token='token', EnCodingAESKey='aeskey', Corpid='corp', logger=logger)
+        """
+
+        self.Token = Token
+        self.EnCodingAESKey = EnCodingAESKey
+        self.Corpid = Corpid
+        self.ReceiveId = ''
+        self.app = Quart(__name__)
+        self.app.add_url_rule(
+            '/callback/command',
+            'handle_callback',
+            self.handle_callback_request,
+            methods=['POST', 'GET']
+        )
+        self._message_handlers = {
+            'example': [],
+        }
+        self.logger = logger
+        self.generated_content: dict[str, str] = {}
+        self.msg_id_map: dict[str, int] = {}
+        self.stream_sessions = StreamSessionManager(logger=logger)
+        self.stream_poll_timeout = 0.5
+
+    @staticmethod
+    def _build_stream_payload(stream_id: str, content: str, finish: bool) -> dict[str, Any]:
+        """按照企业微信协议拼装返回报文。
+
+        Args:
+            stream_id: 企业微信会话 ID。
+            content: 推送的文本内容。
+            finish: 是否为最终片段。
+
+        Returns:
+            dict[str, Any]: 可直接加密返回的 payload。
+
+        Example:
+            组装 `{'msgtype': 'stream', 'stream': {'id': 'sid', ...}}` 结构。
+        """
+        return {
+            'msgtype': 'stream',
+            'stream': {
+                'id': stream_id,
+                'finish': finish,
+                'content': content,
+            },
+        }
+
+    async def _encrypt_and_reply(self, payload: dict[str, Any], nonce: str) -> tuple[Response, int]:
+        """对响应进行加密封装并返回给企业微信。
+
+        Args:
+            payload: 待加密的响应内容。
+            nonce: 企业微信回调参数中的 nonce。
+
+        Returns:
+            Tuple[Response, int]: Quart Response 对象及状态码。
+
+        Example:
+            在首包或刷新场景中调用以生成加密响应。
+        """
+        reply_plain_str = json.dumps(payload, ensure_ascii=False)
+        reply_timestamp = str(int(time.time()))
+        ret, encrypt_text = self.wxcpt.EncryptMsg(reply_plain_str, nonce, reply_timestamp)
+        if ret != 0:
+            await self.logger.error(f'加密失败: {ret}')
+            return jsonify({'error': 'encrypt_failed'}), 500
+
+        root = ET.fromstring(encrypt_text)
+        encrypt = root.find('Encrypt').text
+        resp = {
+            'encrypt': encrypt,
+        }
+        return jsonify(resp), 200
+
+    async def _dispatch_event(self, event: wecombotevent.WecomBotEvent) -> None:
+        """异步触发流水线处理，避免阻塞首包响应。
+
+        Args:
+            event: 由企业微信消息转换的内部事件对象。
+        """
+        try:
+            await self._handle_message(event)
+        except Exception:
+            await self.logger.error(traceback.format_exc())
+
+    async def _handle_post_initial_response(self, msg_json: dict[str, Any], nonce: str) -> tuple[Response, int]:
+        """处理企业微信首次推送的消息，返回 stream_id 并开启流水线。
+
+        Args:
+            msg_json: 解密后的企业微信消息 JSON。
+            nonce: 企业微信回调参数 nonce。
+
+        Returns:
+            Tuple[Response, int]: Quart Response 及状态码。
+
+        Example:
+            首次回调时调用，立即返回带 `stream_id` 的响应。
+        """
+        session, is_new = self.stream_sessions.create_or_get(msg_json)
+
+        message_data = await self.get_message(msg_json)
+        if message_data:
+            message_data['stream_id'] = session.stream_id
+            try:
+                event = wecombotevent.WecomBotEvent(message_data)
+            except Exception:
+                await self.logger.error(traceback.format_exc())
+            else:
+                if is_new:
+                    asyncio.create_task(self._dispatch_event(event))
+
+        payload = self._build_stream_payload(session.stream_id, '', False)
+        return await self._encrypt_and_reply(payload, nonce)
+
+    async def _handle_post_followup_response(self, msg_json: dict[str, Any], nonce: str) -> tuple[Response, int]:
+        """处理企业微信的流式刷新请求，按需返回增量片段。
+
+        Args:
+            msg_json: 解密后的企业微信刷新请求。
+            nonce: 企业微信回调参数 nonce。
+
+        Returns:
+            Tuple[Response, int]: Quart Response 及状态码。
+
+        Example:
+            在刷新请求中调用，按需返回增量片段。
+        """
+        stream_info = msg_json.get('stream', {})
+        stream_id = stream_info.get('id', '')
+        if not stream_id:
+            await self.logger.error('刷新请求缺少 stream.id')
+            return await self._encrypt_and_reply(self._build_stream_payload('', '', True), nonce)
+
+        session = self.stream_sessions.get_session(stream_id)
+        chunk = await self.stream_sessions.consume(stream_id, timeout=self.stream_poll_timeout)
+
+        if not chunk:
+            cached_content = None
+            if session and session.msg_id:
+                cached_content = self.generated_content.pop(session.msg_id, None)
+            if cached_content is not None:
+                chunk = StreamChunk(content=cached_content, is_final=True)
+            else:
+                payload = self._build_stream_payload(stream_id, '', False)
+                return await self._encrypt_and_reply(payload, nonce)
+
+        payload = self._build_stream_payload(stream_id, chunk.content, chunk.is_final)
+        if chunk.is_final:
+            self.stream_sessions.mark_finished(stream_id)
+        return await self._encrypt_and_reply(payload, nonce)
+
+    async def handle_callback_request(self):
+        """企业微信回调入口。
+
+        Returns:
+            Quart Response: 根据请求类型返回验证、首包或刷新结果。
+
+        Example:
+            作为 Quart 路由处理函数直接注册并使用。
+        """
+        try:
+            self.wxcpt = WXBizMsgCrypt(self.Token, self.EnCodingAESKey, '')
+            await self.logger.info(f'{request.method} {request.url} {str(request.args)}')
+
+            if request.method == 'GET':
+                return await self._handle_get_callback()
+
+            if request.method == 'POST':
+                return await self._handle_post_callback()
+
+            return Response('', status=405)
+
+        except Exception:
+            await self.logger.error(traceback.format_exc())
+            return Response('Internal Server Error', status=500)
+
+    async def _handle_get_callback(self) -> tuple[Response, int] | Response:
+        """处理企业微信的 GET 验证请求。"""
+
+        msg_signature = unquote(request.args.get('msg_signature', ''))
+        timestamp = unquote(request.args.get('timestamp', ''))
+        nonce = unquote(request.args.get('nonce', ''))
+        echostr = unquote(request.args.get('echostr', ''))
+
+        if not all([msg_signature, timestamp, nonce, echostr]):
+            await self.logger.error('请求参数缺失')
+            return Response('缺少参数', status=400)
+
+        ret, decrypted_str = self.wxcpt.VerifyURL(msg_signature, timestamp, nonce, echostr)
+        if ret != 0:
+            await self.logger.error('验证URL失败')
+            return Response('验证失败', status=403)
+
+        return Response(decrypted_str, mimetype='text/plain')
+
+    async def _handle_post_callback(self) -> tuple[Response, int] | Response:
+        """处理企业微信的 POST 回调请求。"""
+
+        self.stream_sessions.cleanup()
+
+        msg_signature = unquote(request.args.get('msg_signature', ''))
+        timestamp = unquote(request.args.get('timestamp', ''))
+        nonce = unquote(request.args.get('nonce', ''))
+
+        encrypted_json = await request.get_json()
+        encrypted_msg = (encrypted_json or {}).get('encrypt', '')
+        if not encrypted_msg:
+            await self.logger.error("请求体中缺少 'encrypt' 字段")
+            return Response('Bad Request', status=400)
+
+        xml_post_data = f"<xml><Encrypt><![CDATA[{encrypted_msg}]]></Encrypt></xml>"
+        ret, decrypted_xml = self.wxcpt.DecryptMsg(xml_post_data, msg_signature, timestamp, nonce)
+        if ret != 0:
+            await self.logger.error('解密失败')
+            return Response('解密失败', status=400)
+
+        msg_json = json.loads(decrypted_xml)
+
+        if msg_json.get('msgtype') == 'stream':
+            return await self._handle_post_followup_response(msg_json, nonce)
+
+        return await self._handle_post_initial_response(msg_json, nonce)
+
+    async def get_message(self, msg_json):
+        message_data = {}
+
+        if msg_json.get('chattype', '') == 'single':
+            message_data['type'] = 'single'
+        elif msg_json.get('chattype', '') == 'group':
+            message_data['type'] = 'group'
+
+        if msg_json.get('msgtype') == 'text':
+            message_data['content'] = msg_json.get('text', {}).get('content')
+        elif msg_json.get('msgtype') == 'image':
+            picurl = msg_json.get('image', {}).get('url', '')
+            base64 = await self.download_url_to_base64(picurl, self.EnCodingAESKey)
+            message_data['picurl'] = base64
+        elif msg_json.get('msgtype') == 'mixed':
+            items = msg_json.get('mixed', {}).get('msg_item', [])
+            texts = []
+            picurl = None
+            for item in items:
+                if item.get('msgtype') == 'text':
+                    texts.append(item.get('text', {}).get('content', ''))
+                elif item.get('msgtype') == 'image' and picurl is None:
+                    picurl = item.get('image', {}).get('url')
+
+            if texts:
+                message_data['content'] = "".join(texts)  # 拼接所有 text
+            if picurl:
+                base64 = await self.download_url_to_base64(picurl, self.EnCodingAESKey)
+                message_data['picurl'] = base64  # 只保留第一个 image
+
+        message_data['userid'] = msg_json.get('from', {}).get('userid', '')
+        message_data['msgid'] = msg_json.get('msgid', '')
+
+        if msg_json.get('aibotid'):
+            message_data['aibotid'] = msg_json.get('aibotid', '')
+
+        return message_data
+
+    async def _handle_message(self, event: wecombotevent.WecomBotEvent):
+        """
+        处理消息事件。
+        """
+        try:
+            message_id = event.message_id
+            if message_id in self.msg_id_map.keys():
+                self.msg_id_map[message_id] += 1
+                return
+            self.msg_id_map[message_id] = 1
+            msg_type = event.type
+            if msg_type in self._message_handlers:
+                for handler in self._message_handlers[msg_type]:
+                    await handler(event)
+        except Exception:
+            print(traceback.format_exc())
+
+    async def push_stream_chunk(self, msg_id: str, content: str, is_final: bool = False) -> bool:
+        """将流水线片段推送到 stream 会话。
+
+        Args:
+            msg_id: 原始企业微信消息 ID。
+            content: 模型产生的片段内容。
+            is_final: 是否为最终片段。
+
+        Returns:
+            bool: 当成功写入流式队列时返回 True。
+
+        Example:
+            在流水线 `reply_message_chunk` 中调用，将增量推送至企业微信。
+        """
+        # 根据 msg_id 找到对应 stream 会话，如果不存在说明当前消息非流式
+        stream_id = self.stream_sessions.get_stream_id_by_msg(msg_id)
+        if not stream_id:
+            return False
+
+        chunk = StreamChunk(content=content, is_final=is_final)
+        await self.stream_sessions.publish(stream_id, chunk)
+        if is_final:
+            self.stream_sessions.mark_finished(stream_id)
+        return True
+
+    async def set_message(self, msg_id: str, content: str):
+        """兼容旧逻辑：若无法流式返回则缓存最终结果。
+
+        Args:
+            msg_id: 企业微信消息 ID。
+            content: 最终回复的文本内容。
+
+        Example:
+            在非流式场景下缓存最终结果以备刷新时返回。
+        """
+        handled = await self.push_stream_chunk(msg_id, content, is_final=True)
+        if not handled:
+            self.generated_content[msg_id] = content
+
+    def on_message(self, msg_type: str):
+        def decorator(func: Callable[[wecombotevent.WecomBotEvent], 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 download_url_to_base64(self, download_url, encoding_aes_key):
+        async with httpx.AsyncClient() as client:
+            response = await client.get(download_url)
+            if response.status_code != 200:
+                await self.logger.error(f'failed to get file: {response.text}')
+                return None
+
+            encrypted_bytes = response.content
+
+        aes_key = base64.b64decode(encoding_aes_key + "=")  # base64 补齐
+        iv = aes_key[:16]
+
+        cipher = AES.new(aes_key, AES.MODE_CBC, iv)
+        decrypted = cipher.decrypt(encrypted_bytes)
+
+        pad_len = decrypted[-1]
+        decrypted = decrypted[:-pad_len]
+
+        if decrypted.startswith(b"\xff\xd8"):  # JPEG
+            mime_type = "image/jpeg"
+        elif decrypted.startswith(b"\x89PNG"):  # PNG
+            mime_type = "image/png"
+        elif decrypted.startswith((b"GIF87a", b"GIF89a")):  # GIF
+            mime_type = "image/gif"
+        elif decrypted.startswith(b"BM"):  # BMP
+            mime_type = "image/bmp"
+        elif decrypted.startswith(b"II*\x00") or decrypted.startswith(b"MM\x00*"):  # TIFF
+            mime_type = "image/tiff"
+        else:
+            mime_type = "application/octet-stream"
+
+        # 转 base64
+        base64_str = base64.b64encode(decrypted).decode("utf-8")
+        return f"data:{mime_type};base64,{base64_str}"
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)

libs/wecom_ai_bot_api/ierror.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#########################################################################
+# Author: jonyqin
+# Created Time: Thu 11 Sep 2014 01:53:58 PM CST
+# File Name: ierror.py
+# Description:定义错误码含义
+#########################################################################
+WXBizMsgCrypt_OK = 0
+WXBizMsgCrypt_ValidateSignature_Error = -40001
+WXBizMsgCrypt_ParseXml_Error = -40002
+WXBizMsgCrypt_ComputeSignature_Error = -40003
+WXBizMsgCrypt_IllegalAesKey = -40004
+WXBizMsgCrypt_ValidateCorpid_Error = -40005
+WXBizMsgCrypt_EncryptAES_Error = -40006
+WXBizMsgCrypt_DecryptAES_Error = -40007
+WXBizMsgCrypt_IllegalBuffer = -40008
+WXBizMsgCrypt_EncodeBase64_Error = -40009
+WXBizMsgCrypt_DecodeBase64_Error = -40010
+WXBizMsgCrypt_GenReturnXml_Error = -40011

libs/wecom_ai_bot_api/wecombotevent.py

@@ -0,0 +1,60 @@
+from typing import Dict, Any, Optional
+
+
+class WecomBotEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional['WecomBotEvent']:
+        try:
+            event = WecomBotEvent(payload)
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型
+        """
+        return self.get('type', '')
+
+    @property
+    def userid(self) -> str:
+        """
+        用户id
+        """
+        return self.get('from', {}).get('userid', '')
+
+    @property
+    def content(self) -> str:
+        """
+        内容
+        """
+        return self.get('content', '')
+
+    @property
+    def picurl(self) -> str:
+        """
+        图片url
+        """
+        return self.get('picurl', '')
+
+    @property
+    def chatid(self) -> str:
+        """
+        群组id
+        """
+        return self.get('chatid', {})
+
+    @property
+    def message_id(self) -> str:
+        """
+        消息id
+        """
+        return self.get('msgid', '')
+    
+    @property
+    def ai_bot_id(self) -> str:
+        """
+        AI Bot ID
+        """
+        return self.get('aibotid', '')

libs/wecom_api/api.py

@@ -340,3 +340,4 @@ class WecomClient:
     async def get_media_id(self, image: platform_message.Image):
         media_id = await self.upload_to_work(image=image)
         return media_id
+    

main.py

@@ -18,8 +18,13 @@ asciiart = r"""
 
 async def main_entry(loop: asyncio.AbstractEventLoop):
     parser = argparse.ArgumentParser(description='LangBot')
-    parser.add_argument('--skip-plugin-deps-check', action='store_true', help='跳过插件依赖项检查', default=False)
-    parser.add_argument('--standalone-runtime', action='store_true', help='使用独立插件运行时', default=False)
+    parser.add_argument(
+        '--standalone-runtime',
+        action='store_true',
+        help='Use standalone plugin runtime / 使用独立插件运行时',
+        default=False,
+    )
+    parser.add_argument('--debug', action='store_true', help='Debug mode / 调试模式', default=False)
     args = parser.parse_args()
 
     if args.standalone_runtime:
@@ -27,6 +32,11 @@ async def main_entry(loop: asyncio.AbstractEventLoop):
 
         platform.standalone_runtime = True
 
+    if args.debug:
+        from pkg.utils import constants
+
+        constants.debug_mode = True
+
     print(asciiart)
 
     import sys
@@ -49,10 +59,6 @@ async def main_entry(loop: asyncio.AbstractEventLoop):
         print('The missing dependencies have been installed automatically, please restart the program.')
         sys.exit(0)
 
-    # check plugin deps
-    if not args.skip_plugin_deps_check:
-        await deps.precheck_plugin_deps()
-
     # # 检查pydantic版本，如果没有 pydantic.v1，则把 pydantic 映射为 v1
     # import pydantic.version
 

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

@@ -15,6 +15,9 @@ class FilesRouterGroup(group.RouterGroup):
     async def initialize(self) -> None:
         @self.route('/image/<image_key>', methods=['GET'], auth_type=group.AuthType.NONE)
         async def _(image_key: str) -> quart.Response:
+            if '/' in image_key or '\\' in image_key:
+                return quart.Response(status=404)
+
             if not await self.ap.storage_mgr.storage_provider.exists(image_key):
                 return quart.Response(status=404)
 
@@ -36,6 +39,10 @@ class FilesRouterGroup(group.RouterGroup):
             extension = file.filename.split('.')[-1]
             file_name = file.filename.split('.')[0]
 
+            # check if file name contains '/' or '\'
+            if '/' in file_name or '\\' in file_name:
+                return self.fail(400, 'File name contains invalid characters')
+
             file_key = file_name + '_' + str(uuid.uuid4())[:8] + '.' + extension
             # save file to storage
             await self.ap.storage_mgr.storage_provider.save(file_key, file_bytes)

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

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import base64
 import quart
+import re
+import httpx
 
 from .....core import taskmgr
 from .. import group
@@ -45,9 +47,12 @@ class PluginsRouterGroup(group.RouterGroup):
                     return self.http_status(404, -1, 'plugin not found')
                 return self.success(data={'plugin': plugin})
             elif quart.request.method == 'DELETE':
+                delete_data = quart.request.args.get('delete_data', 'false').lower() == 'true'
                 ctx = taskmgr.TaskContext.new()
                 wrapper = self.ap.task_mgr.create_user_task(
-                    self.ap.plugin_connector.delete_plugin(author, plugin_name, task_context=ctx),
+                    self.ap.plugin_connector.delete_plugin(
+                        author, plugin_name, delete_data=delete_data, task_context=ctx
+                    ),
                     kind='plugin-operation',
                     name=f'plugin-remove-{plugin_name}',
                     label=f'Removing plugin {plugin_name}',
@@ -75,23 +80,159 @@ class PluginsRouterGroup(group.RouterGroup):
 
                 return self.success(data={})
 
+        @self.route(
+            '/<author>/<plugin_name>/icon',
+            methods=['GET'],
+            auth_type=group.AuthType.NONE,
+        )
+        async def _(author: str, plugin_name: str) -> quart.Response:
+            icon_data = await self.ap.plugin_connector.get_plugin_icon(author, plugin_name)
+            icon_base64 = icon_data['plugin_icon_base64']
+            mime_type = icon_data['mime_type']
+
+            icon_data = base64.b64decode(icon_base64)
+
+            return quart.Response(icon_data, mimetype=mime_type)
+
+        @self.route('/github/releases', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+        async def _() -> str:
+            """Get releases from a GitHub repository URL"""
+            data = await quart.request.json
+            repo_url = data.get('repo_url', '')
+
+            # Parse GitHub repository URL to extract owner and repo
+            # Supports: https://github.com/owner/repo or github.com/owner/repo
+            pattern = r'github\.com/([^/]+)/([^/]+?)(?:\.git)?(?:/.*)?$'
+            match = re.search(pattern, repo_url)
+
+            if not match:
+                return self.http_status(400, -1, 'Invalid GitHub repository URL')
+
+            owner, repo = match.groups()
+
+            try:
+                # Fetch releases from GitHub API
+                url = f'https://api.github.com/repos/{owner}/{repo}/releases'
+                async with httpx.AsyncClient(
+                    trust_env=True,
+                    follow_redirects=True,
+                    timeout=10,
+                ) as client:
+                    response = await client.get(url)
+                    response.raise_for_status()
+                    releases = response.json()
+
+                # Format releases data for frontend
+                formatted_releases = []
+                for release in releases:
+                    formatted_releases.append(
+                        {
+                            'id': release['id'],
+                            'tag_name': release['tag_name'],
+                            'name': release['name'],
+                            'published_at': release['published_at'],
+                            'prerelease': release['prerelease'],
+                            'draft': release['draft'],
+                        }
+                    )
+
+                return self.success(data={'releases': formatted_releases, 'owner': owner, 'repo': repo})
+            except httpx.RequestError as e:
+                return self.http_status(500, -1, f'Failed to fetch releases: {str(e)}')
+
+        @self.route(
+            '/github/release-assets',
+            methods=['POST'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
+        async def _() -> str:
+            """Get assets from a specific GitHub release"""
+            data = await quart.request.json
+            owner = data.get('owner', '')
+            repo = data.get('repo', '')
+            release_id = data.get('release_id', '')
+
+            if not all([owner, repo, release_id]):
+                return self.http_status(400, -1, 'Missing required parameters')
+
+            try:
+                # Fetch release assets from GitHub API
+                url = f'https://api.github.com/repos/{owner}/{repo}/releases/{release_id}'
+                async with httpx.AsyncClient(
+                    trust_env=True,
+                    follow_redirects=True,
+                    timeout=10,
+                ) as client:
+                    response = await client.get(
+                        url,
+                    )
+                    response.raise_for_status()
+                    release = response.json()
+
+                # Format assets data for frontend
+                formatted_assets = []
+                for asset in release.get('assets', []):
+                    formatted_assets.append(
+                        {
+                            'id': asset['id'],
+                            'name': asset['name'],
+                            'size': asset['size'],
+                            'download_url': asset['browser_download_url'],
+                            'content_type': asset['content_type'],
+                        }
+                    )
+
+                # add zipball as a downloadable asset
+                # formatted_assets.append(
+                #     {
+                #         "id": 0,
+                #         "name": "Source code (zip)",
+                #         "size": -1,
+                #         "download_url": release["zipball_url"],
+                #         "content_type": "application/zip",
+                #     }
+                # )
+
+                return self.success(data={'assets': formatted_assets})
+            except httpx.RequestError as e:
+                return self.http_status(500, -1, f'Failed to fetch release assets: {str(e)}')
+
         @self.route('/install/github', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
+            """Install plugin from GitHub release asset"""
             data = await quart.request.json
+            asset_url = data.get('asset_url', '')
+            owner = data.get('owner', '')
+            repo = data.get('repo', '')
+            release_tag = data.get('release_tag', '')
+
+            if not asset_url:
+                return self.http_status(400, -1, 'Missing asset_url parameter')
 
             ctx = taskmgr.TaskContext.new()
-            short_source_str = data['source'][-8:]
+            install_info = {
+                'asset_url': asset_url,
+                'owner': owner,
+                'repo': repo,
+                'release_tag': release_tag,
+                'github_url': f'https://github.com/{owner}/{repo}',
+            }
+
             wrapper = self.ap.task_mgr.create_user_task(
-                self.ap.plugin_mgr.install_plugin(data['source'], task_context=ctx),
+                self.ap.plugin_connector.install_plugin(PluginInstallSource.GITHUB, install_info, task_context=ctx),
                 kind='plugin-operation',
                 name='plugin-install-github',
-                label=f'Installing plugin from github ...{short_source_str}',
+                label=f'Installing plugin from GitHub {owner}/{repo}@{release_tag}',
                 context=ctx,
             )
 
             return self.success(data={'task_id': wrapper.id})
 
-        @self.route('/install/marketplace', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+        @self.route(
+            '/install/marketplace',
+            methods=['POST'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
         async def _() -> str:
             data = await quart.request.json
 
@@ -114,10 +255,8 @@ class PluginsRouterGroup(group.RouterGroup):
 
             file_bytes = file.read()
 
-            file_base64 = base64.b64encode(file_bytes).decode('utf-8')
-
             data = {
-                'plugin_file': file_base64,
+                'plugin_file': file_bytes,
             }
 
             ctx = taskmgr.TaskContext.new()

pkg/api/http/controller/groups/resources/mcp.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import quart
+import traceback
+
+
+from ... import group
+
+
+@group.group_class('mcp', '/api/v1/mcp')
+class MCPRouterGroup(group.RouterGroup):
+    async def initialize(self) -> None:
+        @self.route('/servers', methods=['GET', 'POST'], auth_type=group.AuthType.USER_TOKEN)
+        async def _() -> str:
+            """获取MCP服务器列表"""
+            if quart.request.method == 'GET':
+                servers = await self.ap.mcp_service.get_mcp_servers(contain_runtime_info=True)
+
+                return self.success(data={'servers': servers})
+
+            elif quart.request.method == 'POST':
+                data = await quart.request.json
+
+                try:
+                    uuid = await self.ap.mcp_service.create_mcp_server(data)
+                    return self.success(data={'uuid': uuid})
+                except Exception as e:
+                    traceback.print_exc()
+                    return self.http_status(500, -1, f'Failed to create MCP server: {str(e)}')
+
+        @self.route('/servers/<server_name>', methods=['GET', 'PUT', 'DELETE'], auth_type=group.AuthType.USER_TOKEN)
+        async def _(server_name: str) -> str:
+            """获取、更新或删除MCP服务器配置"""
+
+            server_data = await self.ap.mcp_service.get_mcp_server_by_name(server_name)
+            if server_data is None:
+                return self.http_status(404, -1, 'Server not found')
+
+            if quart.request.method == 'GET':
+                return self.success(data={'server': server_data})
+
+            elif quart.request.method == 'PUT':
+                data = await quart.request.json
+                try:
+                    await self.ap.mcp_service.update_mcp_server(server_data['uuid'], data)
+                    return self.success()
+                except Exception as e:
+                    return self.http_status(500, -1, f'Failed to update MCP server: {str(e)}')
+
+            elif quart.request.method == 'DELETE':
+                try:
+                    await self.ap.mcp_service.delete_mcp_server(server_data['uuid'])
+                    return self.success()
+                except Exception as e:
+                    return self.http_status(500, -1, f'Failed to delete MCP server: {str(e)}')
+
+        @self.route('/servers/<server_name>/test', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+        async def _(server_name: str) -> str:
+            """测试MCP服务器连接"""
+            server_data = await quart.request.json
+            task_id = await self.ap.mcp_service.test_mcp_server(server_name=server_name, server_data=server_data)
+            return self.success(data={'task_id': task_id})

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

@@ -14,9 +14,14 @@ class SystemRouterGroup(group.RouterGroup):
                     'version': constants.semantic_version,
                     'debug': constants.debug_mode,
                     'enabled_platform_count': len(self.ap.platform_mgr.get_running_adapters()),
+                    'enable_marketplace': self.ap.instance_config.data.get('plugin', {}).get(
+                        'enable_marketplace', True
+                    ),
                     'cloud_service_url': (
-                        self.ap.instance_config.data['plugin']['cloud_service_url']
-                        if 'cloud_service_url' in self.ap.instance_config.data['plugin']
+                        self.ap.instance_config.data.get('plugin', {}).get(
+                            'cloud_service_url', 'https://space.langbot.app'
+                        )
+                        if 'cloud_service_url' in self.ap.instance_config.data.get('plugin', {})
                         else 'https://space.langbot.app'
                     ),
                 }
@@ -86,3 +91,26 @@ class SystemRouterGroup(group.RouterGroup):
             )
 
             return self.success(data=resp)
+
+        @self.route(
+            '/status/plugin-system',
+            methods=['GET'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
+        async def _() -> str:
+            plugin_connector_error = 'ok'
+            is_connected = True
+
+            try:
+                await self.ap.plugin_connector.ping_plugin_runtime()
+            except Exception as e:
+                plugin_connector_error = str(e)
+                is_connected = False
+
+            return self.success(
+                data={
+                    'is_enable': self.ap.plugin_connector.is_enable_plugin,
+                    'is_connected': is_connected,
+                    'plugin_connector_error': plugin_connector_error,
+                }
+            )

pkg/api/http/controller/main.py

@@ -15,12 +15,14 @@ from .groups import provider as groups_provider
 from .groups import platform as groups_platform
 from .groups import pipelines as groups_pipelines
 from .groups import knowledge as groups_knowledge
+from .groups import resources as groups_resources
 
 importutil.import_modules_in_pkg(groups)
 importutil.import_modules_in_pkg(groups_provider)
 importutil.import_modules_in_pkg(groups_platform)
 importutil.import_modules_in_pkg(groups_pipelines)
 importutil.import_modules_in_pkg(groups_knowledge)
+importutil.import_modules_in_pkg(groups_resources)
 
 
 class HTTPController:

pkg/api/http/service/mcp.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import sqlalchemy
+import uuid
+import asyncio
+
+from ....core import app
+from ....entity.persistence import mcp as persistence_mcp
+from ....core import taskmgr
+from ....provider.tools.loaders.mcp import RuntimeMCPSession, MCPSessionStatus
+
+
+class MCPService:
+    ap: app.Application
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+
+    async def get_runtime_info(self, server_name: str) -> dict | None:
+        session = self.ap.tool_mgr.mcp_tool_loader.get_session(server_name)
+        if session:
+            return session.get_runtime_info_dict()
+        return None
+
+    async def get_mcp_servers(self, contain_runtime_info: bool = False) -> list[dict]:
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_mcp.MCPServer))
+
+        servers = result.all()
+        serialized_servers = [
+            self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, server) for server in servers
+        ]
+        if contain_runtime_info:
+            for server in serialized_servers:
+                runtime_info = await self.get_runtime_info(server['name'])
+
+                server['runtime_info'] = runtime_info if runtime_info else None
+
+        return serialized_servers
+
+    async def create_mcp_server(self, server_data: dict) -> str:
+        server_data['uuid'] = str(uuid.uuid4())
+        await self.ap.persistence_mgr.execute_async(sqlalchemy.insert(persistence_mcp.MCPServer).values(server_data))
+
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_data['uuid'])
+        )
+        server_entity = result.first()
+        if server_entity:
+            server_config = self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, server_entity)
+            if self.ap.tool_mgr.mcp_tool_loader:
+                task = asyncio.create_task(self.ap.tool_mgr.mcp_tool_loader.host_mcp_server(server_config))
+                self.ap.tool_mgr.mcp_tool_loader._hosted_mcp_tasks.append(task)
+
+        return server_data['uuid']
+
+    async def get_mcp_server_by_name(self, server_name: str) -> dict | None:
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.name == server_name)
+        )
+        server = result.first()
+        if server is None:
+            return None
+
+        runtime_info = await self.get_runtime_info(server.name)
+        server_data = self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, server)
+        server_data['runtime_info'] = runtime_info if runtime_info else None
+        return server_data
+
+    async def update_mcp_server(self, server_uuid: str, server_data: dict) -> None:
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_uuid)
+        )
+        old_server = result.first()
+        old_server_name = old_server.name if old_server else None
+        old_enable = old_server.enable if old_server else False
+
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.update(persistence_mcp.MCPServer)
+            .where(persistence_mcp.MCPServer.uuid == server_uuid)
+            .values(server_data)
+        )
+
+        if self.ap.tool_mgr.mcp_tool_loader:
+            new_enable = server_data.get('enable', False)
+
+            need_remove = old_server_name and old_server_name in self.ap.tool_mgr.mcp_tool_loader.sessions
+            need_start = new_enable
+
+            
+            if old_enable and not new_enable:
+                if need_remove:
+                    await self.ap.tool_mgr.mcp_tool_loader.remove_mcp_server(old_server_name)
+            
+            elif not old_enable and new_enable:
+                result = await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_uuid)
+                )
+                updated_server = result.first()
+                if updated_server:
+                    server_config = self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, updated_server)
+                    task = asyncio.create_task(self.ap.tool_mgr.mcp_tool_loader.host_mcp_server(server_config))
+                    self.ap.tool_mgr.mcp_tool_loader._hosted_mcp_tasks.append(task)
+            
+            elif old_enable and new_enable:
+                if need_remove:
+                    await self.ap.tool_mgr.mcp_tool_loader.remove_mcp_server(old_server_name)
+                result = await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_uuid)
+                )
+                updated_server = result.first()
+                if updated_server:
+                    server_config = self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, updated_server)
+                    task = asyncio.create_task(self.ap.tool_mgr.mcp_tool_loader.host_mcp_server(server_config))
+                    self.ap.tool_mgr.mcp_tool_loader._hosted_mcp_tasks.append(task)
+            
+
+    async def delete_mcp_server(self, server_uuid: str) -> None:
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_uuid)
+        )
+        server = result.first()
+        server_name = server.name if server else None
+
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.delete(persistence_mcp.MCPServer).where(persistence_mcp.MCPServer.uuid == server_uuid)
+        )
+
+        if server_name and self.ap.tool_mgr.mcp_tool_loader:
+            if server_name in self.ap.tool_mgr.mcp_tool_loader.sessions:
+                await self.ap.tool_mgr.mcp_tool_loader.remove_mcp_server(server_name)
+
+    async def test_mcp_server(self, server_name: str, server_data: dict) -> int:
+        """测试 MCP 服务器连接并返回任务 ID"""
+
+        runtime_mcp_session: RuntimeMCPSession | None = None
+
+        if server_name != '_':
+            runtime_mcp_session = self.ap.tool_mgr.mcp_tool_loader.get_session(server_name)
+            if runtime_mcp_session is None:
+                raise ValueError(f'Server not found: {server_name}')
+
+            if runtime_mcp_session.status == MCPSessionStatus.ERROR:
+                coroutine = runtime_mcp_session.start()
+            else:
+                coroutine = runtime_mcp_session.refresh()
+        else:
+            runtime_mcp_session = await self.ap.tool_mgr.mcp_tool_loader.load_mcp_server(server_config=server_data)
+            coroutine = runtime_mcp_session.start()
+
+        ctx = taskmgr.TaskContext.new()
+        wrapper = self.ap.task_mgr.create_user_task(
+            coroutine,
+            kind='mcp-operation',
+            name=f'mcp-test-{server_name}',
+            label=f'Testing MCP server {server_name}',
+            context=ctx,
+        )
+        return wrapper.id

pkg/command/cmdmgr.py

@@ -39,9 +39,9 @@ class CommandManager:
                 set_path(cls, [])
 
         # 应用命令权限配置
-        for cls in operator.preregistered_operators:
-            if cls.path in self.ap.instance_config.data['command']['privilege']:
-                cls.lowest_privilege = self.ap.instance_config.data['command']['privilege'][cls.path]
+        # for cls in operator.preregistered_operators:
+        #     if cls.path in self.ap.instance_config.data['command']['privilege']:
+        #         cls.lowest_privilege = self.ap.instance_config.data['command']['privilege'][cls.path]
 
         # 实例化所有类
         self.cmd_list = [cls(self.ap) for cls in operator.preregistered_operators]
@@ -75,6 +75,7 @@ class CommandManager:
     async def execute(
         self,
         command_text: str,
+        full_command_text: str,
         query: pipeline_query.Query,
         session: provider_session.Session,
     ) -> typing.AsyncGenerator[command_context.CommandReturn, None]:
@@ -89,6 +90,7 @@ class CommandManager:
             query_id=query.query_id,
             session=session,
             command_text=command_text,
+            full_command_text=full_command_text,
             command='',
             crt_command='',
             params=command_text.split(' '),

pkg/command/operators/cmd.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .. import operator
-from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
-
-
-@operator.operator_class(name='cmd', help='显示命令列表', usage='!cmd\n!cmd <命令名称>')
-class CmdOperator(operator.CommandOperator):
-    """命令列表"""
-
-    async def execute(
-        self, context: command_context.ExecuteContext
-    ) -> typing.AsyncGenerator[command_context.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 command_context.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 command_context.CommandReturn(error=command_errors.CommandNotFoundError(cmd_name))
-            else:
-                reply_str = f'{cmd.name}: {cmd.help}\n\n'
-                reply_str += f'使用方法: \n{cmd.usage}'
-
-                yield command_context.CommandReturn(text=reply_str.strip())

pkg/command/operators/delc.py

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

pkg/command/operators/func.py

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

pkg/command/operators/help.py

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

pkg/command/operators/last.py

@@ -1,33 +1,33 @@
-from __future__ import annotations
+# from __future__ import annotations
 
-import typing
+# import typing
 
 
-from .. import operator
-from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
+# from .. import operator
+# from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
 
 
-@operator.operator_class(name='last', help='切换到前一个对话', usage='!last')
-class LastOperator(operator.CommandOperator):
-    async def execute(
-        self, context: command_context.ExecuteContext
-    ) -> typing.AsyncGenerator[command_context.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 command_context.CommandReturn(
-                            error=command_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')
+# @operator.operator_class(name='last', help='切换到前一个对话', usage='!last')
+# class LastOperator(operator.CommandOperator):
+#     async def execute(
+#         self, context: command_context.ExecuteContext
+#     ) -> typing.AsyncGenerator[command_context.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 command_context.CommandReturn(
+#                             error=command_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 command_context.CommandReturn(
-                            text=f'已切换到上一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].readable_str()}'
-                        )
-                        return
-        else:
-            yield command_context.CommandReturn(error=command_errors.CommandOperationError('当前没有对话'))
+#                         yield command_context.CommandReturn(
+#                             text=f'已切换到上一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].readable_str()}'
+#                         )
+#                         return
+#         else:
+#             yield command_context.CommandReturn(error=command_errors.CommandOperationError('当前没有对话'))

pkg/command/operators/list.py

@@ -1,51 +1,51 @@
-from __future__ import annotations
+# from __future__ import annotations
 
-import typing
+# import typing
 
-from .. import operator
-from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
+# from .. import operator
+# from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
 
 
-@operator.operator_class(name='list', help='列出此会话中的所有历史对话', usage='!list\n!list <页码>')
-class ListOperator(operator.CommandOperator):
-    async def execute(
-        self, context: command_context.ExecuteContext
-    ) -> typing.AsyncGenerator[command_context.CommandReturn, None]:
-        page = 0
+# @operator.operator_class(name='list', help='列出此会话中的所有历史对话', usage='!list\n!list <页码>')
+# class ListOperator(operator.CommandOperator):
+#     async def execute(
+#         self, context: command_context.ExecuteContext
+#     ) -> typing.AsyncGenerator[command_context.CommandReturn, None]:
+#         page = 0
 
-        if len(context.crt_params) > 0:
-            try:
-                page = int(context.crt_params[0] - 1)
-            except Exception:
-                yield command_context.CommandReturn(error=command_errors.CommandOperationError('页码应为整数'))
-                return
+#         if len(context.crt_params) > 0:
+#             try:
+#                 page = int(context.crt_params[0] - 1)
+#             except Exception:
+#                 yield command_context.CommandReturn(error=command_errors.CommandOperationError('页码应为整数'))
+#                 return
 
-        record_per_page = 10
+#         record_per_page = 10
 
-        content = ''
+#         content = ''
 
-        index = 0
+#         index = 0
 
-        using_conv_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')
+#         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 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 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 "无内容"}'
+#         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 command_context.CommandReturn(text=f'第 {page + 1} 页 (时间倒序):\n{content}')
+#         yield command_context.CommandReturn(text=f'第 {page + 1} 页 (时间倒序):\n{content}')

pkg/command/operators/next.py

@@ -1,32 +1,32 @@
-from __future__ import annotations
+# from __future__ import annotations
 
-import typing
+# import typing
 
-from .. import operator
-from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
+# from .. import operator
+# from langbot_plugin.api.entities.builtin.command import context as command_context, errors as command_errors
 
 
-@operator.operator_class(name='next', help='切换到后一个对话', usage='!next')
-class NextOperator(operator.CommandOperator):
-    async def execute(
-        self, context: command_context.ExecuteContext
-    ) -> typing.AsyncGenerator[command_context.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 command_context.CommandReturn(
-                            error=command_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')
+# @operator.operator_class(name='next', help='切换到后一个对话', usage='!next')
+# class NextOperator(operator.CommandOperator):
+#     async def execute(
+#         self, context: command_context.ExecuteContext
+#     ) -> typing.AsyncGenerator[command_context.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 command_context.CommandReturn(
+#                             error=command_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 command_context.CommandReturn(
-                            text=f'已切换到后一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].content}'
-                        )
-                        return
-        else:
-            yield command_context.CommandReturn(error=command_errors.CommandOperationError('当前没有对话'))
+#                         yield command_context.CommandReturn(
+#                             text=f'已切换到后一个对话: {index} {time_str}: {context.session.using_conversation.messages[0].content}'
+#                         )
+#                         return
+#         else:
+#             yield command_context.CommandReturn(error=command_errors.CommandOperationError('当前没有对话'))

pkg/command/operators/plugin.py

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

pkg/command/operators/prompt.py

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

pkg/command/operators/resend.py

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

pkg/command/operators/reset.py

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

pkg/command/operators/version.py

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

pkg/core/app.py

@@ -22,6 +22,7 @@ from ..api.http.service import model as model_service
 from ..api.http.service import pipeline as pipeline_service
 from ..api.http.service import bot as bot_service
 from ..api.http.service import knowledge as knowledge_service
+from ..api.http.service import mcp as mcp_service
 from ..discover import engine as discover_engine
 from ..storage import mgr as storagemgr
 from ..utils import logcache
@@ -119,6 +120,8 @@ class Application:
 
     knowledge_service: knowledge_service.KnowledgeService = None
 
+    mcp_service: mcp_service.MCPService = None
+
     def __init__(self):
         pass
 

pkg/core/bootutils/deps.py

@@ -40,6 +40,7 @@ required_deps = {
     'sqlmodel': 'sqlmodel',
     'telegramify_markdown': 'telegramify-markdown',
     'slack_sdk': 'slack_sdk',
+    'asyncpg': 'asyncpg',
 }
 
 

pkg/core/stages/build_app.py

@@ -19,6 +19,7 @@ from ...api.http.service import model as model_service
 from ...api.http.service import pipeline as pipeline_service
 from ...api.http.service import bot as bot_service
 from ...api.http.service import knowledge as knowledge_service
+from ...api.http.service import mcp as mcp_service
 from ...discover import engine as discover_engine
 from ...storage import mgr as storagemgr
 from ...utils import logcache
@@ -126,5 +127,8 @@ class BuildAppStage(stage.BootingStage):
         knowledge_service_inst = knowledge_service.KnowledgeService(ap)
         ap.knowledge_service = knowledge_service_inst
 
+        mcp_service_inst = mcp_service.MCPService(ap)
+        ap.mcp_service = mcp_service_inst
+
         ctrl = controller.Controller(ap)
         ap.ctrl = ctrl

pkg/core/taskmgr.py

@@ -156,7 +156,7 @@ class TaskWrapper:
                 'state': self.task._state,
                 'exception': self.assume_exception().__str__() if self.assume_exception() is not None else None,
                 'exception_traceback': exception_traceback,
-                'result': self.assume_result().__str__() if self.assume_result() is not None else None,
+                'result': self.assume_result() if self.assume_result() is not None else None,
             },
         }
 

pkg/entity/persistence/mcp.py

@@ -0,0 +1,20 @@
+import sqlalchemy
+
+from .base import Base
+
+
+class MCPServer(Base):
+    __tablename__ = 'mcp_servers'
+
+    uuid = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True, unique=True)
+    name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
+    enable = sqlalchemy.Column(sqlalchemy.Boolean, nullable=False, default=False)
+    mode = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)  # stdio, sse
+    extra_args = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default={})
+    created_at = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False, server_default=sqlalchemy.func.now())
+    updated_at = sqlalchemy.Column(
+        sqlalchemy.DateTime,
+        nullable=False,
+        server_default=sqlalchemy.func.now(),
+        onupdate=sqlalchemy.func.now(),
+    )

pkg/persistence/databases/postgresql.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import sqlalchemy.ext.asyncio as sqlalchemy_asyncio
+
+from .. import database
+
+
+@database.manager_class('postgresql')
+class PostgreSQLDatabaseManager(database.BaseDatabaseManager):
+    """PostgreSQL database manager"""
+
+    async def initialize(self) -> None:
+        postgresql_config = self.ap.instance_config.data.get('database', {}).get('postgresql', {})
+
+        host = postgresql_config.get('host', '127.0.0.1')
+        port = postgresql_config.get('port', 5432)
+        user = postgresql_config.get('user', 'postgres')
+        password = postgresql_config.get('password', 'postgres')
+        database = postgresql_config.get('database', 'postgres')
+        engine_url = f'postgresql+asyncpg://{user}:{password}@{host}:{port}/{database}'
+        self.engine = sqlalchemy_asyncio.create_async_engine(engine_url)

pkg/persistence/databases/sqlite.py

@@ -10,5 +10,6 @@ class SQLiteDatabaseManager(database.BaseDatabaseManager):
     """SQLite database manager"""
 
     async def initialize(self) -> None:
-        sqlite_path = 'data/langbot.db'
-        self.engine = sqlalchemy_asyncio.create_async_engine(f'sqlite+aiosqlite:///{sqlite_path}')
+        db_file_path = self.ap.instance_config.data.get('database', {}).get('sqlite', {}).get('path', 'data/langbot.db')
+        engine_url = f'sqlite+aiosqlite:///{db_file_path}'
+        self.engine = sqlalchemy_asyncio.create_async_engine(engine_url)

pkg/persistence/mgr.py

@@ -36,11 +36,13 @@ class PersistenceManager:
         self.meta = base.Base.metadata
 
     async def initialize(self):
-        self.ap.logger.info('Initializing database...')
-
+        database_type = self.ap.instance_config.data.get('database', {}).get('use', 'sqlite')
+        self.ap.logger.info(f'Initializing database type: {database_type}...')
         for manager in database.preregistered_managers:
-            self.db = manager(self.ap)
-            await self.db.initialize()
+            if manager.name == database_type:
+                self.db = manager(self.ap)
+                await self.db.initialize()
+                break
 
         await self.create_tables()
 

pkg/persistence/migrations/dbm001_migrate_v3_config.py

@@ -212,6 +212,7 @@ class DBMigrateV3Config(migration.DBMigration):
         self.ap.instance_config.data['api']['port'] = self.ap.system_cfg.data['http-api']['port']
         self.ap.instance_config.data['command'] = {
             'prefix': self.ap.command_cfg.data['command-prefix'],
+            'enable': self.ap.command_cfg.data['command-enable'] if 'command-enable' in self.ap.command_cfg.data else True,
             'privilege': self.ap.command_cfg.data['privilege'],
         }
         self.ap.instance_config.data['concurrency']['pipeline'] = self.ap.system_cfg.data['pipeline-concurrency']

pkg/persistence/migrations/dbm006_langflow_api_config.py

@@ -0,0 +1,45 @@
+from .. import migration
+
+import sqlalchemy
+
+from ...entity.persistence import pipeline as persistence_pipeline
+
+
+@migration.migration_class(6)
+class DBMigrateLangflowApiConfig(migration.DBMigration):
+    """Langflow API config"""
+
+    async def upgrade(self):
+        """Upgrade"""
+        # read all pipelines
+        pipelines = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_pipeline.LegacyPipeline))
+
+        for pipeline in pipelines:
+            serialized_pipeline = self.ap.persistence_mgr.serialize_model(persistence_pipeline.LegacyPipeline, pipeline)
+
+            config = serialized_pipeline['config']
+
+            if 'langflow-api' not in config['ai']:
+                config['ai']['langflow-api'] = {
+                    'base-url': 'http://localhost:7860',
+                    'api-key': 'your-api-key',
+                    'flow-id': 'your-flow-id',
+                    'input-type': 'chat',
+                    'output-type': 'chat',
+                    'tweaks': '{}',
+                }
+
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.update(persistence_pipeline.LegacyPipeline)
+                .where(persistence_pipeline.LegacyPipeline.uuid == serialized_pipeline['uuid'])
+                .values(
+                    {
+                        'config': config,
+                        'for_version': self.ap.ver_mgr.get_current_version(),
+                    }
+                )
+            )
+
+    async def downgrade(self):
+        """Downgrade"""
+        pass

pkg/persistence/migrations/dbm007_plugin_install_source.py

@@ -2,16 +2,28 @@ import sqlalchemy
 from .. import migration
 
 
-@migration.migration_class(6)
+@migration.migration_class(7)
 class DBMigratePluginInstallSource(migration.DBMigration):
     """插件安装来源"""
 
     async def upgrade(self):
         """升级"""
         # 查询表结构获取所有列名（异步执行 SQL）
-        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.text('PRAGMA table_info(plugin_settings);'))
-        # fetchall() 是同步方法，无需 await
-        columns = [row[1] for row in result.fetchall()]
+
+        columns = []
+
+        if self.ap.persistence_mgr.db.name == 'postgresql':
+            result = await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text(
+                    "SELECT column_name FROM information_schema.columns WHERE table_name = 'plugin_settings';"
+                )
+            )
+            all_result = result.fetchall()
+            columns = [row[0] for row in all_result]
+        else:
+            result = await self.ap.persistence_mgr.execute_async(sqlalchemy.text('PRAGMA table_info(plugin_settings);'))
+            all_result = result.fetchall()
+            columns = [row[1] for row in all_result]
 
         # 检查并添加 install_source 列
         if 'install_source' not in columns:

pkg/persistence/migrations/dbm008_plugin_config.py

@@ -1,7 +1,7 @@
 from .. import migration
 
 
-@migration.migration_class(4)
+@migration.migration_class(8)
 class DBMigratePluginConfig(migration.DBMigration):
     """插件配置"""
 
@@ -10,7 +10,9 @@ class DBMigratePluginConfig(migration.DBMigration):
 
         if 'plugin' not in self.ap.instance_config.data:
             self.ap.instance_config.data['plugin'] = {
-                'runtime_ws_url': 'ws://localhost:5400/control/ws',
+                'runtime_ws_url': 'ws://langbot_plugin_runtime:5400/control/ws',
+                'enable_marketplace': True,
+                'cloud_service_url': 'https://space.langbot.app',
             }
 
             await self.ap.instance_config.dump_config()

pkg/pipeline/bansess/bansess.py

@@ -30,6 +30,10 @@ class BanSessionCheckStage(stage.PipelineStage):
                 if sess == f'{query.launcher_type.value}_{query.launcher_id}':
                     found = True
                     break
+                # 使用 *_id 来表示加白/拉黑某用户的私聊和群聊场景
+                if sess.startswith('*_') and (sess[2:] == query.launcher_id or sess[2:] == query.sender_id):
+                    found = True
+                    break
 
         ctn = False
 

pkg/pipeline/longtext/longtext.py

@@ -21,10 +21,15 @@ class LongTextProcessStage(stage.PipelineStage):
         - resp_message_chain
     """
 
-    strategy_impl: strategy.LongTextStrategy
+    strategy_impl: strategy.LongTextStrategy | None
 
     async def initialize(self, pipeline_config: dict):
         config = pipeline_config['output']['long-text-processing']
+
+        if config['strategy'] == 'none':
+            self.strategy_impl = None
+            return
+
         if config['strategy'] == 'image':
             use_font = config['font-path']
             try:
@@ -67,6 +72,10 @@ class LongTextProcessStage(stage.PipelineStage):
         await self.strategy_impl.initialize()
 
     async def process(self, query: pipeline_query.Query, stage_inst_name: str) -> entities.StageProcessResult:
+        if self.strategy_impl is None:
+            self.ap.logger.debug('Long message processing strategy is not set, skip long message processing.')
+            return entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
+
         # 检查是否包含非 Plain 组件
         contains_non_plain = False
 

pkg/pipeline/longtext/strategies/forward.py

@@ -26,7 +26,7 @@ class ForwardComponentStrategy(strategy_model.LongTextStrategy):
             platform_message.ForwardMessageNode(
                 sender_id=query.adapter.bot_account_id,
                 sender_name='User',
-                message_chain=platform_message.MessageChain([message]),
+                message_chain=platform_message.MessageChain([platform_message.Plain(text=message)]),
             )
         ]
 

pkg/pipeline/pipelinemgr.py

@@ -96,7 +96,7 @@ class RuntimePipeline:
             if query.pipeline_config['output']['misc']['at-sender'] and isinstance(
                 query.message_event, platform_events.GroupMessage
             ):
-                result.user_notice.insert(0, platform_message.At(query.message_event.sender.id))
+                result.user_notice.insert(0, platform_message.At(target=query.message_event.sender.id))
             if await query.adapter.is_stream_output_supported():
                 await query.adapter.reply_message_chunk(
                     message_source=query.message_event,
@@ -213,7 +213,7 @@ class RuntimePipeline:
             await self._execute_from_stage(0, query)
         except Exception as e:
             inst_name = query.current_stage_name if query.current_stage_name else 'unknown'
-            self.ap.logger.error(f'处理请求时出错 query_id={query.query_id} stage={inst_name} : {e}')
+            self.ap.logger.error(f'Error processing query {query.query_id} stage={inst_name} : {e}')
             self.ap.logger.error(f'Traceback: {traceback.format_exc()}')
         finally:
             self.ap.logger.debug(f'Query {query.query_id} processed')

pkg/pipeline/preproc/preproc.py

@@ -35,11 +35,17 @@ class PreProcessor(stage.PipelineStage):
         session = await self.ap.sess_mgr.get_session(query)
 
         # When not local-agent, llm_model is None
-        llm_model = (
-            await self.ap.model_mgr.get_model_by_uuid(query.pipeline_config['ai']['local-agent']['model'])
-            if selected_runner == 'local-agent'
-            else None
-        )
+        try:
+            llm_model = (
+                await self.ap.model_mgr.get_model_by_uuid(query.pipeline_config['ai']['local-agent']['model'])
+                if selected_runner == 'local-agent'
+                else None
+            )
+        except ValueError:
+            self.ap.logger.warning(
+                f'LLM model {query.pipeline_config["ai"]["local-agent"]["model"] + " "}not found or not configured'
+            )
+            llm_model = None
 
         conversation = await self.ap.sess_mgr.get_conversation(
             query,
@@ -54,10 +60,9 @@ class PreProcessor(stage.PipelineStage):
         query.prompt = conversation.prompt.copy()
         query.messages = conversation.messages.copy()
 
-        query.use_llm_model_uuid = llm_model.model_entity.uuid
-
-        if selected_runner == 'local-agent':
+        if selected_runner == 'local-agent' and llm_model:
             query.use_funcs = []
+            query.use_llm_model_uuid = llm_model.model_entity.uuid
 
             if llm_model.model_entity.abilities.__contains__('func_call'):
                 query.use_funcs = await self.ap.tool_mgr.get_all_tools()
@@ -73,7 +78,11 @@ class PreProcessor(stage.PipelineStage):
 
         # Check if this model supports vision, if not, remove all images
         # TODO this checking should be performed in runner, and in this stage, the image should be reserved
-        if selected_runner == 'local-agent' and not llm_model.model_entity.abilities.__contains__('vision'):
+        if (
+            selected_runner == 'local-agent'
+            and llm_model
+            and not llm_model.model_entity.abilities.__contains__('vision')
+        ):
             for msg in query.messages:
                 if isinstance(msg.content, list):
                     for me in msg.content:
@@ -90,15 +99,22 @@ class PreProcessor(stage.PipelineStage):
                 content_list.append(provider_message.ContentElement.from_text(me.text))
                 plain_text += me.text
             elif isinstance(me, platform_message.Image):
-                if selected_runner != 'local-agent' or llm_model.model_entity.abilities.__contains__('vision'):
+                if selected_runner != 'local-agent' or (
+                    llm_model and llm_model.model_entity.abilities.__contains__('vision')
+                ):
                     if me.base64 is not None:
                         content_list.append(provider_message.ContentElement.from_image_base64(me.base64))
+            elif isinstance(me, platform_message.File):
+                # if me.url is not None:
+                content_list.append(provider_message.ContentElement.from_file_url(me.url, me.name))
             elif isinstance(me, platform_message.Quote) and qoute_msg:
                 for msg in me.origin:
                     if isinstance(msg, platform_message.Plain):
                         content_list.append(provider_message.ContentElement.from_text(msg.text))
                     elif isinstance(msg, platform_message.Image):
-                        if selected_runner != 'local-agent' or llm_model.model_entity.abilities.__contains__('vision'):
+                        if selected_runner != 'local-agent' or (
+                            llm_model and llm_model.model_entity.abilities.__contains__('vision')
+                        ):
                             if msg.base64 is not None:
                                 content_list.append(provider_message.ContentElement.from_image_base64(msg.base64))
 

pkg/pipeline/process/handlers/chat.py

@@ -9,7 +9,6 @@ from .. import handler
 from ... import entities
 from ....provider import runner as runner_module
 
-import langbot_plugin.api.entities.builtin.platform.message as platform_message
 import langbot_plugin.api.entities.events as events
 from ....utils import importutil
 from ....provider import runners
@@ -46,18 +45,20 @@ class ChatMessageHandler(handler.MessageHandler):
 
         event_ctx = await self.ap.plugin_connector.emit_event(event)
 
+        is_create_card = False  # 判断下是否需要创建流式卡片
+
         if event_ctx.is_prevented_default():
-            if event_ctx.event.reply is not None:
-                mc = platform_message.MessageChain(event_ctx.event.reply)
+            if event_ctx.event.reply_message_chain is not None:
+                mc = event_ctx.event.reply_message_chain
                 query.resp_messages.append(mc)
 
                 yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
             else:
                 yield entities.StageProcessResult(result_type=entities.ResultType.INTERRUPT, new_query=query)
         else:
-            if event_ctx.event.alter is not None:
+            if event_ctx.event.user_message_alter is not None:
                 # if isinstance(event_ctx.event, str):  # 现在暂时不考虑多模态alter
-                query.user_message.content = event_ctx.event.alter
+                query.user_message.content = event_ctx.event.user_message_alter
 
             text_length = 0
             try:
@@ -74,14 +75,17 @@ class ChatMessageHandler(handler.MessageHandler):
                     raise ValueError(f'未找到请求运行器: {query.pipeline_config["ai"]["runner"]["runner"]}')
                 if is_stream:
                     resp_message_id = uuid.uuid4()
-                    await query.adapter.create_message_card(str(resp_message_id), query.message_event)
+
                     async for result in runner.run(query):
                         result.resp_message_id = str(resp_message_id)
                         if query.resp_messages:
                             query.resp_messages.pop()
                         if query.resp_message_chain:
                             query.resp_message_chain.pop()
-
+                        # 此时连接外部 AI 服务正常,创建卡片
+                        if not is_create_card:  # 只有不是第一次才创建卡片
+                            await query.adapter.create_message_card(str(resp_message_id), query.message_event)
+                            is_create_card = True
                         query.resp_messages.append(result)
                         self.ap.logger.info(f'对话({query.query_id})流式响应: {self.cut_str(result.readable_str())}')
 

pkg/pipeline/process/handlers/command.py

@@ -5,7 +5,6 @@ import typing
 from .. import handler
 from ... import entities
 import langbot_plugin.api.entities.builtin.provider.message as provider_message
-import langbot_plugin.api.entities.builtin.platform.message as platform_message
 import langbot_plugin.api.entities.builtin.provider.session as provider_session
 import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
 import langbot_plugin.api.entities.events as events
@@ -18,7 +17,9 @@ class CommandHandler(handler.MessageHandler):
     ) -> typing.AsyncGenerator[entities.StageProcessResult, None]:
         """Process"""
 
-        command_text = str(query.message_chain).strip()[1:]
+        full_command_text = str(query.message_chain).strip()
+
+        command_text = full_command_text[1:]
 
         privilege = 1
 
@@ -39,7 +40,7 @@ class CommandHandler(handler.MessageHandler):
             sender_id=query.sender_id,
             command=spt[0],
             params=spt[1:] if len(spt) > 1 else [],
-            text_message=str(query.message_chain),
+            text_message=full_command_text,
             is_admin=(privilege == 2),
             query=query,
         )
@@ -47,8 +48,8 @@ class CommandHandler(handler.MessageHandler):
         event_ctx = await self.ap.plugin_connector.emit_event(event)
 
         if event_ctx.is_prevented_default():
-            if event_ctx.event.reply is not None:
-                mc = platform_message.MessageChain(event_ctx.event.reply)
+            if event_ctx.event.reply_message_chain is not None:
+                mc = event_ctx.event.reply_message_chain
 
                 query.resp_messages.append(mc)
 
@@ -57,12 +58,11 @@ class CommandHandler(handler.MessageHandler):
                 yield entities.StageProcessResult(result_type=entities.ResultType.INTERRUPT, new_query=query)
 
         else:
-            if event_ctx.event.alter is not None:
-                query.message_chain = platform_message.MessageChain([platform_message.Plain(event_ctx.event.alter)])
-
             session = await self.ap.sess_mgr.get_session(query)
 
-            async for ret in self.ap.cmd_mgr.execute(command_text=command_text, query=query, session=session):
+            async for ret in self.ap.cmd_mgr.execute(
+                command_text=command_text, full_command_text=full_command_text, query=query, session=session
+            ):
                 if ret.error is not None:
                     query.resp_messages.append(
                         provider_message.Message(
@@ -74,7 +74,12 @@ class CommandHandler(handler.MessageHandler):
                     self.ap.logger.info(f'Command({query.query_id}) error: {self.cut_str(str(ret.error))}')
 
                     yield entities.StageProcessResult(result_type=entities.ResultType.CONTINUE, new_query=query)
-                elif ret.text is not None or ret.image_url is not None:
+                elif (
+                    ret.text is not None
+                    or ret.image_url is not None
+                    or ret.image_base64 is not None
+                    or ret.file_url is not None
+                ):
                     content: list[provider_message.ContentElement] = []
 
                     if ret.text is not None:
@@ -83,6 +88,12 @@ class CommandHandler(handler.MessageHandler):
                     if ret.image_url is not None:
                         content.append(provider_message.ContentElement.from_image_url(ret.image_url))
 
+                    if ret.image_base64 is not None:
+                        content.append(provider_message.ContentElement.from_image_base64(ret.image_base64))
+
+                    if ret.file_url is not None:
+                        # 此时为 file 类型
+                        content.append(provider_message.ContentElement.from_file_url(ret.file_url, ret.file_name))
                     query.resp_messages.append(
                         provider_message.Message(
                             role='command',

pkg/pipeline/process/process.py

@@ -42,12 +42,14 @@ class Processor(stage.PipelineStage):
 
         async def generator():
             cmd_prefix = self.ap.instance_config.data['command']['prefix']
+            cmd_enable = self.ap.instance_config.data['command'].get('enable', True)
 
-            if any(message_text.startswith(prefix) for prefix in cmd_prefix):
-                async for result in self.cmd_handler.handle(query):
-                    yield result
+            if cmd_enable and any(message_text.startswith(prefix) for prefix in cmd_prefix):
+                handler_to_use = self.cmd_handler
             else:
-                async for result in self.chat_handler.handle(query):
-                    yield result
+                handler_to_use = self.chat_handler
+
+            async for result in handler_to_use.handle(query):
+                yield result
 
         return generator()

pkg/pipeline/respback/respback.py

@@ -33,7 +33,7 @@ class SendResponseBackStage(stage.PipelineStage):
         if query.pipeline_config['output']['misc']['at-sender'] and isinstance(
             query.message_event, platform_events.GroupMessage
         ):
-            query.resp_message_chain[-1].insert(0, platform_message.At(query.message_event.sender.id))
+            query.resp_message_chain[-1].insert(0, platform_message.At(target=query.message_event.sender.id))
 
         quote_origin = query.pipeline_config['output']['misc']['quote-origin']
 

pkg/pipeline/resprule/rules/atbot.py

@@ -16,26 +16,17 @@ class AtBotRule(rule_model.GroupRespondRule):
         rule_dict: dict,
         query: pipeline_query.Query,
     ) -> entities.RuleJudgeResult:
+        found = False
+
         def remove_at(message_chain: platform_message.MessageChain):
+            nonlocal found
             for component in message_chain.root:
-                if isinstance(component, platform_message.At) and component.target == query.adapter.bot_account_id:
+                if isinstance(component, platform_message.At) and str(component.target) == str(query.adapter.bot_account_id):
                     message_chain.remove(component)
+                    found = True
                     break
 
         remove_at(message_chain)
         remove_at(message_chain)  # 回复消息时会at两次，检查并删除重复的
 
-        # if message_chain.has(platform_message.At(query.adapter.bot_account_id)) and rule_dict['at']:
-        #     message_chain.remove(platform_message.At(query.adapter.bot_account_id))
-
-        #     if message_chain.has(
-        #         platform_message.At(query.adapter.bot_account_id)
-        #     ):  # 回复消息时会at两次，检查并删除重复的
-        #         message_chain.remove(platform_message.At(query.adapter.bot_account_id))
-
-        #     return entities.RuleJudgeResult(
-        #         matching=True,
-        #         replacement=message_chain,
-        #     )
-
-        return entities.RuleJudgeResult(matching=False, replacement=message_chain)
+        return entities.RuleJudgeResult(matching=found, replacement=message_chain)

pkg/pipeline/wrapper/wrapper.py

@@ -80,8 +80,8 @@ class ResponseWrapper(stage.PipelineStage):
                                 new_query=query,
                             )
                         else:
-                            if event_ctx.event.reply is not None:
-                                query.resp_message_chain.append(platform_message.MessageChain(event_ctx.event.reply))
+                            if event_ctx.event.reply_message_chain is not None:
+                                query.resp_message_chain.append(event_ctx.event.reply_message_chain)
 
                             else:
                                 query.resp_message_chain.append(result.get_content_platform_message_chain())
@@ -123,10 +123,8 @@ class ResponseWrapper(stage.PipelineStage):
                                     new_query=query,
                                 )
                             else:
-                                if event_ctx.event.reply is not None:
-                                    query.resp_message_chain.append(
-                                        platform_message.MessageChain(text=event_ctx.event.reply)
-                                    )
+                                if event_ctx.event.reply_message_chain is not None:
+                                    query.resp_message_chain.append(event_ctx.event.reply_message_chain)
 
                                 else:
                                     query.resp_message_chain.append(

pkg/platform/sources/dingtalk.py

@@ -20,6 +20,9 @@ class DingTalkMessageConverter(abstract_platform_adapter.AbstractMessageConverte
                 at = True
             if type(msg) is platform_message.Plain:
                 content += msg.text
+            if type(msg) is platform_message.Forward:
+                for node in msg.node_list:
+                    content += (await DingTalkMessageConverter.yiri2target(node.message_chain))[0]
         return content, at
 
     @staticmethod
@@ -38,6 +41,8 @@ class DingTalkMessageConverter(abstract_platform_adapter.AbstractMessageConverte
             yiri_msg_list.append(platform_message.Plain(text=text_content))
         if event.picture:
             yiri_msg_list.append(platform_message.Image(base64=event.picture))
+        if event.file:
+            yiri_msg_list.append(platform_message.File(url=event.file, name=event.name))
         if event.audio:
             yiri_msg_list.append(platform_message.Voice(base64=event.audio))
 
@@ -58,7 +63,7 @@ class DingTalkEventConverter(abstract_platform_adapter.AbstractEventConverter):
         if event.conversation == 'FriendMessage':
             return platform_events.FriendMessage(
                 sender=platform_entities.Friend(
-                    id=event.incoming_message.sender_id,
+                    id=event.incoming_message.sender_staff_id,
                     nickname=event.incoming_message.sender_nick,
                     remark='',
                 ),
@@ -68,7 +73,7 @@ class DingTalkEventConverter(abstract_platform_adapter.AbstractEventConverter):
             )
         elif event.conversation == 'GroupMessage':
             sender = platform_entities.GroupMember(
-                id=event.incoming_message.sender_id,
+                id=event.incoming_message.sender_staff_id,
                 member_name=event.incoming_message.sender_nick,
                 permission='MEMBER',
                 group=platform_entities.Group(
@@ -99,13 +104,9 @@ class DingTalkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
     card_instance_id_dict: (
         dict  # 回复卡片消息字典，key为消息id，value为回复卡片实例id，用于在流式消息时判断是否发送到指定卡片
     )
-    seq: int  # 消息顺序，直接以seq作为标识
 
     def __init__(self, config: dict, logger: EventLogger):
-        self.config = config
-        self.logger = logger
-        self.card_instance_id_dict = {}
-        # self.seq = 1
+
         required_keys = [
             'client_id',
             'client_secret',
@@ -115,16 +116,23 @@ class DingTalkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         missing_keys = [key for key in required_keys if key not in config]
         if missing_keys:
             raise Exception('钉钉缺少相关配置项，请查看文档或联系管理员')
+        bot = DingTalkClient(
+                client_id=config['client_id'],
+                client_secret=config['client_secret'],
+                robot_name=config['robot_name'],
+                robot_code=config['robot_code'],
+                markdown_card=config['markdown_card'],
+                logger=logger,
+            )
+        bot_account_id = config['robot_name']
+        super().__init__(
+            config=config,
+            logger=logger,
+            card_instance_id_dict={},
+            bot_account_id=bot_account_id,
+            bot=bot,
+            listeners={},
 
-        self.bot_account_id = self.config['robot_name']
-
-        self.bot = DingTalkClient(
-            client_id=config['client_id'],
-            client_secret=config['client_secret'],
-            robot_name=config['robot_name'],
-            robot_code=config['robot_code'],
-            markdown_card=config['markdown_card'],
-            logger=self.logger,
         )
 
     async def reply_message(
@@ -162,8 +170,11 @@ class DingTalkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
             content, at = await DingTalkMessageConverter.yiri2target(message)
 
             card_instance, card_instance_id = self.card_instance_id_dict[message_id]
+            if not content and bot_message.content:
+                content = bot_message.content  # 兼容直接传入content的情况
             # print(card_instance_id)
-            await self.bot.send_card_message(card_instance, card_instance_id, content, is_final)
+            if content:
+                await self.bot.send_card_message(card_instance, card_instance_id, content, is_final)
             if is_final and bot_message.tool_calls is None:
                 # self.seq = 1  # 消息回复结束之后重置seq
                 self.card_instance_id_dict.pop(message_id)  # 消息回复结束之后删除卡片实例id
@@ -216,6 +227,9 @@ class DingTalkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
     async def kill(self) -> bool:
         return False
 
+    async def is_muted(self) -> bool:
+        return False
+
     async def unregister_listener(
         self,
         event_type: type,

pkg/platform/sources/discord.py

@@ -22,6 +22,7 @@ import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_
 from ..logger import EventLogger
 
 
+
 # 语音功能相关异常定义
 class VoiceConnectionError(Exception):
     """语音连接基础异常"""

pkg/platform/sources/lark.py

@@ -620,15 +620,13 @@ class LarkAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
                     f'client.cardkit.v1.card.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}'
                 )
 
-            self.ap.logger.debug(f'飞书卡片创建成功,卡片ID: {response.data.card_id}')
             self.card_id_dict[message_id] = response.data.card_id
 
             card_id = response.data.card_id
             return card_id
 
         except Exception as e:
-            self.ap.logger.error(f'飞书卡片创建失败,错误信息: {e}')
-
+            raise e
     async def create_message_card(self, message_id, event) -> str:
         """
         创建卡片消息。

pkg/platform/sources/line.py

@@ -0,0 +1,286 @@
+import typing
+import quart
+
+
+import traceback
+import typing
+import asyncio
+import re
+import base64
+import uuid
+import json
+import datetime
+import hashlib
+from Crypto.Cipher import AES
+
+
+from ...core import app
+import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+from ..logger import EventLogger
+
+
+
+from linebot.v3 import (
+    WebhookHandler
+)
+from linebot.v3.exceptions import (
+    InvalidSignatureError
+)
+from linebot.v3.messaging import (
+    Configuration,
+    ApiClient,
+    MessagingApi,
+    ReplyMessageRequest,
+    TextMessage,
+    ImageMessage
+)
+from linebot.v3.webhooks import (
+    MessageEvent,
+    TextMessageContent,
+    ImageMessageContent,
+    VideoMessageContent,
+    AudioMessageContent,
+    FileMessageContent,
+    LocationMessageContent,
+    StickerMessageContent
+)
+
+# from linebot import WebhookParser
+from linebot.v3.webhook import WebhookParser
+from linebot.v3.messaging import MessagingApiBlob
+
+
+
+class LINEMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain, api_client: ApiClient
+    ) -> typing.Tuple[list]:
+        content_list = []
+        for component in message_chain:
+            if isinstance(component, platform_message.At):
+                content_list.append({'type': 'at', 'target': component.target})
+            elif isinstance(component, platform_message.Plain):
+                content_list.append({'type': 'text', 'content': component.text})
+            elif isinstance(component, platform_message.Image):
+                if not component.url:
+                    pass
+                content_list.append({'type': 'image', 'image': component.url})
+
+            elif isinstance(component, platform_message.Voice):
+                content_list.append({'type': 'voice', 'url': component.url, 'length': component.length})
+            
+
+        return content_list
+
+    @staticmethod
+    async def target2yiri(
+        message,
+        bot_client
+    ) -> platform_message.MessageChain:
+        lb_msg_list = []
+        msg_create_time = datetime.datetime.fromtimestamp(int(message.timestamp) / 1000)
+
+        lb_msg_list.append(platform_message.Source(id=message.webhook_event_id, time=msg_create_time))
+
+        if isinstance(message.message, TextMessageContent):
+            lb_msg_list.append(platform_message.Plain(text=message.message.text))
+        elif isinstance(message.message, AudioMessageContent):
+            pass
+        elif isinstance(message.message, VideoMessageContent):
+            pass
+        elif isinstance(message.message, ImageMessageContent):
+            message_content = MessagingApiBlob(bot_client).get_message_content(message.message.id)
+
+            base64_string = base64.b64encode(message_content).decode('utf-8')
+
+            # 如果需要Data URI格式（用于直接嵌入HTML等）
+            # 首先需要知道图片类型，LINE图片通常是JPEG
+            data_uri = f"data:image/jpeg;base64,{base64_string}"
+            lb_msg_list.append(platform_message.Image(base64 = data_uri))
+        return platform_message.MessageChain(lb_msg_list)
+
+
+class LINEEventConverter(abstract_platform_adapter.AbstractEventConverter):
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.MessageEvent,
+    ) -> MessageEvent:
+        pass
+
+    @staticmethod
+    async def target2yiri(
+        event,
+        bot_client
+    ) -> platform_events.Event:
+        message_chain = await LINEMessageConverter.target2yiri(event, bot_client)
+
+        if event.source.type== 'user':
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.message.id,
+                    nickname=event.source.user_id,
+                    remark='',
+                ),
+                message_chain=message_chain,
+                time=event.timestamp,
+                source_platform_object=event,
+            )
+        else:
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=event.event.sender.sender_id.open_id,
+                    member_name=event.event.sender.sender_id.union_id,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event.message.id,
+                        name='',
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title='',
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event.timestamp,
+                source_platform_object=event,
+            )
+
+class LINEAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
+    bot: MessagingApi
+    api_client: ApiClient
+
+    bot_account_id: str  # 用于在流水线中识别at是否是本bot，直接以bot_name作为标识
+    message_converter: LINEMessageConverter
+    event_converter: LINEEventConverter
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ]
+
+    config: dict
+    quart_app: quart.Quart
+
+
+    card_id_dict: dict[str, str]  # 消息id到卡片id的映射，便于创建卡片后的发送消息到指定卡片
+
+    seq: int  # 用于在发送卡片消息中识别消息顺序，直接以seq作为标识
+
+    def __init__(self, config: dict, logger: EventLogger):
+        configuration = Configuration(access_token=config['channel_access_token'])
+        line_webhook = WebhookHandler(config['channel_secret'])
+        parser = WebhookParser(config['channel_secret'])
+        api_client = ApiClient(configuration)
+
+        bot_account_id = config.get('bot_account_id', 'langbot')
+
+
+        super().__init__(
+            config = config,
+            logger = logger,
+            quart_app = quart.Quart(__name__),
+            listeners = {},
+            card_id_dict = {},
+            seq = 1,
+            event_converter = LINEEventConverter(),
+            message_converter = LINEMessageConverter(),
+            line_webhook = line_webhook,
+            parser = parser,
+            configuration=configuration,
+            api_client = api_client,
+            bot = MessagingApi(api_client),
+            bot_account_id = bot_account_id,
+        )
+
+        @self.quart_app.route('/line/callback', methods=['POST'])
+        async def line_callback():
+            try:
+                signature = quart.request.headers.get('X-Line-Signature')
+                body = await quart.request.get_data(as_text=True)
+                events = parser.parse(body, signature)  # 解密解析消息
+
+                try:
+
+                    # print(events)
+                    lb_event = await self.event_converter.target2yiri(events[0], self.api_client)
+                    if lb_event.__class__ in self.listeners:
+                        await self.listeners[lb_event.__class__](lb_event, self)
+                except InvalidSignatureError:
+                    self.logger.info(f"Invalid signature. Please check your channel access token/channel secret.{traceback.format_exc()}")
+                    return quart.Response('Invalid signature', status=400)
+
+
+                return {'code': 200, 'message': 'ok'}
+            except Exception:
+                await self.logger.error(f'Error in LINE callback: {traceback.format_exc()}')
+                return {'code': 500, 'message': 'error'}
+        
+        
+
+
+    
+
+    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
+        
+        pass
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        content_list = await self.message_converter.yiri2target(message, self.api_client)
+
+        for content in content_list:
+            if content['type'] == 'text':
+                self.bot.reply_message_with_http_info(
+                    ReplyMessageRequest(
+                        reply_token=message_source.source_platform_object.reply_token,
+                        messages=[TextMessage(text=content['content'])]
+                    )
+                )
+            elif content['type'] == 'image':
+                 self.bot.reply_message_with_http_info(
+                    ReplyMessageRequest(
+                        reply_token=message_source.source_platform_object.reply_token,
+                        messages=[ImageMessage(text=content['content'])]
+                    )
+                )
+
+    async def is_muted(self, group_id: int) -> bool:
+        return False
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ):
+        self.listeners.pop(event_type)
+
+    async def run_async(self):
+        port = self.config['port']
+
+        async def shutdown_trigger_placeholder():
+            while True:
+                await asyncio.sleep(1)
+        await self.quart_app.run_task(
+            host='0.0.0.0',
+            port=port,
+            shutdown_trigger=shutdown_trigger_placeholder,
+        )
+
+    async def kill(self) -> bool:
+        pass

pkg/platform/sources/line.yaml

@@ -0,0 +1,54 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: LINE
+  label:
+    en_US: LINE
+    zh_Hans: LINE
+  description:
+    en_US: LINE Adapter
+    zh_Hans: LINE适配器，请查看文档了解使用方式
+    ja_JP: LINEアダプター、ドキュメントを参照してください
+    zh_Hant: LINE適配器，請查看文檔了解使用方式
+  icon: line.png
+spec:
+  config:
+    - name: channel_access_token
+      label:
+        en_US: Channel access token
+        zh_Hans: 频道访问令牌
+        ja_JP: チャンネルアクセストークン
+        zh_Hant: 頻道訪問令牌
+      type: string
+      required: true
+      default: ""
+    - name: port
+      label:
+        en_US: Webhook Port
+        zh_Hans: Webhook端口
+      description:
+        en_US: Only valid when webhook mode is enabled, please fill in the webhook port
+        zh_Hans: 请填写 Webhook 端口
+        ja_JP: Webhookポートを入力してください
+        zh_Hant: 請填寫 Webhook 端口
+      type: integer
+      required: true
+      default: 2287
+    - name: channel_secret
+      label:
+        en_US: Channel secret
+        zh_Hans: 消息密钥
+        ja_JP: チャンネルシークレット
+        zh_Hant: 消息密钥
+      description:
+        en_US: Only valid when webhook mode is enabled, please fill in the encrypt key
+        zh_Hans: 请填写加密密钥
+        ja_JP: Webhookモードが有効な場合にのみ、暗号化キーを入力してください
+        zh_Hant: 請填寫加密密钥
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./line.py
+    attr: LINEAdapter

pkg/platform/sources/officialaccount.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import typing
 import asyncio
 import traceback
-
+import pydantic
 import datetime
 import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
 from libs.official_account_api.oaevent import OAEvent
@@ -56,47 +56,51 @@ class OAEventConverter(abstract_platform_adapter.AbstractEventConverter):
 
 
 class OfficialAccountAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
-    bot: OAClient | OAClientForLongerResponse
-    bot_account_id: str
     message_converter: OAMessageConverter = OAMessageConverter()
     event_converter: OAEventConverter = OAEventConverter()
-    config: dict
+    bot: typing.Union[OAClient, OAClientForLongerResponse] = pydantic.Field(exclude=True)
 
     def __init__(self, config: dict, logger: EventLogger):
-        self.config = config
-        self.logger = logger
-
-        required_keys = [
-            'token',
-            'EncodingAESKey',
-            'AppSecret',
-            'AppID',
-            'Mode',
-        ]
-        missing_keys = [key for key in required_keys if key not in config]
+        required_keys = ['token', 'EncodingAESKey', 'AppSecret', 'AppID', 'Mode']
+        missing_keys = [k for k in required_keys if k not in config]
         if missing_keys:
-            raise command_errors.ParamNotEnoughError('微信公众号缺少相关配置项，请查看文档或联系管理员')
+            raise Exception(f'OfficialAccount 缺少配置项: {missing_keys}')
 
-        if self.config['Mode'] == 'drop':
-            self.bot = OAClient(
+        
+        if config['Mode'] == 'drop':
+            bot = OAClient(
                 token=config['token'],
                 EncodingAESKey=config['EncodingAESKey'],
                 Appsecret=config['AppSecret'],
                 AppID=config['AppID'],
-                logger=self.logger,
+                logger=logger,
             )
-        elif self.config['Mode'] == 'passive':
-            self.bot = OAClientForLongerResponse(
+        elif config['Mode'] == 'passive':
+            bot = OAClientForLongerResponse(
                 token=config['token'],
                 EncodingAESKey=config['EncodingAESKey'],
                 Appsecret=config['AppSecret'],
                 AppID=config['AppID'],
-                LoadingMessage=config['LoadingMessage'],
-                logger=self.logger,
+                LoadingMessage=config.get('LoadingMessage', ''),
+                logger=logger,
             )
         else:
             raise KeyError('请设置微信公众号通信模式')
 
+        bot_account_id = config.get('AppID', '')
+
+        
+        super().__init__(
+            bot=bot,
+            bot_account_id=bot_account_id,
+            config=config,
+            logger=logger,
+        )
+
+
+
+
+
     async def reply_message(
         self,
         message_source: platform_events.FriendMessage,
@@ -154,3 +158,6 @@ class OfficialAccountAdapter(abstract_platform_adapter.AbstractMessagePlatformAd
         ],
     ):
         return super().unregister_listener(event_type, callback)
+
+    async def is_muted(self, group_id: str, ) -> bool:
+        pass

pkg/platform/sources/qqofficial.py

@@ -139,19 +139,15 @@ class QQOfficialAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter
     event_converter: QQOfficialEventConverter = QQOfficialEventConverter()
 
     def __init__(self, config: dict, logger: EventLogger):
-        self.config = config
-        self.logger = logger
+        bot = QQOfficialClient(
+            app_id=config['appid'], secret=config['secret'], token=config['token'], logger=logger
+        )
 
-        required_keys = [
-            'appid',
-            'secret',
-        ]
-        missing_keys = [key for key in required_keys if key not in config]
-        if missing_keys:
-            raise command_errors.ParamNotEnoughError('QQ官方机器人缺少相关配置项，请查看文档或联系管理员')
-
-        self.bot = QQOfficialClient(
-            app_id=config['appid'], secret=config['secret'], token=config['token'], logger=self.logger
+        super().__init__(
+            config=config,
+            logger=logger,
+            bot=bot,
+            bot_account_id=config['appid'],
         )
 
     async def reply_message(

pkg/platform/sources/telegram.py

@@ -102,7 +102,7 @@ class TelegramEventConverter(abstract_platform_adapter.AbstractEventConverter):
                 sender=platform_entities.Friend(
                     id=event.effective_chat.id,
                     nickname=event.effective_chat.first_name,
-                    remark=event.effective_chat.id,
+                    remark=str(event.effective_chat.id),
                 ),
                 message_chain=lb_message,
                 time=event.message.date.timestamp(),

pkg/platform/sources/wechatpad.py

@@ -30,10 +30,16 @@ import langbot_plugin.api.definition.abstract.platform.event_logger as abstract_
 
 class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
     def __init__(self, config: dict, logger: abstract_platform_logger.AbstractEventLogger):
+        self.bot = WeChatPadClient(config['wechatpad_url'], config['token'])
         self.config = config
-        self.bot = WeChatPadClient(self.config['wechatpad_url'], self.config['token'])
         self.logger = logger
 
+        # super().__init__(
+        #     config = config,
+        #     bot = bot,
+        #     logger = logger,
+        # )
+
     @staticmethod
     async def yiri2target(message_chain: platform_message.MessageChain) -> list[dict]:
         content_list = []
@@ -133,7 +139,7 @@ class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConvert
             pattern = r'@\S{1,20}'
             content_no_preifx = re.sub(pattern, '', content_no_preifx)
 
-        return platform_message.MessageChain([platform_message.Plain(content_no_preifx)])
+        return platform_message.MessageChain([platform_message.Plain(text=content_no_preifx)])
 
     async def _handler_image(self, message: Optional[dict], content_no_preifx: str) -> platform_message.MessageChain:
         """处理图像消息 (msg_type=3)"""
@@ -259,7 +265,7 @@ class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConvert
             # 文本消息
             try:
                 if '<msg>' not in quote_data:
-                    quote_data_message_list.append(platform_message.Plain(quote_data))
+                    quote_data_message_list.append(platform_message.Plain(text=quote_data))
                 else:
                     # 引用消息展开
                     quote_data_xml = ET.fromstring(quote_data)
@@ -274,7 +280,7 @@ class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConvert
                         quote_data_message_list.extend(await self._handler_compound(None, quote_data))
             except Exception as e:
                 self.logger.error(f'处理引用消息异常 expcetion:{e}')
-                quote_data_message_list.append(platform_message.Plain(quote_data))
+                quote_data_message_list.append(platform_message.Plain(text=quote_data))
             message_list.append(
                 platform_message.Quote(
                     sender_id=sender_id,
@@ -284,7 +290,7 @@ class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConvert
             if len(user_data) > 0:
                 pattern = r'@\S{1,20}'
                 user_data = re.sub(pattern, '', user_data)
-                message_list.append(platform_message.Plain(user_data))
+                message_list.append(platform_message.Plain(text=user_data))
 
         return platform_message.MessageChain(message_list)
 
@@ -450,8 +456,13 @@ class WeChatPadMessageConverter(abstract_platform_adapter.AbstractMessageConvert
 class WeChatPadEventConverter(abstract_platform_adapter.AbstractEventConverter):
     def __init__(self, config: dict, logger: logging.Logger):
         self.config = config
-        self.message_converter = WeChatPadMessageConverter(config, logger)
         self.logger = logger
+        self.message_converter = WeChatPadMessageConverter(self.config, self.logger)
+        # super().__init__(
+        #     config=config,
+        #     message_converter=message_converter,
+        #     logger = logger,
+        # )
 
     @staticmethod
     async def yiri2target(event: platform_events.MessageEvent) -> dict:
@@ -532,12 +543,22 @@ class WeChatPadAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter)
     ] = {}
 
     def __init__(self, config: dict, logger: EventLogger):
-        self.config = config
-        self.logger = logger
-        self.quart_app = quart.Quart(__name__)
+        quart_app = quart.Quart(__name__)
 
-        self.message_converter = WeChatPadMessageConverter(config, logger)
-        self.event_converter = WeChatPadEventConverter(config, logger)
+        message_converter = WeChatPadMessageConverter(config, logger)
+        event_converter = WeChatPadEventConverter(config, logger)
+        bot = WeChatPadClient(config['wechatpad_url'], config['token'])
+        super().__init__(
+            config=config,
+            logger=logger,
+            quart_app=quart_app,
+            message_converter=message_converter,
+            event_converter=event_converter,
+            listeners={},
+            bot_account_id='',
+            name='WeChatPad',
+            bot=bot,
+        )
 
     async def ws_message(self, data):
         """处理接收到的消息"""

pkg/platform/sources/wecom.py

@@ -134,9 +134,7 @@ class WecomAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
     config: dict
 
     def __init__(self, config: dict, logger: EventLogger):
-        self.config = config
-        self.logger = logger
-
+        # 校验必填项
         required_keys = [
             'corpid',
             'secret',
@@ -146,17 +144,27 @@ class WecomAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         ]
         missing_keys = [key for key in required_keys if key not in config]
         if missing_keys:
-            raise command_errors.ParamNotEnoughError('企业微信缺少相关配置项，请查看文档或联系管理员')
+            raise Exception(f'Wecom 缺少配置项: {missing_keys}')
 
-        self.bot = WecomClient(
+        # 创建运行时 bot 对象
+        bot = WecomClient(
             corpid=config['corpid'],
             secret=config['secret'],
             token=config['token'],
             EncodingAESKey=config['EncodingAESKey'],
             contacts_secret=config['contacts_secret'],
-            logger=self.logger,
+            logger=logger,
         )
 
+        
+        super().__init__(
+            config=config,
+            logger=logger,
+            bot=bot,
+            bot_account_id="",
+        )
+
+
     async def reply_message(
         self,
         message_source: platform_events.MessageEvent,
@@ -231,3 +239,6 @@ class WecomAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
         ],
     ):
         return super().unregister_listener(event_type, callback)
+    
+    async def is_muted(self, group_id: int) -> bool:
+        pass

pkg/platform/sources/wecombot.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+
+import datetime
+import langbot_plugin.api.definition.abstract.platform.adapter as abstract_platform_adapter
+import langbot_plugin.api.entities.builtin.platform.message as platform_message
+import langbot_plugin.api.entities.builtin.platform.events as platform_events
+import langbot_plugin.api.entities.builtin.platform.entities as platform_entities
+import pydantic
+from ..logger import  EventLogger
+from libs.wecom_ai_bot_api.wecombotevent import WecomBotEvent
+from libs.wecom_ai_bot_api.api import WecomBotClient
+from ...core import app
+
+class WecomBotMessageConverter(abstract_platform_adapter.AbstractMessageConverter):
+    @staticmethod
+    async def yiri2target(message_chain: platform_message.MessageChain):
+        content = ''
+        for msg in message_chain:
+            if type(msg) is platform_message.Plain:
+                content += msg.text
+        return content
+
+    @staticmethod
+    async def target2yiri(event: WecomBotEvent):
+        yiri_msg_list = []
+        if event.type == 'group':
+            yiri_msg_list.append(platform_message.At(target=event.ai_bot_id))
+        yiri_msg_list.append(platform_message.Source(id=event.message_id, time=datetime.datetime.now()))
+        yiri_msg_list.append(platform_message.Plain(text=event.content))
+        if event.picurl != '':
+            yiri_msg_list.append(platform_message.Image(base64=event.picurl))
+        chain = platform_message.MessageChain(yiri_msg_list)
+
+        return chain
+
+class WecomBotEventConverter(abstract_platform_adapter.AbstractEventConverter):
+
+    @staticmethod
+    async def yiri2target(event:platform_events.MessageEvent):
+        return event.source_platform_object
+    
+    @staticmethod
+    async def target2yiri(event:WecomBotEvent):
+        message_chain = await WecomBotMessageConverter.target2yiri(event)
+        if event.type == 'single':
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.userid,
+                    nickname='',
+                    remark='',
+                ),
+                message_chain=message_chain,
+                time=datetime.datetime.now().timestamp(),
+                source_platform_object=event,
+            )
+        elif event.type == 'group':
+            try:
+                sender = platform_entities.GroupMember(
+                    id=event.userid,
+                    permission='MEMBER',
+                    member_name=event.userid,
+                    group=platform_entities.Group(
+                        id=str(event.chatid),
+                        name='',
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title='',
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                )
+                time = datetime.datetime.now().timestamp()
+                return platform_events.GroupMessage(
+                    sender=sender,
+                    message_chain=message_chain,
+                    time=time,
+                    source_platform_object=event,
+                )
+            except Exception:
+                print(traceback.format_exc())
+
+class WecomBotAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter):
+    bot: WecomBotClient
+    bot_account_id: str
+    message_converter: WecomBotMessageConverter = WecomBotMessageConverter()
+    event_converter: WecomBotEventConverter = WecomBotEventConverter()
+    config: dict
+
+    def __init__(self, config: dict, logger: EventLogger):
+        required_keys = ['Token', 'EncodingAESKey', 'Corpid', 'BotId', 'port']
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise Exception(f'WecomBot 缺少配置项: {missing_keys}')
+
+        # 创建运行时 bot 对象
+        bot = WecomBotClient(
+            Token=config['Token'],
+            EnCodingAESKey=config['EncodingAESKey'],
+            Corpid=config['Corpid'],
+            logger=logger,
+        )
+        bot_account_id = config['BotId']
+
+        super().__init__(
+            config=config,
+            logger=logger,
+            bot=bot,
+            bot_account_id=bot_account_id,
+        )
+
+
+    async def reply_message(self, message_source:platform_events.MessageEvent, message:platform_message.MessageChain,quote_origin: bool = False):
+
+        content = await self.message_converter.yiri2target(message)
+        await self.bot.set_message(message_source.source_platform_object.message_id, content)
+
+    async def reply_message_chunk(
+        self,
+        message_source: platform_events.MessageEvent,
+        bot_message,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+        is_final: bool = False,
+    ):
+        """将流水线增量输出写入企业微信 stream 会话。
+
+        Args:
+            message_source: 流水线提供的原始消息事件。
+            bot_message: 当前片段对应的模型元信息（未使用）。
+            message: 需要回复的消息链。
+            quote_origin: 是否引用原消息（企业微信暂不支持）。
+            is_final: 标记当前片段是否为最终回复。
+
+        Returns:
+            dict: 包含 `stream` 键，标识写入是否成功。
+
+        Example:
+            在流水线 `reply_message_chunk` 调用中自动触发，无需手动调用。
+        """
+        # 转换为纯文本（智能机器人当前协议仅支持文本流）
+        content = await self.message_converter.yiri2target(message)
+        msg_id = message_source.source_platform_object.message_id
+
+        # 将片段推送到 WecomBotClient 中的队列，返回值用于判断是否走降级逻辑
+        success = await self.bot.push_stream_chunk(msg_id, content, is_final=is_final)
+        if not success and is_final:
+            # 未命中流式队列时使用旧有 set_message 兜底
+            await self.bot.set_message(msg_id, content)
+        return {'stream': success}
+
+    async def is_stream_output_supported(self) -> bool:
+        """智能机器人侧默认开启流式能力。
+
+        Returns:
+            bool: 恒定返回 True。
+
+        Example:
+            流水线执行阶段会调用此方法以确认是否启用流式。"""
+        return True
+
+    async def send_message(self, target_type, target_id, message):
+        pass
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ):
+        async def on_message(event: WecomBotEvent):
+            try:
+                return await callback(await self.event_converter.target2yiri(event), self)
+            except Exception:
+                await self.logger.error(f'Error in wecombot callback: {traceback.format_exc()}')
+                print(traceback.format_exc())
+        try:
+            if event_type == platform_events.FriendMessage:
+                self.bot.on_message('single')(on_message)
+            elif event_type == platform_events.GroupMessage:
+                self.bot.on_message('group')(on_message)
+        except Exception:
+            print(traceback.format_exc())
+            
+
+    async def run_async(self):
+        async def shutdown_trigger_placeholder():
+            while True:
+                await asyncio.sleep(1)
+
+        await self.bot.run_task(
+            host='0.0.0.0',
+            port=self.config['port'],
+            shutdown_trigger=shutdown_trigger_placeholder,
+        )
+
+    async def kill(self) -> bool:
+        return False
+
+    async def unregister_listener(
+        self,
+        event_type: type,
+        callback: typing.Callable[[platform_events.Event, abstract_platform_adapter.AbstractMessagePlatformAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)
+    
+    async def is_muted(self, group_id: int) -> bool:
+        pass
+
+    

pkg/platform/sources/wecombot.yaml

@@ -0,0 +1,52 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: wecombot
+  label:
+    en_US: WeComBot
+    zh_Hans: 企业微信智能机器人
+  description:
+    en_US: WeComBot Adapter
+    zh_Hans: 企业微信智能机器人适配器，请查看文档了解使用方式
+  icon: wecombot.png
+spec:
+  config:
+    - name: port
+      label:
+        en_US: Port
+        zh_Hans: 监听端口
+      type: integer
+      required: true
+      default: 2291
+    - name: Corpid
+      label:
+        en_US: Corpid
+        zh_Hans: 企业ID
+      type: string
+      required: true
+      default: ""
+    - name: Token
+      label:
+        en_US: Token
+        zh_Hans: 令牌
+      type: string
+      required: true
+      default: ""
+    - name: EncodingAESKey
+      label:
+        en_US: EncodingAESKey
+        zh_Hans: 消息加解密密钥
+      type: string
+      required: true
+      default: ""
+    - name: BotId
+      label:
+        en_US: BotId
+        zh_Hans: 机器人ID
+      type: string
+      required: false
+      default: ""
+execution:
+  python:
+    path: ./wecombot.py
+    attr: WecomBotAdapter

pkg/plugin/connector.py

@@ -6,17 +6,24 @@ from typing import Any
 import typing
 import os
 import sys
+import httpx
+from async_lru import alru_cache
 
 from ..core import app
 from . import handler
 from ..utils import platform
-from langbot_plugin.runtime.io.controllers.stdio import client as stdio_client_controller
+from langbot_plugin.runtime.io.controllers.stdio import (
+    client as stdio_client_controller,
+)
 from langbot_plugin.runtime.io.controllers.ws import client as ws_client_controller
 from langbot_plugin.api.entities import events
 from langbot_plugin.api.entities import context
 import langbot_plugin.runtime.io.connection as base_connection
 from langbot_plugin.api.definition.components.manifest import ComponentManifest
-from langbot_plugin.api.entities.builtin.command import context as command_context
+from langbot_plugin.api.entities.builtin.command import (
+    context as command_context,
+    errors as command_errors,
+)
 from langbot_plugin.runtime.plugin.mgr import PluginInstallSource
 from ..core import taskmgr
 
@@ -30,6 +37,8 @@ class PluginRuntimeConnector:
 
     handler_task: asyncio.Task
 
+    heartbeat_task: asyncio.Task | None = None
+
     stdio_client_controller: stdio_client_controller.StdioClientController
 
     ctrl: stdio_client_controller.StdioClientController | ws_client_controller.WebSocketClientController
@@ -38,6 +47,9 @@ class PluginRuntimeConnector:
         [PluginRuntimeConnector], typing.Coroutine[typing.Any, typing.Any, None]
     ]
 
+    is_enable_plugin: bool = True
+    """Mark if the plugin system is enabled"""
+
     def __init__(
         self,
         ap: app.Application,
@@ -47,10 +59,26 @@ class PluginRuntimeConnector:
     ):
         self.ap = ap
         self.runtime_disconnect_callback = runtime_disconnect_callback
+        self.is_enable_plugin = self.ap.instance_config.data.get('plugin', {}).get('enable', True)
+
+    async def heartbeat_loop(self):
+        while True:
+            await asyncio.sleep(20)
+            try:
+                await self.ping_plugin_runtime()
+                self.ap.logger.debug('Heartbeat to plugin runtime success.')
+            except Exception as e:
+                self.ap.logger.debug(f'Failed to heartbeat to plugin runtime: {e}')
 
     async def initialize(self):
+        if not self.is_enable_plugin:
+            self.ap.logger.info('Plugin system is disabled.')
+            return
+
         async def new_connection_callback(connection: base_connection.Connection):
-            async def disconnect_callback(rchandler: handler.RuntimeConnectionHandler) -> bool:
+            async def disconnect_callback(
+                rchandler: handler.RuntimeConnectionHandler,
+            ) -> bool:
                 if platform.get_platform() == 'docker' or platform.use_websocket_to_connect_plugin_runtime():
                     self.ap.logger.error('Disconnected from plugin runtime, trying to reconnect...')
                     await self.runtime_disconnect_callback(self)
@@ -62,6 +90,7 @@ class PluginRuntimeConnector:
                     return False
 
             self.handler = handler.RuntimeConnectionHandler(connection, disconnect_callback, self.ap)
+
             self.handler_task = asyncio.create_task(self.handler.run())
             _ = await self.handler.ping()
             self.ap.logger.info('Connected to plugin runtime.')
@@ -71,10 +100,18 @@ class PluginRuntimeConnector:
 
         if platform.get_platform() == 'docker' or platform.use_websocket_to_connect_plugin_runtime():  # use websocket
             self.ap.logger.info('use websocket to connect to plugin runtime')
-            ws_url = self.ap.instance_config.data['plugin']['runtime_ws_url']
+            ws_url = self.ap.instance_config.data.get('plugin', {}).get(
+                'runtime_ws_url', 'ws://langbot_plugin_runtime:5400/control/ws'
+            )
 
-            async def make_connection_failed_callback(ctrl: ws_client_controller.WebSocketClientController) -> None:
-                self.ap.logger.error('Failed to connect to plugin runtime, trying to reconnect...')
+            async def make_connection_failed_callback(
+                ctrl: ws_client_controller.WebSocketClientController,
+                exc: Exception = None,
+            ) -> None:
+                if exc is not None:
+                    self.ap.logger.error(f'Failed to connect to plugin runtime({ws_url}): {exc}')
+                else:
+                    self.ap.logger.error(f'Failed to connect to plugin runtime({ws_url}), trying to reconnect...')
                 await self.runtime_disconnect_callback(self)
 
             self.ctrl = ws_client_controller.WebSocketClientController(
@@ -94,17 +131,53 @@ class PluginRuntimeConnector:
             )
             task = self.ctrl.run(new_connection_callback)
 
+        if self.heartbeat_task is None:
+            self.heartbeat_task = asyncio.create_task(self.heartbeat_loop())
+
         asyncio.create_task(task)
 
     async def initialize_plugins(self):
         pass
 
+    async def ping_plugin_runtime(self):
+        if not hasattr(self, 'handler'):
+            raise Exception('Plugin runtime is not connected')
+
+        return await self.handler.ping()
+
     async def install_plugin(
         self,
         install_source: PluginInstallSource,
         install_info: dict[str, Any],
         task_context: taskmgr.TaskContext | None = None,
     ):
+        if install_source == PluginInstallSource.LOCAL:
+            # transfer file before install
+            file_bytes = install_info['plugin_file']
+            file_key = await self.handler.send_file(file_bytes, 'lbpkg')
+            install_info['plugin_file_key'] = file_key
+            del install_info['plugin_file']
+            self.ap.logger.info(f'Transfered file {file_key} to plugin runtime')
+        elif install_source == PluginInstallSource.GITHUB:
+            # download and transfer file
+            try:
+                async with httpx.AsyncClient(
+                    trust_env=True,
+                    follow_redirects=True,
+                    timeout=20,
+                ) as client:
+                    response = await client.get(
+                        install_info['asset_url'],
+                    )
+                    response.raise_for_status()
+                    file_bytes = response.content
+                    file_key = await self.handler.send_file(file_bytes, 'lbpkg')
+                    install_info['plugin_file_key'] = file_key
+                    self.ap.logger.info(f'Transfered file {file_key} to plugin runtime')
+            except Exception as e:
+                self.ap.logger.error(f'Failed to download file from GitHub: {e}')
+                raise Exception(f'Failed to download file from GitHub: {e}')
+
         async for ret in self.handler.install_plugin(install_source.value, install_info):
             current_action = ret.get('current_action', None)
             if current_action is not None:
@@ -117,7 +190,10 @@ class PluginRuntimeConnector:
                     task_context.trace(trace)
 
     async def upgrade_plugin(
-        self, plugin_author: str, plugin_name: str, task_context: taskmgr.TaskContext | None = None
+        self,
+        plugin_author: str,
+        plugin_name: str,
+        task_context: taskmgr.TaskContext | None = None,
     ) -> dict[str, Any]:
         async for ret in self.handler.upgrade_plugin(plugin_author, plugin_name):
             current_action = ret.get('current_action', None)
@@ -131,7 +207,11 @@ class PluginRuntimeConnector:
                     task_context.trace(trace)
 
     async def delete_plugin(
-        self, plugin_author: str, plugin_name: str, task_context: taskmgr.TaskContext | None = None
+        self,
+        plugin_author: str,
+        plugin_name: str,
+        delete_data: bool = False,
+        task_context: taskmgr.TaskContext | None = None,
     ) -> dict[str, Any]:
         async for ret in self.handler.delete_plugin(plugin_author, plugin_name):
             current_action = ret.get('current_action', None)
@@ -144,7 +224,16 @@ class PluginRuntimeConnector:
                 if task_context is not None:
                     task_context.trace(trace)
 
+        # Clean up plugin settings and binary storage if requested
+        if delete_data:
+            if task_context is not None:
+                task_context.trace('Cleaning up plugin configuration and storage...')
+            await self.handler.cleanup_plugin_data(plugin_author, plugin_name)
+
     async def list_plugins(self) -> list[dict[str, Any]]:
+        if not self.is_enable_plugin:
+            return []
+
         return await self.handler.list_plugins()
 
     async def get_plugin_info(self, author: str, plugin_name: str) -> dict[str, Any]:
@@ -153,27 +242,43 @@ class PluginRuntimeConnector:
     async def set_plugin_config(self, plugin_author: str, plugin_name: str, config: dict[str, Any]) -> dict[str, Any]:
         return await self.handler.set_plugin_config(plugin_author, plugin_name, config)
 
+    @alru_cache(ttl=5 * 60)  # 5 minutes
+    async def get_plugin_icon(self, plugin_author: str, plugin_name: str) -> dict[str, Any]:
+        return await self.handler.get_plugin_icon(plugin_author, plugin_name)
+
     async def emit_event(
         self,
         event: events.BaseEventModel,
     ) -> context.EventContext:
         event_ctx = context.EventContext.from_event(event)
 
-        event_ctx_result = await self.handler.emit_event(event_ctx.model_dump(serialize_as_any=True))
+        if not self.is_enable_plugin:
+            return event_ctx
+
+        event_ctx_result = await self.handler.emit_event(event_ctx.model_dump(serialize_as_any=False))
 
         event_ctx = context.EventContext.model_validate(event_ctx_result['event_context'])
 
         return event_ctx
 
     async def list_tools(self) -> list[ComponentManifest]:
+        if not self.is_enable_plugin:
+            return []
+
         list_tools_data = await self.handler.list_tools()
 
         return [ComponentManifest.model_validate(tool) for tool in list_tools_data]
 
     async def call_tool(self, tool_name: str, parameters: dict[str, Any]) -> dict[str, Any]:
+        if not self.is_enable_plugin:
+            return {'error': 'Tool not found: plugin system is disabled'}
+
         return await self.handler.call_tool(tool_name, parameters)
 
     async def list_commands(self) -> list[ComponentManifest]:
+        if not self.is_enable_plugin:
+            return []
+
         list_commands_data = await self.handler.list_commands()
 
         return [ComponentManifest.model_validate(command) for command in list_commands_data]
@@ -181,6 +286,9 @@ class PluginRuntimeConnector:
     async def execute_command(
         self, command_ctx: command_context.ExecuteContext
     ) -> typing.AsyncGenerator[command_context.CommandReturn, None]:
+        if not self.is_enable_plugin:
+            yield command_context.CommandReturn(error=command_errors.CommandNotFoundError(command_ctx.command))
+
         gen = self.handler.execute_command(command_ctx.model_dump(serialize_as_any=True))
 
         async for ret in gen:
@@ -189,6 +297,10 @@ class PluginRuntimeConnector:
             yield cmd_ret
 
     def dispose(self):
-        if isinstance(self.ctrl, stdio_client_controller.StdioClientController):
+        if self.is_enable_plugin and isinstance(self.ctrl, stdio_client_controller.StdioClientController):
             self.ap.logger.info('Terminating plugin runtime process...')
             self.ctrl.process.terminate()
+
+        if self.heartbeat_task is not None:
+            self.heartbeat_task.cancel()
+            self.heartbeat_task = None

pkg/plugin/handler.py

@@ -56,7 +56,9 @@ class RuntimeConnectionHandler(handler.Handler):
                     .where(persistence_plugin.PluginSetting.plugin_name == plugin_name)
                 )
 
-                if result.first() is not None:
+                setting = result.first()
+
+                if setting is not None:
                     # delete plugin setting
                     await self.ap.persistence_mgr.execute_async(
                         sqlalchemy.delete(persistence_plugin.PluginSetting)
@@ -71,6 +73,10 @@ class RuntimeConnectionHandler(handler.Handler):
                         plugin_name=plugin_name,
                         install_source=install_source,
                         install_info=install_info,
+                        # inherit from existing setting
+                        enabled=setting.enabled if setting is not None else True,
+                        priority=setting.priority if setting is not None else 0,
+                        config=setting.config if setting is not None else {},  # noqa: F821
                     )
                 )
 
@@ -216,6 +222,23 @@ class RuntimeConnectionHandler(handler.Handler):
                 },
             )
 
+        @self.action(PluginToRuntimeAction.CREATE_NEW_CONVERSATION)
+        async def create_new_conversation(data: dict[str, Any]) -> handler.ActionResponse:
+            """Create new conversation"""
+            query_id = data['query_id']
+            if query_id not in self.ap.query_pool.cached_queries:
+                return handler.ActionResponse.error(
+                    message=f'Query with query_id {query_id} not found',
+                )
+
+            query = self.ap.query_pool.cached_queries[query_id]
+
+            query.session.using_conversation = None
+
+            return handler.ActionResponse.success(
+                data={},
+            )
+
         @self.action(PluginToRuntimeAction.GET_LANGBOT_VERSION)
         async def get_langbot_version(data: dict[str, Any]) -> handler.ActionResponse:
             """Get langbot version"""
@@ -519,7 +542,7 @@ class RuntimeConnectionHandler(handler.Handler):
             {
                 'event_context': event_context,
             },
-            timeout=30,
+            timeout=60,
         )
 
         return result
@@ -529,11 +552,50 @@ class RuntimeConnectionHandler(handler.Handler):
         result = await self.call_action(
             LangBotToRuntimeAction.LIST_TOOLS,
             {},
-            timeout=10,
+            timeout=20,
         )
 
         return result['tools']
 
+    async def get_plugin_icon(self, plugin_author: str, plugin_name: str) -> dict[str, Any]:
+        """Get plugin icon"""
+        result = await self.call_action(
+            LangBotToRuntimeAction.GET_PLUGIN_ICON,
+            {
+                'plugin_author': plugin_author,
+                'plugin_name': plugin_name,
+            },
+        )
+
+        plugin_icon_file_key = result['plugin_icon_file_key']
+        mime_type = result['mime_type']
+
+        plugin_icon_bytes = await self.read_local_file(plugin_icon_file_key)
+
+        await self.delete_local_file(plugin_icon_file_key)
+
+        return {
+            'plugin_icon_base64': base64.b64encode(plugin_icon_bytes).decode('utf-8'),
+            'mime_type': mime_type,
+        }
+
+    async def cleanup_plugin_data(self, plugin_author: str, plugin_name: str) -> None:
+        """Cleanup plugin settings and binary storage"""
+        # Delete plugin settings
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.delete(persistence_plugin.PluginSetting)
+            .where(persistence_plugin.PluginSetting.plugin_author == plugin_author)
+            .where(persistence_plugin.PluginSetting.plugin_name == plugin_name)
+        )
+
+        # Delete all binary storage for this plugin
+        owner = f'{plugin_author}/{plugin_name}'
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.delete(persistence_bstorage.BinaryStorage)
+            .where(persistence_bstorage.BinaryStorage.owner_type == 'plugin')
+            .where(persistence_bstorage.BinaryStorage.owner == owner)
+        )
+
     async def call_tool(self, tool_name: str, parameters: dict[str, Any]) -> dict[str, Any]:
         """Call tool"""
         result = await self.call_action(
@@ -542,7 +604,7 @@ class RuntimeConnectionHandler(handler.Handler):
                 'tool_name': tool_name,
                 'tool_parameters': parameters,
             },
-            timeout=30,
+            timeout=60,
         )
 
         return result['tool_response']
@@ -563,7 +625,7 @@ class RuntimeConnectionHandler(handler.Handler):
             {
                 'command_context': command_context,
             },
-            timeout=30,
+            timeout=60,
         )
 
         async for ret in gen:

pkg/provider/modelmgr/modelmgr.py

@@ -59,7 +59,7 @@ class ModelManager:
             try:
                 await self.load_llm_model(llm_model)
             except provider_errors.RequesterNotFoundError as e:
-                self.ap.logger.warning(f'Requester {e.requester_name} not found, skipping model {llm_model.uuid}')
+                self.ap.logger.warning(f'Requester {e.requester_name} not found, skipping llm model {llm_model.uuid}')
             except Exception as e:
                 self.ap.logger.error(f'Failed to load model {llm_model.uuid}: {e}\n{traceback.format_exc()}')
 
@@ -67,7 +67,14 @@ class ModelManager:
         result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.EmbeddingModel))
         embedding_models = result.all()
         for embedding_model in embedding_models:
-            await self.load_embedding_model(embedding_model)
+            try:
+                await self.load_embedding_model(embedding_model)
+            except provider_errors.RequesterNotFoundError as e:
+                self.ap.logger.warning(
+                    f'Requester {e.requester_name} not found, skipping embedding model {embedding_model.uuid}'
+                )
+            except Exception as e:
+                self.ap.logger.error(f'Failed to load model {embedding_model.uuid}: {e}\n{traceback.format_exc()}')
 
     async def init_runtime_llm_model(
         self,
@@ -107,6 +114,9 @@ class ModelManager:
         elif isinstance(model_info, dict):
             model_info = persistence_model.EmbeddingModel(**model_info)
 
+        if model_info.requester not in self.requester_dict:
+            raise provider_errors.RequesterNotFoundError(model_info.requester)
+
         requester_inst = self.requester_dict[model_info.requester](ap=self.ap, config=model_info.requester_config)
 
         await requester_inst.initialize()

pkg/provider/modelmgr/requesters/bailianchatcmpl.py

@@ -1,9 +1,14 @@
 from __future__ import annotations
 
 import typing
+import dashscope
 import openai
 
 from . import modelscopechatcmpl
+from .. import requester
+import langbot_plugin.api.entities.builtin.resource.tool as resource_tool
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+import langbot_plugin.api.entities.builtin.provider.message as provider_message
 
 
 class BailianChatCompletions(modelscopechatcmpl.ModelScopeChatCompletions):
@@ -15,3 +20,211 @@ class BailianChatCompletions(modelscopechatcmpl.ModelScopeChatCompletions):
         'base_url': 'https://dashscope.aliyuncs.com/compatible-mode/v1',
         'timeout': 120,
     }
+
+    async def _closure_stream(
+        self,
+        query: pipeline_query.Query,
+        req_messages: list[dict],
+        use_model: requester.RuntimeLLMModel,
+        use_funcs: list[resource_tool.LLMTool] = None,
+        extra_args: dict[str, typing.Any] = {},
+        remove_think: bool = False,
+    ) -> provider_message.Message | typing.AsyncGenerator[provider_message.MessageChunk, None]:
+        self.client.api_key = use_model.token_mgr.get_token()
+
+        args = {}
+        args['model'] = use_model.model_entity.name
+
+        if use_funcs:
+            tools = await self.ap.tool_mgr.generate_tools_for_openai(use_funcs)
+
+            if tools:
+                args['tools'] = tools
+
+        # 设置此次请求中的messages
+        messages = req_messages.copy()
+
+        is_use_dashscope_call = False   # 是否使用阿里原生库调用
+        is_enable_multi_model = True  # 是否支持多轮对话
+        use_time_num = 0 # 模型已调用次数，防止存在多文件时重复调用
+        use_time_ids = [] # 已调用的ID列表
+        message_id = 0  # 记录消息序号
+
+        for msg in messages:
+            # print(msg)
+            if 'content' in msg and isinstance(msg['content'], list):
+                for me in msg['content']:
+                    if me['type'] == 'image_base64':
+                        me['image_url'] = {'url': me['image_base64']}
+                        me['type'] = 'image_url'
+                        del me['image_base64']
+                    elif me['type'] == 'file_url' and '.' in me.get('file_name', ''):
+                        # 1. 视频文件推理
+                        # https://bailian.console.aliyun.com/?tab=doc#/doc/?type=model&url=2845871
+                        file_type = me.get('file_name').lower().split('.')[-1]
+                        if file_type in ['mp4', 'avi', 'mkv', 'mov', 'flv', 'wmv']:
+                            me['type'] = 'video_url'
+                            me['video_url'] = {'url': me['file_url']}
+                            del me['file_url']
+                            del me['file_name']
+                            use_time_num +=1
+                            use_time_ids.append(message_id)
+                            is_enable_multi_model = False
+                        # 2. 语音文件识别, 无法通过openai的audio字段传递，暂时不支持
+                        # https://bailian.console.aliyun.com/?tab=doc#/doc/?type=model&url=2979031
+                        elif file_type in ['aac', 'amr', 'aiff', 'flac', 'm4a',
+                                           'mp3', 'mpeg', 'ogg', 'opus', 'wav', 'webm', 'wma']:
+                            me['audio'] = me['file_url']
+                            me['type'] = 'audio'
+                            del me['file_url']
+                            del me['type']
+                            del me['file_name']
+                            is_use_dashscope_call = True
+                            use_time_num +=1
+                            use_time_ids.append(message_id)
+                            is_enable_multi_model = False
+            message_id += 1
+
+        # 使用列表推导式，保留不在 use_time_ids[:-1] 中的元素，仅保留最后一个多媒体消息
+        if not is_enable_multi_model and use_time_num > 1:
+            messages = [msg for idx, msg in enumerate(messages) if idx not in use_time_ids[:-1]]
+
+        if not is_enable_multi_model:
+            messages = [msg for msg in messages if 'resp_message_id' not in msg]
+
+        args['messages'] = messages
+        args['stream'] = True
+
+        # 流式处理状态
+        # tool_calls_map: dict[str, provider_message.ToolCall] = {}
+        chunk_idx = 0
+        thinking_started = False
+        thinking_ended = False
+        role = 'assistant'  # 默认角色
+
+        if is_use_dashscope_call:
+            response = dashscope.MultiModalConversation.call(
+                # 若没有配置环境变量，请用百炼API Key将下行替换为：api_key = "sk-xxx"
+                api_key=use_model.token_mgr.get_token(),
+                model=use_model.model_entity.name,
+                messages=messages,
+                result_format="message",
+                asr_options={
+                    # "language": "zh", # 可选，若已知音频的语种，可通过该参数指定待识别语种，以提升识别准确率
+                    "enable_lid": True,
+                    "enable_itn": False
+                },
+                stream=True
+            )
+            content_length_list = []
+            previous_length = 0  # 记录上一次的内容长度
+            for res in response:
+                chunk = res["output"]
+                # 解析 chunk 数据
+                if hasattr(chunk, 'choices') and chunk.choices:
+                    choice = chunk.choices[0]
+                    delta_content = choice["message"].content[0]["text"]
+                    finish_reason = choice["finish_reason"]
+                    content_length_list.append(len(delta_content))
+                else:
+                    delta_content = ""
+                    finish_reason = None
+
+                # 跳过空的第一个 chunk（只有 role 没有内容）
+                if chunk_idx == 0 and not delta_content:
+                    chunk_idx += 1
+                    continue
+
+                # 检查 content_length_list 是否有足够的数据
+                if len(content_length_list) >= 2:
+                    now_content = delta_content[previous_length: content_length_list[-1]]
+                    previous_length = content_length_list[-1]  # 更新上一次的长度
+                else:
+                    now_content = delta_content  # 第一次循环时直接使用 delta_content
+                    previous_length = len(delta_content)  # 更新上一次的长度
+
+                # 构建 MessageChunk - 只包含增量内容
+                chunk_data = {
+                    'role': role,
+                    'content': now_content if now_content else None,
+                    'is_final': bool(finish_reason) and finish_reason != "null",
+                }
+
+                # 移除 None 值
+                chunk_data = {k: v for k, v in chunk_data.items() if v is not None}
+                yield provider_message.MessageChunk(**chunk_data)
+                chunk_idx += 1
+        else:
+            async for chunk in self._req_stream(args, extra_body=extra_args):
+                # 解析 chunk 数据
+                if hasattr(chunk, 'choices') and chunk.choices:
+                    choice = chunk.choices[0]
+                    delta = choice.delta.model_dump() if hasattr(choice, 'delta') else {}
+                    finish_reason = getattr(choice, 'finish_reason', None)
+                else:
+                    delta = {}
+                    finish_reason = None
+
+                # 从第一个 chunk 获取 role，后续使用这个 role
+                if 'role' in delta and delta['role']:
+                    role = delta['role']
+
+                # 获取增量内容
+                delta_content = delta.get('content', '')
+                reasoning_content = delta.get('reasoning_content', '')
+
+                # 处理 reasoning_content
+                if reasoning_content:
+                    # accumulated_reasoning += reasoning_content
+                    # 如果设置了 remove_think，跳过 reasoning_content
+                    if remove_think:
+                        chunk_idx += 1
+                        continue
+
+                    # 第一次出现 reasoning_content，添加 <think> 开始标签
+                    if not thinking_started:
+                        thinking_started = True
+                        delta_content = '<think>\n' + reasoning_content
+                    else:
+                        # 继续输出 reasoning_content
+                        delta_content = reasoning_content
+                elif thinking_started and not thinking_ended and delta_content:
+                    # reasoning_content 结束，normal content 开始，添加 </think> 结束标签
+                    thinking_ended = True
+                    delta_content = '\n</think>\n' + delta_content
+
+                # 处理工具调用增量
+                if delta.get('tool_calls'):
+                    for tool_call in delta['tool_calls']:
+                        if tool_call['id'] != '':
+                            tool_id = tool_call['id']
+                        if tool_call['function']['name'] is not None:
+                            tool_name = tool_call['function']['name']
+
+                        if tool_call['type'] is None:
+                            tool_call['type'] = 'function'
+                        tool_call['id'] = tool_id
+                        tool_call['function']['name'] = tool_name
+                        tool_call['function']['arguments'] = (
+                            '' if tool_call['function']['arguments'] is None else tool_call['function']['arguments']
+                        )
+
+                # 跳过空的第一个 chunk（只有 role 没有内容）
+                if chunk_idx == 0 and not delta_content and not reasoning_content and not delta.get('tool_calls'):
+                    chunk_idx += 1
+                    continue
+
+                # 构建 MessageChunk - 只包含增量内容
+                chunk_data = {
+                    'role': role,
+                    'content': delta_content if delta_content else None,
+                    'tool_calls': delta.get('tool_calls'),
+                    'is_final': bool(finish_reason),
+                }
+
+                # 移除 None 值
+                chunk_data = {k: v for k, v in chunk_data.items() if v is not None}
+
+                yield provider_message.MessageChunk(**chunk_data)
+                chunk_idx += 1
+                # return

pkg/provider/modelmgr/requesters/tokenpony.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="450" height="280" viewBox="0 0 450 280" class="cursor-pointer h-24 flex-shrink-0 w-149"><g fill="none" fill-rule="nonzero"><path fill="#0005DE" d="M97.705 6.742c58.844 0 90.962 34.353 90.962 98.341v21.843c-15.118-2.479-30.297-6.573-45.558-12.3v-9.543c0-35.97-15.564-56.281-45.404-56.281s-45.404 20.31-45.404 56.281v72.48c0 36.117 15.65 56.818 45.404 56.818 26.78 0 42.133-16.768 44.936-46.452q22.397 6.473 44.905 9.356c-6.15 51.52-37.492 79.155-89.841 79.155-58.678 0-90.963-34.72-90.963-98.878v-72.479c0-63.988 32.119-98.34 90.963-98.34m253.627 0c58.844 0 90.963 34.353 90.963 98.341v72.48c0 64.157-32.285 98.877-90.963 98.877-52.438 0-83.797-27.729-89.874-79.415 15-2.026 29.965-5.252 44.887-9.67 2.658 30.042 18.036 47.026 44.987 47.026 29.755 0 45.404-20.7 45.404-56.819v-72.479c0-35.97-15.564-56.281-45.404-56.281s-45.403 20.31-45.403 56.281v8.778c-15.262 5.868-30.44 10.104-45.559 12.725v-21.503c0-63.988 32.118-98.34 90.962-98.34m-164.37 140.026.57.09.831.127-.83-.128a234.5 234.5 0 0 0 35.979 2.79q18.408.002 36.858-2.928l1.401-.226a242 242 0 0 0 1.45-.244l-1.037.175q.729-.12 1.458-.247l-.421.072 1.26-.219-.84.147a244 244 0 0 0 2.8-.5l-.792.144q.648-.117 1.298-.239l-.506.094q.66-.122 1.322-.248l-.816.154q.759-.142 1.518-.289l-.702.135a247 247 0 0 0 5.364-1.084l-.463.098a250 250 0 0 0 3.928-.864l-.785.178 1.45-.33-.665.152q.597-.137 1.193-.276l-.528.123a253 253 0 0 0 3.685-.882l-.254.063q.683-.168 1.366-.34l-1.112.277q.809-.2 1.618-.405l-.506.128q.818-.206 1.634-.417l-1.128.289q.71-.18 1.419-.365l1.506-.397a259 259 0 0 0 1.804-.488l-.433.119a261 261 0 0 0 3.751-1.053l-.681.196a264 264 0 0 0 1.735-.502l-1.054.306q.636-.184 1.272-.37l-.218.064 1.238-.366-1.02.302a266 266 0 0 0 2.936-.882l-1.026.312q.71-.214 1.42-.433l-.394.121q.675-.207 1.35-.418l-.955.297q.8-.246 1.6-.499l-.645.202q.86-.269 1.72-.543l-1.076.341q.666-.21 1.33-.423l-.254.082q.833-.266 1.665-.539l-1.41.457q.874-.28 1.75-.568l-.34.111q.702-.229 1.403-.462l-1.063.351q.818-.269 1.634-.542l-.571.19a276 276 0 0 0 4.038-1.378l-.735.256q.657-.228 1.315-.46l-.58.204q16.86-5.903 33.78-14.256l-7.114-12.453 42.909 6.553-13.148 45.541-7.734-13.537q-23.832 11.94-47.755 19.504l-.199.063a298 298 0 0 1-11.65 3.412 288 288 0 0 1-10.39 2.603 280 280 0 0 1-11.677 2.431 273 273 0 0 1-11.643 1.903 263.5 263.5 0 0 1-36.858 2.599q-17.437 0-34.844-2.323l-.227-.03q-.635-.085-1.27-.174l1.497.204a268 268 0 0 1-13.673-2.182 275 275 0 0 1-12.817-2.697 282 282 0 0 1-11.859-3.057 291 291 0 0 1-7.21-2.123c-17.23-5.314-34.43-12.334-51.59-21.051l-8.258 14.455-13.148-45.541 42.909-6.553-6.594 11.544q18.421 9.24 36.776 15.572l1.316.45 1.373.462-.831-.278q.795.267 1.589.53l-.758-.252q.632.211 1.264.419l-.506-.167q.642.212 1.284.42l-.778-.253a271 271 0 0 0 3.914 1.251l-.227-.07a267 267 0 0 0 3.428 1.046l-.194-.058 1.315.389-1.121-.331q.864.256 1.73.508l-.609-.177q.826.241 1.651.478l-1.043-.3 1.307.375-.264-.075q.802.228 1.603.452l-1.34-.377q1.034.294 2.067.58l-.727-.203q.713.2 1.426.394l-.699-.192q.62.171 1.237.338l-.538-.146a259 259 0 0 0 3.977 1.051l-.66-.17q.683.177 1.367.35l-.707-.18q.687.175 1.373.348l-.666-.168q.738.186 1.475.368l-.809-.2q.716.179 1.43.353l-.621-.153a253 253 0 0 0 3.766.898l-.308-.07q.735.17 1.472.336l-1.164-.266q.747.173 1.496.34l-.332-.074q.845.19 1.69.374l-1.358-.3q.932.21 1.864.41l-.505-.11q.726.159 1.452.313l-.947-.203q.72.156 1.44.307l-.493-.104q.684.144 1.368.286l-.875-.182q.743.155 1.485.306l-.61-.124q.932.192 1.864.376l-1.254-.252q.904.184 1.809.361l-.555-.109q.752.15 1.504.293l-.95-.184q.69.135 1.377.265l-.427-.081q.784.15 1.569.295l-1.142-.214q.717.136 1.434.268l-.292-.054a244 244 0 0 0 3.808.673l-.68-.116 1.063.18-.383-.064q1.076.18 2.152.352z"></path></g></svg>

pkg/provider/modelmgr/requesters/tokenpony.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: tokenpony-chat-completions
+  label:
+    en_US: TokenPony
+    zh_Hans: 小马算力
+  icon: tokenpony.svg
+spec:
+  config:
+    - name: base_url
+      label:
+        en_US: Base URL
+        zh_Hans: 基础 URL
+      type: string
+      required: true
+      default: "https://api.tokenpony.cn/v1"
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_Hans: 超时时间
+      type: integer
+      required: true
+      default: 120
+  support_type:
+    - llm
+    - text-embedding
+execution:
+  python:
+    path: ./tokenponychatcmpl.py
+    attr: TokenPonyChatCompletions

pkg/provider/modelmgr/requesters/tokenponychatcmpl.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import typing
+import openai
+
+from . import chatcmpl
+
+
+class TokenPonyChatCompletions(chatcmpl.OpenAIChatCompletions):
+    """TokenPony ChatCompletion API 请求器"""
+
+    client: openai.AsyncClient
+
+    default_config: dict[str, typing.Any] = {
+        'base_url': 'https://api.tokenpony.cn/v1',
+        'timeout': 120,
+    }

pkg/provider/runner.py

@@ -36,6 +36,6 @@ class RequestRunner(abc.ABC):
         self.pipeline_config = pipeline_config
 
     @abc.abstractmethod
-    async def run(self, query: pipeline_query.Query) -> typing.AsyncGenerator[provider_message.Message, None]:
+    async def run(self, query: core_entities.Query) -> typing.AsyncGenerator[llm_entities.Message | llm_entities.MessageChunk, None]:
         """运行请求"""
-        pass
+        pass

pkg/provider/runners/cozeapi.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import typing
+import json
+import uuid
+import base64
+
+from .. import runner
+from ...core import app
+import langbot_plugin.api.entities.builtin.provider.message as provider_message
+from ...utils import image
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+from libs.coze_server_api.client import AsyncCozeAPIClient
+
+@runner.runner_class('coze-api')
+class CozeAPIRunner(runner.RequestRunner):
+    """Coze API 对话请求器"""
+
+    def __init__(self, ap: app.Application, pipeline_config: dict):
+        self.pipeline_config = pipeline_config
+        self.ap = ap
+        self.agent_token = pipeline_config["ai"]['coze-api']['api-key']
+        self.bot_id = pipeline_config["ai"]['coze-api'].get('bot-id')
+        self.chat_timeout = pipeline_config["ai"]['coze-api'].get('timeout')
+        self.auto_save_history = pipeline_config["ai"]['coze-api'].get('auto_save_history')
+        self.api_base = pipeline_config["ai"]['coze-api'].get('api-base')
+
+        self.coze = AsyncCozeAPIClient(
+            self.agent_token,
+            self.api_base
+        )
+    
+    def _process_thinking_content(
+        self,
+        content: str,
+    ) -> tuple[str, str]:
+        """处理思维链内容
+
+        Args:
+            content: 原始内容
+        Returns:
+            (处理后的内容, 提取的思维链内容)
+        """
+        remove_think = self.pipeline_config.get('output', {}).get('misc', {}).get('remove-think', False)
+        thinking_content = ''
+        # 从 content 中提取 <think> 标签内容
+        if content and '<think>' in content and '</think>' in content:
+            import re
+
+            think_pattern = r'<think>(.*?)</think>'
+            think_matches = re.findall(think_pattern, content, re.DOTALL)
+            if think_matches:
+                thinking_content = '\n'.join(think_matches)
+                # 移除 content 中的 <think> 标签
+                content = re.sub(think_pattern, '', content, flags=re.DOTALL).strip()
+
+        # 根据 remove_think 参数决定是否保留思维链
+        if remove_think:
+            return content, ''
+        else:
+            # 如果有思维链内容，将其以 <think> 格式添加到 content 开头
+            if thinking_content:
+                content = f'<think>\n{thinking_content}\n</think>\n{content}'.strip()
+            return content, thinking_content
+    
+    async def _preprocess_user_message(self, query: pipeline_query.Query) -> list[dict]:
+        """预处理用户消息，转换为Coze消息格式
+
+        Returns:
+            list[dict]: Coze消息列表
+        """
+        messages = []
+        
+        if isinstance(query.user_message.content, list):
+            # 多模态消息处理
+            content_parts = []
+            
+            for ce in query.user_message.content:
+                if ce.type == 'text':
+                    content_parts.append({"type": "text", "text": ce.text})
+                elif ce.type == 'image_base64':
+                    image_b64, image_format = await image.extract_b64_and_format(ce.image_base64)
+                    file_bytes = base64.b64decode(image_b64)
+                    file_id = await self._get_file_id(file_bytes)
+                    content_parts.append({"type": "image", "file_id": file_id})
+                elif ce.type == 'file':
+                    # 处理文件，上传到Coze
+                    file_id = await self._get_file_id(ce.file)
+                    content_parts.append({"type": "file", "file_id": file_id})
+            
+            # 创建多模态消息
+            if content_parts:
+                messages.append({
+                    "role": "user", 
+                    "content": json.dumps(content_parts),
+                    "content_type": "object_string", 
+                    "meta_data": None
+                })
+                
+        elif isinstance(query.user_message.content, str):
+            # 纯文本消息
+            messages.append({
+                "role": "user", 
+                "content": query.user_message.content,
+                "content_type": "text", 
+                "meta_data": None
+            })
+            
+        return messages
+    
+    async def _get_file_id(self, file) -> str:
+        """上传文件到Coze服务
+        Args:
+            file: 文件
+        Returns:
+            str: 文件ID
+        """
+        file_id = await self.coze.upload(file=file)
+        return file_id
+
+    async def _chat_messages(
+        self, query: pipeline_query.Query
+    ) -> typing.AsyncGenerator[provider_message.Message, None]:
+        """调用聊天助手（非流式）
+        
+        注意：由于cozepy没有提供非流式API，这里使用流式API并在结束后一次性返回完整内容
+        """
+        user_id = f'{query.launcher_id}_{query.sender_id}'
+        
+        # 预处理用户消息
+        additional_messages = await self._preprocess_user_message(query)
+        
+        # 获取会话ID
+        conversation_id = None
+        
+        # 收集完整内容
+        full_content = ''
+        full_reasoning = ''
+        
+        try:
+            # 调用Coze API流式接口
+            async for chunk in self.coze.chat_messages(
+                bot_id=self.bot_id,
+                user_id=user_id,
+                additional_messages=additional_messages,
+                conversation_id=conversation_id,
+                timeout=self.chat_timeout,
+                auto_save_history=self.auto_save_history,
+                stream=True
+            ):
+                self.ap.logger.debug(f'coze-chat-stream: {chunk}')
+                
+                event_type = chunk.get('event')
+                data = chunk.get('data', {})
+                
+                if event_type == 'conversation.message.delta':
+                    # 收集内容
+                    if 'content' in data:
+                        full_content += data.get('content', '')
+                    
+                    # 收集推理内容（如果有）
+                    if 'reasoning_content' in data:
+                        full_reasoning += data.get('reasoning_content', '')
+                
+                elif event_type == 'done':
+                    # 保存会话ID
+                    if 'conversation_id' in data:
+                        conversation_id = data.get('conversation_id')
+                
+                elif event_type == 'error':
+                    # 处理错误
+                    error_msg = f"Coze API错误: {data.get('message', '未知错误')}"
+                    yield provider_message.Message(
+                        role='assistant',
+                        content=error_msg,
+                    )
+                    return
+            
+            # 处理思维链内容
+            content, thinking_content = self._process_thinking_content(full_content)
+            if full_reasoning:
+                remove_think = self.pipeline_config.get('output', {}).get('misc', {}).get('remove-think', False)
+                if not remove_think:
+                    content = f'<think>\n{full_reasoning}\n</think>\n{content}'.strip()
+            
+            # 一次性返回完整内容
+            yield provider_message.Message(
+                role='assistant',
+                content=content,
+            )
+            
+            # 保存会话ID
+            if conversation_id and query.session.using_conversation:
+                query.session.using_conversation.uuid = conversation_id
+                
+        except Exception as e:
+            self.ap.logger.error(f'Coze API错误: {str(e)}')
+            yield provider_message.Message(
+                role='assistant',
+                content=f'Coze API调用失败: {str(e)}',
+            )
+
+
+    async def _chat_messages_chunk(
+        self, query: pipeline_query.Query
+    ) -> typing.AsyncGenerator[provider_message.MessageChunk, None]:
+        """调用聊天助手（流式）"""
+        user_id = f'{query.launcher_id}_{query.sender_id}'
+
+        # 预处理用户消息
+        additional_messages = await self._preprocess_user_message(query)
+
+        # 获取会话ID
+        conversation_id = None
+
+        start_reasoning = False
+        stop_reasoning = False
+        message_idx = 1
+        is_final = False
+        full_content = ''
+        remove_think = self.pipeline_config.get('output', {}).get('misc', {}).get('remove-think', False)
+
+
+
+        try:
+            # 调用Coze API流式接口
+            async for chunk in self.coze.chat_messages(
+                bot_id=self.bot_id,
+                user_id=user_id,
+                additional_messages=additional_messages,
+                conversation_id=conversation_id,
+                timeout=self.chat_timeout,
+                auto_save_history=self.auto_save_history,
+                stream=True
+            ):
+                self.ap.logger.debug(f'coze-chat-stream-chunk: {chunk}')
+
+                event_type = chunk.get('event')
+                data = chunk.get('data', {})
+                content = ""
+                
+                if event_type == 'conversation.message.delta':
+                    message_idx += 1
+                    # 处理内容增量
+                    if "reasoning_content" in data and not remove_think:
+
+                        reasoning_content = data.get('reasoning_content', '')
+                        if reasoning_content and not start_reasoning:
+                            content = f"<think/>\n"
+                            start_reasoning = True
+                        content += reasoning_content
+
+                    if 'content' in data:
+                        if data.get('content', ''):
+                            content += data.get('content', '')
+                            if not stop_reasoning and start_reasoning:
+                                content = f"</think>\n{content}"
+                                stop_reasoning = True
+
+                
+                elif event_type == 'done':
+                    # 保存会话ID
+                    if 'conversation_id' in data:
+                        conversation_id = data.get('conversation_id')
+                        if query.session.using_conversation:
+                            query.session.using_conversation.uuid = conversation_id
+                    is_final = True
+
+                
+                elif event_type == 'error':
+                    # 处理错误
+                    error_msg = f"Coze API错误: {data.get('message', '未知错误')}"
+                    yield provider_message.MessageChunk(
+                        role='assistant',
+                        content=error_msg,
+                        finish_reason='error'
+                    )
+                    return
+                full_content += content
+                if message_idx % 8 == 0 or is_final:
+                    if full_content:
+                        yield provider_message.MessageChunk(
+                            role='assistant',
+                            content=full_content,
+                            is_final=is_final
+                        )
+                    
+        except Exception as e:
+            self.ap.logger.error(f'Coze API流式调用错误: {str(e)}')
+            yield provider_message.MessageChunk(
+                role='assistant',
+                content=f'Coze API流式调用失败: {str(e)}',
+                finish_reason='error'
+            )
+
+
+    async def run(self, query: pipeline_query.Query) -> typing.AsyncGenerator[provider_message.Message, None]:
+        """运行"""
+        msg_seq = 0
+        if await query.adapter.is_stream_output_supported():
+            async for msg in self._chat_messages_chunk(query):
+                if isinstance(msg, provider_message.MessageChunk):
+                    msg_seq += 1
+                    msg.msg_sequence = msg_seq
+                yield msg
+        else:
+            async for msg in self._chat_messages(query):
+                yield msg
+
+
+
+

pkg/provider/runners/langflowapi.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import typing
+import json
+import httpx
+import uuid
+import traceback
+
+from .. import runner
+from ...core import app
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+import langbot_plugin.api.entities.builtin.provider.message as provider_message
+
+
+@runner.runner_class('langflow-api')
+class LangflowAPIRunner(runner.RequestRunner):
+    """Langflow API 对话请求器"""
+
+    def __init__(self, ap: app.Application, pipeline_config: dict):
+        self.ap = ap
+        self.pipeline_config = pipeline_config
+
+    async def _build_request_payload(self, query: pipeline_query.Query) -> dict:
+        """构建请求负载
+
+        Args:
+            query: 用户查询对象
+
+        Returns:
+            dict: 请求负载
+        """
+        # 获取用户消息文本
+        user_message_text = ''
+        if isinstance(query.user_message.content, str):
+            user_message_text = query.user_message.content
+        elif isinstance(query.user_message.content, list):
+            for item in query.user_message.content:
+                if item.type == 'text':
+                    user_message_text += item.text
+
+        # 从配置中获取 input_type 和 output_type，如果未配置则使用默认值
+        input_type = self.pipeline_config['ai']['langflow-api'].get('input_type', 'chat')
+        output_type = self.pipeline_config['ai']['langflow-api'].get('output_type', 'chat')
+
+        # 构建基本负载
+        payload = {
+            'output_type': output_type,
+            'input_type': input_type,
+            'input_value': user_message_text,
+            'session_id': str(uuid.uuid4()),
+        }
+
+        # 如果配置中有tweaks，则添加到负载中
+        tweaks = json.loads(self.pipeline_config['ai']['langflow-api'].get('tweaks'))
+        if tweaks:
+            payload['tweaks'] = tweaks
+
+        return payload
+
+    async def run(
+        self, query: pipeline_query.Query
+    ) -> typing.AsyncGenerator[provider_message.Message | provider_message.MessageChunk, None]:
+        """运行请求
+
+        Args:
+            query: 用户查询对象
+
+        Yields:
+            Message: 回复消息
+        """
+        # 检查是否支持流式输出
+        is_stream = False
+        try:
+            is_stream = await query.adapter.is_stream_output_supported()
+        except AttributeError:
+            is_stream = False
+
+        # 从配置中获取API参数
+        base_url = self.pipeline_config['ai']['langflow-api']['base-url']
+        api_key = self.pipeline_config['ai']['langflow-api']['api-key']
+        flow_id = self.pipeline_config['ai']['langflow-api']['flow-id']
+
+        # 构建API URL
+        url = f'{base_url.rstrip("/")}/api/v1/run/{flow_id}'
+
+        # 构建请求负载
+        payload = await self._build_request_payload(query)
+
+        # 设置请求头
+        headers = {'Content-Type': 'application/json', 'x-api-key': api_key}
+
+        # 发送请求
+        async with httpx.AsyncClient() as client:
+            if is_stream:
+                # 流式请求
+                async with client.stream('POST', url, json=payload, headers=headers, timeout=120.0) as response:
+                    print(response)
+                    response.raise_for_status()
+
+                    accumulated_content = ''
+                    message_count = 0
+
+                    async for line in response.aiter_lines():
+                        data_str = line
+
+                        if data_str.startswith('data: '):
+                            data_str = data_str[6:]  # 移除 "data: " 前缀
+
+                        try:
+                            data = json.loads(data_str)
+
+                            # 提取消息内容
+                            message_text = ''
+                            if 'outputs' in data and len(data['outputs']) > 0:
+                                output = data['outputs'][0]
+                                if 'outputs' in output and len(output['outputs']) > 0:
+                                    inner_output = output['outputs'][0]
+                                    if 'outputs' in inner_output and 'message' in inner_output['outputs']:
+                                        message_data = inner_output['outputs']['message']
+                                        if 'message' in message_data:
+                                            message_text = message_data['message']
+
+                            # 如果没有找到消息，尝试其他可能的路径
+                            if not message_text and 'messages' in data:
+                                messages = data['messages']
+                                if messages and len(messages) > 0:
+                                    message_text = messages[0].get('message', '')
+
+                            if message_text:
+                                # 更新累积内容
+                                accumulated_content = message_text
+                                message_count += 1
+
+                                # 每8条消息或有新内容时生成一个chunk
+                                if message_count % 8 == 0 or len(message_text) > 0:
+                                    yield provider_message.MessageChunk(
+                                        role='assistant', content=accumulated_content, is_final=False
+                                    )
+                        except json.JSONDecodeError:
+                            # 如果不是JSON，跳过这一行
+                            traceback.print_exc()
+                            continue
+
+                    # 发送最终消息
+                    yield provider_message.MessageChunk(role='assistant', content=accumulated_content, is_final=True)
+            else:
+                # 非流式请求
+                response = await client.post(url, json=payload, headers=headers, timeout=120.0)
+                response.raise_for_status()
+
+                # 解析响应
+                response_data = response.json()
+
+                # 提取消息内容
+                # 根据Langflow API文档，响应结构可能在outputs[0].outputs[0].outputs.message.message中
+                message_text = ''
+                if 'outputs' in response_data and len(response_data['outputs']) > 0:
+                    output = response_data['outputs'][0]
+                    if 'outputs' in output and len(output['outputs']) > 0:
+                        inner_output = output['outputs'][0]
+                        if 'outputs' in inner_output and 'message' in inner_output['outputs']:
+                            message_data = inner_output['outputs']['message']
+                            if 'message' in message_data:
+                                message_text = message_data['message']
+
+                # 如果没有找到消息，尝试其他可能的路径
+                if not message_text and 'messages' in response_data:
+                    messages = response_data['messages']
+                    if messages and len(messages) > 0:
+                        message_text = messages[0].get('message', '')
+
+                # 如果仍然没有找到消息，返回完整响应的字符串表示
+                if not message_text:
+                    message_text = json.dumps(response_data, ensure_ascii=False, indent=2)
+
+                # 生成回复消息
+                if is_stream:
+                    yield provider_message.MessageChunk(role='assistant', content=message_text, is_final=True)
+                else:
+                    reply_message = provider_message.Message(role='assistant', content=message_text)
+                    yield reply_message

pkg/provider/runners/tboxapi.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import typing
+import json
+import base64
+import tempfile
+import os
+
+from tboxsdk.tbox import TboxClient
+from tboxsdk.model.file import File, FileType
+
+from .. import runner
+from ...core import app
+from ...utils import image
+import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
+import langbot_plugin.api.entities.builtin.provider.message as provider_message
+
+
+class TboxAPIError(Exception):
+    """TBox API 请求失败"""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+@runner.runner_class('tbox-app-api')
+class TboxAPIRunner(runner.RequestRunner):
+    "蚂蚁百宝箱API对话请求器"
+
+    # 运行器内部使用的配置
+    app_id: str  # 蚂蚁百宝箱平台中的应用ID
+    api_key: str  # 在蚂蚁百宝箱平台中申请的令牌
+
+    def __init__(self, ap: app.Application, pipeline_config: dict):
+        """初始化"""
+        self.ap = ap
+        self.pipeline_config = pipeline_config
+
+        # 初始化Tbox 参数配置
+        self.app_id = self.pipeline_config['ai']['tbox-app-api']['app-id']
+        self.api_key = self.pipeline_config['ai']['tbox-app-api']['api-key']
+
+        # 初始化Tbox client
+        self.tbox_client = TboxClient(authorization=self.api_key)
+
+    async def _preprocess_user_message(self, query: pipeline_query.Query) -> tuple[str, list[str]]:
+        """预处理用户消息，提取纯文本，并将图片上传到 Tbox 服务
+
+        Returns:
+            tuple[str, list[str]]: 纯文本和图片的 Tbox 文件ID
+        """
+        plain_text = ''
+        image_ids = []
+
+        if isinstance(query.user_message.content, list):
+            for ce in query.user_message.content:
+                if ce.type == 'text':
+                    plain_text += ce.text
+                elif ce.type == 'image_base64':
+                    image_b64, image_format = await image.extract_b64_and_format(ce.image_base64)
+                    # 创建临时文件
+                    file_bytes = base64.b64decode(image_b64)
+                    try:
+                        with tempfile.NamedTemporaryFile(suffix=f'.{image_format}', delete=False) as tmp_file:
+                            tmp_file.write(file_bytes)
+                            tmp_file_path = tmp_file.name
+                        file_upload_resp = self.tbox_client.upload_file(
+                            tmp_file_path
+                        )
+                        image_id = file_upload_resp.get("data", "")
+                        image_ids.append(image_id)
+                    finally:
+                        # 清理临时文件
+                        if os.path.exists(tmp_file_path):
+                            os.unlink(tmp_file_path)
+        elif isinstance(query.user_message.content, str):
+            plain_text = query.user_message.content
+
+        return plain_text, image_ids
+
+    async def _agent_messages(
+        self, query: pipeline_query.Query
+    ) -> typing.AsyncGenerator[provider_message.Message, None]:
+        """TBox 智能体对话请求"""
+
+        plain_text, image_ids = await self._preprocess_user_message(query)
+        remove_think = self.pipeline_config['output'].get('misc', {}).get('remove-think')
+
+        try:
+            is_stream = await query.adapter.is_stream_output_supported()
+        except AttributeError:
+            is_stream = False
+
+        # 获取Tbox的conversation_id
+        conversation_id = query.session.using_conversation.uuid or None
+
+        files = None
+        if image_ids:
+            files = [
+                File(file_id=image_id, type=FileType.IMAGE)
+                for image_id in image_ids
+            ]
+
+        # 发送对话请求
+        response = self.tbox_client.chat(
+            app_id=self.app_id,  # Tbox中智能体应用的ID
+            user_id=query.bot_uuid, # 用户ID
+            query=plain_text,  # 用户输入的文本信息
+            stream=is_stream,  # 是否流式输出
+            conversation_id=conversation_id,  # 会话ID，为None时Tbox会自动创建一个新会话
+            files=files,  # 图片内容
+        )
+
+        if is_stream:
+            # 解析Tbox流式输出内容，并发送给上游
+            for chunk in self._process_stream_message(response, query, remove_think):
+                yield chunk
+        else:
+            message = self._process_non_stream_message(response, query, remove_think)
+            yield provider_message.Message(
+                role='assistant',
+                content=message,
+            )
+
+    def _process_non_stream_message(self, response: typing.Dict, query: pipeline_query.Query, remove_think: bool):
+        if response.get('errorCode') != "0":
+            raise TboxAPIError(f'Tbox API 请求失败: {response.get("errorMsg", "")}')
+        payload = response.get('data', {})
+        conversation_id = payload.get('conversationId', '')
+        query.session.using_conversation.uuid = conversation_id
+        thinking_content = payload.get('reasoningContent', [])
+        result = ""
+        if thinking_content and not remove_think:
+            result += f'<think>\n{thinking_content[0].get("text", "")}\n</think>\n'
+        content = payload.get('result', [])
+        if content:
+            result += content[0].get('chunk', '')
+        return result
+
+    def _process_stream_message(self, response: typing.Generator[dict], query: pipeline_query.Query, remove_think: bool):
+        idx_msg = 0
+        pending_content = ''
+        conversation_id = None
+        think_start = False
+        think_end = False
+        for chunk in response:
+            if chunk.get('type', '') == 'chunk':
+                """
+                Tbox返回的消息内容chunk结构
+                {'lane': 'default', 'payload': {'conversationId': '20250918tBI947065406', 'messageId': '20250918TB1f53230954', 'text': '️'}, 'type': 'chunk'}
+                """
+                # 如果包含思考过程，拼接</think>
+                if think_start and not think_end:
+                    pending_content += '\n</think>\n'
+                    think_end = True
+
+                payload = chunk.get('payload', {})
+                if not conversation_id:
+                    conversation_id = payload.get('conversationId')
+                    query.session.using_conversation.uuid = conversation_id
+                if payload.get('text'):
+                    idx_msg += 1
+                    pending_content += payload.get('text')
+            elif chunk.get('type', '') == 'thinking' and not remove_think:
+                """
+                Tbox返回的思考过程chunk结构
+                {'payload': '{"ext_data":{"text":"日期"},"event":"flow.node.llm.thinking","entity":{"node_type":"text-completion","execute_id":"6","group_id":0,"parent_execute_id":"6","node_name":"模型推理","node_id":"TC_5u6gl0"}}', 'type': 'thinking'}
+                """
+                payload = json.loads(chunk.get('payload', '{}'))
+                if payload.get('ext_data', {}).get('text'):
+                    idx_msg += 1
+                    content = payload.get('ext_data', {}).get('text')   
+                    if not think_start:
+                        think_start = True
+                        pending_content += f'<think>\n{content}'
+                    else:
+                        pending_content += content
+            elif chunk.get('type', '') == 'error':
+                raise TboxAPIError(
+                    f'Tbox API 请求失败: status_code={chunk.get("status_code")} message={chunk.get("message")} request_id={chunk.get("request_id")} '
+                )
+
+            if idx_msg % 8 == 0:
+                yield provider_message.MessageChunk(
+                    role='assistant',
+                    content=pending_content,
+                    is_final=False,
+                )
+
+        # Tbox不返回END事件，默认发一个最终消息
+        yield provider_message.MessageChunk(
+            role='assistant',
+            content=pending_content,
+            is_final=True,
+        )
+
+    async def run(self, query: pipeline_query.Query) -> typing.AsyncGenerator[provider_message.Message, None]:
+        """运行"""
+        msg_seq = 0
+        async for msg in self._agent_messages(query):
+            if isinstance(msg, provider_message.MessageChunk):
+                msg_seq += 1
+                msg.msg_sequence = msg_seq
+            yield msg

pkg/provider/tools/loaders/mcp.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+import enum
 import typing
 from contextlib import AsyncExitStack
+import traceback
+import sqlalchemy
+import asyncio
 
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
@@ -10,6 +14,13 @@ from mcp.client.sse import sse_client
 from .. import loader
 from ....core import app
 import langbot_plugin.api.entities.builtin.resource.tool as resource_tool
+from ....entity.persistence import mcp as persistence_mcp
+
+
+class MCPSessionStatus(enum.Enum):
+    CONNECTING = 'connecting'
+    CONNECTED = 'connected'
+    ERROR = 'error'
 
 
 class RuntimeMCPSession:
@@ -27,16 +38,34 @@ class RuntimeMCPSession:
 
     functions: list[resource_tool.LLMTool] = []
 
-    def __init__(self, server_name: str, server_config: dict, ap: app.Application):
+    enable: bool
+
+    # connected: bool
+    status: MCPSessionStatus
+
+
+    _lifecycle_task: asyncio.Task | None
+
+    _shutdown_event: asyncio.Event
+
+    _ready_event: asyncio.Event
+
+    def __init__(self, server_name: str, server_config: dict, enable: bool, ap: app.Application):
         self.server_name = server_name
         self.server_config = server_config
         self.ap = ap
-
+        self.enable = enable
         self.session = None
 
         self.exit_stack = AsyncExitStack()
         self.functions = []
 
+        self.status = MCPSessionStatus.CONNECTING
+
+        self._lifecycle_task = None
+        self._shutdown_event = asyncio.Event()
+        self._ready_event = asyncio.Event()
+
     async def _init_stdio_python_server(self):
         server_params = StdioServerParameters(
             command=self.server_config['command'],
@@ -58,6 +87,7 @@ class RuntimeMCPSession:
                 self.server_config['url'],
                 headers=self.server_config.get('headers', {}),
                 timeout=self.server_config.get('timeout', 10),
+                sse_read_timeout=self.server_config.get('ssereadtimeout', 30),
             )
         )
 
@@ -67,19 +97,65 @@ class RuntimeMCPSession:
 
         await self.session.initialize()
 
-    async def initialize(self):
-        self.ap.logger.debug(f'初始化 MCP 会话: {self.server_name} {self.server_config}')
+    async def _lifecycle_loop(self):
+        """在后台任务中管理整个MCP会话的生命周期"""
+        try:
+            if self.server_config['mode'] == 'stdio':
+                await self._init_stdio_python_server()
+            elif self.server_config['mode'] == 'sse':
+                await self._init_sse_server()
+            else:
+                raise ValueError(f'无法识别 MCP 服务器类型: {self.server_name}: {self.server_config}')
 
-        if self.server_config['mode'] == 'stdio':
-            await self._init_stdio_python_server()
-        elif self.server_config['mode'] == 'sse':
-            await self._init_sse_server()
-        else:
-            raise ValueError(f'无法识别 MCP 服务器类型: {self.server_name}: {self.server_config}')
+            await self.refresh()
+
+            self.status = MCPSessionStatus.CONNECTED
+
+            # 通知start()方法连接已建立
+            self._ready_event.set()
+
+            # 等待shutdown信号
+            await self._shutdown_event.wait()
+
+        except Exception as e:
+            self.status = MCPSessionStatus.ERROR
+            self.ap.logger.error(f'Error in MCP session lifecycle {self.server_name}: {e}\n{traceback.format_exc()}')
+            # 即使出错也要设置ready事件，让start()方法知道初始化已完成
+            self._ready_event.set()
+        finally:
+            # 在同一个任务中清理所有资源
+            try:
+                if self.exit_stack:
+                    await self.exit_stack.aclose()
+                self.functions.clear()
+                self.session = None
+            except Exception as e:
+                self.ap.logger.error(f'Error cleaning up MCP session {self.server_name}: {e}\n{traceback.format_exc()}')
+
+    async def start(self):
+        if not self.enable:
+            return
+
+        # 创建后台任务来管理生命周期
+        self._lifecycle_task = asyncio.create_task(self._lifecycle_loop())
+
+        # 等待连接建立或失败（带超时）
+        try:
+            await asyncio.wait_for(self._ready_event.wait(), timeout=30.0)
+        except asyncio.TimeoutError:
+            self.status = MCPSessionStatus.ERROR
+            raise Exception('Connection timeout after 30 seconds')
+
+        # 检查是否有错误
+        if self.status == MCPSessionStatus.ERROR:
+            raise Exception('Connection failed, please check URL')
+
+    async def refresh(self):
+        self.functions.clear()
 
         tools = await self.session.list_tools()
 
-        self.ap.logger.debug(f'获取 MCP 工具: {tools}')
+        self.ap.logger.debug(f'Refresh MCP tools: {tools}')
 
         for tool in tools.tools:
 
@@ -101,58 +177,212 @@ class RuntimeMCPSession:
                 )
             )
 
+    def get_tools(self) -> list[resource_tool.LLMTool]:
+        return self.functions
+
+    def get_runtime_info_dict(self) -> dict:
+        return {
+            'status': self.status.value,
+            'tool_count': len(self.get_tools()),
+            'tools': [
+                {
+                    'name': tool.name,
+                    'description': tool.description,
+                }
+                for tool in self.get_tools()
+            ],
+        }
+
     async def shutdown(self):
-        """关闭工具"""
-        await self.session._exit_stack.aclose()
+        """关闭会话并清理资源"""
+        try:
+            # 设置shutdown事件，通知lifecycle任务退出
+            self._shutdown_event.set()
+
+            # 等待lifecycle任务完成（带超时）
+            if self._lifecycle_task and not self._lifecycle_task.done():
+                try:
+                    await asyncio.wait_for(self._lifecycle_task, timeout=5.0)
+                except asyncio.TimeoutError:
+                    self.ap.logger.warning(f'MCP session {self.server_name} shutdown timeout, cancelling task')
+                    self._lifecycle_task.cancel()
+                    try:
+                        await self._lifecycle_task
+                    except asyncio.CancelledError:
+                        pass
+
+            self.ap.logger.info(f'MCP session {self.server_name} shutdown complete')
+        except Exception as e:
+            self.ap.logger.error(f'Error shutting down MCP session {self.server_name}: {e}\n{traceback.format_exc()}')
 
 
-@loader.loader_class('mcp')
+# @loader.loader_class('mcp')
 class MCPLoader(loader.ToolLoader):
     """MCP 工具加载器。
 
     在此加载器中管理所有与 MCP Server 的连接。
     """
 
-    sessions: dict[str, RuntimeMCPSession] = {}
+    sessions: dict[str, RuntimeMCPSession]
 
-    _last_listed_functions: list[resource_tool.LLMTool] = []
+    _last_listed_functions: list[resource_tool.LLMTool]
+
+    _hosted_mcp_tasks: list[asyncio.Task]
 
     def __init__(self, ap: app.Application):
         super().__init__(ap)
         self.sessions = {}
         self._last_listed_functions = []
+        self._hosted_mcp_tasks = []
 
     async def initialize(self):
-        for server_config in self.ap.instance_config.data.get('mcp', {}).get('servers', []):
-            if not server_config['enable']:
-                continue
-            session = RuntimeMCPSession(server_config['name'], server_config, self.ap)
-            await session.initialize()
-            # self.ap.event_loop.create_task(session.initialize())
+        await self.load_mcp_servers_from_db()
+
+    async def load_mcp_servers_from_db(self):
+        self.ap.logger.info('Loading MCP servers from db...')
+
+        self.sessions = {}
+
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_mcp.MCPServer))
+        servers = result.all()
+
+        for server in servers:
+            config = self.ap.persistence_mgr.serialize_model(persistence_mcp.MCPServer, server)
+
+            task = asyncio.create_task(self.host_mcp_server(config))
+            self._hosted_mcp_tasks.append(task)
+
+    async def host_mcp_server(self, server_config: dict):
+        self.ap.logger.debug(f'Loading MCP server {server_config}')
+        try:
+            session = await self.load_mcp_server(server_config)
             self.sessions[server_config['name']] = session
+        except Exception as e:
+            self.ap.logger.error(
+                f'Failed to load MCP server from db: {server_config["name"]}({server_config["uuid"]}): {e}\n{traceback.format_exc()}'
+            )
+            return
+
+        self.ap.logger.debug(f'Starting MCP server {server_config["name"]}({server_config["uuid"]})')
+        try:
+            await session.start()
+        except Exception as e:
+            self.ap.logger.error(
+                f'Failed to start MCP server {server_config["name"]}({server_config["uuid"]}): {e}\n{traceback.format_exc()}'
+            )
+            return
+
+        self.ap.logger.debug(f'Started MCP server {server_config["name"]}({server_config["uuid"]})')
+
+    async def load_mcp_server(self, server_config: dict) -> RuntimeMCPSession:
+        """加载 MCP 服务器到运行时
+
+        Args:
+            server_config: 服务器配置字典，必须包含:
+                - name: 服务器名称
+                - mode: 连接模式 (stdio/sse)
+                - enable: 是否启用
+                - extra_args: 额外的配置参数 (可选)
+        """
+
+        name = server_config['name']
+        mode = server_config['mode']
+        enable = server_config['enable']
+        extra_args = server_config.get('extra_args', {})
+
+        mixed_config = {
+            'name': name,
+            'mode': mode,
+            'enable': enable,
+            **extra_args,
+        }
+
+        session = RuntimeMCPSession(name, mixed_config, enable, self.ap)
+
+        return session
 
     async def get_tools(self) -> list[resource_tool.LLMTool]:
         all_functions = []
 
         for session in self.sessions.values():
-            all_functions.extend(session.functions)
+            all_functions.extend(session.get_tools())
 
         self._last_listed_functions = all_functions
 
         return all_functions
 
     async def has_tool(self, name: str) -> bool:
-        return name in [f.name for f in self._last_listed_functions]
+        """检查工具是否存在"""
+        for session in self.sessions.values():
+            for function in session.get_tools():
+                if function.name == name:
+                    return True
+        return False
 
     async def invoke_tool(self, name: str, parameters: dict) -> typing.Any:
-        for server_name, session in self.sessions.items():
-            for function in session.functions:
+        """执行工具调用"""
+        for session in self.sessions.values():
+            for function in session.get_tools():
                 if function.name == name:
-                    return await function.func(**parameters)
+                    self.ap.logger.debug(f'Invoking MCP tool: {name} with parameters: {parameters}')
+                    try:
+                        result = await function.func(**parameters)
+                        self.ap.logger.debug(f'MCP tool {name} executed successfully')
+                        return result
+                    except Exception as e:
+                        self.ap.logger.error(f'Error invoking MCP tool {name}: {e}\n{traceback.format_exc()}')
+                        raise
 
-        raise ValueError(f'未找到工具: {name}')
+        raise ValueError(f'Tool not found: {name}')
+
+    async def remove_mcp_server(self, server_name: str):
+        """移除 MCP 服务器"""
+        if server_name not in self.sessions:
+            self.ap.logger.warning(f'MCP server {server_name} not found in sessions, skipping removal')
+            return
+
+        session = self.sessions.pop(server_name)
+        await session.shutdown()
+        self.ap.logger.info(f'Removed MCP server: {server_name}')
+
+    def get_session(self, server_name: str) -> RuntimeMCPSession | None:
+        """获取指定名称的 MCP 会话"""
+        return self.sessions.get(server_name)
+
+    def has_session(self, server_name: str) -> bool:
+        """检查是否存在指定名称的 MCP 会话"""
+        return server_name in self.sessions
+
+    def get_all_server_names(self) -> list[str]:
+        """获取所有已加载的 MCP 服务器名称"""
+        return list(self.sessions.keys())
+
+    def get_server_tool_count(self, server_name: str) -> int:
+        """获取指定服务器的工具数量"""
+        session = self.get_session(server_name)
+        return len(session.get_tools()) if session else 0
+
+    def get_all_servers_info(self) -> dict[str, dict]:
+        """获取所有服务器的信息"""
+        info = {}
+        for server_name, session in self.sessions.items():
+            info[server_name] = {
+                'name': server_name,
+                'mode': session.server_config.get('mode'),
+                'enable': session.enable,
+                'tools_count': len(session.get_tools()),
+                'tool_names': [f.name for f in session.get_tools()],
+            }
+        return info
 
     async def shutdown(self):
-        """关闭工具"""
-        for session in self.sessions.values():
-            await session.shutdown()
+        """关闭所有工具"""
+        self.ap.logger.info('Shutting down all MCP sessions...')
+        for server_name, session in list(self.sessions.items()):
+            try:
+                await session.shutdown()
+                self.ap.logger.debug(f'Shutdown MCP session: {server_name}')
+            except Exception as e:
+                self.ap.logger.error(f'Error shutting down MCP session {server_name}: {e}\n{traceback.format_exc()}')
+        self.sessions.clear()
+        self.ap.logger.info('All MCP sessions shutdown complete')

pkg/provider/tools/loaders/plugin.py

@@ -7,7 +7,7 @@ from .. import loader
 import langbot_plugin.api.entities.builtin.resource.tool as resource_tool
 
 
-@loader.loader_class('plugin-tool-loader')
+# @loader.loader_class('plugin-tool-loader')
 class PluginToolLoader(loader.ToolLoader):
     """插件工具加载器。
 

pkg/provider/tools/toolmgr.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import typing
 
 from ...core import app
-from . import loader as tools_loader
 from ...utils import importutil
 from . import loaders
+from .loaders import mcp as mcp_loader, plugin as plugin_loader
 import langbot_plugin.api.entities.builtin.resource.tool as resource_tool
 
 importutil.import_modules_in_pkg(loaders)
@@ -16,25 +16,24 @@ class ToolManager:
 
     ap: app.Application
 
-    loaders: list[tools_loader.ToolLoader]
+    plugin_tool_loader: plugin_loader.PluginToolLoader
+    mcp_tool_loader: mcp_loader.MCPLoader
 
     def __init__(self, ap: app.Application):
         self.ap = ap
-        self.all_functions = []
-        self.loaders = []
 
     async def initialize(self):
-        for loader_cls in tools_loader.preregistered_loaders:
-            loader_inst = loader_cls(self.ap)
-            await loader_inst.initialize()
-            self.loaders.append(loader_inst)
+        self.plugin_tool_loader = plugin_loader.PluginToolLoader(self.ap)
+        await self.plugin_tool_loader.initialize()
+        self.mcp_tool_loader = mcp_loader.MCPLoader(self.ap)
+        await self.mcp_tool_loader.initialize()
 
     async def get_all_tools(self) -> list[resource_tool.LLMTool]:
         """获取所有函数"""
         all_functions: list[resource_tool.LLMTool] = []
 
-        for loader in self.loaders:
-            all_functions.extend(await loader.get_tools())
+        all_functions.extend(await self.plugin_tool_loader.get_tools())
+        all_functions.extend(await self.mcp_tool_loader.get_tools())
 
         return all_functions
 
@@ -93,13 +92,14 @@ class ToolManager:
     async def execute_func_call(self, name: str, parameters: dict) -> typing.Any:
         """执行函数调用"""
 
-        for loader in self.loaders:
-            if await loader.has_tool(name):
-                return await loader.invoke_tool(name, parameters)
+        if await self.plugin_tool_loader.has_tool(name):
+            return await self.plugin_tool_loader.invoke_tool(name, parameters)
+        elif await self.mcp_tool_loader.has_tool(name):
+            return await self.mcp_tool_loader.invoke_tool(name, parameters)
         else:
             raise ValueError(f'未找到工具: {name}')
 
     async def shutdown(self):
         """关闭所有工具"""
-        for loader in self.loaders:
-            await loader.shutdown()
+        await self.plugin_tool_loader.shutdown()
+        await self.mcp_tool_loader.shutdown()

pkg/rag/knowledge/services/chunker.py

@@ -4,6 +4,7 @@ import json
 from typing import List
 from pkg.rag.knowledge.services import base_service
 from pkg.core import app
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
 
 class Chunker(base_service.BaseService):
@@ -27,21 +28,6 @@ class Chunker(base_service.BaseService):
         """
         if not text:
             return []
-        # words = text.split()
-        # chunks = []
-        # current_chunk = []
-
-        # for word in words:
-        #     current_chunk.append(word)
-        #     if len(current_chunk) > self.chunk_size:
-        #         chunks.append(" ".join(current_chunk[:self.chunk_size]))
-        #         current_chunk = current_chunk[self.chunk_size - self.chunk_overlap:]
-
-        # if current_chunk:
-        #     chunks.append(" ".join(current_chunk))
-
-        # A more robust chunking strategy (e.g., using recursive character text splitter)
-        from langchain.text_splitter import RecursiveCharacterTextSplitter
 
         text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=self.chunk_size,

pkg/rag/knowledge/services/retriever.py

@@ -24,23 +24,23 @@ class Retriever(base_service.BaseService):
             extra_args={},  # TODO: add extra args
         )
 
-        chroma_results = await self.ap.vector_db_mgr.vector_db.search(kb_id, query_embedding[0], k)
+        vector_results = await self.ap.vector_db_mgr.vector_db.search(kb_id, query_embedding[0], k)
 
-        # 'ids' is always returned by ChromaDB, even if not explicitly in 'include'
-        matched_chroma_ids = chroma_results.get('ids', [[]])[0]
-        distances = chroma_results.get('distances', [[]])[0]
-        chroma_metadatas = chroma_results.get('metadatas', [[]])[0]
+        # 'ids' shape mirrors the Chroma-style response contract for compatibility
+        matched_vector_ids = vector_results.get('ids', [[]])[0]
+        distances = vector_results.get('distances', [[]])[0]
+        vector_metadatas = vector_results.get('metadatas', [[]])[0]
 
-        if not matched_chroma_ids:
-            self.ap.logger.info('No relevant chunks found in Chroma.')
+        if not matched_vector_ids:
+            self.ap.logger.info('No relevant chunks found in vector database.')
             return []
 
         result: list[retriever_entities.RetrieveResultEntry] = []
 
-        for i, id in enumerate(matched_chroma_ids):
+        for i, id in enumerate(matched_vector_ids):
             entry = retriever_entities.RetrieveResultEntry(
                 id=id,
-                metadata=chroma_metadatas[i],
+                metadata=vector_metadatas[i],
                 distance=distances[i],
             )
             result.append(entry)

pkg/utils/announce.py

@@ -45,17 +45,23 @@ class AnnouncementManager:
 
     async def fetch_all(self) -> list[Announcement]:
         """获取所有公告"""
-        resp = requests.get(
-            url='https://api.github.com/repos/langbot-app/LangBot/contents/res/announcement.json',
-            proxies=self.ap.proxy_mgr.get_forward_proxies(),
-            timeout=5,
-        )
-        obj_json = resp.json()
-        b64_content = obj_json['content']
-        # 解码
-        content = base64.b64decode(b64_content).decode('utf-8')
+        try:
+            resp = requests.get(
+                url='https://api.github.com/repos/langbot-app/LangBot/contents/res/announcement.json',
+                proxies=self.ap.proxy_mgr.get_forward_proxies(),
+                timeout=5,
+            )
+            resp.raise_for_status()  # 检查请求是否成功
+            obj_json = resp.json()
+            b64_content = obj_json['content']
+            # 解码
+            content = base64.b64decode(b64_content).decode('utf-8')
 
-        return [Announcement(**item) for item in json.loads(content)]
+            return [Announcement(**item) for item in json.loads(content)]
+        except (requests.RequestException, json.JSONDecodeError, KeyError) as e:
+            self.ap.logger.warning(f'获取公告失败: {e}')
+            pass
+        return []  # 请求失败时返回空列表
 
     async def fetch_saved(self) -> list[Announcement]:
         if not os.path.exists('data/labels/announcement_saved.json'):

pkg/utils/constants.py

@@ -1,7 +1,7 @@
-semantic_version = 'v4.3.0.beta3'
+semantic_version = 'v4.4.0'
 
-required_database_version = 6
-"""标记本版本所需要的数据库结构版本，用于判断数据库迁移"""
+required_database_version = 8
+"""Tag the version of the database schema, used to check if the database needs to be migrated"""
 
 debug_mode = False
 

pkg/utils/version.py

@@ -28,15 +28,19 @@ class VersionManager:
 
     async def get_release_list(self) -> list:
         """获取发行列表"""
-        rls_list_resp = requests.get(
-            url='https://api.github.com/repos/langbot-app/LangBot/releases',
-            proxies=self.ap.proxy_mgr.get_forward_proxies(),
-            timeout=5,
-        )
-
-        rls_list = rls_list_resp.json()
-
-        return rls_list
+        try:
+            rls_list_resp = requests.get(
+                url='https://api.github.com/repos/langbot-app/LangBot/releases',
+                proxies=self.ap.proxy_mgr.get_forward_proxies(),
+                timeout=5,
+            )
+            rls_list_resp.raise_for_status()  # 检查请求是否成功
+            rls_list = rls_list_resp.json()
+            return rls_list
+        except Exception as e:
+            self.ap.logger.warning(f"获取发行列表失败: {e}")
+            pass
+        return []
 
     async def update_all(self):
         """检查更新并下载源码"""

pkg/vector/mgr.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from ..core import app
 from .vdb import VectorDatabase
 from .vdbs.chroma import ChromaVectorDatabase
+from .vdbs.qdrant import QdrantVectorDatabase
 
 
 class VectorDBManager:
@@ -13,6 +14,17 @@ class VectorDBManager:
         self.ap = ap
 
     async def initialize(self):
-        # 初始化 Chroma 向量数据库（可扩展为多种实现）
-        if self.vector_db is None:
+        kb_config = self.ap.instance_config.data.get('vdb')
+        if kb_config:
+            if kb_config.get('use') == 'chroma':
+                self.vector_db = ChromaVectorDatabase(self.ap)
+                self.ap.logger.info('Initialized Chroma vector database backend.')
+            elif kb_config.get('use') == 'qdrant':
+                self.vector_db = QdrantVectorDatabase(self.ap)
+                self.ap.logger.info('Initialized Qdrant vector database backend.')
+            else:
+                self.vector_db = ChromaVectorDatabase(self.ap)
+                self.ap.logger.warning('No valid vector database backend configured, defaulting to Chroma.')
+        else:
             self.vector_db = ChromaVectorDatabase(self.ap)
+            self.ap.logger.warning('No vector database backend configured, defaulting to Chroma.')

pkg/vector/vdb.py

@@ -14,24 +14,25 @@ class VectorDatabase(abc.ABC):
         metadatas: list[dict[str, Any]],
         documents: list[str],
     ) -> None:
-        """向指定 collection 添加向量数据。"""
+        """Add vector data to the specified collection."""
         pass
 
     @abc.abstractmethod
     async def search(self, collection: str, query_embedding: np.ndarray, k: int = 5) -> Dict[str, Any]:
-        """在指定 collection 中检索最相似的向量。"""
+        """Search for the most similar vectors in the specified collection."""
         pass
 
     @abc.abstractmethod
     async def delete_by_file_id(self, collection: str, file_id: str) -> None:
-        """根据 file_id 删除指定 collection 中的向量。"""
+        """Delete vectors from the specified collection by file_id."""
         pass
 
     @abc.abstractmethod
     async def get_or_create_collection(self, collection: str):
-        """获取或创建 collection。"""
+        """Get or create collection."""
         pass
 
     @abc.abstractmethod
     async def delete_collection(self, collection: str):
+        """Delete collection."""
         pass

pkg/vector/vdbs/qdrant.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from qdrant_client import AsyncQdrantClient, models
+from pkg.core import app
+from pkg.vector.vdb import VectorDatabase
+
+
+class QdrantVectorDatabase(VectorDatabase):
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+        url = self.ap.instance_config.data['vdb']['qdrant']['url']
+        host = self.ap.instance_config.data['vdb']['qdrant']['host']
+        port = self.ap.instance_config.data['vdb']['qdrant']['port']
+        api_key = self.ap.instance_config.data['vdb']['qdrant']['api_key']
+
+        if url:
+            self.client = AsyncQdrantClient(url=url, api_key=api_key)
+        else:
+            self.client = AsyncQdrantClient(host=host, port=int(port), api_key=api_key)
+
+        self._collections: set[str] = set()
+
+    async def _ensure_collection(self, collection: str, vector_size: int) -> None:
+        if collection in self._collections:
+            return
+
+        exists = await self.client.collection_exists(collection)
+        if exists:
+            self._collections.add(collection)
+            return
+
+        await self.client.create_collection(
+            collection_name=collection,
+            vectors_config=models.VectorParams(size=vector_size, distance=models.Distance.COSINE),
+        )
+        self._collections.add(collection)
+        self.ap.logger.info(f"Qdrant collection '{collection}' created with dim={vector_size}.")
+
+    async def get_or_create_collection(self, collection: str):
+        # Qdrant requires vector size to create a collection; no-op here.
+        pass
+
+    async def add_embeddings(
+        self,
+        collection: str,
+        ids: List[str],
+        embeddings_list: List[List[float]],
+        metadatas: List[Dict[str, Any]],
+    ) -> None:
+        if not embeddings_list:
+            return
+
+        await self._ensure_collection(collection, len(embeddings_list[0]))
+
+        points = [
+            models.PointStruct(id=ids[i], vector=embeddings_list[i], payload=metadatas[i]) for i in range(len(ids))
+        ]
+        await self.client.upsert(collection_name=collection, points=points)
+        self.ap.logger.info(f"Added {len(ids)} embeddings to Qdrant collection '{collection}'.")
+
+    async def search(self, collection: str, query_embedding: list[float], k: int = 5) -> dict[str, Any]:
+        exists = await self.client.collection_exists(collection)
+        if not exists:
+            return {'ids': [[]], 'metadatas': [[]], 'distances': [[]]}
+
+        hits = (
+            await self.client.query_points(
+                collection_name=collection,
+                query=query_embedding,
+                limit=k,
+                with_payload=True,
+            )
+        ).points
+        ids = [str(hit.id) for hit in hits]
+        metadatas = [hit.payload or {} for hit in hits]
+        # Qdrant's score is similarity; convert to a pseudo-distance for consistency
+        distances = [1 - float(hit.score) if hit.score is not None else 1.0 for hit in hits]
+        results = {'ids': [ids], 'metadatas': [metadatas], 'distances': [distances]}
+
+        self.ap.logger.info(f"Qdrant search in '{collection}' returned {len(results.get('ids', [[]])[0])} results.")
+        return results
+
+    async def delete_by_file_id(self, collection: str, file_id: str) -> None:
+        exists = await self.client.collection_exists(collection)
+        if not exists:
+            return
+
+        await self.client.delete(
+            collection_name=collection,
+            points_selector=models.Filter(
+                must=[models.FieldCondition(key='file_id', match=models.MatchValue(value=file_id))]
+            ),
+        )
+        self.ap.logger.info(f"Deleted embeddings from Qdrant collection '{collection}' with file_id: {file_id}")
+
+    async def delete_collection(self, collection: str):
+        try:
+            await self.client.delete_collection(collection)
+            self._collections.discard(collection)
+            self.ap.logger.info(f"Qdrant collection '{collection}' deleted.")
+        except Exception:
+            self.ap.logger.warning(f"Qdrant collection '{collection}' not found.")

pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "langbot"
-version = "4.3.0.beta4"
-description = "高稳定、支持扩展、多模态 - 大模型原生即时通信机器人平台"
+version = "4.4.0"
+description = "Easy-to-use global IM bot platform designed for LLM era"
 readme = "README.md"
-requires-python = ">=3.10.1"
+requires-python = ">=3.10.1,<4.0"
 dependencies = [
     "aiocqhttp>=1.4.4",
     "aiofiles>=24.1.0",
@@ -19,7 +19,7 @@ dependencies = [
     "dashscope>=1.23.2",
     "dingtalk-stream>=0.24.0",
     "discord-py>=2.5.2",
-    "pynacl>=1.5.0",  # Required for Discord voice support
+    "pynacl>=1.5.0", # Required for Discord voice support
     "gewechat-client>=0.1.5",
     "lark-oapi>=1.4.15",
     "mcp>=1.8.1",
@@ -60,8 +60,13 @@ dependencies = [
     "ebooklib>=0.18",
     "html2text>=2024.2.26",
     "langchain>=0.2.0",
+    "langchain-text-splitters>=0.0.1",
     "chromadb>=0.4.24",
-    "langbot-plugin==0.1.1b5",
+    "qdrant-client (>=1.15.1,<2.0.0)",
+    "langbot-plugin==0.1.6",
+    "asyncpg>=0.30.0",
+    "line-bot-sdk>=3.19.0",
+    "tboxsdk>=0.0.10",
 ]
 keywords = [
     "bot",
@@ -99,6 +104,7 @@ dev = [
     "pre-commit>=4.2.0",
     "pytest>=8.4.1",
     "pytest-asyncio>=1.0.0",
+    "pytest-cov>=7.0.0",
     "ruff>=0.11.9",
 ]