commit 0873d9e68879f7a8f814f656bf0e488b6d2b64b6
Author: Seiun <140777969+lonh-jing@users.noreply.github.com>
Date:   Wed Feb 11 10:26:47 2026 +0800

    Squashed 'plugins/tts_voice_plugin/' content from commit d14ba1bd
    
    git-subtree-dir: plugins/tts_voice_plugin
    git-subtree-split: d14ba1bdf00b09521a4eab8fd66ee83c64f2314c

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..f937ce2b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,40 @@
+# 敏感配置文件
+config.toml
+config.toml.backup.*
+config.toml.reset.*
+
+# Python缓存文件
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# 虚拟环境
+venv/
+ENV/
+env/
+
+# IDE配置
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# 临时文件
+*.log
+*.tmp
+.DS_Store
+
+# 生成的音频文件
+tts_*.mp3
+tts_*.wav
+tts_*.ogg
+
+# 数据目录（包含临时音频文件）
+data/
+
+# 规范工作流目录
+.spec-workflow/
+
+# Claude配置
+.claude/
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 00000000..0ad25db4
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,661 @@
+                    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/>.
diff --git a/README.md b/README.md
new file mode 100644
index 00000000..9cd5f91c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,311 @@
+# TTS 语音合成插件
+
+MaiBot 的文本转语音插件，支持多种 TTS 后端。
+
+## 支持的后端
+
+| 后端 | 说明 | 适用场景 |
+|------|------|----------|
+| AI Voice | MaiCore 内置，无需配置 | 仅群聊 |
+| GSV2P | 云端 API，需要 Token | 群聊/私聊 |
+| GPT-SoVITS | 本地服务，需自行部署 | 群聊/私聊 |
+| 豆包语音 | 火山引擎云服务，高质量 | 群聊/私聊 |
+| CosyVoice | 阿里云 CosyVoice3，支持方言和声音克隆 | 群聊/私聊 |
+| ComfyUI | 本地 ComfyUI 工作流 API（MLX Qwen3-TTS VoiceClone） | 群聊/私聊 |
+
+## 安装
+
+```bash
+pip install aiohttp gradio_client
+```
+
+## 配置
+
+编辑 `config.toml`，设置默认后端：
+
+```toml
+[general]
+default_backend = "cosyvoice"  # 可选：ai_voice / gsv2p / gpt_sovits / doubao / cosyvoice / comfyui
+audio_output_dir = ""          # 音频输出目录，留空使用项目根目录
+use_base64_audio = false       # 是否使用base64发送（备选方案）
+split_sentences = true         # 是否分段发送语音（长文本逐句发送）
+split_delay = 0.3              # 分段发送间隔时间（秒）
+send_error_messages = true     # 是否发送错误提示消息（false=静默失败）
+```
+
+### Docker环境配置说明
+
+**问题：** Docker环境中可能遇到音频上传失败或文件路径识别错误（如`识别URL失败`）
+
+**解决方案（按推荐顺序）：**
+
+#### 方案1：使用相对路径（推荐）
+
+```toml
+[general]
+audio_output_dir = ""  # 留空，默认使用项目根目录
+```
+
+音频文件将保存在项目根目录，OneBot/NapCat可以正确识别相对路径。
+
+#### 方案2：自定义输出目录
+
+```toml
+[general]
+audio_output_dir = "data/tts_audio"  # 相对路径，相对于项目根目录
+# 或
+audio_output_dir = "/app/data/audio" # 绝对路径
+```
+
+#### 方案3：使用base64编码（备选）
+
+如果路径方案都不生效，可启用base64发送：
+
+```toml
+[general]
+use_base64_audio = true  # 使用base64编码发送（会增加约33%数据大小）
+```
+
+### 豆包语音配置
+
+```toml
+[doubao]
+app_id = "你的APP_ID"
+access_key = "你的ACCESS_KEY"
+resource_id = "seed-tts-2.0"
+default_voice = "zh_female_vv_uranus_bigtts"
+```
+
+**预置音色：**
+
+| 音色名称 | voice_type |
+|----------|------------|
+| vivi 2.0 | zh_female_vv_uranus_bigtts |
+| 大壹 | zh_male_dayi_saturn_bigtts |
+| 黑猫侦探社咪仔 | zh_female_mizai_saturn_bigtts |
+
+**复刻音色：** 将 `resource_id` 改为 `seed-icl-2.0`，`default_voice` 填音色 ID（如 `S_xxxxxx`）
+
+凭证获取：[火山引擎控制台](https://console.volcengine.com/speech/service/8)
+
+### GSV2P 配置
+
+```toml
+[gsv2p]
+api_token = "你的Token"
+default_voice = "原神-中文-派蒙_ZH"
+```
+
+Token 获取：[https://tts.acgnai.top](https://tts.acgnai.top)
+
+### AI Voice 配置
+
+```toml
+[ai_voice]
+default_character = "温柔妹妹"
+```
+
+可用音色：小新、猴哥、妲己、酥心御姐、温柔妹妹、邻家小妹 等 22 种
+
+### GPT-SoVITS 配置
+
+**支持两种配置格式：**
+
+#### 格式1：数组格式（推荐，WebUI 友好）
+
+```toml
+[gpt_sovits]
+server = "http://127.0.0.1:9880"
+
+[[gpt_sovits.styles]]
+name = "default"
+refer_wav = "/path/to/reference.wav"
+prompt_text = "参考文本"
+prompt_language = "zh"
+gpt_weights = "/path/to/model.ckpt"      # 可选：动态模型切换
+sovits_weights = "/path/to/model.pth"    # 可选：动态模型切换
+
+[[gpt_sovits.styles]]
+name = "happy"
+refer_wav = "/path/to/happy.wav"
+prompt_text = "开心的参考文本"
+prompt_language = "zh"
+```
+
+#### 格式2：字典格式（兼容旧版）
+
+```toml
+[gpt_sovits]
+server = "http://127.0.0.1:9880"
+
+[gpt_sovits.styles.default]
+refer_wav = "/path/to/reference.wav"
+prompt_text = "参考文本"
+prompt_language = "zh"
+gpt_weights = "/path/to/model.ckpt"
+sovits_weights = "/path/to/model.pth"
+```
+
+> **提示：** 插件会自动识别并兼容两种格式，推荐使用数组格式以获得更好的 WebUI 支持。
+
+### CosyVoice 配置
+
+```toml
+[cosyvoice]
+gradio_url = "https://funaudiollm-fun-cosyvoice3-0-5b.ms.show/"
+default_mode = "3s极速复刻"           # 或 "自然语言控制"
+default_instruct = "You are a helpful assistant. 请用广东话表达。<|endofprompt|>" # 只有自然语言控制模式才会生效，3s极速复刻模式下不生效
+reference_audio = "/path/to/ref.wav"  # 参考音频路径
+prompt_text = "参考音频对应的文本"      # 参考音频的对应文本
+timeout = 300                          # API超时（秒）
+```
+
+**支持的方言/情感/语速：**
+
+| 类型 | 可用选项 |
+|------|----------|
+| 方言 | 广东话、东北话、四川话、上海话、闽南话、山东话、陕西话、湖南话等17种 |
+| 情感 | 开心、伤心、生气 |
+| 语速 | 慢速、快速 |
+| 音量 | 大声、小声 |
+| 特殊风格 | 小猪佩奇、机器人 |
+
+**推理模式：**
+- `3s极速复刻`：需要提供参考音频进行声音克隆
+- `自然语言控制`：通过指令控制方言、情感、语速等
+
+## 使用方法
+
+### 命令触发
+
+```
+/tts 你好世界                    # 使用默认后端
+/tts 今天天气不错 小新            # 指定音色
+/gsv2p 你好世界                  # 使用 GSV2P
+/doubao 你好世界                 # 使用豆包
+/cosyvoice 你好世界 四川话        # 使用 CosyVoice，四川话
+/comfyui 你好世界 -v default     # 使用 ComfyUI 本地工作流（MLX VoiceClone）
+```
+
+## ComfyUI 后端配置
+
+该后端通过 ComfyUI 的 HTTP API 执行工作流（`/prompt` -> `/history` -> `/view`），并用 `LoadAudio` 从 ComfyUI 的 `input` 目录读取参考音频。
+
+```toml
+[comfyui]
+server = "http://127.0.0.1:8188"
+input_dir = "/Users/xenon/Downloads/seiun_tts/ComfyUI/ComfyUI/input"
+timeout = 120
+audio_quality = "128k" # SaveAudioMP3: V0/128k/320k
+mlx_python = "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/.venv/bin/python"
+mlx_cli = "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/mlx_voice_clone_cli.py"
+default_style = "default"
+
+[[comfyui.styles]]
+name = "default"
+refer_wav = "/path/to/ref.wav"
+prompt_text = "参考音频逐字稿"
+language = "Auto" # 可选: Auto/Chinese/English/Japanese...
+model_choice = "1.7B"
+precision = "bf16"
+seed = 0
+max_new_tokens = 2048
+top_p = 0.8
+top_k = 20
+temperature = 1.0
+repetition_penalty = 1.05
+```
+
+### 自动触发
+
+LLM 判断需要语音回复时会自动触发，可通过概率控制：
+
+```toml
+[probability]
+enabled = false          # 默认关闭，每次都触发语音
+base_probability = 0.3   # 启用时 30% 概率触发
+```
+
+### 智能分割插件支持
+
+本插件已适配智能分割插件，支持使用 `|||SPLIT|||` 分隔符进行精确分段：
+
+- **优先级**：智能分割标记 > 自动句子分割 > 单句发送
+- **使用方式**：智能分割插件会在适当位置插入 `|||SPLIT|||` 标记，本插件自动识别并按标记分段发送
+- **示例**：`今天天气不错|||SPLIT|||适合出去玩|||SPLIT|||你觉得呢` 会分成三段语音依次发送
+
+## 项目结构
+
+```
+tts_voice_plugin/
+├── plugin.py          # 插件入口
+├── config.toml        # 配置文件
+├── backends/          # 后端实现
+│   ├── ai_voice.py
+│   ├── gsv2p.py
+│   ├── gpt_sovits.py
+│   ├── doubao.py
+│   └── cosyvoice.py
+└── utils/             # 工具函数
+```
+
+## 常见问题
+
+**Q: Docker环境中提示"文件处理失败 识别URL失败"？**
+A: 留空 `audio_output_dir` 配置项，插件将使用项目根目录保存音频（相对路径）。如仍有问题，可设置 `use_base64_audio = true` 使用base64编码发送。
+
+**Q: AI Voice 提示"仅支持群聊"？**
+A: AI Voice 只能在群聊使用，私聊会自动切换到其他后端。
+
+**Q: 豆包语音怎么获取凭证？**
+A: 登录火山引擎控制台，开通语音合成服务获取。
+
+**Q: 文本太长被截断？**
+A: 修改 `config.toml` 中 `max_text_length = 1000`
+
+**Q: 语音合成失败时不想让Bot发送错误消息？**
+A: 设置 `send_error_messages = false`，语音合成失败时将静默处理，不向用户发送错误提示。
+
+## 更新日志
+
+### v3.2.3
+- 修复豆包语音 WAV 流式响应合并问题（正确处理 LIST/INFO 元数据块和多 header 情况）
+- 默认后端改为 CosyVoice（更稳定的声音克隆体验）
+- 默认关闭概率控制（每次触发都生成语音，更可预期的行为）
+- 优化 LLM 长度约束提示（利用"近因效应"提高遵守率）
+- 优化 action 记录格式，帮助 planner 避免重复执行
+- GSV2P/豆包音频格式默认改为 WAV（更好的兼容性）
+- CosyVoice 默认模式改为 3s 极速复刻（更快响应）
+- 更新默认超时配置（CosyVoice 300s, GSV2P 120s）
+
+### v3.2.2
+- 适配智能分割插件（支持 `|||SPLIT|||` 分隔符精确分段）
+- GPT-SoVITS 支持数组格式配置（WebUI 友好，向后兼容字典格式）
+- 修复豆包语音音色信息显示乱码问题
+- 优化配置文件注释，更简洁清晰
+- 优化分段发送逻辑优先级（智能分割 > 自动分割 > 单句）
+- 禁用 Python 字节码生成（保持目录干净）
+- 添加插件 ID 标识字段
+
+### v3.2.1
+- 新增 `send_error_messages` 配置项（可选择关闭错误提示消息）
+- 统一错误消息处理逻辑（通过 `_send_error` 方法）
+
+### v3.2.0
+- 新增 CosyVoice 后端（阿里云 ModelScope，支持 17 种方言、3 秒声音克隆）
+- 新增分段发送功能（长文本自动分割逐句发送）
+- GPT-SoVITS 支持动态模型切换（在风格配置中指定 gpt_weights/sovits_weights）
+- GSV2P 后端新增重试机制（5 次重试，3 秒间隔）
+- 新增 `/cosyvoice` 命令
+- 新增 gradio_client 依赖
+
+### v3.1.0
+- 新增豆包语音后端（火山引擎云服务）
+- 重构为模块化架构
+- HTTP Session 复用优化
+
+## 信息
+
+- 版本：3.2.3
+- 作者：靓仔
+- 许可：AGPL-v3.0
diff --git a/_manifest.json b/_manifest.json
new file mode 100644
index 00000000..d640b6a3
--- /dev/null
+++ b/_manifest.json
@@ -0,0 +1,235 @@
+{
+  "manifest_version": 1,
+  "name": "统一TTS语音合成插件",
+  "version": "3.2.3",
+  "description": "统一TTS语音合成插件，整合AI Voice、GSV2P、GPT-SoVITS、豆包语音、CosyVoice五种后端引擎，提供灵活的语音合成能力。",
+  "author": {
+    "name": "靓仔",
+    "url": "https://github.com/xuqian13"
+  },
+  "license": "AGPL-v3.0",
+  "homepage_url": "",
+  "repository_url": "https://github.com/xuqian13/tts_voice_plugin",
+  "keywords": [
+    "TTS",
+    "语音合成",
+    "文本转语音",
+    "AI语音",
+    "GSV2P",
+    "GPT-SoVITS",
+    "豆包",
+    "CosyVoice",
+    "火山引擎",
+    "多后端",
+    "语音",
+    "朗读",
+    "音色",
+    "语音播报",
+    "方言",
+    "声音克隆",
+    "MaiCore"
+  ],
+  "categories": [
+    "语音",
+    "AI",
+    "聊天增强",
+    "娱乐",
+    "Utility",
+    "Communication",
+    "Accessibility"
+  ],
+  "host_application": {
+    "min_version": "0.12.0"
+  },
+  "default_locale": "zh-CN",
+  "plugin_info": {
+    "is_built_in": false,
+    "plugin_type": "general",
+    "components": [
+      {
+        "type": "action",
+        "name": "unified_tts_action",
+        "description": "统一TTS语音合成Action，支持四种后端引擎智能切换，LLM自主判断触发"
+      },
+      {
+        "type": "command",
+        "name": "unified_tts_command",
+        "description": "统一TTS命令，支持/tts、/voice、/gsv2p、/doubao多种命令格式，灵活指定后端和音色"
+      }
+    ],
+    "features": [
+      "支持五种TTS后端：AI Voice、GSV2P、GPT-SoVITS、豆包语音、CosyVoice",
+      "AI Voice: MaiCore内置，简单快速，22+预设音色",
+      "GSV2P: 云端API，高质量合成，丰富的调节参数",
+      "GPT-SoVITS: 本地服务，高度定制化，多风格支持",
+      "豆包语音: 字节跳动云服务，支持复刻音色和情感控制",
+      "CosyVoice: 阿里云语音合成，支持17种方言、3秒声音克隆、情感控制",
+      "模块化架构，后端独立实现，易于扩展",
+      "HTTP Session复用，提升性能",
+      "临时文件自动清理，避免并发冲突",
+      "智能触发模式（LLM自主判断）和手动命令模式",
+      "概率控制机制，避免语音回复过于频繁",
+      "智能语言检测（中文/英文/日文）",
+      "文本自动清理和网络用语转换",
+      "完善的错误处理和重试机制",
+      "灵活的配置系统，支持各后端独立配置"
+    ],
+    "dependencies": {
+      "python": [
+        "aiohttp",
+        "gradio_client"
+      ],
+      "system": [],
+      "plugins": []
+    },
+    "backend_info": {
+      "ai_voice": {
+        "provider": "MaiCore内置",
+        "endpoint": "AI_VOICE_SEND命令",
+        "authentication": "无需认证",
+        "limitations": "仅支持群聊使用",
+        "voices": "22+预设音色（小新、妲己、酥心御姐等）"
+      },
+      "gsv2p": {
+        "provider": "GSV2P云服务",
+        "endpoint": "https://gsv2p.acgnai.top/v1/audio/speech",
+        "authentication": "需要API Token",
+        "limitations": "API调用限制",
+        "features": "高质量合成、多语言支持、丰富参数调节"
+      },
+      "gpt_sovits": {
+        "provider": "本地GPT-SoVITS服务",
+        "endpoint": "http://127.0.0.1:9880",
+        "authentication": "无需认证",
+        "limitations": "需要本地部署服务",
+        "features": "高度定制化、多风格支持、模型权重切换"
+      },
+      "doubao": {
+        "provider": "字节跳动火山引擎",
+        "endpoint": "https://openspeech.bytedance.com/api/v3/tts/unidirectional",
+        "authentication": "需要app_id、access_key、resource_id",
+        "limitations": "需要火山引擎账号",
+        "features": "快速高质量、支持复刻音色、情感语气控制"
+      },
+      "cosyvoice": {
+        "provider": "阿里云 CosyVoice",
+        "endpoint": "ModelScope Gradio API",
+        "authentication": "无需认证（公开Gradio接口）",
+        "limitations": "依赖ModelScope服务可用性",
+        "features": "3秒声音克隆、17种方言支持、情感语速控制、自然语言指令"
+      }
+    }
+  },
+  "configuration": {
+    "config_file": "config.toml",
+    "config_template": "config.toml.example",
+    "auto_generate": true,
+    "sections": [
+      {
+        "name": "plugin",
+        "description": "插件基本配置"
+      },
+      {
+        "name": "general",
+        "description": "通用设置（默认后端、超时、文本长度等）"
+      },
+      {
+        "name": "components",
+        "description": "组件启用控制"
+      },
+      {
+        "name": "probability",
+        "description": "概率控制配置（避免语音回复过于频繁）"
+      },
+      {
+        "name": "ai_voice",
+        "description": "AI Voice后端配置（音色映射等）"
+      },
+      {
+        "name": "gsv2p",
+        "description": "GSV2P后端配置（API地址、Token、参数等）"
+      },
+      {
+        "name": "gpt_sovits",
+        "description": "GPT-SoVITS后端配置（服务地址、风格配置等）"
+      },
+      {
+        "name": "doubao",
+        "description": "豆包语音后端配置（火山引擎认证、音色、情感等）"
+      },
+      {
+        "name": "cosyvoice",
+        "description": "CosyVoice后端配置（Gradio URL、模式、方言等）"
+      }
+    ]
+  },
+  "usage_examples": [
+    {
+      "type": "action",
+      "backend": "auto",
+      "description": "LLM自动触发语音回复",
+      "example": "用户：请用语音说\"你好世界\"\n机器人：[使用默认后端自动生成语音文件并发送]"
+    },
+    {
+      "type": "command",
+      "backend": "ai_voice",
+      "description": "手动命令使用AI Voice",
+      "example": "/tts 你好世界 小新"
+    },
+    {
+      "type": "command",
+      "backend": "gsv2p",
+      "description": "手动命令使用GSV2P",
+      "example": "/gsv2p 今天天气不错"
+    },
+    {
+      "type": "command",
+      "backend": "doubao",
+      "description": "手动命令使用豆包语音",
+      "example": "/doubao 你好世界"
+    },
+    {
+      "type": "command",
+      "backend": "gpt_sovits",
+      "description": "手动命令使用GPT-SoVITS",
+      "example": "/tts 测试一下 default gpt_sovits"
+    },
+    {
+      "type": "command",
+      "backend": "cosyvoice",
+      "description": "手动命令使用CosyVoice",
+      "example": "/cosyvoice 你好世界 四川话"
+    },
+    {
+      "type": "command",
+      "backend": "auto",
+      "description": "使用默认后端",
+      "example": "/tts 你好世界"
+    }
+  ],
+  "migration_info": {
+    "from_plugins": [
+      "ai_voice_plugin (v1.0.0)",
+      "gsv2p_tts_plugin (v1.0.0)",
+      "tts_voice_plugin (v2.0.0)",
+      "tts_voice_plugin (v3.0.0)"
+    ],
+    "migration_notes": [
+      "本插件整合了ai_voice_plugin、gsv2p_tts_plugin和旧版tts_voice_plugin的所有功能",
+      "v3.2.2适配智能分割插件（支持|||SPLIT|||分隔符精确分段）",
+      "v3.2.2支持GPT-SoVITS数组格式配置（WebUI友好，向后兼容字典格式）",
+      "v3.2.2修复豆包语音音色信息显示乱码问题",
+      "v3.2.2优化配置文件注释，更简洁清晰",
+      "v3.2.0新增CosyVoice后端支持（阿里云语音合成，支持17种方言和3秒声音克隆）",
+      "v3.1.0新增豆包语音后端支持",
+      "v3.1.0重构为模块化架构，提升代码可维护性",
+      "配置文件需要重新生成，原配置需手动迁移",
+      "建议备份旧插件配置后再迁移",
+      "AI Voice音色映射保持兼容",
+      "GSV2P API配置需重新填写Token",
+      "GPT-SoVITS风格配置需要重新设置",
+      "新增config.toml.example模板文件"
+    ]
+  },
+  "id": "tts_voice_plugin"
+}
\ No newline at end of file
diff --git a/backends/__init__.py b/backends/__init__.py
new file mode 100644
index 00000000..ddcafef1
--- /dev/null
+++ b/backends/__init__.py
@@ -0,0 +1,38 @@
+"""
+TTS后端模块
+"""
+
+import sys
+sys.dont_write_bytecode = True
+
+from .base import TTSBackendBase, TTSBackendRegistry, TTSResult
+from .ai_voice import AIVoiceBackend
+from .gsv2p import GSV2PBackend
+from .gpt_sovits import GPTSoVITSBackend
+from .doubao import DoubaoBackend
+from .cosyvoice import CosyVoiceBackend
+from .comfyui import ComfyUIBackend, ComfyUIVoiceCloneBackend, ComfyUICustomVoiceBackend
+
+# 注册后端
+TTSBackendRegistry.register("ai_voice", AIVoiceBackend)
+TTSBackendRegistry.register("gsv2p", GSV2PBackend)
+TTSBackendRegistry.register("gpt_sovits", GPTSoVITSBackend)
+TTSBackendRegistry.register("doubao", DoubaoBackend)
+TTSBackendRegistry.register("cosyvoice", CosyVoiceBackend)
+TTSBackendRegistry.register("comfyui", ComfyUIBackend)
+TTSBackendRegistry.register("comfyui_voiceclone", ComfyUIVoiceCloneBackend)
+TTSBackendRegistry.register("comfyui_customvoice", ComfyUICustomVoiceBackend)
+
+__all__ = [
+    "TTSBackendBase",
+    "TTSBackendRegistry",
+    "TTSResult",
+    "AIVoiceBackend",
+    "GSV2PBackend",
+    "GPTSoVITSBackend",
+    "DoubaoBackend",
+    "CosyVoiceBackend",
+    "ComfyUIBackend",
+    "ComfyUIVoiceCloneBackend",
+    "ComfyUICustomVoiceBackend",
+]
diff --git a/backends/ai_voice.py b/backends/ai_voice.py
new file mode 100644
index 00000000..c916fa00
--- /dev/null
+++ b/backends/ai_voice.py
@@ -0,0 +1,133 @@
+"""
+AI Voice 后端实现
+使用 MaiCore 内置的 AI 语音功能
+"""
+
+from typing import Optional, Callable, Dict
+from .base import TTSBackendBase, TTSResult
+from ..utils.text import TTSTextUtils
+from ..config_keys import ConfigKeys
+from src.common.logger import get_logger
+
+logger = get_logger("tts_ai_voice")
+
+# AI Voice 音色映射表
+AI_VOICE_ALIAS_MAP = {
+    "小新": "lucy-voice-laibixiaoxin",
+    "猴哥": "lucy-voice-houge",
+    "四郎": "lucy-voice-silang",
+    "东北老妹儿": "lucy-voice-guangdong-f1",
+    "广西大表哥": "lucy-voice-guangxi-m1",
+    "妲己": "lucy-voice-daji",
+    "霸道总裁": "lucy-voice-lizeyan",
+    "酥心御姐": "lucy-voice-suxinjiejie",
+    "说书先生": "lucy-voice-m8",
+    "憨憨小弟": "lucy-voice-male1",
+    "憨厚老哥": "lucy-voice-male3",
+    "吕布": "lucy-voice-lvbu",
+    "元气少女": "lucy-voice-xueling",
+    "文艺少女": "lucy-voice-f37",
+    "磁性大叔": "lucy-voice-male2",
+    "邻家小妹": "lucy-voice-female1",
+    "低沉男声": "lucy-voice-m14",
+    "傲娇少女": "lucy-voice-f38",
+    "爹系男友": "lucy-voice-m101",
+    "暖心姐姐": "lucy-voice-female2",
+    "温柔妹妹": "lucy-voice-f36",
+    "书香少女": "lucy-voice-f34"
+}
+
+
+class AIVoiceBackend(TTSBackendBase):
+    """
+    AI Voice 后端
+
+    使用 MaiCore 内置的 AI 语音功能
+    注意：仅支持群聊环境
+    """
+
+    backend_name = "ai_voice"
+    backend_description = "MaiCore内置AI语音（仅群聊）"
+    support_private_chat = False  # 不支持私聊
+    default_audio_format = ""  # AI Voice不需要音频格式
+
+    def __init__(self, config_getter, log_prefix: str = ""):
+        super().__init__(config_getter, log_prefix)
+        self._send_command = None  # 由外部注入
+
+    def set_send_command(self, send_command_func: Callable) -> None:
+        """设置发送命令的函数（由Action/Command注入）"""
+        self._send_command = send_command_func
+
+    def get_default_voice(self) -> str:
+        """获取默认音色"""
+        return self.get_config(ConfigKeys.AI_VOICE_DEFAULT_CHARACTER, "温柔妹妹")
+
+    def resolve_voice(self, voice: Optional[str]) -> str:
+        """解析音色别名"""
+        alias_map: Dict[str, str] = self.get_config(
+            ConfigKeys.AI_VOICE_ALIAS_MAP,
+            AI_VOICE_ALIAS_MAP
+        )
+        default_voice = self.get_default_voice()
+        return TTSTextUtils.resolve_voice_alias(
+            voice,
+            alias_map,
+            default_voice,
+            prefix="lucy-voice-"
+        )
+
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行AI Voice语音合成
+
+        Args:
+            text: 待转换的文本
+            voice: 音色名称或别名
+
+        Returns:
+            TTSResult
+        """
+        if not self._send_command:
+            return TTSResult(
+                success=False,
+                message="AI Voice后端未正确初始化（缺少send_command）",
+                backend_name=self.backend_name
+            )
+
+        # 解析音色
+        character = self.resolve_voice(voice)
+
+        try:
+            success = await self._send_command(
+                command_name="AI_VOICE_SEND",
+                args={"text": text, "character": character},
+                storage_message=False
+            )
+
+            if success:
+                logger.info(f"{self.log_prefix} AI语音发送成功 (音色: {character})")
+                return TTSResult(
+                    success=True,
+                    message=f"成功发送AI语音 (音色: {character})",
+                    backend_name=self.backend_name
+                )
+            else:
+                return TTSResult(
+                    success=False,
+                    message="AI语音命令发送失败",
+                    backend_name=self.backend_name
+                )
+
+        except Exception as e:
+            logger.error(f"{self.log_prefix} AI语音执行错误: {e}")
+            return TTSResult(
+                success=False,
+                message=f"AI语音执行错误: {e}",
+                backend_name=self.backend_name
+            )
diff --git a/backends/base.py b/backends/base.py
new file mode 100644
index 00000000..9d8936f4
--- /dev/null
+++ b/backends/base.py
@@ -0,0 +1,239 @@
+"""
+TTS后端抽象基类和注册表
+"""
+
+import asyncio
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, Type, Optional, Any, Callable, Tuple, Union
+from src.common.logger import get_logger
+from ..config_keys import ConfigKeys
+
+logger = get_logger("tts_backend")
+
+
+@dataclass
+class TTSResult:
+    """TTS执行结果"""
+    success: bool
+    message: str
+    audio_path: Optional[str] = None
+    backend_name: str = ""
+
+    def __iter__(self):
+        """支持解包为 (success, message)"""
+        return iter((self.success, self.message))
+
+
+class TTSBackendBase(ABC):
+    """
+    TTS后端抽象基类
+
+    所有TTS后端必须继承此类并实现 execute 方法
+    """
+
+    # 后端名称（子类必须覆盖）
+    backend_name: str = "base"
+
+    # 后端描述
+    backend_description: str = "TTS后端基类"
+
+    # 是否支持私聊
+    support_private_chat: bool = True
+
+    # 默认音频格式
+    default_audio_format: str = "mp3"
+
+    def __init__(self, config_getter: Callable[[str, Any], Any], log_prefix: str = ""):
+        """
+        初始化后端
+
+        Args:
+            config_getter: 配置获取函数，签名为 get_config(key, default)
+            log_prefix: 日志前缀
+        """
+        self.get_config = config_getter
+        self.log_prefix = log_prefix or f"[{self.backend_name}]"
+        self._send_custom = None
+
+    def set_send_custom(self, send_custom_func: Callable) -> None:
+        """设置发送自定义消息的函数"""
+        self._send_custom = send_custom_func
+
+    async def send_audio(
+        self,
+        audio_data: bytes,
+        audio_format: str = "mp3",
+        prefix: str = "tts",
+        voice_info: str = ""
+    ) -> TTSResult:
+        """
+        统一的音频发送方法
+
+        Args:
+            audio_data: 音频二进制数据
+            audio_format: 音频格式（如mp3、wav）
+            prefix: 文件名前缀
+            voice_info: 音色信息（用于日志）
+
+        Returns:
+            TTSResult
+        """
+        from ..utils.file import TTSFileManager
+
+        # 检查是否使用base64发送
+        use_base64 = self.get_config(ConfigKeys.GENERAL_USE_BASE64_AUDIO, False)
+        logger.debug(f"{self.log_prefix} 开始发送音频 (原始大小: {len(audio_data)}字节, 格式: {audio_format})")
+
+        if use_base64:
+            # 使用base64编码发送
+            base64_audio = TTSFileManager.audio_to_base64(audio_data)
+            if not base64_audio:
+                return TTSResult(False, "音频数据转base64失败", backend_name=self.backend_name)
+
+            logger.debug(f"{self.log_prefix} base64编码完成，准备通过send_custom发送")
+            if self._send_custom:
+                await self._send_custom(message_type="voice", content=base64_audio)
+                logger.info(f"{self.log_prefix} 语音已通过send_custom发送 (base64模式, 音频大小: {len(audio_data)}字节)")
+            else:
+                logger.warning(f"{self.log_prefix} send_custom未设置，无法发送语音")
+                return TTSResult(False, "send_custom回调未设置", backend_name=self.backend_name)
+
+            return TTSResult(
+                success=True,
+                message=f"成功发送{self.backend_name}语音{(' ('+voice_info+')') if voice_info else ''}, base64模式",
+                backend_name=self.backend_name
+            )
+        else:
+            # 使用文件路径发送
+            output_dir = self.get_config(ConfigKeys.GENERAL_AUDIO_OUTPUT_DIR, "")
+            audio_path = TTSFileManager.generate_temp_path(
+                prefix=prefix,
+                suffix=f".{audio_format}",
+                output_dir=output_dir
+            )
+
+            if not await TTSFileManager.write_audio_async(audio_path, audio_data):
+                return TTSResult(False, "保存音频文件失败", backend_name=self.backend_name)
+
+            logger.debug(f"{self.log_prefix} 音频文件已保存, 路径: {audio_path}")
+            # 发送语音
+            if self._send_custom:
+                await self._send_custom(message_type="voiceurl", content=audio_path)
+                logger.info(f"{self.log_prefix} 语音已通过send_custom发送 (文件路径模式, 路径: {audio_path})")
+                # 延迟清理临时文件
+                asyncio.create_task(TTSFileManager.cleanup_file_async(audio_path, delay=30))
+            else:
+                logger.warning(f"{self.log_prefix} send_custom未设置，无法发送语音")
+                return TTSResult(False, "send_custom回调未设置", backend_name=self.backend_name)
+
+            return TTSResult(
+                success=True,
+                message=f"成功发送{self.backend_name}语音{(' ('+voice_info+')') if voice_info else ''}",
+                audio_path=audio_path,
+                backend_name=self.backend_name
+            )
+
+    @abstractmethod
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行TTS转换
+
+        Args:
+            text: 待转换的文本
+            voice: 音色/风格
+            **kwargs: 其他参数（如emotion等）
+
+        Returns:
+            TTSResult 包含执行结果
+        """
+        raise NotImplementedError
+
+    def validate_config(self) -> Tuple[bool, str]:
+        """
+        验证后端配置是否完整
+
+        Returns:
+            (is_valid, error_message)
+        """
+        return True, ""
+
+    def get_default_voice(self) -> str:
+        """获取默认音色"""
+        return ""
+
+    def is_available(self) -> bool:
+        """检查后端是否可用"""
+        is_valid, _ = self.validate_config()
+        return is_valid
+
+
+class TTSBackendRegistry:
+    """
+    TTS后端注册表
+
+    使用策略模式 + 工厂模式管理后端
+    """
+
+    _backends: Dict[str, Type[TTSBackendBase]] = {}
+
+    @classmethod
+    def register(cls, name: str, backend_class: Type[TTSBackendBase]) -> None:
+        """
+        注册后端
+
+        Args:
+            name: 后端名称
+            backend_class: 后端类
+        """
+        cls._backends[name] = backend_class
+        logger.debug(f"注册TTS后端: {name}")
+
+    @classmethod
+    def unregister(cls, name: str) -> None:
+        """注销后端"""
+        if name in cls._backends:
+            del cls._backends[name]
+
+    @classmethod
+    def get(cls, name: str) -> Optional[Type[TTSBackendBase]]:
+        """获取后端类"""
+        return cls._backends.get(name)
+
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        config_getter: Callable[[str, Any], Any],
+        log_prefix: str = ""
+    ) -> Optional[TTSBackendBase]:
+        """
+        创建后端实例
+
+        Args:
+            name: 后端名称
+            config_getter: 配置获取函数
+            log_prefix: 日志前缀
+
+        Returns:
+            后端实例或None
+        """
+        backend_class = cls.get(name)
+        if backend_class:
+            return backend_class(config_getter, log_prefix)
+        return None
+
+    @classmethod
+    def list_backends(cls) -> list[str]:
+        """列出所有已注册的后端名称"""
+        return list(cls._backends.keys())
+
+    @classmethod
+    def is_registered(cls, name: str) -> bool:
+        """检查后端是否已注册"""
+        return name in cls._backends
diff --git a/backends/comfyui.py b/backends/comfyui.py
new file mode 100644
index 00000000..d574e9fe
--- /dev/null
+++ b/backends/comfyui.py
@@ -0,0 +1,827 @@
+"""
+ComfyUI backend (Workflow API).
+
+This backend calls a fixed ComfyUI prompt graph that:
+LoadAudio -> MLX_Qwen3TTSVoiceClone -> SaveAudioMP3
+
+Rationale:
+- ComfyUI expects API-format "prompt" graphs (not UI workflow json).
+- For audio inputs, the simplest reliable path is to copy the reference audio into ComfyUI/input
+  and use the built-in LoadAudio node.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+import re
+import time
+import uuid
+from typing import Any, ClassVar, Dict, Optional, Tuple
+from urllib.parse import urlencode
+
+from src.common.logger import get_logger
+from src.plugin_system.apis import generator_api
+
+from .base import TTSBackendBase, TTSResult
+from ..config_keys import ConfigKeys
+from ..utils.file import TTSFileManager
+from ..utils.session import TTSSessionManager
+from ..utils.text import TTSTextUtils
+
+logger = get_logger("tts_comfyui")
+
+
+LANG_TO_DEMO = {
+    "zh": "Chinese",
+    "ja": "Japanese",
+    "en": "English",
+}
+
+
+class ComfyUIBackend(TTSBackendBase):
+    backend_name = "comfyui"
+    backend_description = "ComfyUI 工作流 API（MLX Qwen3-TTS VoiceClone/CustomVoice）"
+    support_private_chat = True
+    default_audio_format = "mp3"
+
+    _ref_cache: ClassVar[Dict[str, str]] = {}
+    _instruct_cache: ClassVar[Dict[str, str]] = {}
+    # If set by subclasses, only these modes are allowed (e.g. {"voice_clone"}).
+    allowed_modes: ClassVar[Optional[set[str]]] = None
+
+    def get_default_voice(self) -> str:
+        return self.get_config(ConfigKeys.COMFYUI_DEFAULT_STYLE, "default")
+
+    def _filter_styles_by_mode(self, styles: Dict[str, Any]) -> Dict[str, Any]:
+        allowed = self.allowed_modes
+        if not allowed:
+            return styles
+        out: Dict[str, Any] = {}
+        for name, st in (styles or {}).items():
+            if not isinstance(st, dict):
+                continue
+            mode = str(st.get("mode") or "voice_clone").strip()
+            if mode in allowed:
+                out[name] = st
+        return out
+
+    def _normalize_styles_config(self, styles_config: Any) -> Dict[str, Any]:
+        # Match GPT-SoVITS backend style schema: list[{name,...}] or dict{name:{...}}
+        if isinstance(styles_config, dict):
+            return styles_config
+        if isinstance(styles_config, list):
+            result = {}
+            for style in styles_config:
+                if isinstance(style, dict) and "name" in style:
+                    name = style["name"]
+                    result[name] = {k: v for k, v in style.items() if k != "name"}
+            return result
+        return {}
+
+    def _clean_instruct(self, s: str, max_chars: int) -> str:
+        s = (s or "").strip()
+        if not s:
+            return ""
+
+        # Strip common wrappers.
+        s = s.replace("```", "").strip()
+        s = re.sub(r"^instruct\\s*[:：]\\s*", "", s, flags=re.IGNORECASE).strip()
+
+        # Prefer first non-empty line.
+        for line in s.splitlines():
+            line = line.strip()
+            if line:
+                s = line
+                break
+
+        # Trim quotes.
+        if len(s) >= 2 and ((s[0] == s[-1] == '"') or (s[0] == s[-1] == "'")):
+            s = s[1:-1].strip()
+
+        if max_chars and len(s) > max_chars:
+            s = s[:max_chars].rstrip()
+        return s
+
+    def _clean_base_tone(self, s: str) -> str:
+        """
+        Clean a base tone/persona string so it can safely live inside `基调=...`:
+        - single-line
+        - no semicolons (they are field separators)
+        - no '=' (KV separator)
+        """
+        s = (s or "").strip()
+        if not s:
+            return ""
+        s = s.replace("\r", " ").replace("\n", " ")
+        s = re.sub(r"\\s+", " ", s).strip()
+        # Avoid breaking KV parsing.
+        s = s.replace("；", ",").replace(";", ",")
+        s = s.replace("＝", " ").replace("=", " ")
+        return s.strip(" ,，")
+
+    def _attach_base_tone(self, instruct: str, max_chars: int) -> str:
+        """
+        If configured, prefix inferred instruct with a fixed base tone/persona:
+        `基调=<...>;情绪=...;语速=...;停顿=...`
+
+        Priority when trimming: keep the inferred instruct fields intact if possible.
+        """
+        base_raw = self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_BASE_TONE, "") or ""
+        base = self._clean_base_tone(str(base_raw))
+        if not base:
+            return (instruct or "").strip()
+
+        s = (instruct or "").strip()
+        fields = self._parse_instruct_fields(s)
+        if "基调" in fields:
+            return s
+
+        prefix = f"基调={base}"
+        if not s:
+            return prefix[:max_chars].rstrip() if max_chars else prefix
+
+        combined = f"{prefix};{s}"
+        if not max_chars or len(combined) <= max_chars:
+            return combined
+
+        # Too long: try trimming base first, keeping inferred instruct intact.
+        remain = max_chars - len(s) - len(";") - len("基调=")
+        if remain <= 0:
+            # Can't fit base at all; keep instruct (already max_chars-limited upstream).
+            return s[:max_chars].rstrip()
+        base_trim = base[:remain].rstrip(" ,，")
+        return f"基调={base_trim};{s}"
+
+    def _parse_instruct_fields(self, instruct: str) -> Dict[str, str]:
+        """
+        Parse a 1-line instruct like:
+        情绪=愤怒;语速=很快;停顿=很少;表现=咬牙切齿
+
+        We only *use* a few keys (情绪/语速/停顿/强度/表现...), but keep it generic.
+        """
+        s = (instruct or "").strip()
+        if not s:
+            return {}
+
+        # Normalize separators (full-width punctuation).
+        s = s.replace("；", ";").replace("：", ":").replace("＝", "=")
+
+        # Split by semicolon/comma-like separators.
+        parts = [p.strip() for p in re.split(r"[;]+", s) if p.strip()]
+        out: Dict[str, str] = {}
+        for p in parts:
+            if "=" not in p:
+                continue
+            k, v = p.split("=", 1)
+            k = k.strip()
+            v = v.strip()
+            if not k or not v:
+                continue
+            # Limit key length to avoid garbage.
+            if len(k) > 8:
+                continue
+            out[k] = v
+        return out
+
+    def _map_speed_label(self, label: str) -> Optional[float]:
+        lab = (label or "").strip()
+        m = {
+            "很慢": 0.85,
+            "稍慢": 0.93,
+            "正常": 1.00,
+            "稍快": 1.07,
+            "很快": 1.15,
+        }
+        return m.get(lab)
+
+    def _map_pause_label(self, label: str) -> Optional[float]:
+        lab = (label or "").strip()
+        m = {
+            "很少": 0.6,
+            "自然": 1.0,
+            "稍多": 1.3,
+            "很多": 1.7,
+        }
+        return m.get(lab)
+
+    def _ensure_base_pause_cfg(self, pause_cfg: Dict[str, float]) -> Dict[str, float]:
+        # If caller didn't configure pauses (all zeros), apply a conservative base so "停顿" can take effect.
+        keys = ["pause_linebreak", "period_pause", "comma_pause", "question_pause", "hyphen_pause"]
+        if all(float(pause_cfg.get(k, 0.0) or 0.0) == 0.0 for k in keys):
+            return {
+                **pause_cfg,
+                "pause_linebreak": 0.18,
+                "period_pause": 0.22,
+                "comma_pause": 0.10,
+                "question_pause": 0.20,
+                "hyphen_pause": 0.06,
+            }
+        return pause_cfg
+
+    def _enrich_instruct_for_emotion(self, instruct: str, max_chars: int) -> str:
+        """
+        Add short performance cues for common emotions, keeping it single-line KV style.
+        This helps when the model under-reacts to simple labels like "愤怒".
+        """
+        s = (instruct or "").strip()
+        if not s:
+            return ""
+
+        fields = self._parse_instruct_fields(s)
+        emo = fields.get("情绪", "")
+        if not emo:
+            return s
+
+        # Only add if it doesn't already contain a "表现=" field.
+        if "表现" in fields:
+            return s
+
+        emo_norm = emo
+        cues = ""
+        if "愤怒" in emo_norm or "生气" in emo_norm:
+            cues = "声压高,咬字重,重音强,尾音下压"
+        elif "开心" in emo_norm or "高兴" in emo_norm:
+            cues = "笑意明显,轻快上扬,尾音明亮"
+        elif "悲伤" in emo_norm or "难过" in emo_norm:
+            cues = "气声略多,音量偏低,语尾下沉"
+        elif "温柔" in emo_norm:
+            cues = "音量轻,气声柔,语尾轻收"
+        elif "冷淡" in emo_norm or "冷静" in emo_norm:
+            cues = "平直克制,少起伏,干净收尾"
+
+        if not cues:
+            return s
+
+        extra = f";表现={cues}"
+        if max_chars and len(s) + len(extra) > max_chars:
+            # Trim cues to fit.
+            allow = max_chars - len(s) - len(";表现=")
+            if allow <= 0:
+                return s[:max_chars].rstrip()
+            cues = cues[:allow].rstrip(",， ")
+            extra = f";表现={cues}"
+        return (s + extra)[:max_chars].rstrip() if max_chars else (s + extra)
+
+    def _apply_instruct_controls(
+        self, instruct: str, speed: float, pause_cfg: Dict[str, float], max_chars: int
+    ) -> Tuple[str, float, Dict[str, float]]:
+        """
+        If instruct contains '语速'/'停顿', map them to real synthesis controls.
+        This makes auto_instruct meaningfully affect output even if the model is insensitive to labels.
+        """
+        s = (instruct or "").strip()
+        if not s:
+            return "", speed, pause_cfg
+
+        fields = self._parse_instruct_fields(s)
+        speed_label = fields.get("语速", "")
+        pause_label = fields.get("停顿", "")
+
+        out_speed = float(speed)
+        mapped_speed = self._map_speed_label(speed_label)
+        if mapped_speed is not None:
+            out_speed = mapped_speed
+
+        out_pause_cfg = dict(pause_cfg or {})
+        mapped_pause = self._map_pause_label(pause_label)
+        if mapped_pause is not None:
+            out_pause_cfg = self._ensure_base_pause_cfg(out_pause_cfg)
+            for k in ["pause_linebreak", "period_pause", "comma_pause", "question_pause", "hyphen_pause"]:
+                try:
+                    out_pause_cfg[k] = float(out_pause_cfg.get(k, 0.0) or 0.0) * float(mapped_pause)
+                except Exception:
+                    pass
+
+        # Add short performance cues (kept within max_chars).
+        s = self._enrich_instruct_for_emotion(s, max_chars=max_chars)
+        return s, out_speed, out_pause_cfg
+
+    async def _infer_instruct(
+        self,
+        text: str,
+        detected_lang: str,
+        chat_stream=None,
+        chat_id: Optional[str] = None,
+        style_name: str = "",
+    ) -> str:
+        """
+        Infer a short CustomVoice `instruct` string from the target text via MaiBot's LLM interface.
+        """
+        enabled = bool(self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_ENABLED, False))
+        if not enabled:
+            return ""
+
+        max_chars = int(self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_MAX_CHARS, 40) or 40)
+
+        # Default prompt: output ONE short instruct line only.
+        default_tpl = (
+            "你是配音导演。请根据要朗读的文本生成一行 TTS instruct。\\n"
+            "硬性要求：必须同时包含【情绪】【语速】【停顿】三项。可以额外补充 1-2 个表演提示（如 音量/重音/音高/表现）。\\n"
+            "只输出一行，不要解释，不要复述原文，不要引号/代码块。\\n"
+            "输出格式固定为：情绪=<...>;语速=<...>;停顿=<...>\\n"
+            "语速可选：很慢/稍慢/正常/稍快/很快。\\n"
+            "停顿可选：很少/自然/稍多/很多。\\n"
+            "长度<= {max_chars} 字。\\n"
+            "文本语言: {lang}\\n"
+            "待朗读文本: {text}\\n"
+        )
+        prompt_tpl = str(self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_PROMPT, default_tpl) or "")
+        if not prompt_tpl.strip():
+            prompt_tpl = default_tpl
+
+        # Cache key should change if prompt/base_tone/max_chars changes.
+        base_raw = str(self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_BASE_TONE, "") or "")
+        cfg_sig_src = f"{max_chars}\\n{prompt_tpl}\\n{base_raw}"
+        cfg_sig = hashlib.sha256(cfg_sig_src.encode("utf-8")).hexdigest()[:12]
+        text_sig = hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]
+        cache_key = f"{cfg_sig}:{detected_lang}:{text_sig}"
+        cached = self._instruct_cache.get(cache_key)
+        if cached:
+            return cached
+
+        lang = detected_lang or "auto"
+        prompt = prompt_tpl.format(text=text.strip(), lang=lang, max_chars=max_chars)
+
+        try:
+            resp = await generator_api.generate_tts_instruct(
+                prompt=prompt,
+                request_type="tts_instruct",
+            )
+            instruct = self._clean_instruct(resp or "", max_chars=max_chars)
+            instruct = self._attach_base_tone(instruct, max_chars=max_chars)
+            if instruct:
+                self._instruct_cache[cache_key] = instruct
+            return instruct
+        except Exception as e:
+            logger.warning(f"{self.log_prefix} auto_instruct 失败(style={style_name}): {e}")
+            return ""
+
+    def validate_config(self) -> Tuple[bool, str]:
+        server = self.get_config(ConfigKeys.COMFYUI_SERVER, "http://127.0.0.1:8188")
+        if not server:
+            return False, "ComfyUI 未配置 server"
+
+        input_dir = self.get_config(
+            ConfigKeys.COMFYUI_INPUT_DIR,
+            "/Users/xenon/Downloads/seiun_tts/ComfyUI/ComfyUI/input",
+        )
+        if not input_dir:
+            return False, "ComfyUI 未配置 input_dir"
+
+        styles_raw = self.get_config(ConfigKeys.COMFYUI_STYLES, {})
+        styles = self._normalize_styles_config(styles_raw)
+        if not styles:
+            return False, "ComfyUI 后端未配置任何风格（至少需要配置 1 个 style）"
+
+        default_name = self.get_default_voice() or "default"
+        if default_name not in styles:
+            # Fallback to "default" if present.
+            if "default" in styles:
+                default_name = "default"
+            else:
+                return False, f"ComfyUI default_style='{default_name}' 不存在"
+
+        st = styles.get(default_name, {})
+        mode = (st.get("mode") or "voice_clone").strip()
+        if mode == "voice_clone":
+            if not st.get("refer_wav") or not st.get("prompt_text"):
+                return False, f"ComfyUI 风格 '{default_name}' 配置不完整（voice_clone 需要 refer_wav 和 prompt_text）"
+        elif mode == "custom_voice":
+            if not st.get("model_path") or not st.get("speaker"):
+                return False, f"ComfyUI 风格 '{default_name}' 配置不完整（custom_voice 需要 model_path 和 speaker）"
+        else:
+            return False, f"ComfyUI 风格 '{default_name}' mode 无效: {mode}"
+
+        return True, ""
+
+    def _ensure_ref_in_input(self, input_dir: str, refer_wav: str) -> str:
+        refer_wav = TTSFileManager.resolve_path(refer_wav)
+        if not os.path.exists(refer_wav):
+            raise FileNotFoundError(f"参考音频不存在: {refer_wav}")
+
+        st = os.stat(refer_wav)
+        cache_key = f"{os.path.abspath(refer_wav)}:{st.st_mtime_ns}:{st.st_size}"
+        if cache_key in self._ref_cache:
+            name = self._ref_cache[cache_key]
+            if os.path.exists(os.path.join(input_dir, name)):
+                return name
+
+        ext = os.path.splitext(refer_wav)[1] or ".wav"
+        h = hashlib.sha256(cache_key.encode("utf-8")).hexdigest()[:16]
+        name = f"maibot_ref_{h}{ext}"
+        dst = os.path.join(input_dir, name)
+
+        os.makedirs(input_dir, exist_ok=True)
+        if not os.path.exists(dst):
+            # Keep it simple: copy file bytes. LoadAudio can decode common formats (wav/mp3).
+            import shutil
+
+            shutil.copyfile(refer_wav, dst)
+
+        self._ref_cache[cache_key] = name
+        return name
+
+    def _build_prompt_voice_clone(
+        self,
+        ref_filename: str,
+        ref_text: str,
+        target_text: str,
+        language: str,
+        model_choice: str,
+        precision: str,
+        seed: int,
+        max_new_tokens: int,
+        top_p: float,
+        top_k: int,
+        temperature: float,
+        repetition_penalty: float,
+        audio_quality: str,
+        mlx_python: str,
+        mlx_cli: str,
+        pause_cfg: Dict[str, float],
+    ) -> Dict[str, Any]:
+        # Node IDs are arbitrary but stable in this prompt template.
+        # 1: LoadAudio -> outputs AUDIO
+        # 2: Pause config (FB_Qwen3TTSConfig) -> outputs TTS_CONFIG
+        # 3: MLX VoiceClone -> outputs AUDIO
+        # 4: SaveAudioMP3 -> outputs UI audio file info
+        filename_prefix = f"audio/maibot_comfyui_{int(time.time())}_{uuid.uuid4().hex[:8]}"
+        prompt: Dict[str, Any] = {
+            "1": {
+                "class_type": "LoadAudio",
+                "inputs": {
+                    "audio": ref_filename,
+                },
+            },
+            "2": {
+                "class_type": "FB_Qwen3TTSConfig",
+                "inputs": {
+                    "pause_linebreak": float(pause_cfg.get("pause_linebreak", 0.0)),
+                    "period_pause": float(pause_cfg.get("period_pause", 0.0)),
+                    "comma_pause": float(pause_cfg.get("comma_pause", 0.0)),
+                    "question_pause": float(pause_cfg.get("question_pause", 0.0)),
+                    "hyphen_pause": float(pause_cfg.get("hyphen_pause", 0.0)),
+                },
+            },
+            "3": {
+                "class_type": "MLX_Qwen3TTSVoiceClone",
+                "inputs": {
+                    "target_text": target_text,
+                    "model_choice": model_choice,
+                    "device": "auto",
+                    "precision": precision,
+                    "language": language,
+                    "ref_audio": ["1", 0],
+                    "ref_text": ref_text,
+                    "seed": int(seed),
+                    "max_new_tokens": int(max_new_tokens),
+                    "top_p": float(top_p),
+                    "top_k": int(top_k),
+                    "temperature": float(temperature),
+                    "repetition_penalty": float(repetition_penalty),
+                    "attention": "auto",
+                    "unload_model_after_generate": False,
+                    "config": ["2", 0],
+                    "mlx_python": mlx_python,
+                    "mlx_cli": mlx_cli,
+                },
+            },
+            "4": {
+                "class_type": "SaveAudioMP3",
+                "inputs": {
+                    "audio": ["3", 0],
+                    "filename_prefix": filename_prefix,
+                    "quality": audio_quality,
+                },
+            },
+        }
+        return prompt
+
+    def _build_prompt_custom_voice(
+        self,
+        target_text: str,
+        speaker: str,
+        model_path: str,
+        instruct: str,
+        speed: float,
+        language: str,
+        seed: int,
+        max_new_tokens: int,
+        top_p: float,
+        top_k: int,
+        temperature: float,
+        repetition_penalty: float,
+        audio_quality: str,
+        mlx_python: str,
+        mlx_cli: str,
+        pause_cfg: Dict[str, float],
+    ) -> Dict[str, Any]:
+        # 2: Pause config (FB_Qwen3TTSConfig) -> outputs TTS_CONFIG
+        # 3: MLX CustomVoice -> outputs AUDIO
+        # 4: SaveAudioMP3 -> outputs UI audio file info
+        filename_prefix = f"audio/maibot_comfyui_{int(time.time())}_{uuid.uuid4().hex[:8]}"
+        prompt: Dict[str, Any] = {
+            "2": {
+                "class_type": "FB_Qwen3TTSConfig",
+                "inputs": {
+                    "pause_linebreak": float(pause_cfg.get("pause_linebreak", 0.0)),
+                    "period_pause": float(pause_cfg.get("period_pause", 0.0)),
+                    "comma_pause": float(pause_cfg.get("comma_pause", 0.0)),
+                    "question_pause": float(pause_cfg.get("question_pause", 0.0)),
+                    "hyphen_pause": float(pause_cfg.get("hyphen_pause", 0.0)),
+                },
+            },
+            "3": {
+                "class_type": "MLX_Qwen3TTSCustomVoice",
+                "inputs": {
+                    "text": target_text,
+                    "speaker": speaker,
+                    "model_path": model_path,
+                    "instruct": instruct or "",
+                    "speed": float(speed),
+                    "language": language,
+                    "seed": int(seed),
+                    "max_new_tokens": int(max_new_tokens),
+                    "top_p": float(top_p),
+                    "top_k": int(top_k),
+                    "temperature": float(temperature),
+                    "repetition_penalty": float(repetition_penalty),
+                    "config": ["2", 0],
+                    "mlx_python": mlx_python,
+                    "mlx_cli": mlx_cli,
+                },
+            },
+            "4": {
+                "class_type": "SaveAudioMP3",
+                "inputs": {
+                    "audio": ["3", 0],
+                    "filename_prefix": filename_prefix,
+                    "quality": audio_quality,
+                },
+            },
+        }
+        return prompt
+
+    async def _queue_and_wait(
+        self, server: str, prompt: Dict[str, Any], timeout: int
+    ) -> Dict[str, Any]:
+        session_manager = await TTSSessionManager.get_instance()
+        prompt_id = str(uuid.uuid4())
+
+        post_url = f"{server.rstrip('/')}/prompt"
+        payload = {
+            "prompt": prompt,
+            "client_id": "maibot-tts-voice-plugin",
+            "prompt_id": prompt_id,
+        }
+
+        async with session_manager.post(
+            post_url, json=payload, backend_name=self.backend_name, timeout=timeout
+        ) as resp:
+            data = await resp.json(content_type=None)
+            if resp.status != 200:
+                raise RuntimeError(f"ComfyUI /prompt 失败: {resp.status} {str(data)[:200]}")
+            if "error" in data:
+                raise RuntimeError(f"ComfyUI /prompt 返回错误: {data['error']}")
+
+        # Poll history until prompt_id appears
+        hist_url = f"{server.rstrip('/')}/history/{prompt_id}"
+        deadline = time.time() + float(timeout)
+        while time.time() < deadline:
+            async with session_manager.get(
+                hist_url, backend_name=self.backend_name, timeout=timeout
+            ) as resp:
+                history = await resp.json(content_type=None)
+            if prompt_id in history:
+                return history[prompt_id]
+            await asyncio.sleep(0.35)
+
+        raise TimeoutError("等待 ComfyUI 生成超时")
+
+    async def _download_output_audio(self, server: str, history_item: Dict[str, Any], timeout: int) -> bytes:
+        outputs = history_item.get("outputs") or {}
+        node_out = outputs.get("4") or {}
+        audios = node_out.get("audio") or []
+        if not audios:
+            # Some failures show up only in status/messages.
+            status = history_item.get("status") or {}
+            raise RuntimeError(f"ComfyUI 未产出音频. status={status}")
+
+        a0 = audios[0]
+        filename = a0.get("filename")
+        subfolder = a0.get("subfolder", "")
+        folder_type = a0.get("type", "output")
+        if not filename:
+            raise RuntimeError(f"ComfyUI 音频输出结构异常: {a0}")
+
+        q = urlencode({"filename": filename, "subfolder": subfolder, "type": folder_type})
+        url = f"{server.rstrip('/')}/view?{q}"
+
+        session_manager = await TTSSessionManager.get_instance()
+        async with session_manager.get(url, backend_name=self.backend_name, timeout=timeout) as resp:
+            if resp.status != 200:
+                txt = await resp.text()
+                raise RuntimeError(f"ComfyUI /view 失败: {resp.status} {txt[:200]}")
+            return await resp.read()
+
+    async def execute(self, text: str, voice: Optional[str] = None, **kwargs) -> TTSResult:
+        is_valid, err = self.validate_config()
+        if not is_valid:
+            return TTSResult(False, err, backend_name=self.backend_name)
+
+        if not text or not text.strip():
+            return TTSResult(False, "待合成的文本为空", backend_name=self.backend_name)
+
+        server = self.get_config(ConfigKeys.COMFYUI_SERVER, "http://127.0.0.1:8188")
+        input_dir = self.get_config(
+            ConfigKeys.COMFYUI_INPUT_DIR,
+            "/Users/xenon/Downloads/seiun_tts/ComfyUI/ComfyUI/input",
+        )
+        timeout = int(self.get_config(ConfigKeys.COMFYUI_TIMEOUT, self.get_config(ConfigKeys.GENERAL_TIMEOUT, 60)))
+
+        audio_quality = self.get_config(ConfigKeys.COMFYUI_AUDIO_QUALITY, "128k")
+        mlx_python = self.get_config(
+            ConfigKeys.COMFYUI_MLX_PYTHON,
+            "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/.venv/bin/python",
+        )
+        mlx_cli = self.get_config(
+            ConfigKeys.COMFYUI_MLX_CLI,
+            "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/mlx_voice_clone_cli.py",
+        )
+
+        styles_raw = self.get_config(ConfigKeys.COMFYUI_STYLES, {})
+        styles = self._filter_styles_by_mode(self._normalize_styles_config(styles_raw))
+
+        style_name = (voice or self.get_default_voice() or "").strip() or "default"
+        if style_name not in styles:
+            # For split backends (voiceclone/customvoice), make "wrong style" errors explicit.
+            if (voice or "").strip() and self.allowed_modes:
+                return TTSResult(
+                    False,
+                    f"ComfyUI风格 '{style_name}' 不存在或不属于当前后端({self.backend_name})",
+                    backend_name=self.backend_name,
+                )
+            # Fallback order: "default" -> first available style.
+            if "default" in styles:
+                style_name = "default"
+            elif styles:
+                style_name = sorted(styles.keys())[0]
+            else:
+                return TTSResult(
+                    False,
+                    f"ComfyUI 未配置任何风格（{self.backend_name}）",
+                    backend_name=self.backend_name,
+                )
+        style = styles.get(style_name, {})
+
+        mode = (style.get("mode") or "voice_clone").strip()
+        if mode == "voice_clone":
+            refer_wav = style.get("refer_wav", "")
+            prompt_text = style.get("prompt_text", "")
+            if not refer_wav or not prompt_text:
+                return TTSResult(False, f"ComfyUI风格 '{style_name}' 配置不完整（voice_clone）", backend_name=self.backend_name)
+        elif mode == "custom_voice":
+            model_path = style.get("model_path", "")
+            speaker = style.get("speaker", "")
+            if not model_path or not speaker:
+                return TTSResult(False, f"ComfyUI风格 '{style_name}' 配置不完整（custom_voice）", backend_name=self.backend_name)
+        else:
+            return TTSResult(False, f"ComfyUI风格 '{style_name}' mode 无效: {mode}", backend_name=self.backend_name)
+
+        # Map language to the MLX node's language combo. Default to Auto.
+        detected = TTSTextUtils.detect_language(text)
+        language = style.get("language") or LANG_TO_DEMO.get(detected, "Auto")
+
+        # Sampling defaults match the MLX node defaults we exposed.
+        seed = int(style.get("seed", 0) or 0)
+        model_choice = str(style.get("model_choice", "1.7B") or "1.7B")
+        precision = str(style.get("precision", "bf16") or "bf16")
+        max_new_tokens = int(style.get("max_new_tokens", 2048) or 2048)
+        top_p = float(style.get("top_p", 0.8) or 0.8)
+        top_k = int(style.get("top_k", 20) or 20)
+        temperature = float(style.get("temperature", 1.0) or 1.0)
+        repetition_penalty = float(style.get("repetition_penalty", 1.05) or 1.05)
+
+        pause_cfg = {
+            "pause_linebreak": float(self.get_config(ConfigKeys.COMFYUI_PAUSE_LINEBREAK, 0.0)),
+            "period_pause": float(self.get_config(ConfigKeys.COMFYUI_PERIOD_PAUSE, 0.0)),
+            "comma_pause": float(self.get_config(ConfigKeys.COMFYUI_COMMA_PAUSE, 0.0)),
+            "question_pause": float(self.get_config(ConfigKeys.COMFYUI_QUESTION_PAUSE, 0.0)),
+            "hyphen_pause": float(self.get_config(ConfigKeys.COMFYUI_HYPHEN_PAUSE, 0.0)),
+        }
+        # Allow per-style override.
+        if isinstance(style.get("pause_cfg"), dict):
+            for k in pause_cfg.keys():
+                if k in style["pause_cfg"]:
+                    try:
+                        pause_cfg[k] = float(style["pause_cfg"][k])
+                    except Exception:
+                        pass
+
+        try:
+            if mode == "voice_clone":
+                ref_filename = self._ensure_ref_in_input(input_dir, style.get("refer_wav", ""))
+                prompt = self._build_prompt_voice_clone(
+                    ref_filename=ref_filename,
+                    ref_text=style.get("prompt_text", ""),
+                    target_text=text,
+                    language=language,
+                    model_choice=model_choice,
+                    precision=precision,
+                    seed=seed,
+                    max_new_tokens=max_new_tokens,
+                    top_p=top_p,
+                    top_k=top_k,
+                    temperature=temperature,
+                    repetition_penalty=repetition_penalty,
+                    audio_quality=audio_quality,
+                    mlx_python=mlx_python,
+                    mlx_cli=mlx_cli,
+                    pause_cfg=pause_cfg,
+                )
+            else:
+                # Allow per-style / automatic instruct inference.
+                instruct = str(style.get("instruct", "")).strip()
+                auto_style = bool(style.get("auto_instruct", False))
+                inferred = ""
+                if instruct == "__AUTO__" or (not instruct and auto_style):
+                    chat_stream = kwargs.get("chat_stream")
+                    chat_id = kwargs.get("chat_id")
+                    inferred = await self._infer_instruct(
+                        text=text,
+                        detected_lang=detected,
+                        chat_stream=chat_stream,
+                        chat_id=chat_id,
+                        style_name=style_name,
+                    )
+                if inferred:
+                    instruct = inferred
+
+                # If the instruct contains usable fields, map them to real controls.
+                max_chars = int(self.get_config(ConfigKeys.COMFYUI_AUTO_INSTRUCT_MAX_CHARS, 40) or 40)
+                instruct, mapped_speed, mapped_pause_cfg = self._apply_instruct_controls(
+                    instruct=instruct,
+                    speed=float(style.get("speed", 1.0) or 1.0),
+                    pause_cfg=pause_cfg,
+                    max_chars=max_chars,
+                )
+
+                prompt = self._build_prompt_custom_voice(
+                    target_text=text,
+                    speaker=str(style.get("speaker", "")).strip(),
+                    model_path=str(style.get("model_path", "")).strip(),
+                    instruct=instruct,
+                    speed=mapped_speed,
+                    language=language,
+                    seed=seed,
+                    max_new_tokens=max_new_tokens,
+                    top_p=top_p,
+                    top_k=top_k,
+                    temperature=temperature,
+                    repetition_penalty=repetition_penalty,
+                    audio_quality=audio_quality,
+                    mlx_python=mlx_python,
+                    mlx_cli=mlx_cli,
+                    pause_cfg=mapped_pause_cfg,
+                )
+
+            logger.info(f"{self.log_prefix} ComfyUI请求: text='{text[:50]}...', style={style_name}")
+            history_item = await self._queue_and_wait(server, prompt, timeout=timeout)
+            audio_bytes = await self._download_output_audio(server, history_item, timeout=timeout)
+
+            ok, msg = TTSFileManager.validate_audio_data(audio_bytes)
+            if not ok:
+                return TTSResult(False, f"ComfyUI 返回音频无效: {msg}", backend_name=self.backend_name)
+
+            return await self.send_audio(
+                audio_data=audio_bytes,
+                audio_format="mp3",
+                prefix="tts_comfyui",
+                voice_info=f"style: {style_name}",
+            )
+        except Exception as e:
+            return TTSResult(False, f"ComfyUI后端错误: {e}", backend_name=self.backend_name)
+
+
+class ComfyUIVoiceCloneBackend(ComfyUIBackend):
+    backend_name = "comfyui_voiceclone"
+    backend_description = "ComfyUI 工作流 API（MLX Qwen3-TTS VoiceClone 专用）"
+    allowed_modes = {"voice_clone"}
+
+    def get_default_voice(self) -> str:
+        v = self.get_config(ConfigKeys.COMFYUI_VOICECLONE_DEFAULT_STYLE, "") or ""
+        v = v.strip()
+        return v or super().get_default_voice()
+
+
+class ComfyUICustomVoiceBackend(ComfyUIBackend):
+    backend_name = "comfyui_customvoice"
+    backend_description = "ComfyUI 工作流 API（MLX Qwen3-TTS CustomVoice 专用）"
+    allowed_modes = {"custom_voice"}
+
+    def get_default_voice(self) -> str:
+        v = self.get_config(ConfigKeys.COMFYUI_CUSTOMVOICE_DEFAULT_STYLE, "") or ""
+        v = v.strip()
+        return v or super().get_default_voice()
diff --git a/backends/cosyvoice.py b/backends/cosyvoice.py
new file mode 100644
index 00000000..28199815
--- /dev/null
+++ b/backends/cosyvoice.py
@@ -0,0 +1,285 @@
+"""
+CosyVoice后端实现
+使用 ModelScope 的 Fun-CosyVoice3-0.5B Gradio API 进行语音合成
+"""
+
+import asyncio
+import os
+import shutil
+from typing import Optional, Tuple
+from .base import TTSBackendBase, TTSResult
+from ..utils.file import TTSFileManager
+from ..config_keys import ConfigKeys
+from src.common.logger import get_logger
+
+logger = get_logger("tts_cosyvoice")
+
+# CosyVoice指令映射表（方言、情感、语速等）
+COSYVOICE_INSTRUCT_MAP = {
+    # 方言
+    "广东话": "You are a helpful assistant. 请用广东话表达。<|endofprompt|>",
+    "东北话": "You are a helpful assistant. 请用东北话表达。<|endofprompt|>",
+    "甘肃话": "You are a helpful assistant. 请用甘肃话表达。<|endofprompt|>",
+    "贵州话": "You are a helpful assistant. 请用贵州话表达。<|endofprompt|>",
+    "河南话": "You are a helpful assistant. 请用河南话表达。<|endofprompt|>",
+    "湖北话": "You are a helpful assistant. 请用湖北话表达。<|endofprompt|>",
+    "湖南话": "You are a helpful assistant. 请用湖南话表达。<|endofprompt|>",
+    "江西话": "You are a helpful assistant. 请用江西话表达。<|endofprompt|>",
+    "闽南话": "You are a helpful assistant. 请用闽南话表达。<|endofprompt|>",
+    "宁夏话": "You are a helpful assistant. 请用宁夏话表达。<|endofprompt|>",
+    "山西话": "You are a helpful assistant. 请用山西话表达。<|endofprompt|>",
+    "陕西话": "You are a helpful assistant. 请用陕西话表达。<|endofprompt|>",
+    "山东话": "You are a helpful assistant. 请用山东话表达。<|endofprompt|>",
+    "上海话": "You are a helpful assistant. 请用上海话表达。<|endofprompt|>",
+    "四川话": "You are a helpful assistant. 请用四川话表达。<|endofprompt|>",
+    "天津话": "You are a helpful assistant. 请用天津话表达。<|endofprompt|>",
+    "云南话": "You are a helpful assistant. 请用云南话表达。<|endofprompt|>",
+
+    # 音量
+    "大声": "You are a helpful assistant. Please say a sentence as loudly as possible.<|endofprompt|>",
+    "小声": "You are a helpful assistant. Please say a sentence in a very soft voice.<|endofprompt|>",
+
+    # 语速
+    "慢速": "You are a helpful assistant. 请用尽可能慢地语速说一句话。<|endofprompt|>",
+    "快速": "You are a helpful assistant. 请用尽可能快地语速说一句话。<|endofprompt|>",
+
+    # 情感
+    "开心": "You are a helpful assistant. 请非常开心地说一句话。<|endofprompt|>",
+    "伤心": "You are a helpful assistant. 请非常伤心地说一句话。<|endofprompt|>",
+    "生气": "You are a helpful assistant. 请非常生气地说一句话。<|endofprompt|>",
+
+    # 特殊风格
+    "小猪佩奇": "You are a helpful assistant. 我想体验一下小猪佩奇风格，可以吗？<|endofprompt|>",
+    "机器人": "You are a helpful assistant. 你可以尝试用机器人的方式解答吗？<|endofprompt|>",
+}
+
+
+class CosyVoiceBackend(TTSBackendBase):
+    """
+    CosyVoice语音后端
+
+    使用 ModelScope 的 Fun-CosyVoice3-0.5B Gradio API 进行语音合成
+    支持3秒极速复刻、自然语言控制（方言、情感、语速等）
+    """
+
+    backend_name = "cosyvoice"
+    backend_description = "阿里云 CosyVoice3 API (ModelScope Gradio)"
+    support_private_chat = True
+    default_audio_format = "wav"
+
+    def get_default_voice(self) -> str:
+        """获取默认音色（CosyVoice 不需要预设音色）"""
+        return ""
+
+    def validate_config(self) -> Tuple[bool, str]:
+        """验证配置"""
+        gradio_url = self.get_config(ConfigKeys.COSYVOICE_GRADIO_URL, "")
+
+        if not gradio_url:
+            return False, "CosyVoice后端缺少必需的 gradio_url 配置"
+
+        return True, ""
+
+    def _resolve_instruct(self, emotion: Optional[str]) -> str:
+        """
+        解析情感参数为指令文本
+
+        Args:
+            emotion: 情感/方言关键词
+
+        Returns:
+            指令文本
+        """
+        if emotion and emotion in COSYVOICE_INSTRUCT_MAP:
+            return COSYVOICE_INSTRUCT_MAP[emotion]
+
+        # 返回默认指令（确保不为空）
+        default_instruct = self.get_config(
+            ConfigKeys.COSYVOICE_DEFAULT_INSTRUCT,
+            "You are a helpful assistant. 请用广东话表达。<|endofprompt|>"
+        )
+
+        # 如果配置为空，强制使用广东话
+        if not default_instruct or not default_instruct.strip():
+            default_instruct = "You are a helpful assistant. 请用广东话表达。<|endofprompt|>"
+
+        return default_instruct
+
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        emotion: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行 CosyVoice 语音合成
+
+        Args:
+            text: 待转换的文本
+            voice: 音色（对于CosyVoice，这个参数用于指定参考音频路径）
+            emotion: 情感/方言/语速参数
+
+        Returns:
+            TTSResult
+        """
+        # 验证配置
+        is_valid, error_msg = self.validate_config()
+        if not is_valid:
+            return TTSResult(False, error_msg, backend_name=self.backend_name)
+
+        # 验证文本
+        if not text or not text.strip():
+            return TTSResult(False, "待合成的文本为空", backend_name=self.backend_name)
+
+        # 获取配置
+        gradio_url = self.get_config(ConfigKeys.COSYVOICE_GRADIO_URL, "")
+        mode_config = self.get_config(ConfigKeys.COSYVOICE_DEFAULT_MODE, "3s极速复刻")
+
+        # mode_checkbox_group 实际上是 Radio 组件，期望字符串而不是列表
+        # 处理配置可能返回字符串或列表的情况
+        if isinstance(mode_config, list):
+            mode_str = mode_config[0] if mode_config else "3s极速复刻"
+        else:
+            mode_str = mode_config if mode_config else "3s极速复刻"
+
+        timeout = self.get_config(ConfigKeys.COSYVOICE_TIMEOUT, 60)
+        reference_audio = self.get_config(ConfigKeys.COSYVOICE_REFERENCE_AUDIO, "")
+        prompt_text = self.get_config(ConfigKeys.COSYVOICE_PROMPT_TEXT, "")
+
+        # CosyVoice 的"自然语言控制"模式实际上需要参考音频和 prompt_text
+        # 如果没有配置，使用默认的参考音频
+        if not reference_audio or not os.path.exists(reference_audio):
+            plugin_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+            default_audio = os.path.join(plugin_dir, "test.wav")
+            if os.path.exists(default_audio):
+                reference_audio = default_audio
+                logger.debug(f"{self.log_prefix} 使用默认参考音频: {reference_audio}")
+
+        # 如果没有 prompt_text，使用默认文本
+        if not prompt_text:
+            prompt_text = "大家好，我是嘉然，今天我来为大家朗读。"
+            logger.debug(f"{self.log_prefix} 使用默认 prompt_text")
+
+        # voice 参数可以覆盖配置文件中的参考音频
+        if voice and os.path.exists(voice):
+            reference_audio = voice
+
+        # 解析指令文本
+        instruct_text = self._resolve_instruct(emotion)
+
+        logger.info(
+            f"{self.log_prefix} CosyVoice请求: text='{text[:50]}...' "
+            f"(共{len(text)}字符), mode={mode_str}, instruct={emotion or '默认'}"
+        )
+
+        try:
+            # 动态导入 gradio_client（避免全局依赖）
+            try:
+                from gradio_client import Client, handle_file
+            except ImportError:
+                logger.error(f"{self.log_prefix} gradio_client 未安装，请运行: pip install gradio_client")
+                return TTSResult(
+                    False,
+                    "gradio_client 未安装，请运行: pip install gradio_client",
+                    backend_name=self.backend_name
+                )
+
+            # 创建 Gradio 客户端（设置超时）
+            try:
+                import httpx
+                httpx_kwargs = {"timeout": httpx.Timeout(timeout, read=timeout, write=timeout, connect=30.0)}
+                client = Client(gradio_url, httpx_kwargs=httpx_kwargs)
+            except Exception as e:
+                logger.warning(f"{self.log_prefix} 无法设置 httpx 超时，使用默认配置: {e}")
+                client = Client(gradio_url)
+
+            # 准备参数
+            logger.debug(f"{self.log_prefix} 准备参考音频: {reference_audio}")
+            prompt_wav_upload = handle_file(reference_audio) if reference_audio and os.path.exists(reference_audio) else None
+            logger.debug(f"{self.log_prefix} 参考音频准备完成")
+
+            # 调用 API
+            logger.info(f"{self.log_prefix} 调用 Gradio API: {gradio_url} (超时: {timeout}秒)")
+            logger.debug(f"{self.log_prefix} mode参数: {mode_str} (type: {type(mode_str).__name__})")
+            logger.debug(f"{self.log_prefix} prompt_text: {prompt_text[:50]}...")
+            logger.debug(f"{self.log_prefix} instruct_text: {instruct_text[:50]}...")
+
+            result = await asyncio.wait_for(
+                asyncio.to_thread(
+                    client.predict,
+                    tts_text=text,
+                    mode_checkbox_group=mode_str,
+                    prompt_text=prompt_text,
+                    prompt_wav_upload=prompt_wav_upload,
+                    prompt_wav_record=None,
+                    instruct_text=instruct_text,
+                    seed=0,
+                    stream=False,  # API 实际期望布尔值 False，虽然文档显示为 Literal['False']
+                    api_name="/generate_audio"
+                ),
+                timeout=timeout
+            )
+
+            logger.info(f"{self.log_prefix} CosyVoice API 响应成功")
+
+            # result 是生成的音频文件路径
+            if not result or not os.path.exists(result):
+                return TTSResult(
+                    False,
+                    f"CosyVoice 生成失败，未返回有效文件: {result}",
+                    backend_name=self.backend_name
+                )
+
+            # 读取音频数据
+            try:
+                with open(result, 'rb') as f:
+                    audio_data = f.read()
+            except Exception as e:
+                logger.error(f"{self.log_prefix} 读取音频文件失败: {e}")
+                return TTSResult(
+                    False,
+                    f"读取音频文件失败: {e}",
+                    backend_name=self.backend_name
+                )
+
+            # 验证音频数据
+            is_valid, error_msg = TTSFileManager.validate_audio_data(audio_data)
+            if not is_valid:
+                logger.warning(f"{self.log_prefix} CosyVoice音频数据验证失败: {error_msg}")
+                return TTSResult(
+                    False,
+                    f"CosyVoice语音{error_msg}",
+                    backend_name=self.backend_name
+                )
+
+            logger.debug(
+                f"{self.log_prefix} CosyVoice音频数据验证通过 "
+                f"(大小: {len(audio_data)}字节)"
+            )
+
+            # 使用统一的发送方法
+            audio_format = self.get_config(ConfigKeys.COSYVOICE_AUDIO_FORMAT, "wav")
+            voice_info = f"模式: {mode_str}, 指令: {emotion or '默认'}"
+
+            return await self.send_audio(
+                audio_data=audio_data,
+                audio_format=audio_format,
+                prefix="tts_cosyvoice",
+                voice_info=voice_info
+            )
+
+        except asyncio.TimeoutError:
+            logger.error(f"{self.log_prefix} CosyVoice API 请求超时 (配置超时: {timeout}秒)")
+            return TTSResult(
+                False,
+                "CosyVoice API 调用超时",
+                backend_name=self.backend_name
+            )
+        except Exception as e:
+            logger.error(f"{self.log_prefix} CosyVoice 执行异常: {e}")
+            return TTSResult(
+                False,
+                f"CosyVoice 执行错误: {e}",
+                backend_name=self.backend_name
+            )
diff --git a/backends/doubao.py b/backends/doubao.py
new file mode 100644
index 00000000..4c566abf
--- /dev/null
+++ b/backends/doubao.py
@@ -0,0 +1,230 @@
+"""
+豆包语音后端实现
+使用字节跳动豆包语音 API 进行语音合成
+"""
+
+import asyncio
+import uuid
+from typing import Optional, List, Dict, Tuple
+from .base import TTSBackendBase, TTSResult
+from .doubao_stream_parser import DoubaoStreamParser
+from ..utils.file import TTSFileManager
+from ..utils.session import TTSSessionManager
+from ..config_keys import ConfigKeys
+from src.common.logger import get_logger
+
+logger = get_logger("tts_doubao")
+
+# 豆包语音情感映射表（用于自动生成context_texts）
+DOUBAO_EMOTION_MAP = {
+    # 积极情绪
+    "开心": "你的语气再欢乐一点",
+    "兴奋": "用特别兴奋激动的语气说话",
+    "温柔": "用温柔体贴的语气说话",
+    "骄傲": "用骄傲的语气说话",
+    "自信": "用自信坚定的语气说话",
+
+    # 消极情绪
+    "生气": "你得跟我互怼！就是跟我用吵架的语气对话",
+    "愤怒": "用愤怒的语气说话",
+    "伤心": "用特别特别痛心的语气说话",
+    "失望": "用失望沮丧的语气说话",
+    "委屈": "用委屈的语气说话",
+
+    # 中性情绪
+    "平静": "用平静淡定的语气说话",
+    "严肃": "用严肃认真的语气说话",
+    "疑惑": "用疑惑不解的语气说话",
+
+    # 语速调整
+    "慢速": "说慢一点",
+    "快速": "说快一点",
+
+    # 音量调整
+    "小声": "你嗓门再小点",
+    "大声": "大声一点",
+}
+
+
+class DoubaoBackend(TTSBackendBase):
+    """
+    豆包语音后端
+
+    使用字节跳动豆包语音 API 进行高质量语音合成
+    支持预置音色和复刻音色
+    """
+
+    backend_name = "doubao"
+    backend_description = "字节跳动豆包语音API"
+    support_private_chat = True
+    default_audio_format = "mp3"
+
+    def get_default_voice(self) -> str:
+        """获取默认音色"""
+        return self.get_config(ConfigKeys.DOUBAO_DEFAULT_VOICE, "zh_female_shuangkuaisisi_moon_bigtts")
+
+    def validate_config(self) -> Tuple[bool, str]:
+        """验证配置"""
+        app_id = self.get_config(ConfigKeys.DOUBAO_APP_ID, "")
+        access_key = self.get_config(ConfigKeys.DOUBAO_ACCESS_KEY, "")
+        resource_id = self.get_config(ConfigKeys.DOUBAO_RESOURCE_ID, "")
+
+        if not app_id or not access_key or not resource_id:
+            return False, "豆包语音后端缺少必需的认证配置（app_id/access_key/resource_id）"
+
+        return True, ""
+
+    def _resolve_emotion(self, emotion: Optional[str]) -> Optional[List[str]]:
+        """
+        解析情感参数为 context_texts
+
+        Args:
+            emotion: 情感关键词
+
+        Returns:
+            context_texts 列表或 None
+        """
+        if emotion and emotion in DOUBAO_EMOTION_MAP:
+            return [DOUBAO_EMOTION_MAP[emotion]]
+        return None
+
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        emotion: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行豆包语音合成
+
+        Args:
+            text: 待转换的文本
+            voice: 音色ID
+            emotion: 情感/语气参数
+
+        Returns:
+            TTSResult
+        """
+        # 验证配置
+        is_valid, error_msg = self.validate_config()
+        if not is_valid:
+            return TTSResult(False, error_msg, backend_name=self.backend_name)
+
+        # 验证文本
+        if not text or not text.strip():
+            return TTSResult(False, "待合成的文本为空", backend_name=self.backend_name)
+
+        # 获取配置
+        api_url = self.get_config(ConfigKeys.DOUBAO_API_URL, "https://openspeech.bytedance.com/api/v3/tts/unidirectional")
+        app_id = self.get_config(ConfigKeys.DOUBAO_APP_ID, "")
+        access_key = self.get_config(ConfigKeys.DOUBAO_ACCESS_KEY, "")
+        resource_id = self.get_config(ConfigKeys.DOUBAO_RESOURCE_ID, "")
+        timeout = self.get_config(ConfigKeys.DOUBAO_TIMEOUT, 30)
+
+        if not voice:
+            voice = self.get_default_voice()
+
+        # 构建请求头
+        headers = {
+            "Content-Type": "application/json",
+            "X-Api-App-Id": app_id,
+            "X-Api-Access-Key": access_key,
+            "X-Api-Resource-Id": resource_id,
+            "X-Api-Request-Id": str(uuid.uuid4()),
+            "Accept-Encoding": "gzip, deflate"
+        }
+
+        # 构建请求体
+        request_data: Dict[str, any] = {
+            "req_params": {
+                "text": text,
+                "speaker": voice,
+                "audio_params": {
+                    "format": self.get_config(ConfigKeys.DOUBAO_AUDIO_FORMAT, "mp3"),
+                    "sample_rate": self.get_config(ConfigKeys.DOUBAO_SAMPLE_RATE, 24000),
+                    "bitrate": self.get_config(ConfigKeys.DOUBAO_BITRATE, 128000)
+                }
+            }
+        }
+
+        # 添加可选参数
+        speed = self.get_config(ConfigKeys.DOUBAO_SPEED, None)
+        if speed is not None:
+            request_data["req_params"]["speed"] = speed
+
+        volume = self.get_config(ConfigKeys.DOUBAO_VOLUME, None)
+        if volume is not None:
+            request_data["req_params"]["volume"] = volume
+
+        # 处理 context_texts
+        context_texts: Optional[List[str]] = None
+
+        # 优先使用传入的emotion参数
+        if emotion:
+            context_texts = self._resolve_emotion(emotion)
+            if context_texts:
+                logger.info(f"{self.log_prefix} 使用emotion参数: {emotion} -> {context_texts[0]}")
+
+        # 否则使用配置文件的默认值
+        if not context_texts:
+            context_texts = self.get_config(ConfigKeys.DOUBAO_CONTEXT_TEXTS, None)
+
+        if context_texts:
+            request_data["req_params"]["context_texts"] = context_texts
+
+        logger.info(f"{self.log_prefix} 豆包语音请求: text='{text[:50]}...' (共{len(text)}字符), voice={voice}")
+
+        try:
+            session_manager = await TTSSessionManager.get_instance()
+            async with session_manager.post(
+                api_url,
+                json=request_data,
+                headers=headers,
+                backend_name="doubao",
+                timeout=timeout
+            ) as response:
+                logger.info(f"{self.log_prefix} 豆包API响应状态码: {response.status}")
+
+                if response.status == 200:
+                    # 使用新的流式响应解析器
+                    audio_data, error_msg = await DoubaoStreamParser.parse_response(
+                        response,
+                        log_prefix=self.log_prefix
+                    )
+
+                    if error_msg:
+                        logger.error(f"{self.log_prefix} 豆包语音解析失败: {error_msg}")
+                        return TTSResult(False, error_msg, backend_name=self.backend_name)
+
+                    # 验证音频数据
+                    is_valid, error_msg = TTSFileManager.validate_audio_data(audio_data)
+                    if not is_valid:
+                        logger.warning(f"{self.log_prefix} 豆包音频数据验证失败: {error_msg}")
+                        return TTSResult(False, f"豆包语音{error_msg}", backend_name=self.backend_name)
+
+                    logger.debug(f"{self.log_prefix} 豆包音频数据验证通过 (大小: {len(audio_data)}字节)")
+
+                    # 使用统一的发送方法
+                    audio_format = self.get_config(ConfigKeys.DOUBAO_AUDIO_FORMAT, "mp3")
+                    return await self.send_audio(
+                        audio_data=audio_data,
+                        audio_format=audio_format,
+                        prefix="tts_doubao",
+                        voice_info=f"音色: {voice}"
+                    )
+                else:
+                    error_text = await response.text()
+                    logger.error(f"{self.log_prefix} 豆包API请求失败[{response.status}]: {error_text[:200]}")
+                    return TTSResult(
+                        False,
+                        f"豆包语音API调用失败: {response.status} - {error_text[:100]}",
+                        backend_name=self.backend_name
+                    )
+
+        except asyncio.TimeoutError:
+            logger.error(f"{self.log_prefix} 豆包API请求超时 (配置超时: {timeout}秒)")
+            return TTSResult(False, "豆包语音API调用超时", backend_name=self.backend_name)
+        except Exception as e:
+            logger.error(f"{self.log_prefix} 豆包语音执行异常: {e}")
+            return TTSResult(False, f"豆包语音执行错误: {e}", backend_name=self.backend_name)
diff --git a/backends/doubao_stream_parser.py b/backends/doubao_stream_parser.py
new file mode 100644
index 00000000..a3f61925
--- /dev/null
+++ b/backends/doubao_stream_parser.py
@@ -0,0 +1,432 @@
+"""
+豆包语音流式响应解析器
+基于官方示例实现，确保兼容性和正确性
+
+官方API说明：
+- code=0: 继续处理，可能包含 "data"（音频）或 "sentence"（文本）
+- code=20000000: 结束标志，可能包含 "usage"（用量统计）
+- code>0: 错误响应
+"""
+
+import json
+import base64
+from typing import Tuple, Optional, List
+from src.common.logger import get_logger
+
+logger = get_logger("doubao_stream_parser")
+
+
+class DoubaoStreamParser:
+    """
+    豆包语音流式响应解析器
+
+    基于官方API实现，忠实还原官方示例逻辑。
+    处理流程：
+    1. 逐行读取 JSON 响应
+    2. 检查状态码：code=0(继续), code=20000000(结束), code>0(错误)
+    3. 提取音频数据（code=0 且有 "data" 字段）
+    4. 记录日志（code=0 且有 "sentence" 字段）
+    """
+
+    def __init__(self, log_prefix: str = "[DoubaoParser]"):
+        """
+        初始化解析器
+
+        Args:
+            log_prefix: 日志前缀
+        """
+        self.log_prefix = log_prefix
+        self._audio_chunks: List[bytes] = []
+        self._buffer: bytes = b''
+        self._line_count: int = 0
+        self._total_bytes: int = 0
+        self._error_message: Optional[str] = None
+        self._finished: bool = False  # 是否收到结束信号
+        self._usage_info: Optional[dict] = None
+
+    def _decode_audio_from_base64(self, audio_base64: str) -> Optional[bytes]:
+        """
+        从 Base64 字符串解码音频数据
+
+        官方示例中直接使用 base64.b64decode(data["data"])，
+        但我们添加了额外的容错和验证。
+
+        Args:
+            audio_base64: Base64 编码的音频数据
+
+        Returns:
+            解码后的音频字节数据或 None
+        """
+        if not audio_base64:
+            return None
+
+        try:
+            # 官方示例直接调用 base64.b64decode()
+            # 这里添加容错处理：补充填充符（如果需要）
+            padding_needed = len(audio_base64) % 4
+            if padding_needed:
+                audio_base64 += '=' * (4 - padding_needed)
+                logger.debug(
+                    f"{self.log_prefix} Base64填充已应用 "
+                    f"(原长: {len(audio_base64) - (4 - padding_needed)}, 新长: {len(audio_base64)})"
+                )
+
+            audio_bytes = base64.b64decode(audio_base64)
+
+            if not audio_bytes:
+                logger.warning(f"{self.log_prefix} Base64解码结果为空")
+                return None
+
+            logger.debug(
+                f"{self.log_prefix} 音频块解码成功 - 大小: {len(audio_bytes)}字节"
+            )
+            return audio_bytes
+
+        except Exception as e:
+            logger.error(
+                f"{self.log_prefix} Base64解码失败: {e} "
+                f"(Base64长度: {len(audio_base64)})"
+            )
+            return None
+
+    def _process_json_line(self, line_str: str) -> Optional[str]:
+        """
+        处理单行 JSON 数据
+
+        严格按照官方示例逻辑：
+        1. 检查 code 字段
+        2. code=0 且有 data → 提取音频
+        3. code=0 且有 sentence → 记录文本（可选）
+        4. code=20000000 → 收到结束信号
+        5. code>0 → 错误
+
+        Args:
+            line_str: JSON 字符串
+
+        Returns:
+            如果收到结束信号，返回 "END"；如果发生错误，返回错误信息；否则返回 None
+        """
+        try:
+            json_obj = json.loads(line_str)
+        except json.JSONDecodeError as e:
+            logger.debug(f"{self.log_prefix} JSON解析失败: {e}")
+            return None
+        except Exception as e:
+            logger.warning(f"{self.log_prefix} JSON处理异常: {e}")
+            return None
+
+        if not isinstance(json_obj, dict):
+            logger.debug(
+                f"{self.log_prefix} 收到非字典JSON对象: {type(json_obj).__name__}"
+            )
+            return None
+
+        code = json_obj.get("code", -1)
+
+        # ✅ 官方逻辑：处理 code=0 的数据帧
+        if code == 0:
+            # 检查是否有音频数据
+            if "data" in json_obj and json_obj["data"]:
+                chunk_audio = self._decode_audio_from_base64(json_obj["data"])
+                if chunk_audio:
+                    self._audio_chunks.append(chunk_audio)
+                    logger.debug(
+                        f"{self.log_prefix} 音频块#{len(self._audio_chunks)} 已接收 "
+                        f"(大小: {len(chunk_audio)}字节)"
+                    )
+
+            # 检查是否有文本/句子信息（可选）
+            if "sentence" in json_obj and json_obj["sentence"]:
+                sentence_data = json_obj.get("sentence", {})
+                logger.debug(
+                    f"{self.log_prefix} 收到句子数据: {sentence_data}"
+                )
+
+            return None  # 继续处理
+
+        # ✅ 官方逻辑：处理 code=20000000 的结束帧
+        elif code == 20000000:
+            logger.info(f"{self.log_prefix} 收到流结束信号 (code=20000000)")
+
+            # 记录用量信息（如果有）
+            if "usage" in json_obj:
+                self._usage_info = json_obj["usage"]
+                logger.info(
+                    f"{self.log_prefix} 豆包用量信息: {self._usage_info}"
+                )
+
+            self._finished = True
+            return "END"  # 表示流已结束
+
+        # ✅ 官方逻辑：错误处理
+        elif code and code > 0:
+            error_msg = json_obj.get("message", f"未知错误 (code={code})")
+            logger.error(
+                f"{self.log_prefix} 豆包语音API返回错误 "
+                f"(code={code}): {error_msg}"
+            )
+            self._error_message = error_msg
+            return error_msg  # 返回错误信息
+
+        # 未知状态码
+        else:
+            logger.debug(
+                f"{self.log_prefix} 收到未知状态码: code={code}"
+            )
+            return None
+
+    def _find_data_chunk_offset(self, header: bytes) -> int:
+        """
+        在 WAV header 中查找 'data' 块的位置
+
+        豆包返回的 WAV 可能包含额外的元数据块（如 LIST/INFO），
+        导致 'data' 块不在标准的 44 字节位置。
+
+        Args:
+            header: WAV 文件头部数据
+
+        Returns:
+            data 块数据开始的位置（即 'data' + 4字节大小之后）
+        """
+        pos = 12  # 跳过 RIFF(4) + size(4) + WAVE(4)
+
+        while pos < len(header) - 8:
+            chunk_id = header[pos:pos+4]
+            chunk_size = int.from_bytes(header[pos+4:pos+8], 'little')
+
+            if chunk_id == b'data':
+                return pos + 8  # 返回音频数据开始位置
+
+            # 移动到下一个块
+            pos += 8 + chunk_size
+            # WAV 块需要对齐到偶数字节
+            if chunk_size % 2 == 1:
+                pos += 1
+
+        # 未找到 data 块，返回默认值
+        return 44
+
+    def _merge_audio_chunks(self, chunks: List[bytes]) -> bytes:
+        """
+        合并音频块，处理 WAV 格式的流式响应
+
+        豆包流式 WAV 响应特点：
+        1. 第一个块包含完整 header（可能 > 44 字节，含 LIST/INFO 元数据）
+        2. header 中的大小字段是 0xFFFFFFFF（流式占位符）
+        3. 后续块是纯音频数据（无 header）
+        4. 需要在合并后修正大小字段
+
+        Args:
+            chunks: 音频数据块列表
+
+        Returns:
+            合并后的有效 WAV 文件
+        """
+        if not chunks:
+            return b''
+
+        first_chunk = chunks[0]
+
+        # 检查是否是 WAV 格式（RIFF header）
+        if len(first_chunk) < 44 or first_chunk[:4] != b'RIFF':
+            # 不是 WAV 格式（如 MP3），直接拼接
+            return b''.join(chunks)
+
+        # 查找 data 块的实际位置
+        data_offset = self._find_data_chunk_offset(first_chunk)
+        logger.debug(f"{self.log_prefix} WAV data 块偏移: {data_offset} 字节")
+
+        # 提取 header 和第一块的音频数据
+        header = bytearray(first_chunk[:data_offset])
+        data_parts = [first_chunk[data_offset:]]
+        skipped_headers = 0
+
+        # 处理后续块
+        for chunk in chunks[1:]:
+            if len(chunk) > 44 and chunk[:4] == b'RIFF':
+                # 后续块也有 RIFF header，需要跳过
+                chunk_data_offset = self._find_data_chunk_offset(chunk)
+                data_parts.append(chunk[chunk_data_offset:])
+                skipped_headers += 1
+            else:
+                # 纯音频数据
+                data_parts.append(chunk)
+
+        # 合并所有音频数据
+        audio_data = b''.join(data_parts)
+        audio_size = len(audio_data)
+
+        # 修正 WAV header 中的大小字段
+        # 字节 4-7: 文件总大小 - 8 = (header_size - 8) + audio_size
+        file_size = len(header) - 8 + audio_size
+        header[4:8] = file_size.to_bytes(4, 'little')
+
+        # 修正 data 块的大小字段（位于 data_offset - 4 处）
+        header[data_offset-4:data_offset] = audio_size.to_bytes(4, 'little')
+
+        if skipped_headers > 0 or audio_size > 0:
+            logger.info(
+                f"{self.log_prefix} WAV 流式合并完成: "
+                f"header={len(header)}字节, 音频={audio_size}字节, "
+                f"跳过重复header={skipped_headers}"
+            )
+
+        return bytes(header) + audio_data
+
+    def feed_chunk(self, chunk: bytes) -> Optional[str]:
+        """
+        输入一块数据
+
+        Args:
+            chunk: 网络数据块
+
+        Returns:
+            如果遇到错误或结束，返回相应信息；否则返回 None
+        """
+        if not chunk:
+            return None
+
+        self._buffer += chunk
+        self._total_bytes += len(chunk)
+
+        # 按行处理（官方示例使用 iter_lines）
+        while b'\n' in self._buffer:
+            line_bytes, self._buffer = self._buffer.split(b'\n', 1)
+
+            # 尝试解码行数据
+            try:
+                line_str = line_bytes.decode('utf-8', errors='replace').strip()
+            except Exception as e:
+                logger.warning(
+                    f"{self.log_prefix} 行解码失败: {e}, 跳过该行"
+                )
+                self._line_count += 1
+                continue
+
+            if not line_str:
+                continue
+
+            self._line_count += 1
+
+            # 处理该行
+            result = self._process_json_line(line_str)
+
+            # 如果收到结束信号或错误，立即返回
+            if result == "END":
+                return None  # 正常结束
+            elif result:  # 返回的是错误信息
+                return result
+
+        return None
+
+    def finalize(self) -> Tuple[Optional[bytes], Optional[str]]:
+        """
+        完成解析，处理剩余数据
+
+        Returns:
+            (audio_data, error_message)
+            - audio_data: 合并后的音频数据（成功时）
+            - error_message: 错误信息（失败时）
+        """
+        # 处理剩余的 buffer 中的最后一行
+        if self._buffer.strip():
+            try:
+                line_str = self._buffer.decode('utf-8', errors='replace').strip()
+                if line_str:
+                    logger.debug(
+                        f"{self.log_prefix} 处理最后的buffer数据 "
+                        f"(长度: {len(line_str)}字符)"
+                    )
+                    result = self._process_json_line(line_str)
+                    if result and result != "END":
+                        # 最后的 buffer 包含错误
+                        self._error_message = result
+            except Exception as e:
+                logger.warning(
+                    f"{self.log_prefix} 最后buffer解析异常: {e}"
+                )
+
+        logger.info(
+            f"{self.log_prefix} 豆包流解析完成 - "
+            f"处理行数: {self._line_count}, "
+            f"音频块数: {len(self._audio_chunks)}, "
+            f"接收字节数: {self._total_bytes}, "
+            f"正常结束: {self._finished}"
+        )
+
+        # 检查是否有错误
+        if self._error_message:
+            logger.error(
+                f"{self.log_prefix} 豆包API返回错误: {self._error_message}"
+            )
+            return None, f"豆包语音API错误: {self._error_message}"
+
+        # 检查是否有音频数据
+        if not self._audio_chunks:
+            if self._total_bytes == 0:
+                logger.warning(
+                    f"{self.log_prefix} 豆包API未返回任何数据"
+                )
+                return None, "未收到任何响应数据"
+
+            logger.warning(
+                f"{self.log_prefix} 收到 {self._total_bytes} 字节数据但无音频块"
+            )
+            return None, "豆包语音未返回任何音频数据"
+
+        # ✅ 额外的数据完整性检查
+        # 过滤掉过小的块（可能是损坏或无效的）
+        min_chunk_size = 50  # 最小块大小
+        valid_chunks = [
+            chunk for chunk in self._audio_chunks
+            if len(chunk) >= min_chunk_size
+        ]
+
+        if not valid_chunks:
+            logger.error(
+                f"{self.log_prefix} 所有音频块都太小 (可能是损坏的数据)"
+            )
+            logger.debug(
+                f"{self.log_prefix} 块大小分布: {[len(c) for c in self._audio_chunks]}"
+            )
+            return None, "音频数据不完整或已损坏"
+
+        # 合并所有有效的音频数据（处理 WAV 多 header 问题）
+        merged_audio = self._merge_audio_chunks(valid_chunks)
+
+        logger.info(
+            f"{self.log_prefix} 音频合并完成 - "
+            f"有效块数: {len(valid_chunks)}/{len(self._audio_chunks)}, "
+            f"总大小: {len(merged_audio)}字节"
+        )
+
+        return merged_audio, None
+
+    @classmethod
+    async def parse_response(
+        cls,
+        response,
+        log_prefix: str = "[DoubaoParser]"
+    ) -> Tuple[Optional[bytes], Optional[str]]:
+        """
+        解析豆包 API 的流式响应
+
+        Args:
+            response: aiohttp 响应对象
+            log_prefix: 日志前缀
+
+        Returns:
+            (audio_data, error_message)
+        """
+        parser = cls(log_prefix)
+
+        # 逐块读取响应流
+        async for chunk in response.content.iter_any():
+            result = parser.feed_chunk(chunk)
+
+            # 如果遇到错误，立即返回
+            if result and result != "END":
+                return None, result
+
+        # 完成解析，处理剩余数据
+        return parser.finalize()
diff --git a/backends/gpt_sovits.py b/backends/gpt_sovits.py
new file mode 100644
index 00000000..126851ff
--- /dev/null
+++ b/backends/gpt_sovits.py
@@ -0,0 +1,326 @@
+"""
+GPT-SoVITS 后端实现
+使用本地 GPT-SoVITS 服务进行语音合成
+"""
+
+import asyncio
+from typing import Optional, Dict, Any, Tuple, ClassVar
+from .base import TTSBackendBase, TTSResult
+from ..utils.text import TTSTextUtils
+from ..utils.file import TTSFileManager
+from ..utils.session import TTSSessionManager
+from ..config_keys import ConfigKeys
+from src.common.logger import get_logger
+
+logger = get_logger("tts_gpt_sovits")
+
+
+class GPTSoVITSBackend(TTSBackendBase):
+    """
+    GPT-SoVITS 后端
+
+    使用本地 GPT-SoVITS 服务进行高度定制化的语音合成
+    支持动态切换 GPT 和 SoVITS 模型权重
+    """
+
+    backend_name = "gpt_sovits"
+    backend_description = "本地GPT-SoVITS服务"
+    support_private_chat = True
+    default_audio_format = "mp3"
+
+    # 类变量：记录当前加载的模型路径，避免重复切换
+    _current_gpt_weights: ClassVar[Optional[str]] = None
+    _current_sovits_weights: ClassVar[Optional[str]] = None
+
+    def get_default_voice(self) -> str:
+        """获取默认风格"""
+        return "default"
+
+    async def _switch_model(
+        self,
+        server: str,
+        gpt_weights: Optional[str],
+        sovits_weights: Optional[str],
+        timeout: int
+    ) -> Tuple[bool, str]:
+        """
+        切换 GPT-SoVITS 模型权重
+
+        Args:
+            server: 服务器地址
+            gpt_weights: GPT 模型权重路径
+            sovits_weights: SoVITS 模型权重路径
+            timeout: 超时时间
+
+        Returns:
+            (success, error_message)
+        """
+        session_manager = await TTSSessionManager.get_instance()
+
+        async def _set_model_v1() -> Tuple[bool, str]:
+            # 兼容旧版 api.py: 仅支持 /set_model 同时切换
+            if not gpt_weights or not sovits_weights:
+                return False, "当前GPT-SoVITS服务不支持单独切换模型（请同时配置GPT与SoVITS权重）"
+            set_model_url = (
+                f"{server.rstrip('/')}/set_model?"
+                f"gpt_model_path={gpt_weights}&sovits_model_path={sovits_weights}"
+            )
+            logger.info(f"{self.log_prefix} 切换模型(兼容模式): {gpt_weights} | {sovits_weights}")
+            try:
+                async with session_manager.get(
+                    set_model_url,
+                    backend_name="gpt_sovits",
+                    timeout=timeout
+                ) as response:
+                    if response.status == 200:
+                        GPTSoVITSBackend._current_gpt_weights = gpt_weights
+                        GPTSoVITSBackend._current_sovits_weights = sovits_weights
+                        logger.info(f"{self.log_prefix} 模型切换成功(兼容模式)")
+                        return True, ""
+                    error_text = await response.text()
+                    return False, f"模型切换失败: {error_text}"
+            except Exception as e:
+                return False, f"模型切换异常: {e}"
+
+        # 切换 GPT 权重
+        if gpt_weights and gpt_weights != GPTSoVITSBackend._current_gpt_weights:
+            gpt_url = f"{server.rstrip('/')}/set_gpt_weights?weights_path={gpt_weights}"
+            logger.info(f"{self.log_prefix} 切换GPT模型: {gpt_weights}")
+
+            try:
+                async with session_manager.get(
+                    gpt_url,
+                    backend_name="gpt_sovits",
+                    timeout=timeout
+                ) as response:
+                    if response.status == 200:
+                        GPTSoVITSBackend._current_gpt_weights = gpt_weights
+                        logger.info(f"{self.log_prefix} GPT模型切换成功")
+                    elif response.status == 404:
+                        # 旧版服务没有 /set_gpt_weights
+                        return await _set_model_v1()
+                    else:
+                        error_text = await response.text()
+                        return False, f"GPT模型切换失败: {error_text}"
+            except Exception as e:
+                return False, f"GPT模型切换异常: {e}"
+
+        # 切换 SoVITS 权重
+        if sovits_weights and sovits_weights != GPTSoVITSBackend._current_sovits_weights:
+            sovits_url = f"{server.rstrip('/')}/set_sovits_weights?weights_path={sovits_weights}"
+            logger.info(f"{self.log_prefix} 切换SoVITS模型: {sovits_weights}")
+
+            try:
+                async with session_manager.get(
+                    sovits_url,
+                    backend_name="gpt_sovits",
+                    timeout=timeout
+                ) as response:
+                    if response.status == 200:
+                        GPTSoVITSBackend._current_sovits_weights = sovits_weights
+                        logger.info(f"{self.log_prefix} SoVITS模型切换成功")
+                    elif response.status == 404:
+                        # 旧版服务没有 /set_sovits_weights
+                        return await _set_model_v1()
+                    else:
+                        error_text = await response.text()
+                        return False, f"SoVITS模型切换失败: {error_text}"
+            except Exception as e:
+                return False, f"SoVITS模型切换异常: {e}"
+
+        return True, ""
+
+    def _normalize_styles_config(self, styles_config: Any) -> Dict[str, Any]:
+        """
+        规范化风格配置格式
+
+        支持两种格式：
+        1. 旧格式（字典）: {"default": {...}, "happy": {...}}
+        2. 新格式（数组）: [{"name": "default", ...}, {"name": "happy", ...}]
+
+        统一转换为字典格式供内部使用
+        """
+        # 如果是字典格式（旧格式），直接返回
+        if isinstance(styles_config, dict):
+            return styles_config
+
+        # 如果是数组格式（新格式），转换为字典
+        if isinstance(styles_config, list):
+            result = {}
+            for style in styles_config:
+                if isinstance(style, dict) and "name" in style:
+                    style_name = style["name"]
+                    # 复制配置，移除 name 字段
+                    style_data = {k: v for k, v in style.items() if k != "name"}
+                    result[style_name] = style_data
+            return result
+
+        # 其他情况返回空字典
+        return {}
+
+    def validate_config(self) -> Tuple[bool, str]:
+        """验证配置"""
+        styles_raw = self.get_config(ConfigKeys.GPT_SOVITS_STYLES, {})
+        styles = self._normalize_styles_config(styles_raw)
+
+        if not styles or "default" not in styles:
+            return False, "GPT-SoVITS未配置任何语音风格"
+
+        default_style = styles.get("default", {})
+        if not default_style.get("refer_wav") or not default_style.get("prompt_text"):
+            return False, "GPT-SoVITS默认风格配置不完整（需要refer_wav和prompt_text）"
+
+        return True, ""
+
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行GPT-SoVITS语音合成
+
+        Args:
+            text: 待转换的文本
+            voice: 风格名称
+
+        Returns:
+            TTSResult
+        """
+        # 验证文本
+        if not text or not text.strip():
+            return TTSResult(False, "待合成的文本为空", backend_name=self.backend_name)
+
+        # 获取配置
+        server = self.get_config(ConfigKeys.GPT_SOVITS_SERVER, "http://127.0.0.1:9880")
+        styles_raw = self.get_config(ConfigKeys.GPT_SOVITS_STYLES, {})
+        styles = self._normalize_styles_config(styles_raw)
+        timeout = self.get_config(ConfigKeys.GENERAL_TIMEOUT, 60)
+
+        # 确定使用的风格
+        voice_style = voice if voice and voice in styles else "default"
+
+        if voice_style not in styles:
+            return TTSResult(
+                False,
+                f"GPT-SoVITS风格 '{voice_style}' 未配置",
+                backend_name=self.backend_name
+            )
+
+        style_config = styles[voice_style]
+        refer_wav_path = style_config.get("refer_wav", "")
+        prompt_text = style_config.get("prompt_text", "")
+        prompt_language = style_config.get("prompt_language", "zh")
+        gpt_weights = style_config.get("gpt_weights")
+        sovits_weights = style_config.get("sovits_weights")
+
+        if not refer_wav_path or not prompt_text:
+            return TTSResult(
+                False,
+                f"GPT-SoVITS风格 '{voice_style}' 配置不完整",
+                backend_name=self.backend_name
+            )
+
+        # 如果配置了模型权重，先切换模型
+        if gpt_weights or sovits_weights:
+            switch_success, switch_error = await self._switch_model(
+                server, gpt_weights, sovits_weights, timeout
+            )
+            if not switch_success:
+                return TTSResult(False, switch_error, backend_name=self.backend_name)
+
+        # 检测文本语言
+        text_language = TTSTextUtils.detect_language(text)
+
+        # 构建请求数据
+        data = {
+            "text": text,
+            "text_lang": text_language,
+            "ref_audio_path": refer_wav_path,
+            "prompt_text": prompt_text,
+            "prompt_lang": prompt_language
+        }
+
+        tts_url = f"{server.rstrip('/')}/tts"
+        legacy_tts_url = f"{server.rstrip('/')}/"
+        legacy_data = {
+            "text": text,
+            "text_language": text_language,
+            "refer_wav_path": refer_wav_path,
+            "prompt_text": prompt_text,
+            "prompt_language": prompt_language,
+        }
+
+        logger.info(f"{self.log_prefix} GPT-SoVITS请求: text='{text[:50]}...', style={voice_style}")
+
+        try:
+            session_manager = await TTSSessionManager.get_instance()
+            async with session_manager.post(
+                tts_url,
+                json=data,
+                backend_name="gpt_sovits",
+                timeout=timeout
+            ) as response:
+                if response.status == 200:
+                    audio_data = await response.read()
+
+                    # 验证音频数据
+                    is_valid, error_msg = TTSFileManager.validate_audio_data(audio_data)
+                    if not is_valid:
+                        return TTSResult(False, f"GPT-SoVITS{error_msg}", backend_name=self.backend_name)
+
+                    # 使用统一的发送方法
+                    return await self.send_audio(
+                        audio_data=audio_data,
+                        audio_format="wav",
+                        prefix="tts_gpt_sovits",
+                        voice_info=f"风格: {voice_style}"
+                    )
+                elif response.status == 404:
+                    # 兼容旧版 api.py：没有 /tts 端点，回退到根路径
+                    logger.warning(f"{self.log_prefix} /tts 端点不存在，尝试兼容模式请求根路径")
+                else:
+                    error_info = await response.text()
+                    logger.error(f"{self.log_prefix} GPT-SoVITS API失败[{response.status}]: {error_info[:200]}")
+                    return TTSResult(
+                        False,
+                        f"GPT-SoVITS API调用失败: {response.status}",
+                        backend_name=self.backend_name
+                    )
+
+            # 仅在 /tts 404 时回退到旧版根路径
+            async with session_manager.post(
+                legacy_tts_url,
+                json=legacy_data,
+                backend_name="gpt_sovits",
+                timeout=timeout
+            ) as response:
+                if response.status == 200:
+                    audio_data = await response.read()
+
+                    # 验证音频数据
+                    is_valid, error_msg = TTSFileManager.validate_audio_data(audio_data)
+                    if not is_valid:
+                        return TTSResult(False, f"GPT-SoVITS{error_msg}", backend_name=self.backend_name)
+
+                    return await self.send_audio(
+                        audio_data=audio_data,
+                        audio_format="wav",
+                        prefix="tts_gpt_sovits",
+                        voice_info=f"风格: {voice_style}"
+                    )
+                else:
+                    error_info = await response.text()
+                    logger.error(f"{self.log_prefix} GPT-SoVITS API失败[{response.status}]: {error_info[:200]}")
+                    return TTSResult(
+                        False,
+                        f"GPT-SoVITS API调用失败: {response.status}",
+                        backend_name=self.backend_name
+                    )
+
+        except asyncio.TimeoutError:
+            return TTSResult(False, "GPT-SoVITS API调用超时", backend_name=self.backend_name)
+        except Exception as e:
+            logger.error(f"{self.log_prefix} GPT-SoVITS执行错误: {e}")
+            return TTSResult(False, f"GPT-SoVITS执行错误: {e}", backend_name=self.backend_name)
diff --git a/backends/gsv2p.py b/backends/gsv2p.py
new file mode 100644
index 00000000..8837d881
--- /dev/null
+++ b/backends/gsv2p.py
@@ -0,0 +1,186 @@
+"""
+GSV2P 后端实现
+使用 GSV2P 云端 API 进行语音合成
+"""
+
+import asyncio
+import json
+from typing import Optional, Dict, Any, Tuple
+from .base import TTSBackendBase, TTSResult
+from ..utils.file import TTSFileManager
+from ..utils.session import TTSSessionManager
+from ..config_keys import ConfigKeys
+from src.common.logger import get_logger
+
+logger = get_logger("tts_gsv2p")
+
+# 重试配置
+MAX_RETRIES = 5  # 最大重试次数
+RETRY_DELAY = 3.0  # 重试间隔（秒）
+
+
+class GSV2PBackend(TTSBackendBase):
+    """
+    GSV2P 后端
+
+    使用 GSV2P 云端 API 进行高质量语音合成
+    """
+
+    backend_name = "gsv2p"
+    backend_description = "GSV2P云端API语音合成"
+    support_private_chat = True
+    default_audio_format = "mp3"
+
+    def get_default_voice(self) -> str:
+        """获取默认音色"""
+        return self.get_config(ConfigKeys.GSV2P_DEFAULT_VOICE, "原神-中文-派蒙_ZH")
+
+    def validate_config(self) -> Tuple[bool, str]:
+        """验证配置"""
+        api_token = self.get_config(ConfigKeys.GSV2P_API_TOKEN, "")
+        if not api_token:
+            return False, "GSV2P后端缺少API Token配置"
+        return True, ""
+
+    async def _make_request(
+        self,
+        api_url: str,
+        request_data: Dict[str, Any],
+        headers: Dict[str, str],
+        timeout: int
+    ) -> Tuple[bool, Any, str]:
+        """
+        发送单次API请求
+
+        Returns:
+            (成功标志, 音频数据或None, 错误信息)
+        """
+        session_manager = await TTSSessionManager.get_instance()
+        async with session_manager.post(
+            api_url,
+            json=request_data,
+            headers=headers,
+            backend_name="gsv2p",
+            timeout=timeout
+        ) as response:
+            if response.status == 200:
+                content_type = response.headers.get('Content-Type', '')
+                audio_data = await response.read()
+
+                # 检查是否返回了JSON错误（服务端不稳定时会返回参数错误）
+                if 'application/json' in content_type:
+                    try:
+                        error_json = json.loads(audio_data.decode('utf-8'))
+                        error_msg = error_json.get('error', {}).get('message', str(error_json))
+                        # 参数错误通常是服务端临时问题，可以重试
+                        return False, None, f"API返回错误: {error_msg}"
+                    except Exception:
+                        return False, None, "API返回异常响应"
+
+                # 验证音频数据
+                is_valid, error_msg = TTSFileManager.validate_audio_data(audio_data)
+                if not is_valid:
+                    return False, None, f"音频数据无效: {error_msg}"
+
+                return True, audio_data, ""
+            else:
+                error_text = await response.text()
+                return False, None, f"API调用失败: {response.status} - {error_text[:100]}"
+
+    async def execute(
+        self,
+        text: str,
+        voice: Optional[str] = None,
+        **kwargs
+    ) -> TTSResult:
+        """
+        执行GSV2P语音合成（带重试机制）
+
+        Args:
+            text: 待转换的文本
+            voice: 音色名称
+
+        Returns:
+            TTSResult
+        """
+        # 验证配置
+        is_valid, error_msg = self.validate_config()
+        if not is_valid:
+            return TTSResult(False, error_msg, backend_name=self.backend_name)
+
+        # 验证文本
+        if not text or not text.strip():
+            return TTSResult(False, "待合成的文本为空", backend_name=self.backend_name)
+
+        # 获取配置
+        api_url = self.get_config(ConfigKeys.GSV2P_API_URL, "https://gsv2p.acgnai.top/v1/audio/speech")
+        api_token = self.get_config(ConfigKeys.GSV2P_API_TOKEN, "")
+        timeout = self.get_config(ConfigKeys.GSV2P_TIMEOUT, 30)
+
+        if not voice:
+            voice = self.get_default_voice()
+
+        # 构建请求参数（注意：other_params 已被 API 废弃，不再支持）
+        request_data: Dict[str, Any] = {
+            "model": self.get_config(ConfigKeys.GSV2P_MODEL, "tts-v4"),
+            "input": text,
+            "voice": voice,
+            "response_format": self.get_config(ConfigKeys.GSV2P_RESPONSE_FORMAT, "mp3"),
+            "speed": self.get_config(ConfigKeys.GSV2P_SPEED, 1)
+        }
+
+        headers = {
+            "accept": "application/json",
+            "Authorization": f"Bearer {api_token}",
+            "Content-Type": "application/json"
+        }
+
+        logger.info(f"{self.log_prefix} GSV2P请求: text='{text[:50]}...', voice={voice}")
+        logger.debug(f"{self.log_prefix} GSV2P完整请求参数: {json.dumps(request_data, ensure_ascii=False, indent=2)}")
+
+        last_error = ""
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                success, audio_data, error_msg = await self._make_request(
+                    api_url, request_data, headers, timeout
+                )
+
+                if success and audio_data:
+                    if attempt > 1:
+                        logger.info(f"{self.log_prefix} GSV2P第{attempt}次重试成功")
+
+                    logger.info(f"{self.log_prefix} GSV2P响应: 数据大小={len(audio_data)}字节")
+
+                    # 使用统一的发送方法
+                    audio_format = self.get_config(ConfigKeys.GSV2P_RESPONSE_FORMAT, "mp3")
+                    return await self.send_audio(
+                        audio_data=audio_data,
+                        audio_format=audio_format,
+                        prefix="tts_gsv2p",
+                        voice_info=f"音色: {voice}"
+                    )
+                else:
+                    last_error = error_msg
+                    if attempt < MAX_RETRIES:
+                        logger.warning(f"{self.log_prefix} GSV2P请求失败 ({error_msg}), {RETRY_DELAY}秒后重试 (尝试 {attempt}/{MAX_RETRIES})")
+                        await asyncio.sleep(RETRY_DELAY)
+                    else:
+                        logger.error(f"{self.log_prefix} GSV2P请求失败，已达最大重试次数: {error_msg}")
+
+            except asyncio.TimeoutError:
+                last_error = "API调用超时"
+                if attempt < MAX_RETRIES:
+                    logger.warning(f"{self.log_prefix} GSV2P超时, {RETRY_DELAY}秒后重试 (尝试 {attempt}/{MAX_RETRIES})")
+                    await asyncio.sleep(RETRY_DELAY)
+                else:
+                    logger.error(f"{self.log_prefix} GSV2P超时，已达最大重试次数")
+
+            except Exception as e:
+                last_error = str(e)
+                logger.error(f"{self.log_prefix} GSV2P执行错误: {e}")
+                if attempt < MAX_RETRIES:
+                    await asyncio.sleep(RETRY_DELAY)
+                else:
+                    break
+
+        return TTSResult(False, f"GSV2P {last_error} (已重试{MAX_RETRIES}次)", backend_name=self.backend_name)
diff --git a/config.toml b/config.toml
new file mode 100644
index 00000000..9c045560
--- /dev/null
+++ b/config.toml
@@ -0,0 +1,292 @@
+# tts_voice_plugin - 自动生成的配置文件
+# 统一TTS语音合成插件，整合AI Voice、GSV2P、GPT-SoVITS、豆包语音、CosyVoice五种后端引擎，提供灵活的语音合成能力。
+
+# 插件基本配置
+[plugin]
+
+# 是否启用插件
+enabled = true
+
+# 配置文件版本
+config_version = "3.2.3"
+
+# 通用设置
+
+[general]
+
+# 默认TTS后端 (ai_voice/gsv2p/gpt_sovits/doubao/cosyvoice/comfyui)
+# 可选: ai_voice/gsv2p/gpt_sovits/doubao/cosyvoice/comfyui/comfyui_voiceclone/comfyui_customvoice
+default_backend = "comfyui_customvoice"
+
+# 请求超时时间（秒）
+timeout = 60
+
+# 最大文本长度（该限制会在调用LLM时注入到prompt中，让LLM直接生成符合长度的回复，而不是被动截断）
+max_text_length = 200
+
+# 是否使用replyer润色语音内容
+use_replyer_rewrite = true
+
+# 音频文件输出目录（支持相对路径和绝对路径，留空使用项目根目录）
+audio_output_dir = ""
+
+# 是否使用base64编码发送音频（备选方案）
+use_base64_audio = true
+
+# 是否分段发送语音（每句话单独发送一条语音，避免长语音播放问题）
+split_sentences = true
+
+# 分段发送时每条语音之间的延迟（秒）
+split_delay = 0.3
+
+# 自动分段启用阈值：文本长度小于该值时不分段（避免短句被切成多段）
+split_min_total_chars = 120
+
+# 句子最小长度：过短片段会合并到前一句（用于减少碎片段）
+split_min_sentence_chars = 6
+
+# 自动分段最大段数（避免刷屏式多段语音）。0 表示不限制。
+split_max_segments = 3
+
+# 自动分段打包目标长度（字符）。用于把多句合并成更少段。
+split_chunk_chars = 110
+
+# 是否发送错误提示消息（关闭后语音合成失败时不会发送错误信息给用户）
+send_error_messages = true
+
+# 组件启用控制
+
+[components]
+
+# 是否启用Action组件
+action_enabled = true
+
+# 是否启用Command组件
+command_enabled = true
+
+# 是否启用 instruct 调试命令组件（/tts_instruct）
+instruct_command_enabled = true
+
+# 概率控制配置
+
+[probability]
+
+# 是否启用概率控制
+enabled = true
+
+# 基础触发概率
+base_probability = 1
+
+# 关键词强制触发
+keyword_force_trigger = true
+
+# 强制触发关键词
+force_keywords = [
+    "一定要用语音",
+    "必须语音",
+    "语音回复我",
+    "务必用语音",
+]
+
+# AI Voice后端配置
+
+[ai_voice]
+
+# 默认音色（可选：小新、猴哥、四郎、东北老妹儿、广西大表哥、妲己、霸道总裁、酥心御姐、说书先生、憨憨小弟、憨厚老哥、吕布、元气少女、文艺少女、磁性大叔、邻家小妹、低沉男声、傲娇少女、爹系男友、暖心姐姐、温柔妹妹、书香少女）
+default_character = "邻家小妹"
+
+# GSV2P后端配置
+
+[gsv2p]
+
+# GSV2P API地址
+api_url = "https://gsv2p.acgnai.top/v1/audio/speech"
+
+# API认证Token
+api_token = ""
+
+# 默认音色
+default_voice = "原神-中文-派蒙_ZH"
+
+# API请求超时（秒）
+timeout = 149
+
+# TTS模型
+model = "tts-v4"
+
+# 音频格式
+response_format = "wav"
+
+# 语音速度
+speed = 1
+
+# GPT-SoVITS后端配置
+
+[gpt_sovits]
+
+# GPT-SoVITS服务地址
+server = "http://127.0.0.1:9880"
+
+# 语音风格配置
+
+# 豆包语音后端配置
+
+[[gpt_sovits.styles]]
+name = "default"
+refer_wav = "/Users/xenon/Downloads/seiun_tts/qingyun_tiankong_voice/s978ztt245c3jxms6apadwgna4e7hmb.mp3"
+prompt_text = "私にしてはがんばった方ではないでしょーか？"
+prompt_language = "ja"
+gpt_weights = "/Users/xenon/Downloads/GPT-SoVITS/GPT_weights_v4/seiun-e15.ckpt"
+sovits_weights = "/Users/xenon/Downloads/GPT-SoVITS/SoVITS_weights_v4/seiun_e2_s144_l32.pth"
+
+[[gpt_sovits.styles]]
+name = ""
+refer_wav = ""
+prompt_text = ""
+prompt_language = "zh"
+gpt_weights = ""
+sovits_weights = ""
+
+[doubao]
+
+# 豆包语音API地址
+api_url = "https://openspeech.bytedance.com/api/v3/tts/unidirectional"
+
+# 豆包APP ID
+app_id = ""
+
+# 豆包Access Key
+access_key = ""
+
+# 豆包Resource ID
+resource_id = "seed-tts-2.0"
+
+# 默认音色
+default_voice = "zh_female_vv_uranus_bigtts"
+
+# API请求超时（秒）
+timeout = 60
+
+# 音频格式
+audio_format = "wav"
+
+# 采样率
+sample_rate = 24000
+
+# 比特率
+bitrate = 128000
+
+# CosyVoice后端配置
+
+[cosyvoice]
+
+# Gradio API地址
+gradio_url = "https://funaudiollm-fun-cosyvoice3-0-5b.ms.show/"
+
+# 推理模式（3s极速复刻/自然语言控制）
+default_mode = "3s极速复刻"
+
+# 默认指令（用于自然语言控制模式）
+default_instruct = "You are a helpful assistant. 请用广东话表达。<|endofprompt|>"
+
+# 参考音频路径（用于3s极速复刻模式）
+reference_audio = ""
+
+# 提示文本（用于3s极速复刻模式）
+prompt_text = ""
+
+# API请求超时（秒）
+timeout = 300
+
+# 音频格式
+audio_format = "wav"
+
+[comfyui]
+server = "http://127.0.0.1:8188"
+# 必须是 ComfyUI 的 input 目录, backend 会把 refer_wav 复制进去, 再用 LoadAudio 读取
+input_dir = "/Users/xenon/Downloads/seiun_tts/ComfyUI/ComfyUI/input"
+timeout = 120
+audio_quality = "128k" # SaveAudioMP3: V0/128k/320k
+mlx_python = "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/.venv/bin/python"
+mlx_cli = "/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/mlx_voice_clone_cli.py"
+default_style = "default"
+# Split comfyui backend into two convenient aliases:
+# - comfyui_voiceclone: only uses styles whose mode is voice_clone (or absent)
+# - comfyui_customvoice: only uses styles whose mode is custom_voice
+# These keys let you pick different defaults without duplicating comfyui.styles.
+voiceclone_default_style = "default"
+customvoice_default_style = "seiun"
+auto_instruct_enabled = true
+auto_instruct_max_chars = 320
+
+# 自动推断 instruct 时固定附加的“基调”(persona)。会作为 `基调=...;` 前缀插入。
+# 注意：值里不要包含 ';' 或 '='（backend 会做清洗，但建议从源头避免）。
+auto_instruct_base_tone = "女性约15-16岁,清澈透亮但慵懒的轻女高音,句尾元音随意拉长且略带鼻腔撒娇,咬字松弛像刚睡醒,可在慵懒与冷静锐利间切换,带戏谑亲和"
+
+# 可选：完整基调原文（保留备份，当前不启用）
+# auto_instruct_base_tone = """
+# 女性，外表约15-16岁，音色是清澈透亮却带有慵懒感的轻女高音（Light Soprano）。
+#
+# 嗓音轻盈飘逸，带有明显的“云朵般”的漂浮感，起初是漫不经心的拖沓语调，其特征在于句尾元音的随意拉长（Drawl）以及略带鼻腔共鸣的撒娇感。咬字呈现出一种仿佛刚睡醒般的松弛，甚至伴有刻意为之的含糊，像是一只在阳光下伸懒腰的猫。
+#
+# 随后，这种慵懒被一种狡黠的机敏所取代，声音在毫无干劲的叹息与看穿一切的通透感之间自如切换。在表现谋略或胜负欲的瞬间，音色会瞬间收紧，去除了所有的气声装饰与慵懒拖音，转为冷静、干练且直击要害的中高频。
+#
+# 表现风格既显得捉摸不透又带有戏谑的亲和力，伴随着轻巧的换气声和偶尔出现的、带有试探意味的升调尾音。仿佛在脱力系（Listless）的无害表象之下，潜藏着绝顶聪明的头脑与绝不让步的自尊。
+# """
+
+auto_instruct_prompt = """
+你是精通声学特征与戏剧表演的 AI 配音导演。你的任务是根据「待朗读文本」生成一行 TTS instruct（用于 Qwen3-TTS CustomVoice 的语音表演控制）。
+
+硬性要求：
+- 只输出一行（单行 KV），不要解释，不要引号/代码块，不要复述原文。
+- 必须同时包含以下字段，并用英文分号 ';' 分隔：情绪、强度、语速、停顿、表现
+- 输出格式固定为：情绪=<...>;强度=<...>;语速=<...>;停顿=<...>;表现=<...>
+- 语速可选：很慢/稍慢/正常/稍快/很快
+- 停顿可选：很少/自然/稍多/很多
+- 强度可选：很低/低/中/高/很高
+- 表现：用 3-6 个短提示词，使用逗号分隔（不要用分号），如：声压高,咬字重,重音强,尾音下压
+- 长度 <= {max_chars} 字
+
+强制增强规则（避免“生气但听起来不够生气”）：
+- 如果文本出现：非常/极其/真的/气死/怒/吼/滚/闭嘴/你再说一次 等强烈信号，情绪优先用「愤怒」，强度至少「高」，表现要包含“声压高/咬字重/重音强/尾音下压”中的至少 2 项。
+- 如果是嘲讽或冷笑式的怒气：情绪写「愤怒(冷)」或「愤怒+嘲讽」，表现包含“冷硬/压低/咬字利落/少气声”。
+
+文本语言: {lang}
+待朗读文本: {text}
+"""
+
+# 基础停顿（秒）。当 instruct 包含“停顿=...”时，会按 很少/自然/稍多/很多 做倍率缩放。
+pause_linebreak = 0.18
+period_pause = 0.22
+comma_pause = 0.1
+question_pause = 0.2
+hyphen_pause = 0.06
+
+[[comfyui.styles]]
+name = "default"
+refer_wav = "/Users/xenon/Downloads/seiun_tts/qingyun_tiankong_voice/default_ref_24k_mono.wav"
+prompt_text = "私にしてはがんばった方ではないでしょーか？"
+language = "Auto"
+model_choice = "1.7B"
+precision = "bf16"
+seed = 0
+max_new_tokens = 2048
+top_p = 0.8
+top_k = 20
+temperature = 1
+repetition_penalty = 1.05
+
+[[comfyui.styles]]
+name = "seiun"
+mode = "custom_voice"
+model_path = "/Users/xenon/Downloads/checkpoint-epoch-9"
+speaker = "seiun"
+instruct = "__AUTO__"
+speed = 1
+language = "Auto"
+seed = 0
+max_new_tokens = 2048
+top_p = 0.9
+top_k = 20
+temperature = 0.9
+repetition_penalty = 1.05
diff --git a/config_keys.py b/config_keys.py
new file mode 100644
index 00000000..b7993eca
--- /dev/null
+++ b/config_keys.py
@@ -0,0 +1,103 @@
+"""
+配置键常量定义
+集中管理所有配置键，避免硬编码
+"""
+
+
+class ConfigKeys:
+    """配置键常量类"""
+
+    # ========== Plugin 配置 ==========
+    PLUGIN_ENABLED = "plugin.enabled"
+    PLUGIN_CONFIG_VERSION = "plugin.config_version"
+
+    # ========== General 通用配置 ==========
+    GENERAL_DEFAULT_BACKEND = "general.default_backend"
+    GENERAL_TIMEOUT = "general.timeout"
+    GENERAL_MAX_TEXT_LENGTH = "general.max_text_length"
+    GENERAL_USE_REPLYER_REWRITE = "general.use_replyer_rewrite"
+    GENERAL_AUDIO_OUTPUT_DIR = "general.audio_output_dir"
+    GENERAL_USE_BASE64_AUDIO = "general.use_base64_audio"
+    GENERAL_SPLIT_SENTENCES = "general.split_sentences"
+    GENERAL_SPLIT_DELAY = "general.split_delay"
+    GENERAL_SPLIT_MIN_TOTAL_CHARS = "general.split_min_total_chars"
+    GENERAL_SPLIT_MIN_SENTENCE_CHARS = "general.split_min_sentence_chars"
+    GENERAL_SPLIT_MAX_SEGMENTS = "general.split_max_segments"
+    GENERAL_SPLIT_CHUNK_CHARS = "general.split_chunk_chars"
+    GENERAL_SEND_ERROR_MESSAGES = "general.send_error_messages"
+
+    # ========== Components 组件配置 ==========
+    COMPONENTS_ACTION_ENABLED = "components.action_enabled"
+    COMPONENTS_COMMAND_ENABLED = "components.command_enabled"
+    COMPONENTS_INSTRUCT_COMMAND_ENABLED = "components.instruct_command_enabled"
+
+    # ========== Probability 概率控制配置 ==========
+    PROBABILITY_ENABLED = "probability.enabled"
+    PROBABILITY_BASE_PROBABILITY = "probability.base_probability"
+    PROBABILITY_KEYWORD_FORCE_TRIGGER = "probability.keyword_force_trigger"
+    PROBABILITY_FORCE_KEYWORDS = "probability.force_keywords"
+
+    # ========== AI Voice 配置 ==========
+    AI_VOICE_DEFAULT_CHARACTER = "ai_voice.default_character"
+    AI_VOICE_ALIAS_MAP = "ai_voice.alias_map"
+
+    # ========== GSV2P 配置 ==========
+    GSV2P_API_URL = "gsv2p.api_url"
+    GSV2P_API_TOKEN = "gsv2p.api_token"
+    GSV2P_DEFAULT_VOICE = "gsv2p.default_voice"
+    GSV2P_TIMEOUT = "gsv2p.timeout"
+    GSV2P_MODEL = "gsv2p.model"
+    GSV2P_RESPONSE_FORMAT = "gsv2p.response_format"
+    GSV2P_SPEED = "gsv2p.speed"
+
+    # ========== GPT-SoVITS 配置 ==========
+    GPT_SOVITS_SERVER = "gpt_sovits.server"
+    GPT_SOVITS_STYLES = "gpt_sovits.styles"
+
+    # ========== Doubao 豆包配置 ==========
+    DOUBAO_API_URL = "doubao.api_url"
+    DOUBAO_APP_ID = "doubao.app_id"
+    DOUBAO_ACCESS_KEY = "doubao.access_key"
+    DOUBAO_RESOURCE_ID = "doubao.resource_id"
+    DOUBAO_DEFAULT_VOICE = "doubao.default_voice"
+    DOUBAO_TIMEOUT = "doubao.timeout"
+    DOUBAO_AUDIO_FORMAT = "doubao.audio_format"
+    DOUBAO_SAMPLE_RATE = "doubao.sample_rate"
+    DOUBAO_BITRATE = "doubao.bitrate"
+    DOUBAO_SPEED = "doubao.speed"
+    DOUBAO_VOLUME = "doubao.volume"
+    DOUBAO_CONTEXT_TEXTS = "doubao.context_texts"
+
+    # ========== CosyVoice 配置 ==========
+    COSYVOICE_GRADIO_URL = "cosyvoice.gradio_url"
+    COSYVOICE_DEFAULT_MODE = "cosyvoice.default_mode"
+    COSYVOICE_DEFAULT_INSTRUCT = "cosyvoice.default_instruct"
+    COSYVOICE_REFERENCE_AUDIO = "cosyvoice.reference_audio"
+    COSYVOICE_PROMPT_TEXT = "cosyvoice.prompt_text"
+    COSYVOICE_TIMEOUT = "cosyvoice.timeout"
+    COSYVOICE_AUDIO_FORMAT = "cosyvoice.audio_format"
+
+    # ========== ComfyUI (Workflow API) 配置 ==========
+    COMFYUI_SERVER = "comfyui.server"
+    COMFYUI_INPUT_DIR = "comfyui.input_dir"
+    COMFYUI_TIMEOUT = "comfyui.timeout"
+    COMFYUI_DEFAULT_STYLE = "comfyui.default_style"
+    COMFYUI_STYLES = "comfyui.styles"
+    # Convenience aliases to split voiceclone/customvoice at the plugin level.
+    # Both backends still use comfyui.styles, but these keys let you pick different defaults.
+    COMFYUI_VOICECLONE_DEFAULT_STYLE = "comfyui.voiceclone_default_style"
+    COMFYUI_CUSTOMVOICE_DEFAULT_STYLE = "comfyui.customvoice_default_style"
+    COMFYUI_AUDIO_QUALITY = "comfyui.audio_quality"
+    COMFYUI_MLX_PYTHON = "comfyui.mlx_python"
+    COMFYUI_MLX_CLI = "comfyui.mlx_cli"
+    COMFYUI_PAUSE_LINEBREAK = "comfyui.pause_linebreak"
+    COMFYUI_PERIOD_PAUSE = "comfyui.period_pause"
+    COMFYUI_COMMA_PAUSE = "comfyui.comma_pause"
+    COMFYUI_QUESTION_PAUSE = "comfyui.question_pause"
+    COMFYUI_HYPHEN_PAUSE = "comfyui.hyphen_pause"
+
+    # Auto instruct (CustomVoice)
+    COMFYUI_AUTO_INSTRUCT_ENABLED = "comfyui.auto_instruct_enabled"
+    COMFYUI_AUTO_INSTRUCT_BASE_TONE = "comfyui.auto_instruct_base_tone"
+    COMFYUI_AUTO_INSTRUCT_PROMPT = "comfyui.auto_instruct_prompt"
+    COMFYUI_AUTO_INSTRUCT_MAX_CHARS = "comfyui.auto_instruct_max_chars"
diff --git a/plugin.py b/plugin.py
new file mode 100644
index 00000000..8ee2b155
--- /dev/null
+++ b/plugin.py
@@ -0,0 +1,972 @@
+"""
+统一TTS语音合成插件
+支持五种后端：AI Voice (MaiCore内置) / GSV2P (云API) / GPT-SoVITS (本地服务) / 豆包语音 (云API) / CosyVoice (ModelScope Gradio)
+
+Version: 3.2.3
+Author: 靓仔
+"""
+
+import sys
+sys.dont_write_bytecode = True
+
+import asyncio
+import random
+from typing import List, Tuple, Type, Optional
+
+from src.common.logger import get_logger
+from src.plugin_system.base.base_plugin import BasePlugin
+from src.plugin_system.apis.plugin_register_api import register_plugin
+from src.plugin_system.base.base_action import BaseAction, ActionActivationType
+from src.plugin_system.base.base_command import BaseCommand
+from src.plugin_system.base.component_types import ComponentInfo, ChatMode
+from src.plugin_system.base.config_types import ConfigField
+from src.plugin_system.apis import generator_api
+
+# 导入模块化的后端和工具
+from .backends import TTSBackendRegistry, TTSResult
+from .backends.ai_voice import AI_VOICE_ALIAS_MAP
+from .backends.doubao import DOUBAO_EMOTION_MAP
+from .utils.text import TTSTextUtils
+from .config_keys import ConfigKeys
+
+logger = get_logger("tts_voice_plugin")
+
+# 有效后端列表
+VALID_BACKENDS = [
+    "ai_voice",
+    "gsv2p",
+    "gpt_sovits",
+    "doubao",
+    "cosyvoice",
+    "comfyui",
+    "comfyui_voiceclone",
+    "comfyui_customvoice",
+]
+
+
+class TTSExecutorMixin:
+    """
+    TTS执行器混入类
+
+    提供 Action 和 Command 共享的后端执行逻辑
+    """
+
+    def _create_backend(self, backend_name: str):
+        """
+        创建后端实例
+
+        Args:
+            backend_name: 后端名称
+
+        Returns:
+            后端实例
+        """
+        backend = TTSBackendRegistry.create(
+            backend_name,
+            self.get_config,
+            self.log_prefix
+        )
+
+        if backend:
+            # 注入必要的回调函数
+            if hasattr(backend, 'set_send_custom'):
+                backend.set_send_custom(self.send_custom)
+            if hasattr(backend, 'set_send_command'):
+                backend.set_send_command(self.send_command)
+
+        return backend
+
+    async def _execute_backend(
+        self,
+        backend_name: str,
+        text: str,
+        voice: str = "",
+        emotion: str = ""
+    ) -> TTSResult:
+        """
+        执行指定后端
+
+        Args:
+            backend_name: 后端名称
+            text: 待转换文本
+            voice: 音色
+            emotion: 情感（豆包后端）
+
+        Returns:
+            TTSResult
+        """
+        backend = self._create_backend(backend_name)
+
+        if not backend:
+            return TTSResult(
+                success=False,
+                message=f"未知的TTS后端: {backend_name}"
+            )
+
+        # AI Voice 私聊限制检查
+        if backend_name == "ai_voice":
+            is_private = self._check_is_private_chat()
+            if is_private:
+                logger.info(f"{self.log_prefix} AI语音仅支持群聊，自动切换到GSV2P后端")
+                return await self._execute_backend("gsv2p", text, voice, emotion)
+
+        # Pass chat context through for backends that need MaiBot LLM APIs (e.g., comfyui auto_instruct).
+        chat_stream = None
+        if hasattr(self, "chat_stream"):
+            chat_stream = getattr(self, "chat_stream", None)
+        elif hasattr(self, "message"):
+            chat_stream = getattr(getattr(self, "message", None), "chat_stream", None)
+
+        return await backend.execute(text, voice, emotion=emotion, chat_stream=chat_stream)
+
+    def _check_is_private_chat(self) -> bool:
+        """检查是否是私聊"""
+        # Action 中使用 chat_stream
+        if hasattr(self, 'chat_stream'):
+            return not getattr(self.chat_stream, 'group_info', None)
+        # Command 中使用 message
+        if hasattr(self, 'message'):
+            msg_info = getattr(self.message, 'message_info', None)
+            if msg_info:
+                return not getattr(msg_info, 'group_info', None)
+        return False
+
+    def _get_default_backend(self) -> str:
+        """获取配置的默认后端"""
+        backend = self.get_config(ConfigKeys.GENERAL_DEFAULT_BACKEND, "gsv2p")
+        if backend not in VALID_BACKENDS:
+            logger.warning(f"{self.log_prefix} 配置的默认后端 '{backend}' 无效，使用 gsv2p")
+            return "gsv2p"
+        return backend
+
+    async def _send_error(self, message: str) -> None:
+        """
+        发送错误提示信息（受全局配置控制）
+
+        Args:
+            message: 错误消息
+        """
+        if self.get_config(ConfigKeys.GENERAL_SEND_ERROR_MESSAGES, True):
+            await self.send_text(message)
+
+
+class UnifiedTTSAction(BaseAction, TTSExecutorMixin):
+    """统一TTS Action - LLM自动触发"""
+
+    action_name = "unified_tts_action"
+    action_description = "用语音回复（支持AI Voice/GSV2P/GPT-SoVITS/豆包语音多后端）"
+    activation_type = ActionActivationType.KEYWORD
+    mode_enable = ChatMode.ALL
+    parallel_action = False
+
+    activation_keywords = [
+        "语音", "说话", "朗读", "念一下", "读出来",
+        "voice", "speak", "tts", "语音回复", "用语音说", "播报"
+    ]
+    keyword_case_sensitive = False
+
+    action_parameters = {
+        "text": "要转换为语音的文本内容（必填）",
+        "backend": "TTS后端引擎 (ai_voice/gsv2p/gpt_sovits/doubao/cosyvoice/comfyui/comfyui_voiceclone/comfyui_customvoice，可选，建议省略让系统自动使用配置的默认后端)",
+        "voice": "音色/风格参数（可选）",
+        "emotion": "情感/语气参数（可选，仅豆包后端有效）。支持：开心/兴奋/温柔/骄傲/生气/愤怒/伤心/失望/委屈/平静/严肃/疑惑/慢速/快速/小声/大声等"
+    }
+
+    action_require = [
+        "当用户要求用语音回复时使用",
+        "当回复简短问候语时使用（如早上好、晚安、你好等）",
+        "当想让回复更活泼生动时可以使用",
+        "注意：回复内容过长或者过短不适合用语音",
+        "注意：backend参数建议省略，系统会自动使用配置的默认后端"
+    ]
+
+    associated_types = ["text", "command"]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.timeout = self.get_config(ConfigKeys.GENERAL_TIMEOUT, 60)
+        self.max_text_length = self.get_config(ConfigKeys.GENERAL_MAX_TEXT_LENGTH, 500)
+
+    def _check_force_trigger(self, text: str) -> bool:
+        """检查是否强制触发"""
+        if not self.get_config(ConfigKeys.PROBABILITY_KEYWORD_FORCE_TRIGGER, True):
+            return False
+        force_keywords = self.get_config(
+            ConfigKeys.PROBABILITY_FORCE_KEYWORDS,
+            ["一定要用语音", "必须语音", "语音回复我", "务必用语音"]
+        )
+        return any(kw in text for kw in force_keywords)
+
+    def _probability_check(self, text: str) -> bool:
+        """概率控制检查"""
+        if not self.get_config(ConfigKeys.PROBABILITY_ENABLED, True):
+            return True
+
+        base_prob = self.get_config(ConfigKeys.PROBABILITY_BASE_PROBABILITY, 1.0)
+        base_prob = max(0.0, min(1.0, base_prob))
+        result = random.random() < base_prob
+        logger.info(f"{self.log_prefix} 概率检查: {base_prob:.2f}, 结果={'通过' if result else '未通过'}")
+        return result
+
+    async def _get_final_text(self, raw_text: str, reason: str, use_replyer: bool) -> Tuple[bool, str]:
+        """获取最终要转语音的文本（使用与正常回复一致的prompt参数）"""
+        max_text_length = self.get_config(ConfigKeys.GENERAL_MAX_TEXT_LENGTH, 200)
+
+        if not use_replyer:
+            if not raw_text:
+                return False, ""
+            return True, raw_text
+
+        try:
+            # 统一使用 generate_reply 以确保触发 POST_LLM 事件（日程注入）
+            # rewrite_reply 不会触发 POST_LLM 事件，因此不适用
+            # 注意：长度约束放在末尾，利用 LLM 的"近因效应"提高遵守率
+            extra_info_parts = []
+            if raw_text:
+                extra_info_parts.append(f"期望的回复内容：{raw_text}")
+            # 长度约束放在最后，使用更强的表述
+            extra_info_parts.append(
+                f"【重要】你的回复必须控制在{max_text_length}字以内，这是硬性要求。"
+                f"超过此长度将无法转换为语音。请直接回复核心内容，不要啰嗦。"
+            )
+
+            success, llm_response = await generator_api.generate_reply(
+                chat_stream=self.chat_stream,
+                reply_message=self.action_message,
+                reply_reason=reason,
+                extra_info="\n".join(extra_info_parts),
+                request_type="tts_voice_plugin",
+                from_plugin=False  # 允许触发POST_LLM事件，使日程注入生效
+            )
+            if success and llm_response and llm_response.content:
+                logger.info(f"{self.log_prefix} 语音内容生成成功")
+                return True, llm_response.content.strip()
+
+            # 如果生成失败但有原始文本，则使用原始文本
+            if raw_text:
+                logger.warning(f"{self.log_prefix} 内容生成失败，使用原始文本")
+                return True, raw_text
+
+            return False, ""
+        except Exception as e:
+            logger.error(f"{self.log_prefix} 调用 replyer 出错: {e}")
+            return bool(raw_text), raw_text
+
+    async def execute(self) -> Tuple[bool, str]:
+        def _chunk_sentences(
+            parts: List[str], target_chars: int, max_chunks: int
+        ) -> List[str]:
+            # Greedy packing: reduces tiny fragments into fewer, longer segments.
+            if not parts:
+                return []
+            if target_chars <= 0:
+                target_chars = 120
+
+            def pack(tgt: int) -> List[str]:
+                out: List[str] = []
+                cur = ""
+                for s in parts:
+                    s = (s or "").strip()
+                    if not s:
+                        continue
+                    if not cur:
+                        cur = s
+                        continue
+                    if len(cur) + len(s) <= tgt:
+                        cur += s
+                    else:
+                        out.append(cur)
+                        cur = s
+                if cur:
+                    out.append(cur)
+                return out
+
+            packed = pack(target_chars)
+            if max_chunks and max_chunks > 0 and len(packed) > max_chunks:
+                total = len("".join(parts))
+                new_target = max(target_chars, int(total / max_chunks) + 1)
+                packed = pack(new_target)
+            return packed
+
+        async def send_message_single_sentences() -> Tuple[bool, str]:
+            result = await self._execute_backend(backend, clean_text, voice, emotion)
+            if result.success:
+                # 生成更详细的动作记录，帮助 planner 避免重复执行
+                text_preview = clean_text[:80] + "..." if len(clean_text) > 80 else clean_text
+                await self.store_action_info(
+                    action_build_into_prompt=True,
+                    action_prompt_display=f"已用语音回复：{text_preview}",
+                    action_done=True
+                )
+            else:
+                await self._send_error(f"语音合成失败: {result.message}")
+
+            return result.success, result.message
+        async def send_message_with_splited_sentences() -> Tuple[bool, str]:
+        # 分段发送模式：将文本分割成句子，逐句发送语音
+            if len(sentences) > 1:
+                logger.info(f"{self.log_prefix} 分段发送模式：共 {len(sentences)} 句")
+
+                success_count = 0
+                all_sentences_text = []
+
+                for i, sentence in enumerate(sentences):
+                    if not sentence.strip():
+                        continue
+
+                    logger.debug(f"{self.log_prefix} 发送第 {i + 1}/{len(sentences)} 句: {sentence[:30]}...")
+                    result = await self._execute_backend(backend, sentence, voice, emotion)
+
+                    if result.success:
+                        success_count += 1
+                        all_sentences_text.append(sentence)
+                    else:
+                        logger.warning(f"{self.log_prefix} 第 {i + 1} 句发送失败: {result.message}")
+
+                    # 句子之间添加延迟
+                    if i < len(sentences) - 1 and split_delay > 0:
+                        await asyncio.sleep(split_delay)
+
+                # 记录动作信息
+                if success_count > 0:
+                    # 生成更详细的动作记录，帮助 planner 避免重复执行
+                    display_text = "".join(all_sentences_text)
+                    text_preview = display_text[:80] + "..." if len(display_text) > 80 else display_text
+                    await self.store_action_info(
+                        action_build_into_prompt=True,
+                        action_prompt_display=f"已用语音回复（{success_count}段）：{text_preview}",
+                        action_done=True
+                    )
+                    return True, f"成功发送 {success_count}/{len(sentences)} 条语音"
+                else:
+                    await self._send_error("语音合成失败")
+                    return False, "所有语音发送失败"
+            else:
+                # 只有一句，正常发送
+                return await send_message_single_sentences()
+
+        """执行TTS语音合成"""
+        try:
+            raw_text = self.action_data.get("text", "").strip()
+            voice = self.action_data.get("voice", "")
+            reason = self.action_data.get("reason", "")
+            emotion = self.action_data.get("emotion", "")
+
+            use_replyer = self.get_config(ConfigKeys.GENERAL_USE_REPLYER_REWRITE, True)
+
+            # 获取最终文本
+            success, final_text = await self._get_final_text(raw_text, reason, use_replyer)
+            if not success or not final_text:
+                await self._send_error("无法生成语音内容")
+                return False, "文本为空"
+
+            # 概率检查
+            force_trigger = self._check_force_trigger(final_text)
+            if not force_trigger and not self._probability_check(final_text):
+                logger.info(f"{self.log_prefix} 概率检查未通过，使用文字回复")
+                await self.send_text(final_text)
+                text_preview = final_text[:80] + "..." if len(final_text) > 80 else final_text
+                await self.store_action_info(
+                    action_build_into_prompt=True,
+                    action_prompt_display=f"已用文字回复（语音概率未触发）：{text_preview}",
+                    action_done=True
+                )
+                return True, "概率检查未通过，已发送文字回复"
+
+            # 清理文本（移除特殊字符，替换网络用语）
+            # 注意：长度应该由LLM在生成时就遵守，这里只做字符清理
+            clean_text = TTSTextUtils.clean_text(final_text, self.max_text_length)
+            if not clean_text:
+                await self._send_error("文本处理后为空")
+                return False, "文本处理后为空"
+
+            # 如果清理后的文本仍然超过限制，说明LLM未遵守约束
+            if len(clean_text) > self.max_text_length:
+                logger.warning(
+                    f"{self.log_prefix} LLM生成的文本超过长度限制 "
+                    f"({len(clean_text)} > {self.max_text_length}字符)，降级为文字回复"
+                )
+                await self.send_text(clean_text)
+                text_preview = clean_text[:80] + "..." if len(clean_text) > 80 else clean_text
+                await self.store_action_info(
+                    action_build_into_prompt=True,
+                    action_prompt_display=f"已用文字回复（内容过长）：{text_preview}",
+                    action_done=True
+                )
+                return True, "内容超过语音长度限制，已改为文字回复"
+
+            # 获取后端并执行
+            backend = self._get_default_backend()
+            logger.info(f"{self.log_prefix} 使用配置的默认后端: {backend}")
+
+            # 检查是否启用分段发送
+            split_sentences = self.get_config(ConfigKeys.GENERAL_SPLIT_SENTENCES, True)
+            split_delay = self.get_config(ConfigKeys.GENERAL_SPLIT_DELAY, 0.3)
+
+            sentences = None
+
+            # 优先使用智能分割插件的分隔符
+            if '|||SPLIT|||' in clean_text:
+                logger.info("found split marker from smart segmentation plugin")
+                sentences = [s.strip() for s in clean_text.split("|||SPLIT|||") if s.strip()]
+                # If the upstream splitter is too aggressive, pack back into fewer segments.
+                max_segments = int(self.get_config(ConfigKeys.GENERAL_SPLIT_MAX_SEGMENTS, 3) or 3)
+                chunk_chars = int(self.get_config(ConfigKeys.GENERAL_SPLIT_CHUNK_CHARS, 110) or 110)
+                if max_segments and max_segments > 0 and len(sentences) > max_segments:
+                    sentences = _chunk_sentences(sentences, target_chars=chunk_chars, max_chunks=max_segments)
+                return await send_message_with_splited_sentences()
+            elif split_sentences:
+                # 自动分段：短文本不分段；长文本最多分成 N 段，避免刷屏式多段语音。
+                min_total = int(self.get_config(ConfigKeys.GENERAL_SPLIT_MIN_TOTAL_CHARS, 120) or 120)
+                min_sentence = int(self.get_config(ConfigKeys.GENERAL_SPLIT_MIN_SENTENCE_CHARS, 6) or 6)
+                max_segments = int(self.get_config(ConfigKeys.GENERAL_SPLIT_MAX_SEGMENTS, 3) or 3)
+                chunk_chars = int(self.get_config(ConfigKeys.GENERAL_SPLIT_CHUNK_CHARS, 110) or 110)
+
+                if len(clean_text) < min_total:
+                    sentences = [clean_text]
+                else:
+                    sentences = TTSTextUtils.split_sentences(clean_text, min_length=min_sentence)
+                    if max_segments and max_segments > 0:
+                        sentences = _chunk_sentences(sentences, target_chars=chunk_chars, max_chunks=max_segments)
+                return await send_message_with_splited_sentences()
+            else:
+                # 单句发送
+                return await send_message_single_sentences()
+
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"{self.log_prefix} TTS语音合成出错: {error_msg}")
+            await self._send_error(f"语音合成出错: {error_msg}")
+            return False, error_msg
+
+
+class UnifiedTTSCommand(BaseCommand, TTSExecutorMixin):
+    """统一TTS Command - 用户手动触发"""
+
+    command_name = "unified_tts_command"
+    command_description = "将文本转换为语音，支持多种后端和音色"
+    command_pattern = r"^/(?:tts|voice|gsv2p|gptsovits|doubao|cosyvoice|comfyui|comfyui_voiceclone|comfyui_customvoice)\s+(?P<text>.+?)(?:\s+-v\s+(?P<voice>\S+))?(?:\s+(?P<backend>ai_voice|gsv2p|gpt_sovits|doubao|cosyvoice|comfyui|comfyui_voiceclone|comfyui_customvoice))?$"
+    command_help = "将文本转换为语音。用法：/tts 你好世界 [-v 音色] [后端]"
+    command_examples = [
+        "/tts 你好，世界！",
+        "/tts 今天天气不错 -v 小新",
+        "/gptsovits 你好世界 -v default",
+        "/cosyvoice 你好世界 -v 四川话",
+        "/tts 试试 -v 温柔妹妹 ai_voice",
+        "/gsv2p 你好世界",
+        "/doubao 你好世界 -v 开心"
+    ]
+    intercept_message = True
+
+    async def _send_help(self):
+        """发送帮助信息"""
+        default_backend = self._get_default_backend()
+
+        help_text = """【TTS语音合成插件帮助】
+
+📝 基本语法：
+/tts <文本> [-v <音色>] [后端]
+
+	🎯 快捷命令：
+	/tts <文本>        使用默认后端
+	/voice <文本>      使用 AI Voice
+	/gsv2p <文本>      使用 GSV2P
+	/gptsovits <文本>  使用 GPT-SoVITS
+	/doubao <文本>     使用 豆包语音
+	/cosyvoice <文本>  使用 CosyVoice
+	/comfyui <文本>    使用 ComfyUI(本地工作流)
+	/comfyui_voiceclone <文本>  使用 ComfyUI VoiceClone
+	/comfyui_customvoice <文本> 使用 ComfyUI CustomVoice
+
+	🔊 可用后端：
+	• ai_voice   - MaiCore内置（仅群聊）
+	• gsv2p      - 云端API，高质量
+	• gpt_sovits - 本地服务，可定制
+	• doubao     - 火山引擎，支持情感
+	• cosyvoice  - 阿里云，支持方言
+	• comfyui            - 本地ComfyUI工作流(自动按 style.mode 选择)
+	• comfyui_voiceclone - 本地ComfyUI工作流(仅 VoiceClone)
+	• comfyui_customvoice - 本地ComfyUI工作流(仅 CustomVoice)
+
+🎭 音色/情感参数（-v）：
+• AI Voice: 小新、温柔妹妹、霸道总裁、妲己 等22种
+• GSV2P: 原神-中文-派蒙_ZH 等（见API文档）
+• 豆包: 开心、生气、伤心、撒娇、严肃 等
+• CosyVoice: 广东话、四川话、东北话、开心、慢速 等
+
+📌 示例：
+/tts 你好世界
+/tts 今天真开心 -v 开心
+/gptsovits 这是本地语音合成
+/doubao 我生气了 -v 生气
+/cosyvoice 你好 -v 广东话
+/voice 测试一下 -v 温柔妹妹
+
+⚙️ 当前默认后端：""" + default_backend
+
+        await self.send_text(help_text)
+
+    def _determine_backend(self, user_backend: str) -> Tuple[str, str]:
+        """
+        确定使用的后端
+
+        Returns:
+            (backend_name, source_description)
+        """
+        # 1. 检查命令前缀
+        raw_text = self.message.raw_message if self.message.raw_message else self.message.processed_plain_text
+        if raw_text:
+            # 命令前缀到后端的映射
+            prefix_backend_map = {
+                "/gsv2p": "gsv2p",
+                "/gptsovits": "gpt_sovits",
+                "/doubao": "doubao",
+                "/cosyvoice": "cosyvoice",
+                "/voice": "ai_voice",
+                "/comfyui": "comfyui",
+                "/comfyui_voiceclone": "comfyui_voiceclone",
+                "/comfyui_customvoice": "comfyui_customvoice",
+            }
+            for prefix, backend in prefix_backend_map.items():
+                if raw_text.startswith(prefix):
+                    return backend, f"命令前缀 {prefix}"
+
+        # 2. 检查命令参数
+        if user_backend and user_backend in VALID_BACKENDS:
+            return user_backend, f"命令参数 {user_backend}"
+
+        # 3. 使用配置文件默认值
+        return self._get_default_backend(), "配置文件"
+
+    async def execute(self) -> Tuple[bool, str, bool]:
+        """执行TTS命令"""
+        try:
+            text = self.matched_groups.get("text", "").strip()
+            voice = self.matched_groups.get("voice", "")
+            user_backend = self.matched_groups.get("backend", "")
+
+            # 处理帮助命令
+            if text.lower() == "help":
+                await self._send_help()
+                return True, "显示帮助信息", True
+
+            if not text:
+                await self._send_error("请输入要转换为语音的文本内容")
+                return False, "缺少文本内容", True
+
+            # 确定后端
+            backend, backend_source = self._determine_backend(user_backend)
+
+            # 清理文本
+            max_length = self.get_config(ConfigKeys.GENERAL_MAX_TEXT_LENGTH, 500)
+            clean_text = TTSTextUtils.clean_text(text, max_length)
+
+            if not clean_text:
+                await self._send_error("文本处理后为空")
+                return False, "文本处理后为空", True
+
+            # 检查长度限制
+            if len(clean_text) > max_length:
+                await self.send_text(
+                    f"文本过长（{len(clean_text)}字符），"
+                    f"超过语音合成限制（{max_length}字符），"
+                    f"已改为文字发送。\n\n{clean_text}"
+                )
+                return True, "文本过长，已改为文字发送", True
+
+            logger.info(f"{self.log_prefix} 执行TTS命令 (后端: {backend} [来源: {backend_source}], 音色: {voice})")
+
+            # 执行后端
+            # 对于 CosyVoice 和豆包，voice 参数实际上是情感/方言
+            if backend in ["cosyvoice", "doubao"]:
+                result = await self._execute_backend(backend, clean_text, voice="", emotion=voice)
+            else:
+                result = await self._execute_backend(backend, clean_text, voice)
+
+            if not result.success:
+                await self._send_error(f"语音合成失败: {result.message}")
+
+            return result.success, result.message, True
+
+        except Exception as e:
+            logger.error(f"{self.log_prefix} TTS命令执行出错: {e}")
+            await self._send_error(f"语音合成出错: {e}")
+            return False, f"执行出错: {e}", True
+
+
+class TTSInstructCommand(BaseCommand):
+    """生成 CustomVoice instruct（调试/预览用）"""
+
+    command_name = "tts_instruct_command"
+    command_description = "根据待朗读文本生成 CustomVoice 的 instruct（情绪/语速/停顿）"
+    command_pattern = r"^/tts_instruct\\s+(?P<text>.+?)$"
+    command_help = "用法：/tts_instruct <文本>"
+    command_examples = [
+        "/tts_instruct 早上好，今天也要加油。",
+        "/tts_instruct えっ？本当にそうなの？",
+    ]
+    intercept_message = True
+
+    async def execute(self) -> Tuple[bool, str, int]:
+        try:
+            text = (self.matched_groups.get("text") or "").strip()
+            if not text:
+                await self.send_text("请输入要生成 instruct 的文本")
+                return False, "缺少文本", 2
+
+            # Use the same logic as ComfyUI backend auto_instruct.
+            from .backends.comfyui import ComfyUIBackend
+            from .utils.text import TTSTextUtils
+
+            detected = TTSTextUtils.detect_language(text)
+            chat_stream = getattr(self.message, "chat_stream", None)
+            chat_id = getattr(chat_stream, "stream_id", None) if chat_stream else None
+
+            backend = ComfyUIBackend(self.get_config, log_prefix=self.log_prefix)
+            instruct = await backend._infer_instruct(
+                text=text,
+                detected_lang=detected,
+                chat_stream=chat_stream,
+                chat_id=chat_id,
+                style_name="__command__",
+            )
+
+            if not instruct:
+                await self.send_text("instruct 生成失败（可能未启用 comfyui.auto_instruct_enabled 或 LLM 不可用）")
+                return False, "instruct 生成失败", 2
+
+            await self.send_text(instruct)
+            return True, "instruct 已生成", 2
+        except Exception as e:
+            await self.send_text(f"instruct 生成异常: {e}")
+            return False, str(e), 2
+
+
+@register_plugin
+class UnifiedTTSPlugin(BasePlugin):
+    """统一TTS语音合成插件 - 支持多后端的文本转语音插件"""
+
+    plugin_name = "tts_voice_plugin"
+    plugin_description = "统一TTS语音合成插件，支持AI Voice、GSV2P、GPT-SoVITS、豆包语音多种后端"
+    plugin_version = "3.2.3"
+    plugin_author = "靓仔"
+    enable_plugin = True
+    config_file_name = "config.toml"
+    dependencies = []
+    python_dependencies = ["aiohttp"]
+
+    config_section_descriptions = {
+        "plugin": "插件基本配置",
+        "general": "通用设置",
+        "components": "组件启用控制",
+        "probability": "概率控制配置",
+        "ai_voice": "AI Voice后端配置",
+        "gsv2p": "GSV2P后端配置",
+        "gpt_sovits": "GPT-SoVITS后端配置",
+        "doubao": "豆包语音后端配置",
+        "cosyvoice": "CosyVoice后端配置",
+        "comfyui": "ComfyUI工作流API后端配置"
+    }
+
+    config_schema = {
+        "plugin": {
+            "enabled": ConfigField(type=bool, default=True, description="是否启用插件"),
+            "config_version": ConfigField(type=str, default="3.2.3", description="配置文件版本")
+        },
+        "general": {
+            "default_backend": ConfigField(
+                type=str, default="cosyvoice",
+                description="默认TTS后端 (ai_voice/gsv2p/gpt_sovits/doubao/cosyvoice/comfyui/comfyui_voiceclone/comfyui_customvoice)"
+            ),
+            "timeout": ConfigField(type=int, default=60, description="请求超时时间（秒）"),
+            "max_text_length": ConfigField(
+                type=int, default=200,
+                description="最大文本长度（该限制会在调用LLM时注入到prompt中，让LLM直接生成符合长度的回复，而不是被动截断）"
+            ),
+            "use_replyer_rewrite": ConfigField(
+                type=bool, default=True,
+                description="是否使用replyer润色语音内容"
+            ),
+            "audio_output_dir": ConfigField(
+                type=str, default="",
+                description="音频文件输出目录（支持相对路径和绝对路径，留空使用项目根目录）"
+            ),
+            "use_base64_audio": ConfigField(
+                type=bool, default=True,
+                description="是否使用base64编码发送音频（备选方案）"
+            ),
+            "split_sentences": ConfigField(
+                type=bool, default=True,
+                description="是否分段发送语音（每句话单独发送一条语音，避免长语音播放问题）"
+            ),
+            "split_delay": ConfigField(
+                type=float, default=0.3,
+                description="分段发送时每条语音之间的延迟（秒）"
+            ),
+            "split_min_total_chars": ConfigField(
+                type=int, default=120,
+                description="自动分段启用阈值：文本长度小于该值时不分段（避免短句被切成多段）",
+            ),
+            "split_min_sentence_chars": ConfigField(
+                type=int, default=6,
+                description="句子最小长度：过短片段会合并到前一句（用于减少碎片段）",
+            ),
+            "split_max_segments": ConfigField(
+                type=int, default=3,
+                description="自动分段最大段数（避免刷屏式多段语音）。0 表示不限制。",
+            ),
+            "split_chunk_chars": ConfigField(
+                type=int, default=110,
+                description="自动分段打包目标长度（字符）。用于把多句合并成更少段。",
+            ),
+            "send_error_messages": ConfigField(
+                type=bool, default=True,
+                description="是否发送错误提示消息（关闭后语音合成失败时不会发送错误信息给用户）"
+            )
+        },
+        "components": {
+            "action_enabled": ConfigField(type=bool, default=True, description="是否启用Action组件"),
+            "command_enabled": ConfigField(type=bool, default=True, description="是否启用Command组件"),
+            "instruct_command_enabled": ConfigField(type=bool, default=True, description="是否启用instruct调试命令组件(/tts_instruct)")
+        },
+        "probability": {
+            "enabled": ConfigField(type=bool, default=False, description="是否启用概率控制"),
+            "base_probability": ConfigField(type=float, default=1.0, description="基础触发概率"),
+            "keyword_force_trigger": ConfigField(type=bool, default=True, description="关键词强制触发"),
+            "force_keywords": ConfigField(
+                type=list,
+                default=["一定要用语音", "必须语音", "语音回复我", "务必用语音"],
+                description="强制触发关键词"
+            )
+        },
+        "ai_voice": {
+            "default_character": ConfigField(
+                type=str,
+                default="邻家小妹",
+                description="默认音色（可选：小新、猴哥、四郎、东北老妹儿、广西大表哥、妲己、霸道总裁、酥心御姐、说书先生、憨憨小弟、憨厚老哥、吕布、元气少女、文艺少女、磁性大叔、邻家小妹、低沉男声、傲娇少女、爹系男友、暖心姐姐、温柔妹妹、书香少女）"
+            )
+        },
+        "gsv2p": {
+            "api_url": ConfigField(
+                type=str, default="https://gsv2p.acgnai.top/v1/audio/speech",
+                description="GSV2P API地址"
+            ),
+            "api_token": ConfigField(type=str, default="", description="API认证Token"),
+            "default_voice": ConfigField(type=str, default="原神-中文-派蒙_ZH", description="默认音色"),
+            "timeout": ConfigField(type=int, default=120, description="API请求超时（秒）"),
+            "model": ConfigField(type=str, default="tts-v4", description="TTS模型"),
+            "response_format": ConfigField(type=str, default="wav", description="音频格式"),
+            "speed": ConfigField(type=float, default=1.0, description="语音速度")
+        },
+        "gpt_sovits": {
+            "server": ConfigField(
+                type=str, default="http://127.0.0.1:9880",
+                description="GPT-SoVITS服务地址"
+            ),
+            "styles": ConfigField(
+                type=list,
+                default=[
+                    {
+                        "name": "default",
+                        "refer_wav": "",
+                        "prompt_text": "",
+                        "prompt_language": "zh",
+                        "gpt_weights": "",
+                        "sovits_weights": ""
+                    }
+                ],
+                description="语音风格配置",
+                item_type="object",
+                item_fields={
+                    "name": {"type": "string", "label": "风格名称", "required": True},
+                    "refer_wav": {"type": "string", "label": "参考音频路径", "required": True},
+                    "prompt_text": {"type": "string", "label": "参考文本", "required": True},
+                    "prompt_language": {"type": "string", "label": "参考语言", "default": "zh"},
+                    "gpt_weights": {"type": "string", "label": "GPT模型权重路径（可选）", "required": False},
+                    "sovits_weights": {"type": "string", "label": "SoVITS模型权重路径（可选）", "required": False}
+                }
+            )
+        },
+        "doubao": {
+            "api_url": ConfigField(
+                type=str,
+                default="https://openspeech.bytedance.com/api/v3/tts/unidirectional",
+                description="豆包语音API地址"
+            ),
+            "app_id": ConfigField(type=str, default="", description="豆包APP ID"),
+            "access_key": ConfigField(type=str, default="", description="豆包Access Key"),
+            "resource_id": ConfigField(type=str, default="seed-tts-2.0", description="豆包Resource ID"),
+            "default_voice": ConfigField(
+                type=str, default="zh_female_vv_uranus_bigtts",
+                description="默认音色"
+            ),
+            "timeout": ConfigField(type=int, default=60, description="API请求超时（秒）"),
+            "audio_format": ConfigField(type=str, default="wav", description="音频格式"),
+            "sample_rate": ConfigField(type=int, default=24000, description="采样率"),
+            "bitrate": ConfigField(type=int, default=128000, description="比特率"),
+            "speed": ConfigField(type=float, default=None, description="语音速度（可选）"),
+            "volume": ConfigField(type=float, default=None, description="音量（可选）"),
+            "context_texts": ConfigField(
+                type=list, default=None,
+                description="上下文辅助文本（可选，仅豆包2.0模型）"
+            )
+        },
+        "cosyvoice": {
+            "gradio_url": ConfigField(
+                type=str,
+                default="https://funaudiollm-fun-cosyvoice3-0-5b.ms.show/",
+                description="Gradio API地址"
+            ),
+            "default_mode": ConfigField(
+                type=str,
+                default="3s极速复刻",
+                description="推理模式（3s极速复刻/自然语言控制）"
+            ),
+            "default_instruct": ConfigField(
+                type=str,
+                default="You are a helpful assistant. 请用广东话表达。<|endofprompt|>",
+                description="默认指令（用于自然语言控制模式）"
+            ),
+            "reference_audio": ConfigField(
+                type=str,
+                default="",
+                description="参考音频路径（用于3s极速复刻模式）"
+            ),
+            "prompt_text": ConfigField(
+                type=str,
+                default="",
+                description="提示文本（用于3s极速复刻模式）"
+            ),
+            "timeout": ConfigField(type=int, default=300, description="API请求超时（秒）"),
+            "audio_format": ConfigField(type=str, default="wav", description="音频格式")
+        },
+	        "comfyui": {
+            "server": ConfigField(
+                type=str,
+                default="http://127.0.0.1:8188",
+                description="ComfyUI 服务地址（示例: http://127.0.0.1:8188）",
+            ),
+            "input_dir": ConfigField(
+                type=str,
+                default="/Users/xenon/Downloads/seiun_tts/ComfyUI/ComfyUI/input",
+                description="ComfyUI input 目录（用于放参考音频，LoadAudio 会从这里读）",
+            ),
+            "timeout": ConfigField(type=int, default=120, description="ComfyUI 请求超时（秒）"),
+            "audio_quality": ConfigField(
+                type=str,
+                default="128k",
+                description="输出 MP3 质量（SaveAudioMP3 quality: V0/128k/320k）",
+            ),
+            "mlx_python": ConfigField(
+                type=str,
+                default="/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/.venv/bin/python",
+                description="MLX Qwen3-TTS venv python 路径（用于 ComfyUI-MLX 节点子进程）",
+            ),
+            "mlx_cli": ConfigField(
+                type=str,
+                default="/Users/xenon/Downloads/seiun_tts/qwen3-tts-apple-silicon/mlx_voice_clone_cli.py",
+                description="mlx_voice_clone_cli.py 路径",
+            ),
+	            "default_style": ConfigField(type=str, default="default", description="默认风格名称"),
+	            "voiceclone_default_style": ConfigField(
+	                type=str,
+	                default="",
+	                description="VoiceClone 专用默认风格名称（用于 comfyui_voiceclone 后端；留空则回退到 default_style）",
+	            ),
+	            "customvoice_default_style": ConfigField(
+	                type=str,
+	                default="",
+	                description="CustomVoice 专用默认风格名称（用于 comfyui_customvoice 后端；留空则回退到 default_style）",
+	            ),
+	            "auto_instruct_enabled": ConfigField(
+	                type=bool,
+	                default=False,
+	                description="是否启用 CustomVoice instruct 自动推断（使用 MaiBot 的 LLM 接口）",
+	            ),
+            "auto_instruct_max_chars": ConfigField(
+                type=int,
+                default=120,
+                description="自动推断 instruct 的最大长度（字符）。建议 80-160，太短会导致情绪/表演提示被截断。",
+            ),
+            "auto_instruct_prompt": ConfigField(
+                type=str,
+                default="",
+                description="自定义 instruct 推断 prompt（留空使用内置模板）",
+            ),
+            "auto_instruct_base_tone": ConfigField(
+                type=str,
+                default="",
+                description="自动推断 instruct 时固定附加的基调描述（会作为 `基调=...;` 前缀插入；会自动清洗为单行，且不会包含 `;`/`=`）",
+            ),
+            "pause_linebreak": ConfigField(type=float, default=0.0, description="换行停顿（秒）"),
+            "period_pause": ConfigField(type=float, default=0.0, description="句号停顿（秒）"),
+            "comma_pause": ConfigField(type=float, default=0.0, description="逗号停顿（秒）"),
+            "question_pause": ConfigField(type=float, default=0.0, description="问号停顿（秒）"),
+            "hyphen_pause": ConfigField(type=float, default=0.0, description="连字符停顿（秒）"),
+            "styles": ConfigField(
+                type=list,
+                default=[
+                    {
+                        "name": "default",
+                        "refer_wav": "",
+                        "prompt_text": "",
+                        "language": "",
+                        "model_choice": "1.7B",
+                        "precision": "bf16",
+                        "seed": 0,
+                        "max_new_tokens": 2048,
+                        "top_p": 0.8,
+                        "top_k": 20,
+                        "temperature": 1.0,
+                        "repetition_penalty": 1.05,
+                    }
+                ],
+                description="ComfyUI VoiceClone 风格配置（参考音频+逐字稿）",
+                item_type="object",
+                item_fields={
+                    "name": {"type": "string", "label": "风格名称", "required": True},
+                    "mode": {"type": "string", "label": "模式(voice_clone/custom_voice)", "required": False},
+                    "refer_wav": {"type": "string", "label": "参考音频路径", "required": True},
+                    "prompt_text": {"type": "string", "label": "参考文本(逐字稿)", "required": True},
+                    "language": {"type": "string", "label": "语言(可选: Auto/Chinese/English/...) ", "required": False},
+                    "model_choice": {"type": "string", "label": "模型(0.6B/1.7B)", "required": False},
+                    "precision": {"type": "string", "label": "精度(bf16/fp32)", "required": False},
+                    "model_path": {"type": "string", "label": "CustomVoice模型路径", "required": False},
+                    "speaker": {"type": "string", "label": "CustomVoice说话人", "required": False},
+                    "instruct": {"type": "string", "label": "CustomVoice指令(或__AUTO__)", "required": False},
+                    "auto_instruct": {"type": "boolean", "label": "按style启用auto_instruct", "required": False},
+                    "speed": {"type": "number", "label": "speed", "required": False},
+                    "seed": {"type": "number", "label": "seed", "required": False},
+                    "max_new_tokens": {"type": "number", "label": "max_new_tokens", "required": False},
+                    "top_p": {"type": "number", "label": "top_p", "required": False},
+                    "top_k": {"type": "number", "label": "top_k", "required": False},
+                    "temperature": {"type": "number", "label": "temperature", "required": False},
+                    "repetition_penalty": {"type": "number", "label": "repetition_penalty", "required": False},
+                },
+            ),
+        }
+    }
+
+    def get_plugin_components(self) -> List[Tuple[ComponentInfo, Type]]:
+        """返回插件组件列表"""
+        components = []
+
+        try:
+            action_enabled = self.get_config(ConfigKeys.COMPONENTS_ACTION_ENABLED, True)
+            command_enabled = self.get_config(ConfigKeys.COMPONENTS_COMMAND_ENABLED, True)
+            instruct_enabled = self.get_config(ConfigKeys.COMPONENTS_INSTRUCT_COMMAND_ENABLED, True)
+        except AttributeError:
+            action_enabled = True
+            command_enabled = True
+            instruct_enabled = True
+
+        if action_enabled:
+            components.append((UnifiedTTSAction.get_action_info(), UnifiedTTSAction))
+
+        if command_enabled:
+            components.append((UnifiedTTSCommand.get_command_info(), UnifiedTTSCommand))
+
+        if instruct_enabled:
+            components.append((TTSInstructCommand.get_command_info(), TTSInstructCommand))
+
+        return components
diff --git a/test.wav b/test.wav
new file mode 100644
index 00000000..37550701
Binary files /dev/null and b/test.wav differ
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 00000000..1c0e5cd4
--- /dev/null
+++ b/utils/__init__.py
@@ -0,0 +1,12 @@
+"""
+TTS工具模块
+"""
+
+import sys
+sys.dont_write_bytecode = True
+
+from .text import TTSTextUtils
+from .session import TTSSessionManager
+from .file import TTSFileManager
+
+__all__ = ["TTSTextUtils", "TTSSessionManager", "TTSFileManager"]
diff --git a/utils/file.py b/utils/file.py
new file mode 100644
index 00000000..c56469a6
--- /dev/null
+++ b/utils/file.py
@@ -0,0 +1,280 @@
+"""
+文件操作工具类
+提供异步文件操作、临时文件管理等功能
+"""
+
+import os
+import uuid
+import tempfile
+import asyncio
+import base64
+from typing import Optional
+from src.common.logger import get_logger
+
+logger = get_logger("tts_file_manager")
+
+# 音频数据最小有效大小（字节）
+MIN_AUDIO_SIZE = 100
+
+
+class TTSFileManager:
+    """
+    TTS文件管理器
+
+    提供:
+    - 临时文件创建（避免并发冲突）
+    - 异步文件写入
+    - 自动清理
+    - 相对路径和绝对路径支持
+    """
+
+    # 临时文件目录（兼容旧代码）
+    _temp_dir: Optional[str] = None
+
+    # 项目根目录（用于解析相对路径）
+    _project_root: Optional[str] = None
+
+    @classmethod
+    def set_project_root(cls, root_path: str):
+        """设置项目根目录"""
+        if os.path.isdir(root_path):
+            cls._project_root = root_path
+            logger.debug(f"设置项目根目录: {root_path}")
+        else:
+            logger.warning(f"项目根目录不存在: {root_path}")
+
+    @classmethod
+    def get_project_root(cls) -> str:
+        """获取项目根目录"""
+        if cls._project_root is None:
+            # 尝试从当前文件位置推断项目根目录
+            current_file = os.path.abspath(__file__)
+            # 假设结构是: project_root/plugins/tts_voice_plugin/utils/file.py
+            cls._project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(current_file))))
+            logger.debug(f"自动推断项目根目录: {cls._project_root}")
+        return cls._project_root
+
+    @classmethod
+    def resolve_path(cls, path: str) -> str:
+        """
+        解析路径（支持相对路径和绝对路径）
+
+        Args:
+            path: 路径字符串
+
+        Returns:
+            解析后的绝对路径
+        """
+        if os.path.isabs(path):
+            # 已经是绝对路径
+            return path
+        else:
+            # 相对路径，相对于项目根目录
+            return os.path.join(cls.get_project_root(), path)
+
+    @classmethod
+    def ensure_dir(cls, dir_path: str) -> bool:
+        """
+        确保目录存在，不存在则创建
+
+        Args:
+            dir_path: 目录路径
+
+        Returns:
+            是否成功
+        """
+        try:
+            os.makedirs(dir_path, exist_ok=True)
+            return True
+        except Exception as e:
+            logger.error(f"创建目录失败: {dir_path}, 错误: {e}")
+            return False
+
+    @classmethod
+    def get_temp_dir(cls) -> str:
+        """
+        获取临时文件目录（已废弃，保留兼容性）
+
+        Returns:
+            临时目录路径
+        """
+        if cls._temp_dir is None:
+            cls._temp_dir = tempfile.gettempdir()
+        return cls._temp_dir
+
+    @classmethod
+    def set_temp_dir(cls, path: str):
+        """
+        设置临时文件目录（已废弃，保留兼容性）
+
+        Args:
+            path: 目录路径
+        """
+        if os.path.isdir(path):
+            cls._temp_dir = path
+        else:
+            raise ValueError(f"目录不存在: {path}")
+
+    @classmethod
+    def generate_temp_path(cls, prefix: str = "tts", suffix: str = ".mp3", output_dir: str = "") -> str:
+        """
+        生成唯一的临时文件路径
+
+        Args:
+            prefix: 文件名前缀
+            suffix: 文件扩展名
+            output_dir: 输出目录（支持相对路径和绝对路径，留空使用项目根目录）
+
+        Returns:
+            临时文件的绝对路径
+        """
+        # 确定输出目录
+        if not output_dir:
+            # 默认使用项目根目录
+            resolved_dir = cls.get_project_root()
+        else:
+            # 解析用户配置的路径
+            resolved_dir = cls.resolve_path(output_dir)
+            # 确保目录存在
+            if not cls.ensure_dir(resolved_dir):
+                # 如果创建失败，降级到项目根目录
+                logger.warning(f"无法创建输出目录 {resolved_dir}，使用项目根目录")
+                resolved_dir = cls.get_project_root()
+
+        # 生成唯一文件名
+        unique_id = uuid.uuid4().hex[:12]
+        filename = f"{prefix}_{unique_id}{suffix}"
+        return os.path.join(resolved_dir, filename)
+
+    @classmethod
+    async def write_audio_async(cls, path: str, data: bytes) -> bool:
+        """
+        异步写入音频数据到文件
+
+        Args:
+            path: 文件路径
+            data: 音频二进制数据
+
+        Returns:
+            是否写入成功
+        """
+        try:
+            # 使用线程池执行同步文件写入，避免阻塞事件循环
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, cls._write_file_sync, path, data)
+            logger.debug(f"音频文件写入成功: {path} ({len(data)} bytes)")
+            return True
+        except IOError as e:
+            logger.error(f"写入音频文件失败: {path}, 错误: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"写入音频文件时发生未知错误: {path}, 错误: {e}")
+            return False
+
+    @staticmethod
+    def _write_file_sync(path: str, data: bytes):
+        """同步写入文件（内部方法）"""
+        with open(path, "wb") as f:
+            f.write(data)
+
+    @classmethod
+    def write_audio_sync(cls, path: str, data: bytes) -> bool:
+        """
+        同步写入音频数据到文件
+
+        Args:
+            path: 文件路径
+            data: 音频二进制数据
+
+        Returns:
+            是否写入成功
+        """
+        try:
+            cls._write_file_sync(path, data)
+            logger.debug(f"音频文件写入成功: {path} ({len(data)} bytes)")
+            return True
+        except IOError as e:
+            logger.error(f"写入音频文件失败: {path}, 错误: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"写入音频文件时发生未知错误: {path}, 错误: {e}")
+            return False
+
+    @classmethod
+    def cleanup_file(cls, path: str, silent: bool = True) -> bool:
+        """
+        清理临时文件
+
+        Args:
+            path: 文件路径
+            silent: 是否静默处理错误
+
+        Returns:
+            是否清理成功
+        """
+        try:
+            if path and os.path.exists(path):
+                os.remove(path)
+                logger.debug(f"临时文件已清理: {path}")
+                return True
+            return False
+        except Exception as e:
+            if not silent:
+                logger.warning(f"清理临时文件失败: {path}, 错误: {e}")
+            return False
+
+    @classmethod
+    async def cleanup_file_async(cls, path: str, delay: float = 0) -> bool:
+        """
+        异步清理临时文件（可延迟）
+
+        Args:
+            path: 文件路径
+            delay: 延迟秒数
+
+        Returns:
+            是否清理成功
+        """
+        if delay > 0:
+            await asyncio.sleep(delay)
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, cls.cleanup_file, path, True)
+
+    @classmethod
+    def validate_audio_data(cls, data: bytes, min_size: int = None) -> tuple:
+        """
+        验证音频数据有效性
+
+        Args:
+            data: 音频二进制数据
+            min_size: 最小有效大小
+
+        Returns:
+            (is_valid, error_message)
+        """
+        if data is None:
+            return False, "音频数据为空"
+
+        min_size = min_size or MIN_AUDIO_SIZE
+
+        if len(data) < min_size:
+            return False, f"音频数据过小({len(data)}字节 < {min_size}字节)"
+
+        return True, ""
+
+    @classmethod
+    def audio_to_base64(cls, data: bytes) -> str:
+        """
+        将音频数据转换为base64字符串
+
+        Args:
+            data: 音频二进制数据
+
+        Returns:
+            base64编码的字符串
+        """
+        try:
+            return base64.b64encode(data).decode('utf-8')
+        except Exception as e:
+            logger.error(f"音频数据转base64失败: {e}")
+            return ""
diff --git a/utils/session.py b/utils/session.py
new file mode 100644
index 00000000..8535b04c
--- /dev/null
+++ b/utils/session.py
@@ -0,0 +1,186 @@
+"""
+HTTP Session 管理器
+提供连接池复用，避免每次请求创建新连接
+"""
+
+import asyncio
+import aiohttp
+from typing import Optional, Dict, Any
+from contextlib import asynccontextmanager
+from src.common.logger import get_logger
+
+logger = get_logger("tts_session_manager")
+
+
+class TTSSessionManager:
+    """
+    TTS HTTP Session 管理器
+
+    提供:
+    - 连接池复用
+    - 自动超时管理
+    - 优雅关闭
+    """
+
+    _instance: Optional["TTSSessionManager"] = None
+    _lock = asyncio.Lock()
+
+    def __init__(self):
+        self._sessions: Dict[str, aiohttp.ClientSession] = {}
+        self._default_timeout = 60
+
+    @classmethod
+    async def get_instance(cls) -> "TTSSessionManager":
+        """获取单例实例"""
+        if cls._instance is None:
+            async with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls()
+        return cls._instance
+
+    async def get_session(
+        self,
+        backend_name: str = "default",
+        timeout: int = None
+    ) -> aiohttp.ClientSession:
+        """
+        获取或创建 HTTP Session
+
+        Args:
+            backend_name: 后端名称，用于区分不同的session
+            timeout: 超时时间（秒）
+
+        Returns:
+            aiohttp.ClientSession 实例
+        """
+        if backend_name not in self._sessions or self._sessions[backend_name].closed:
+            timeout_val = timeout or self._default_timeout
+            connector = aiohttp.TCPConnector(
+                limit=10,  # 每个主机最大连接数
+                limit_per_host=5,
+                ttl_dns_cache=300,  # DNS缓存5分钟
+                force_close=True,  # 禁用连接复用，修复GSV2P等API的兼容性问题
+            )
+            self._sessions[backend_name] = aiohttp.ClientSession(
+                connector=connector,
+                timeout=aiohttp.ClientTimeout(total=timeout_val)
+            )
+            logger.debug(f"创建新的HTTP Session: {backend_name}")
+
+        return self._sessions[backend_name]
+
+    async def close_session(self, backend_name: str = None):
+        """
+        关闭指定或所有 Session
+
+        Args:
+            backend_name: 后端名称，为None时关闭所有
+        """
+        if backend_name:
+            if backend_name in self._sessions:
+                await self._sessions[backend_name].close()
+                del self._sessions[backend_name]
+                logger.debug(f"关闭HTTP Session: {backend_name}")
+        else:
+            for name, session in self._sessions.items():
+                if not session.closed:
+                    await session.close()
+                    logger.debug(f"关闭HTTP Session: {name}")
+            self._sessions.clear()
+
+    @asynccontextmanager
+    async def post(
+        self,
+        url: str,
+        json: Dict[str, Any] = None,
+        headers: Dict[str, str] = None,
+        data: Any = None,
+        backend_name: str = "default",
+        timeout: int = None
+    ):
+        """
+        发送POST请求（异步上下文管理器）
+
+        Args:
+            url: 请求URL
+            json: JSON请求体
+            headers: 请求头
+            data: 表单数据
+            backend_name: 后端名称
+            timeout: 超时时间
+
+        Yields:
+            aiohttp.ClientResponse
+
+        Usage:
+            async with session_manager.post(url, json=data) as response:
+                ...
+        """
+        session = await self.get_session(backend_name, timeout)
+
+        # 如果指定了不同的超时时间，创建新的超时对象
+        req_timeout = None
+        if timeout:
+            req_timeout = aiohttp.ClientTimeout(total=timeout)
+
+        response = await session.post(
+            url,
+            json=json,
+            headers=headers,
+            data=data,
+            timeout=req_timeout
+        )
+        try:
+            yield response
+        finally:
+            response.release()
+
+    @asynccontextmanager
+    async def get(
+        self,
+        url: str,
+        headers: Dict[str, str] = None,
+        params: Dict[str, Any] = None,
+        backend_name: str = "default",
+        timeout: int = None
+    ):
+        """
+        发送GET请求（异步上下文管理器）
+
+        Args:
+            url: 请求URL
+            headers: 请求头
+            params: URL参数
+            backend_name: 后端名称
+            timeout: 超时时间
+
+        Yields:
+            aiohttp.ClientResponse
+
+        Usage:
+            async with session_manager.get(url) as response:
+                ...
+        """
+        session = await self.get_session(backend_name, timeout)
+
+        # 如果指定了不同的超时时间，创建新的超时对象
+        req_timeout = None
+        if timeout:
+            req_timeout = aiohttp.ClientTimeout(total=timeout)
+
+        response = await session.get(
+            url,
+            headers=headers,
+            params=params,
+            timeout=req_timeout
+        )
+        try:
+            yield response
+        finally:
+            response.release()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close_session()
diff --git a/utils/text.py b/utils/text.py
new file mode 100644
index 00000000..93524c08
--- /dev/null
+++ b/utils/text.py
@@ -0,0 +1,181 @@
+"""
+文本处理工具类
+"""
+
+import re
+from typing import Optional, List
+
+
+class TTSTextUtils:
+    """TTS文本处理工具类"""
+
+    # 网络用语替换映射
+    NETWORK_SLANG_MAP = {
+        'www': '哈哈哈',
+        'hhh': '哈哈',
+        '233': '哈哈',
+        '666': '厉害',
+        '88': '拜拜',
+        '...': '。',
+        '……': '。'
+    }
+
+    # 需要移除的特殊字符正则
+    SPECIAL_CHAR_PATTERN = re.compile(
+        r'[^\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ffa-zA-Z0-9\s，。！？、；：（）【】"\'.,!?;:()\[\]`-]'
+    )
+
+    # 语言检测正则
+    CHINESE_PATTERN = re.compile(r'[\u4e00-\u9fff]')
+    ENGLISH_PATTERN = re.compile(r'[a-zA-Z]')
+    JAPANESE_PATTERN = re.compile(r'[\u3040-\u309f\u30a0-\u30ff]')
+
+    @classmethod
+    def clean_text(cls, text: str, max_length: int = 500) -> str:
+        """
+        清理文本，移除特殊字符，替换网络用语
+
+        Args:
+            text: 原始文本
+            max_length: 最大长度限制（此参数已不用于硬截断，仅用于参考）
+
+        Returns:
+            清理后的文本（不会硬截断，保留完整内容以便上层决策）
+        """
+        if not text:
+            return ""
+
+        # 注释掉文本清理功能，保留原始格式
+        # 移除不支持的特殊字符
+        # text = cls.SPECIAL_CHAR_PATTERN.sub('', text)
+
+        # 替换常见网络用语
+        # for old, new in cls.NETWORK_SLANG_MAP.items():
+        #     text = text.replace(old, new)
+
+        return text.strip()
+
+    @classmethod
+    def detect_language(cls, text: str) -> str:
+        """
+        检测文本语言
+
+        Args:
+            text: 待检测文本
+
+        Returns:
+            语言代码 (zh/ja/en)
+        """
+        if not text:
+            return "zh"
+
+        chinese_chars = len(cls.CHINESE_PATTERN.findall(text))
+        english_chars = len(cls.ENGLISH_PATTERN.findall(text))
+        japanese_chars = len(cls.JAPANESE_PATTERN.findall(text))
+        total_chars = chinese_chars + english_chars + japanese_chars
+
+        if total_chars == 0:
+            return "zh"
+
+        chinese_ratio = chinese_chars / total_chars
+        japanese_ratio = japanese_chars / total_chars
+        english_ratio = english_chars / total_chars
+
+        if chinese_ratio > 0.3:
+            return "zh"
+        elif japanese_ratio > 0.3:
+            return "ja"
+        elif english_ratio > 0.8:
+            return "en"
+        else:
+            return "zh"
+
+    @classmethod
+    def resolve_voice_alias(
+        cls,
+        voice: Optional[str],
+        alias_map: dict,
+        default: str,
+        prefix: str = ""
+    ) -> str:
+        """
+        解析音色别名
+
+        Args:
+            voice: 用户指定的音色
+            alias_map: 别名映射表
+            default: 默认音色
+            prefix: 内部音色ID前缀（如 "lucy-voice-"）
+
+        Returns:
+            解析后的音色ID
+        """
+        if not voice:
+            voice = default
+
+        # 如果已经是内部ID格式，直接返回
+        if prefix and voice.startswith(prefix):
+            return voice
+
+        # 尝试从别名映射查找
+        if voice in alias_map:
+            return alias_map[voice]
+
+        # 尝试使用默认值的别名
+        if default in alias_map:
+            return alias_map[default]
+
+        return default
+
+    @classmethod
+    def split_sentences(cls, text: str, min_length: int = 2) -> List[str]:
+        """
+        将文本分割成句子
+
+        Args:
+            text: 待分割文本
+            min_length: 最小句子长度，过短的句子会合并到前一句
+
+        Returns:
+            句子列表
+        """
+        if not text:
+            return []
+
+        # 使用中英文标点分割
+        # 保留分隔符以便后续处理
+        pattern = r'([。！？!?；;])'
+        parts = re.split(pattern, text)
+
+        sentences = []
+        current = ""
+
+        for i, part in enumerate(parts):
+            if not part:
+                continue
+
+            # 如果是标点符号，附加到当前句子
+            if re.match(pattern, part):
+                current += part
+            else:
+                # 如果当前句子不为空，先保存
+                if current.strip():
+                    sentences.append(current.strip())
+                current = part
+
+        # 处理最后一段
+        if current.strip():
+            sentences.append(current.strip())
+
+        # 合并过短的句子
+        if min_length > 0 and len(sentences) > 1:
+            merged = []
+            for sent in sentences:
+                if merged and len(sent) < min_length:
+                    # 合并到前一句
+                    merged[-1] += sent
+                else:
+                    merged.append(sent)
+            sentences = merged
+
+        return sentences