Switch to kiro-rs (Rust) - build from source

.dockerignore

@@ -1,21 +0,0 @@
-node_modules
-npm-debug.log
-.git
-.gitignore
-Dockerfile
-.dockerignore
-.nyc_output
-coverage
-.nyc_output
-.coverage
-.env
-.env.local
-.env.*.local
-credentials.json
-*.md
-LICENSE
-jest.config.js
-babel.config.js
-tests/
-run-tests.js
-test-summary.js

Dockerfile

@@ -1,21 +1,27 @@
-FROM node:20-alpine
-
-RUN apk add --no-cache tar git procps
-
+# ── Stage 1: Build Admin UI ──
+FROM node:22-alpine AS frontend-builder
+RUN apk add --no-cache git
+RUN git clone --depth 1 https://github.com/hank9999/kiro.rs.git /app
+WORKDIR /app/admin-ui
+RUN npm install -g pnpm && pnpm install && pnpm build
+
+# ── Stage 2: Build Rust Binary ──
+FROM rust:1.82-alpine AS builder
+RUN apk add --no-cache musl-dev openssl-dev openssl-libs-static git
+RUN git clone --depth 1 https://github.com/hank9999/kiro.rs.git /app
+COPY --from=frontend-builder /app/admin-ui/dist /app/admin-ui/dist
 WORKDIR /app
+RUN cargo build --release
 
-COPY package*.json ./
-RUN npm install --omit=dev
-
-COPY . .
-
-# Create directories
-RUN mkdir -p /app/logs /app/configs
+# ── Stage 3: Runtime ──
+FROM alpine:3.21
+RUN apk add --no-cache ca-certificates
+WORKDIR /app
+COPY --from=builder /app/target/release/kiro-rs /app/kiro-rs
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
 
-# HuggingFace Spaces requires port 7860
 EXPOSE 7860
+VOLUME ["/app/config"]
 
-HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
-  CMD node healthcheck.js || exit 1
-
-CMD ["node", "src/core/master.js", "--port", "7860"]
+ENTRYPOINT ["/app/entrypoint.sh"]

LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 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 General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is 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.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  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.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  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 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. Use with the GNU Affero General Public License.
-
-  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 Affero 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 special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU 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 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 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 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 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 General Public License for more details.
-
-    You should have received a copy of the GNU 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 the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  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 GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,13 +1,8 @@
 ---
-title: kiro2api
-emoji: 🔌
+title: Kiro API Proxy
+emoji: 🔑
 colorFrom: blue
-colorTo: purple
+colorTo: indigo
 sdk: docker
-pinned: false
 app_port: 7860
 ---
-
-# kiro2api
-
-OpenAI/Anthropic-compatible API proxy for Kiro (Amazon Q Developer) powered by [aiclient-2-api](https://github.com/justlovemaki/aiclient-2-api).

VERSION

@@ -1 +0,0 @@
-2.11.5.2

configs/api-potluck-data.json.example

@@ -1,29 +0,0 @@
-{
-  "config": {
-    "defaultDailyLimit": 500,
-    "bonusPerCredential": 300,
-    "bonusValidityDays": 30,
-    "persistInterval": 5000
-  },
-  "users": {
-    "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
-      "credentials": [
-        {
-          "id": "cred_0000000000000_xxxxxx",
-          "path": "configs/kiro/example_kiro-auth-token/example_kiro-auth-token.json",
-          "provider": "claude-kiro-oauth",
-          "authMethod": "refresh-token",
-          "addedAt": "2026-01-01T00:00:00.000Z"
-        }
-      ],
-      "credentialBonuses": [
-        {
-          "credentialId": "cred_0000000000000_xxxxxx",
-          "grantedAt": "2026-01-01T00:00:00.000Z",
-          "usedCount": 0
-        }
-      ],
-      "createdAt": "2026-01-01T00:00:00.000Z"
-    }
-  }
-}

configs/api-potluck-keys.json.example

@@ -1,16 +0,0 @@
-{
-  "keys": {
-    "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx": {
-      "id": "maki_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      "name": "示例用户",
-      "createdAt": "2026-01-01T00:00:00.000Z",
-      "dailyLimit": 500,
-      "todayUsage": 0,
-      "totalUsage": 0,
-      "lastResetDate": "2026-01-01",
-      "lastUsedAt": null,
-      "enabled": true,
-      "bonusRemaining": 0
-    }
-  }
-}

configs/config.json

@@ -1,30 +0,0 @@
-{
-    "REQUIRED_API_KEY": "sk-kiro2api",
-    "SERVER_PORT": 7860,
-    "HOST": "0.0.0.0",
-    "MODEL_PROVIDER": "claude-kiro-oauth",
-    "SYSTEM_PROMPT_FILE_PATH": "",
-    "SYSTEM_PROMPT_MODE": "overwrite",
-    "PROMPT_LOG_BASE_NAME": "prompt_log",
-    "PROMPT_LOG_MODE": "none",
-    "REQUEST_MAX_RETRIES": 3,
-    "REQUEST_BASE_DELAY": 1000,
-    "CRON_NEAR_MINUTES": 1,
-    "CRON_REFRESH_TOKEN": true,
-    "PROVIDER_POOLS_FILE_PATH": "configs/provider_pools.json",
-    "MAX_ERROR_COUNT": 3,
-    "providerFallbackChain": {},
-    "modelFallbackMapping": {},
-    "PROXY_URL": null,
-    "PROXY_ENABLED_PROVIDERS": [],
-    "LOG_ENABLED": true,
-    "LOG_OUTPUT_MODE": "all",
-    "LOG_LEVEL": "info",
-    "LOG_DIR": "logs",
-    "LOG_INCLUDE_REQUEST_ID": true,
-    "LOG_INCLUDE_TIMESTAMP": true,
-    "LOG_MAX_FILE_SIZE": 10485760,
-    "LOG_MAX_FILES": 5,
-    "TLS_SIDECAR_ENABLED": false,
-    "TLS_SIDECAR_PORT": 9090
-}

configs/config.json.example

@@ -1,63 +0,0 @@
-{
-    "REQUIRED_API_KEY": "123456",
-    "SERVER_PORT": 3000,
-    "HOST": "0.0.0.0",
-    "MODEL_PROVIDER": "gemini-cli-oauth",
-    "SYSTEM_PROMPT_FILE_PATH": "configs/input_system_prompt.txt",
-    "SYSTEM_PROMPT_MODE": "overwrite",
-    "PROMPT_LOG_BASE_NAME": "prompt_log",
-    "PROMPT_LOG_MODE": "none",
-    "REQUEST_MAX_RETRIES": 3,
-    "REQUEST_BASE_DELAY": 1000,
-    "CRON_NEAR_MINUTES": 1,
-    "CRON_REFRESH_TOKEN": false,
-    "PROVIDER_POOLS_FILE_PATH": "configs/provider_pools.json",
-    "MAX_ERROR_COUNT": 3,
-    "GROK_COOKIE_TOKEN": "your-sso-cookie-token",
-    "GROK_CF_CLEARANCE": "your-cf-clearance-cookie",
-    "GROK_USER_AGENT": "Mozilla/5.0 ...",
-    "GROK_BASE_URL": "https://grok.com",
-    "providerFallbackChain": {
-      "gemini-cli-oauth": ["gemini-antigravity"],
-      "gemini-antigravity": ["gemini-cli-oauth"],
-      "claude-kiro-oauth": ["claude-custom"],
-      "claude-custom": ["claude-kiro-oauth"]
-    },
-    "modelFallbackMapping": {
-      "gemini-claude-opus-4-5-thinking": {
-        "targetProviderType": "claude-kiro-oauth",
-        "targetModel": "claude-opus-4-5"
-      },
-      "gemini-claude-sonnet-4-5-thinking": {
-        "targetProviderType": "claude-kiro-oauth", 
-        "targetModel": "claude-sonnet-4-5"
-      },
-      "gemini-claude-sonnet-4-5": {
-        "targetProviderType": "claude-kiro-oauth",
-        "targetModel": "claude-sonnet-4-5"
-      },
-      "claude-opus-4-5": {
-        "targetProviderType": "gemini-antigravity",
-        "targetModel": "gemini-claude-opus-4-5-thinking"
-      },
-      "claude-sonnet-4-5": {
-        "targetProviderType": "gemini-antigravity",
-        "targetModel": "gemini-claude-sonnet-4-5"
-      }
-    },
-    "PROXY_URL": "http://127.0.0.1:1089",
-    "PROXY_ENABLED_PROVIDERS": [
-            "gemini-cli-oauth",
-            "gemini-antigravity"
-    ],
-    "LOG_ENABLED": true,
-    "LOG_OUTPUT_MODE": "all",
-    "LOG_LEVEL": "info",
-    "LOG_DIR": "logs",
-    "LOG_INCLUDE_REQUEST_ID": true,
-    "LOG_INCLUDE_TIMESTAMP": true,
-    "LOG_MAX_FILE_SIZE": 10485760,
-    "LOG_MAX_FILES": 10,
-    "TLS_SIDECAR_ENABLED": false,
-    "TLS_SIDECAR_PORT": 9090
-}

configs/kiro/chatgpt_account1_kiro-auth-token/chatgpt_account1_kiro-auth-token.json

@@ -1,9 +0,0 @@
-{
-  "accessToken": "aoaAAAAAGm84HYPHOFvOn_ATRhHeZMUuLcDZDbu_-hQrPp473ye8B5xlec8-gRa79ZftJpCSeNkJALBNwDuVc7wAkBkc0:MGUCMQDjWbPSbPmIX4c+42/YduE1MW3xBKwG4r32W2DCk8BYCBwvD638JC+R3VG4KYdWAE0CMGHsWX+omV0sLGLmX/jmmXOG1rzzXy81I///G7jJE2iYy4rPYXFwM/4Tujjufozm8A",
-  "refreshToken": "aorAAAAAGozeWAnmIAixMWulOIdkLKdTGAv5fe87WhdVZEfvvM7pWbuZLdqc2SaUFCrxxRm6MTp9Vm40nBH1nfrgwBkc0:MGQCMFN2i+2A0Ol6PaQ+7poIrguBIFxilhiO73eD/iMpgNADCXzc6eLmLurejfvf6yZ8GQIwY7EnLvAmpIlmR7FW2uhxC/6vLQoHHYnRJkx23sC8aqA+X03j24cDmXyxwlR5azIk",
-  "clientId": "gabI3snTPwTQZGF1TzuWc3VzLWVhc3QtMQ",
-  "clientSecret": "eyJraWQiOiJrZXktMTU2NDAyODA5OSIsImFsZyI6IkhTMzg0In0.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.gsmsFkKFajDcDb4-c31lLTGxYQIqHKTzgZvwB4Wfta0xuDBNw0gzThEXSDZlqP6q",
-  "authMethod": "builder-id",
-  "idcRegion": "us-east-1",
-  "expiresAt": "2026-03-20T06:00:00Z"
-}

configs/kiro/chatgpt_account2_kiro-auth-token/chatgpt_account2_kiro-auth-token.json

@@ -1,9 +0,0 @@
-{
-  "accessToken": "aoaAAAAAGm84HYLp9bxse52TpenBsslXdOVeCse0scBl5EXeX46G47SUJ7cg1Ok2VFQ8uNIg41dAzJ0NV9z7lWvmYBkc0:MGQCMC7JUwaYATAtN9fqgYsXBA7ajXJd0SuVa5jdmpHZ1b+unFh71kJdXsRs4Rs3VIQ+MwIwcCL2gGDRXPli8wGzvlgrtNti8orkDFfkqHkH7pyHJLoDu1bYq7iefaHErMY8kAlZ",
-  "refreshToken": "aorAAAAAGozeWIYaVvTd3pwQl7-_GyGoAvrkgXW5puoFCn1Ck_kxYwNi2Yswz3Z2NaTSkfpP5LpQDYVCu6Yw43oYwBkc0:MGUCMCIe9f1tl2C3QXQda5IdFeBpJPHcReZIr3Zt8bms2hLijzdTtVfzsKQT7a0q9Sq/JAIxAMAmLFxl6kOqqPNfbWVy5dunHn+9+K3O/OXT/lk+1LjOWT1fNkY/+thpKYHM16bVzw",
-  "clientId": "1LFoSWRMsTHl8MdMQKrMM3VzLWVhc3QtMQ",
-  "clientSecret": "eyJraWQiOiJrZXktMTU2NDAyODA5OSIsImFsZyI6IkhTMzg0In0.eyJzZXJpYWxpemVkIjoie1wiY2xpZW50SWRcIjp7XCJ2YWx1ZVwiOlwiMUxGb1NXUk1zVEhsOE1kTVFLck1NM1Z6TFdWaGMzUXRNUVwifSxcImlkZW1wb3RlbnRLZXlcIjpudWxsLFwidGVuYW50SWRcIjpudWxsLFwiY2xpZW50TmFtZVwiOlwiQW1hem9uIFEgRGV2ZWxvcGVyIGZvciBjb21tYW5kIGxpbmVcIixcImJhY2tmaWxsVmVyc2lvblwiOm51bGwsXCJjbGllbnRUeXBlXCI6XCJQVUJMSUNcIixcInRlbXBsYXRlQXJuXCI6bnVsbCxcInRlbXBsYXRlQ29udGV4dFwiOm51bGwsXCJleHBpcmF0aW9uVGltZXN0YW1wXCI6MTc4MTc1ODMxMS4zNjI2MDY5NTMsXCJjcmVhdGVkVGltZXN0YW1wXCI6MTc3Mzk4MjMxMS4zNjI2MDY5NTMsXCJ1cGRhdGVkVGltZXN0YW1wXCI6MTc3Mzk4MjMxMS4zNjI2MDY5NTMsXCJjcmVhdGVkQnlcIjpudWxsLFwidXBkYXRlZEJ5XCI6bnVsbCxcInN0YXR1c1wiOm51bGwsXCJpbml0aWF0ZUxvZ2luVXJpXCI6bnVsbCxcImVudGl0bGVkUmVzb3VyY2VJZFwiOm51bGwsXCJlbnRpdGxlZFJlc291cmNlQ29udGFpbmVySWRcIjpudWxsLFwiZXh0ZXJuYWxJZFwiOm51bGwsXCJzb2Z0d2FyZUlkXCI6bnVsbCxcInNjb3Blc1wiOlt7XCJmdWxsU2NvcGVcIjpcImNvZGV3aGlzcGVyZXI6Y29tcGxldGlvbnNcIixcInN0YXR1c1wiOlwiSU5JVElBTFwiLFwiYXBwbGljYXRpb25Bcm5cIjpudWxsLFwiZnJpZW5kbHlJZFwiOlwiY29kZXdoaXNwZXJlclwiLFwidXNlQ2FzZUFjdGlvblwiOlwiY29tcGxldGlvbnNcIixcInNjb3BlVHlwZVwiOlwiQUNDRVNTX1NDT1BFXCIsXCJ0eXBlXCI6XCJJbW11dGFibGVBY2Nlc3NTY29wZVwifSx7XCJmdWxsU2NvcGVcIjpcImNvZGV3aGlzcGVyZXI6YW5hbHlzaXNcIixcInN0YXR1c1wiOlwiSU5JVElBTFwiLFwiYXBwbGljYXRpb25Bcm5cIjpudWxsLFwiZnJpZW5kbHlJZFwiOlwiY29kZXdoaXNwZXJlclwiLFwidXNlQ2FzZUFjdGlvblwiOlwiYW5hbHlzaXNcIixcInNjb3BlVHlwZVwiOlwiQUNDRVNTX1NDT1BFXCIsXCJ0eXBlXCI6XCJJbW11dGFibGVBY2Nlc3NTY29wZVwifSx7XCJmdWxsU2NvcGVcIjpcImNvZGV3aGlzcGVyZXI6Y29udmVyc2F0aW9uc1wiLFwic3RhdHVzXCI6XCJJTklUSUFMXCIsXCJhcHBsaWNhdGlvbkFyblwiOm51bGwsXCJmcmllbmRseUlkXCI6XCJjb2Rld2hpc3BlcmVyXCIsXCJ1c2VDYXNlQWN0aW9uXCI6XCJjb252ZXJzYXRpb25zXCIsXCJzY29wZVR5cGVcIjpcIkFDQ0VTU19TQ09QRVwiLFwidHlwZVwiOlwiSW1tdXRhYmxlQWNjZXNzU2NvcGVcIn1dLFwiYXV0aGVudGljYXRpb25Db25maWd1cmF0aW9uXCI6bnVsbCxcInNoYWRvd0F1dGhlbnRpY2F0aW9uQ29uZmlndXJhdGlvblwiOm51bGwsXCJlbmFibGVkR3JhbnRzXCI6bnVsbCxcImVuZm9yY2VBdXRoTkNvbmZpZ3VyYXRpb25cIjpudWxsLFwib3duZXJBY2NvdW50SWRcIjpudWxsLFwic3NvSW5zdGFuY2VBY2NvdW50SWRcIjpudWxsLFwidXNlckNvbnNlbnRcIjpudWxsLFwibm9uSW50ZXJhY3RpdmVTZXNzaW9uc0VuYWJsZWRcIjpudWxsLFwiYXNzb2NpYXRlZEluc3RhbmNlQXJuXCI6bnVsbCxcInNob3VsZEdldFZhbHVlRnJvbVRlbXBsYXRlXCI6dHJ1ZSxcImhhc1JlcXVlc3RlZFNjb3Blc1wiOmZhbHNlLFwiY29udGFpbnNPbmx5U3NvU2NvcGVzXCI6ZmFsc2UsXCJzc29TY29wZXNcIjpbXSxcImlzVjFCYWNrZmlsbGVkXCI6ZmFsc2UsXCJpc1YyQmFja2ZpbGxlZFwiOmZhbHNlLFwiaXNWM0JhY2tmaWxsZWRcIjpmYWxzZSxcImlzVjRCYWNrZmlsbGVkXCI6ZmFsc2UsXCJncm91cFNjb3Blc0J5RnJpZW5kbHlJZFwiOntcImNvZGV3aGlzcGVyZXJcIjpbe1wiZnVsbFNjb3BlXCI6XCJjb2Rld2hpc3BlcmVyOmFuYWx5c2lzXCIsXCJzdGF0dXNcIjpcIklOSVRJQUxcIixcImFwcGxpY2F0aW9uQXJuXCI6bnVsbCxcImZyaWVuZGx5SWRcIjpcImNvZGV3aGlzcGVyZXJcIixcInVzZUNhc2VBY3Rpb25cIjpcImFuYWx5c2lzXCIsXCJzY29wZVR5cGVcIjpcIkFDQ0VTU19TQ09QRVwiLFwidHlwZVwiOlwiSW1tdXRhYmxlQWNjZXNzU2NvcGVcIn0se1wiZnVsbFNjb3BlXCI6XCJjb2Rld2hpc3BlcmVyOmNvbnZlcnNhdGlvbnNcIixcInN0YXR1c1wiOlwiSU5JVElBTFwiLFwiYXBwbGljYXRpb25Bcm5cIjpudWxsLFwiZnJpZW5kbHlJZFwiOlwiY29kZXdoaXNwZXJlclwiLFwidXNlQ2FzZUFjdGlvblwiOlwiY29udmVyc2F0aW9uc1wiLFwic2NvcGVUeXBlXCI6XCJBQ0NFU1NfU0NPUEVcIixcInR5cGVcIjpcIkltbXV0YWJsZUFjY2Vzc1Njb3BlXCJ9LHtcImZ1bGxTY29wZVwiOlwiY29kZXdoaXNwZXJlcjpjb21wbGV0aW9uc1wiLFwic3RhdHVzXCI6XCJJTklUSUFMXCIsXCJhcHBsaWNhdGlvbkFyblwiOm51bGwsXCJmcmllbmRseUlkXCI6XCJjb2Rld2hpc3BlcmVyXCIsXCJ1c2VDYXNlQWN0aW9uXCI6XCJjb21wbGV0aW9uc1wiLFwic2NvcGVUeXBlXCI6XCJBQ0NFU1NfU0NPUEVcIixcInR5cGVcIjpcIkltbXV0YWJsZUFjY2Vzc1Njb3BlXCJ9XX0sXCJpc0V4cGlyZWRcIjpmYWxzZSxcImlzQmFja2ZpbGxlZFwiOmZhbHNlLFwiaGFzSW5pdGlhbFNjb3Blc1wiOnRydWUsXCJhcmVBbGxTY29wZXNDb25zZW50ZWRUb1wiOmZhbHNlfSJ9.ZFTKp-PJaA7vKXI3UiBkqbnO-CvjX2kJw75UUIraS04b8HveyUsInBDcc40yKKf1",
-  "authMethod": "builder-id",
-  "idcRegion": "us-east-1",
-  "expiresAt": "2026-03-20T06:00:00Z"
-}

configs/kiro/fresh1_kiro-auth-token/fresh1_kiro-auth-token.json

@@ -1,9 +0,0 @@
-{
-  "accessToken": "aoaAAAAAGm8epsqQIJk5Bj1QoXwTAMGHRMumJWCVJ13MJODTLwCdljXWm-8jmbsXAghY3niBcLEuNr9xTljmhrN-oBkc0:MGUCMQCH/mlgYPdL1PfKCnU1eSRf5NEMyhPCW/2+Y8K2bFmMH2gMFAE6ftTRveCFSe+kTjQCMC/u4EdVSdTr9Bui6OsE280xUPAH7CSDCIHNTTPk2CiYbVtge/oYlRxVoNQizk1AMQ",
-  "refreshToken": "aorAAAAAGozE4YEfji2Ny6mvPuscUKbyPuUc2XD3Nf7SdFbQcE1Z2qoUOR-gZI8cUKubWvDXOivKqghUnyZOMXp7sBkc0:MGQCMCrPdIeyBVkVlB0rtjlIvHhlPURSovG8mcs9qmDBx1VYH5LPdcWvQd74O3XFYCGMfwIwIESOUIiPVFFAMKs+N1YgEoe13glxpAP7Ri0memy2/WdqY0cFEFNqMq/CndDx0dbJ",
-  "clientId": "H6JYDDvxcMALs2QKZfIKgHVzLWVhc3QtMQ",
-  "clientSecret": "eyJraWQiOiJrZXktMTU2NDAyODA5OSIsImFsZyI6IkhTMzg0In0.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.57MdZkhyW6vz98g6JDcRSqh1c8z1Ta1eyH6d9YbsW3TUTrfJ6WxobBzkaP69aK4r",
-  "authMethod": "builder-id",
-  "idcRegion": "us-east-1",
-  "expiresAt": "2026-03-20T07:00:00Z"
-}

configs/kiro/personal_kiro-auth-token/personal_kiro-auth-token.json

@@ -1,7 +0,0 @@
-{
-  "accessToken": "aoaAAAAAGm82R4v3zSqMlkmiPwSHdKAAQAbZ6yu4TywrlVXmFU7XMVtQQb3phAA-gOci2L0S62LjsBj-9NFLMeQPMBkc0:MGUCMQDT2c8RFXspAv/U52k+YkcOeYIge/+GA+axl/jxo48IfcXYRM2RnclaR816zx0v/rkCMGEoQS1GOAZAZN7pUJzu5xgYKo62NwzNNNoUEyyGcPwujYtWRQFbNKgAvlL0O7VFGg",
-  "refreshToken": "",
-  "authMethod": "social",
-  "region": "us-east-1",
-  "expiresAt": "2026-03-20T06:00:00Z"
-}

configs/plugins.json

@@ -1,6 +0,0 @@
-{
-    "plugins": {
-        "api-potluck": {"enabled": false},
-        "default-auth": {"enabled": true}
-    }
-}

configs/plugins.json.example

@@ -1,12 +0,0 @@
-{
-  "plugins": {
-    "api-potluck": {
-      "enabled": false,
-      "description": "API 大锅饭 - Key 管理和用量统计插件"
-    },
-    "default-auth": {
-      "enabled": true,
-      "description": "默认 API Key 认证插件（内置）"
-    }
-  }
-}

configs/provider_pools.json

@@ -1,43 +0,0 @@
-{
-  "claude-kiro-oauth": [
-    {
-      "customName": "Personal Account (cs.shenhao)",
-      "KIRO_OAUTH_CREDS_FILE_PATH": "configs/kiro/personal_kiro-auth-token/personal_kiro-auth-token.json",
-      "uuid": "personal-0000-4000-a000-000000000000",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "ChatGPT Mail Account 1 (kr63b7278504@prestige-leadership.org)",
-      "KIRO_OAUTH_CREDS_FILE_PATH": "configs/kiro/chatgpt_account1_kiro-auth-token/chatgpt_account1_kiro-auth-token.json",
-      "uuid": "chatgpt-0001-4000-a000-000000000001",
-      "checkModelName": null,
-      "checkHealth": true,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "ChatGPT Mail Account 2 (kr0a92d5ad15@mailsa.biz.id)",
-      "KIRO_OAUTH_CREDS_FILE_PATH": "configs/kiro/chatgpt_account2_kiro-auth-token/chatgpt_account2_kiro-auth-token.json",
-      "uuid": "chatgpt-0002-4000-a000-000000000002",
-      "checkModelName": null,
-      "checkHealth": true,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ]
-}

configs/provider_pools.json.example

@@ -1,213 +0,0 @@
-{
-  "openai-custom": [
-    {
-      "customName": "OpenAI节点1",
-      "OPENAI_API_KEY": "sk-openai-key1",
-      "OPENAI_BASE_URL": "https://api.openai.com/v1",
-      "checkModelName": null,
-      "checkHealth": false,
-      "notSupportedModels": ["gpt-4-turbo"],
-      "uuid": "2f579c65-d3c5-41b1-9985-9f6e3d7bf39c",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "OpenAI节点2",
-      "OPENAI_API_KEY": "sk-openai-key2",
-      "OPENAI_BASE_URL": "https://api.openai.com/v1",
-      "checkModelName": null,
-      "checkHealth": false,
-      "notSupportedModels": ["gpt-4-turbo", "gpt-4"],
-      "uuid": "e284628d-302f-456d-91f3-6095386fb3b8",
-      "isHealthy": true,
-      "isDisabled": true,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "openaiResponses-custom": [
-    {
-      "customName": "OpenAI Responses节点",
-      "OPENAI_API_KEY": "sk-openai-key",
-      "OPENAI_BASE_URL": "https://api.openai.com/v1",
-      "checkModelName": null,
-      "checkHealth": false,
-      "uuid": "e284628d-302f-456d-91f3-609538678968",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "gemini-cli-oauth": [
-    {
-      "customName": "Gemini OAuth节点1",
-      "GEMINI_OAUTH_CREDS_FILE_PATH": "./credentials1.json",
-      "PROJECT_ID": "your-project-id-1",
-      "checkModelName": null,
-      "checkHealth": false,
-      "uuid": "ac200154-26b8-4f5f-8650-e8cc738b06e3",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "Gemini OAuth节点2",
-      "GEMINI_OAUTH_CREDS_FILE_PATH": "./credentials2.json",
-      "PROJECT_ID": "your-project-id-2",
-      "checkModelName": null,
-      "checkHealth": false,
-      "uuid": "4f8afcc2-a9bb-4b96-bb50-3b9667a71f54",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "claude-custom": [
-    {
-      "customName": "Claude节点1",
-      "CLAUDE_API_KEY": "sk-claude-key1",
-      "CLAUDE_BASE_URL": "https://api.anthropic.com",
-      "checkModelName": null,
-      "checkHealth": false,
-      "uuid": "bb87047a-3b1d-4249-adbb-1087ecd58128",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "Claude节点2",
-      "CLAUDE_API_KEY": "sk-claude-key2",
-      "CLAUDE_BASE_URL": "https://api.anthropic.com",
-      "checkModelName": null,
-      "checkHealth": false,
-      "uuid": "7c2002c6-122a-4db0-af06-8a0ff433801a",
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "claude-kiro-oauth": [
-    {
-      "customName": "Kiro OAuth节点1",
-      "KIRO_OAUTH_CREDS_FILE_PATH": "./kiro_creds1.json",
-      "uuid": "2c69d0ac-b86f-43d8-9d17-0d300afc5cfd",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "Kiro OAuth节点2",
-      "KIRO_OAUTH_CREDS_FILE_PATH": "./kiro_creds2.json",
-      "uuid": "7482abe6-8083-4288-bb7d-d8ecb7c461e2",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "openai-qwen-oauth": [
-    {
-      "customName": "Qwen OAuth节点",
-      "QWEN_OAUTH_CREDS_FILE_PATH": "./qwen_creds.json",
-      "uuid": "658a2114-c4c9-d713-b8d4-ceabf0e0bf18",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "gemini-antigravity": [
-    {
-      "customName": "Antigravity节点1",
-      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "./antigravity_creds1.json",
-      "PROJECT_ID": "antigravity-project-1",
-      "uuid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "Antigravity节点2",
-      "ANTIGRAVITY_OAUTH_CREDS_FILE_PATH": "./antigravity_creds2.json",
-      "PROJECT_ID": "antigravity-project-2",
-      "uuid": "f0e9d8c7-b6a5-4321-fedc-ba9876543210",
-      "checkModelName": null,
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ],
-  "openai-iflow": [
-    {
-      "customName": "iFlow Token节点1",
-      "IFLOW_TOKEN_FILE_PATH": "./configs/iflow/iflow_token.json",
-      "IFLOW_BASE_URL": "https://apis.iflow.cn/v1",
-      "uuid": "11223344-5566-7788-99aa-bbccddeeff00",
-      "checkModelName": "gpt-4o",
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    },
-    {
-      "customName": "iFlow Token节点2",
-      "IFLOW_TOKEN_FILE_PATH": "./configs/iflow/iflow_token2.json",
-      "IFLOW_BASE_URL": "https://apis.iflow.cn/v1",
-      "uuid": "aabbccdd-eeff-0011-2233-445566778899",
-      "checkModelName": "gpt-4o",
-      "checkHealth": false,
-      "isHealthy": true,
-      "isDisabled": false,
-      "lastUsed": null,
-      "usageCount": 0,
-      "errorCount": 0,
-      "lastErrorTime": null
-    }
-  ]
-}

configs/pwd

@@ -1 +0,0 @@
-kiro2024

entrypoint.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+set -e
+
+CONFIG_DIR="/app/config"
+mkdir -p "${CONFIG_DIR}"
+
+API_KEY="${API_KEY:-sk-kiro2api}"
+ADMIN_API_KEY="${ADMIN_API_KEY:-sk-admin-kiro2api}"
+PROXY="${HTTPS_PROXY:-${ALL_PROXY:-}}"
+
+cat > "${CONFIG_DIR}/config.json" <<EOF
+{
+  "host": "0.0.0.0",
+  "port": 7860,
+  "apiKey": "${API_KEY}",
+  "adminApiKey": "${ADMIN_API_KEY}",
+  "region": "us-east-1",
+  "tlsBackend": "rustls",
+  "proxyUrl": "${PROXY}",
+  "loadBalancingMode": "balanced"
+}
+EOF
+
+# Empty credentials array — populated via admin API sync
+echo "[]" > "${CONFIG_DIR}/credentials.json"
+
+echo "Config generated (port=7860, proxy=${PROXY:+set}${PROXY:-none})"
+exec ./kiro-rs -c "${CONFIG_DIR}/config.json" --credentials "${CONFIG_DIR}/credentials.json"

healthcheck.js

@@ -1,46 +0,0 @@
-/**
- * Docker健康检查脚本
- * 用于检查API服务器是否正常运行
- */
-
-import http from 'http';
-
-// 从环境变量获取主机和端口，如果没有设置则使用默认值
-const HOST = process.env.HOST || 'localhost';
-const PORT = process.env.SERVER_PORT || 3000;
-
-// 发送HTTP请求到健康检查端点
-const options = {
-  hostname: HOST,
-  port: PORT,
-  path: '/health',
-  method: 'GET',
-  timeout: 2000 // 2秒超时
-};
-
-const req = http.request(options, (res) => {
-  // 如果状态码是200，表示服务健康
-  if (res.statusCode === 200) {
-    console.log('Health check passed');
-    process.exit(0);
-  } else {
-    console.log(`Health check failed with status code: ${res.statusCode}`);
-    process.exit(1);
-  }
-});
-
-// 处理请求错误
-req.on('error', (e) => {
-  console.error(`Health check failed: ${e.message}`);
-  process.exit(1);
-});
-
-// 设置超时处理
-req.on('timeout', () => {
-  console.error('Health check timed out');
-  req.destroy();
-  process.exit(1);
-});
-
-// 结束请求
-req.end();

package.json

@@ -1,42 +0,0 @@
-{
-  "type": "module",
-  "dependencies": {
-    "@anthropic-ai/tokenizer": "^0.0.4",
-    "adm-zip": "^0.5.16",
-    "axios": "^1.10.0",
-    "deepmerge": "^4.3.1",
-    "dotenv": "^16.4.5",
-    "google-auth-library": "^10.1.0",
-    "http-proxy-agent": "^7.0.2",
-    "https-proxy-agent": "^7.0.6",
-    "lodash": "^4.17.21",
-    "multer": "^2.0.2",
-    "open": "^10.2.0",
-    "socks-proxy-agent": "^8.0.5",
-    "undici": "^7.12.0",
-    "uuid": "^11.1.0",
-    "ws": "^8.19.0"
-  },
-  "devDependencies": {
-    "@babel/preset-env": "^7.28.0",
-    "@jest/globals": "^29.7.0",
-    "babel-jest": "^30.0.5",
-    "babel-plugin-transform-import-meta": "^2.3.3",
-    "jest": "^29.7.0",
-    "jest-environment-node": "^29.7.0",
-    "supertest": "^6.3.3"
-  },
-  "scripts": {
-    "start": "node src/core/master.js",
-    "start:standalone": "node src/services/api-server.js",
-    "start:dev": "node src/core/master.js --dev",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:verbose": "jest --verbose",
-    "test:silent": "jest --silent",
-    "test:unit": "node run-tests.js --unit",
-    "test:integration": "node run-tests.js --integration",
-    "test:summary": "node test-summary.js"
-  }
-}

src/auth/codex-oauth.js

@@ -1,1056 +0,0 @@
-import http from 'http';
-import logger from '../utils/logger.js';
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import open from 'open';
-import axios from 'axios';
-import { broadcastEvent } from '../services/ui-manager.js';
-import { autoLinkProviderConfigs } from '../services/service-manager.js';
-import { CONFIG } from '../core/config-manager.js';
-import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
-
-/**
- * Codex OAuth 配置
- */
-const CODEX_OAUTH_CONFIG = {
-    clientId: 'app_EMoamEEZ73f0CkXaXp7hrann',
-    authUrl: 'https://auth.openai.com/oauth/authorize',
-    tokenUrl: 'https://auth.openai.com/oauth/token',
-    redirectUri: 'http://localhost:1455/auth/callback',
-    port: 1455,
-    scopes: 'openid email profile offline_access',
-    logPrefix: '[Codex Auth]'
-};
-
-/**
- * 活动的服务器实例管理（与 gemini-oauth 一致）
- */
-const activeServers = new Map();
-
-/**
- * 关闭指定端口的活动服务器
- */
-async function closeActiveServer(provider, port = null) {
-    const existing = activeServers.get(provider);
-    
-    if (existing) {
-        try {
-            // 1. 使用 Promise.race() 添加 2 秒超时
-            const closePromise = new Promise((resolve, reject) => {
-                existing.server.close((err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Server close timeout after 2s')), 2000);
-            });
-
-            await Promise.race([closePromise, timeoutPromise]);
-            logger.info(`[Codex Auth] ${provider} server closed successfully`);
-        } catch (error) {
-            // 2. try-catch 捕获错误
-            logger.warn(`[Codex Auth] Server close failed or timed out: ${error.message}`);
-        } finally {
-            // 3. finally 块强制清理，防止阻塞
-            activeServers.delete(provider);
-        }
-    }
-
-    if (port) {
-        for (const [p, info] of activeServers.entries()) {
-            if (info.port === port) {
-                // 递归调用处理端口冲突的情况
-                await closeActiveServer(p);
-            }
-        }
-    }
-}
-
-/**
- * Codex OAuth 认证类
- * 实现 OAuth2 + PKCE 流程
- */
-class CodexAuth {
-    constructor(config) {
-        this.config = config;
-        
-        // 配置代理支持
-        const axiosConfig = { timeout: 30000 };
-        const proxyConfig = getProxyConfigForProvider(config, 'openai-codex-oauth');
-        if (proxyConfig) {
-            axiosConfig.httpAgent = proxyConfig.httpAgent;
-            axiosConfig.httpsAgent = proxyConfig.httpsAgent;
-            logger.info('[Codex Auth] Proxy enabled for OAuth requests');
-        }
-        
-        this.httpClient = axios.create(axiosConfig);
-        this.server = null; // 存储服务器实例
-    }
-
-    /**
-     * 生成 PKCE 代码
-     * @returns {{verifier: string, challenge: string}}
-     */
-    generatePKCECodes() {
-        // 生成 code verifier (96 随机字节 → 128 base64url 字符)
-        const verifier = crypto.randomBytes(96)
-            .toString('base64url');
-
-        // 生成 code challenge (SHA256 of verifier)
-        const challenge = crypto.createHash('sha256')
-            .update(verifier)
-            .digest('base64url');
-
-        return { verifier, challenge };
-    }
-
-    /**
-     * 生成授权 URL（不启动完整流程）
-     * @returns {{authUrl: string, state: string, pkce: Object, server: Object}}
-     */
-    async generateAuthUrl() {
-        const pkce = this.generatePKCECodes();
-        const state = crypto.randomBytes(16).toString('hex');
-
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Generating auth URL...`);
-
-        // 启动本地回调服务器
-        const server = await this.startCallbackServer();
-        this.server = server;
-
-        // 构建授权 URL
-        const authUrl = new URL(CODEX_OAUTH_CONFIG.authUrl);
-        authUrl.searchParams.set('client_id', CODEX_OAUTH_CONFIG.clientId);
-        authUrl.searchParams.set('response_type', 'code');
-        authUrl.searchParams.set('redirect_uri', CODEX_OAUTH_CONFIG.redirectUri);
-        authUrl.searchParams.set('scope', CODEX_OAUTH_CONFIG.scopes);
-        authUrl.searchParams.set('state', state);
-        authUrl.searchParams.set('code_challenge', pkce.challenge);
-        authUrl.searchParams.set('code_challenge_method', 'S256');
-        authUrl.searchParams.set('prompt', 'login');
-        authUrl.searchParams.set('id_token_add_organizations', 'true');
-        authUrl.searchParams.set('codex_cli_simplified_flow', 'true');
-
-        return {
-            authUrl: authUrl.toString(),
-            state,
-            pkce,
-            server
-        };
-    }
-
-    /**
-     * 完成 OAuth 流程（在收到回调后调用）
-     * @param {string} code - 授权码
-     * @param {string} state - 状态参数
-     * @param {string} expectedState - 期望的状态参数
-     * @param {Object} pkce - PKCE 代码
-     * @returns {Promise<Object>} tokens 和凭据路径
-     */
-    async completeOAuthFlow(code, state, expectedState, pkce) {
-        // 验证 state
-        if (state !== expectedState) {
-            throw new Error('State mismatch - possible CSRF attack');
-        }
-
-        // 用 code 换取 tokens
-        const tokens = await this.exchangeCodeForTokens(code, pkce.verifier);
-
-        // 解析 JWT 提取账户信息
-        const claims = this.parseJWT(tokens.id_token);
-
-        // 保存凭据（遵循 CLIProxyAPI 格式）
-        const credentials = {
-            id_token: tokens.id_token,
-            access_token: tokens.access_token,
-            refresh_token: tokens.refresh_token,
-            account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
-            last_refresh: new Date().toISOString(),
-            email: claims.email,
-            type: 'codex',
-            expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
-        };
-
-        // 保存凭据并获取路径
-        const saveResult = await this.saveCredentials(credentials);
-        const credPath = saveResult.credsPath;
-        const relativePath = saveResult.relativePath;
-
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Authentication successful!`);
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Email: ${credentials.email}`);
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Account ID: ${credentials.account_id}`);
-
-        // 关闭服务器
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
-
-        return {
-            ...credentials,
-            credPath,
-            relativePath
-        };
-    }
-
-    /**
-     * 启动 OAuth 流程
-     * @returns {Promise<Object>} 返回 tokens
-     */
-    async startOAuthFlow() {
-        const pkce = this.generatePKCECodes();
-        const state = crypto.randomBytes(16).toString('hex');
-
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Starting OAuth flow...`);
-
-        // 启动本地回调服务器
-        const server = await this.startCallbackServer();
-
-        // 构建授权 URL
-        const authUrl = new URL(CODEX_OAUTH_CONFIG.authUrl);
-        authUrl.searchParams.set('client_id', CODEX_OAUTH_CONFIG.clientId);
-        authUrl.searchParams.set('response_type', 'code');
-        authUrl.searchParams.set('redirect_uri', CODEX_OAUTH_CONFIG.redirectUri);
-        authUrl.searchParams.set('scope', CODEX_OAUTH_CONFIG.scopes);
-        authUrl.searchParams.set('state', state);
-        authUrl.searchParams.set('code_challenge', pkce.challenge);
-        authUrl.searchParams.set('code_challenge_method', 'S256');
-        authUrl.searchParams.set('prompt', 'login');
-        authUrl.searchParams.set('id_token_add_organizations', 'true');
-        authUrl.searchParams.set('codex_cli_simplified_flow', 'true');
-
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Opening browser for authentication...`);
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} If browser doesn't open, visit: ${authUrl.toString()}`);
-
-        try {
-            await open(authUrl.toString());
-        } catch (error) {
-            logger.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to open browser automatically:`, error.message);
-        }
-
-        // 等待回调
-        const result = await this.waitForCallback(server, state);
-
-        // 用 code 换取 tokens
-        const tokens = await this.exchangeCodeForTokens(result.code, pkce.verifier);
-
-        // 解析 JWT 提取账户信息
-        const claims = this.parseJWT(tokens.id_token);
-
-        // 保存凭据（遵循 CLIProxyAPI 格式）
-        const credentials = {
-            id_token: tokens.id_token,
-            access_token: tokens.access_token,
-            refresh_token: tokens.refresh_token,
-            account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
-            last_refresh: new Date().toISOString(),
-            email: claims.email,
-            type: 'codex',
-            expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
-        };
-
-        await this.saveCredentials(credentials);
-
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Authentication successful!`);
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Email: ${credentials.email}`);
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Account ID: ${credentials.account_id}`);
-
-        return credentials;
-    }
-
-    /**
-     * 启动回调服务器
-     * @returns {Promise<http.Server>}
-     */
-    async startCallbackServer() {
-        // 先清理该提供商或该端口的旧服务器
-        await closeActiveServer('openai-codex-oauth', CODEX_OAUTH_CONFIG.port);
-
-        return new Promise((resolve, reject) => {
-            const server = http.createServer();
-
-            server.on('request', (req, res) => {
-                if (req.url.startsWith('/auth/callback')) {
-                    const url = new URL(req.url, `http://localhost:${CODEX_OAUTH_CONFIG.port}`);
-                    const code = url.searchParams.get('code');
-                    const state = url.searchParams.get('state');
-                    const error = url.searchParams.get('error');
-                    const errorDescription = url.searchParams.get('error_description');
-
-                    if (error) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(`
-                            <!DOCTYPE html>
-                            <html>
-                            <head>
-                                <title>Authentication Failed</title>
-                                <style>
-                                    body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
-                                    h1 { color: #d32f2f; }
-                                    p { color: #666; }
-                                </style>
-                            </head>
-                            <body>
-                                <h1>❌ Authentication Failed</h1>
-                                <p>${errorDescription || error}</p>
-                                <p>You can close this window and try again.</p>
-                            </body>
-                            </html>
-                        `);
-                        server.emit('auth-error', new Error(errorDescription || error));
-                    } else if (code && state) {
-                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(`
-                            <!DOCTYPE html>
-                            <html>
-                            <head>
-                                <title>Authentication Successful</title>
-                                <style>
-                                    body { font-family: Arial, sans-serif; text-align: center; padding: 50px; }
-                                    h1 { color: #4caf50; }
-                                    p { color: #666; }
-                                    .countdown { font-size: 24px; font-weight: bold; color: #2196f3; }
-                                </style>
-                                <script>
-                                    let countdown = 10;
-                                    setInterval(() => {
-                                        countdown--;
-                                        document.getElementById('countdown').textContent = countdown;
-                                        if (countdown <= 0) {
-                                            window.close();
-                                        }
-                                    }, 1000);
-                                </script>
-                            </head>
-                            <body>
-                                <h1>✅ Authentication Successful!</h1>
-                                <p>You can now close this window and return to the application.</p>
-                                <p>This window will close automatically in <span id="countdown" class="countdown">10</span> seconds.</p>
-                            </body>
-                            </html>
-                        `);
-                        server.emit('auth-success', { code, state });
-                    }
-                } else if (req.url === '/success') {
-                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end('<h1>Success!</h1>');
-                }
-            });
-
-            server.listen(CODEX_OAUTH_CONFIG.port, () => {
-                logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Callback server listening on port ${CODEX_OAUTH_CONFIG.port}`);
-                activeServers.set('openai-codex-oauth', { server, port: CODEX_OAUTH_CONFIG.port });
-                resolve(server);
-            });
-
-            server.on('error', (error) => {
-                if (error.code === 'EADDRINUSE') {
-                    reject(new Error(`Port ${CODEX_OAUTH_CONFIG.port} is already in use. Please close other applications using this port.`));
-                } else {
-                    reject(error);
-                }
-            });
-        });
-    }
-
-    /**
-     * 等待 OAuth 回调
-     * @param {http.Server} server
-     * @param {string} expectedState
-     * @returns {Promise<{code: string, state: string}>}
-     */
-    async waitForCallback(server, expectedState) {
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                server.close();
-                reject(new Error('Authentication timeout (10 minutes)'));
-            }, 10 * 60 * 1000); // 10 分钟
-
-            server.once('auth-success', (result) => {
-                clearTimeout(timeout);
-                server.close();
-
-                if (result.state !== expectedState) {
-                    reject(new Error('State mismatch - possible CSRF attack'));
-                } else {
-                    resolve(result);
-                }
-            });
-
-            server.once('auth-error', (error) => {
-                clearTimeout(timeout);
-                server.close();
-                reject(error);
-            });
-        });
-    }
-
-    /**
-     * 用授权码换取 tokens
-     * @param {string} code
-     * @param {string} codeVerifier
-     * @returns {Promise<Object>}
-     */
-    async exchangeCodeForTokens(code, codeVerifier) {
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Exchanging authorization code for tokens...`);
-
-        try {
-            const response = await this.httpClient.post(
-                CODEX_OAUTH_CONFIG.tokenUrl,
-                new URLSearchParams({
-                    grant_type: 'authorization_code',
-                    client_id: CODEX_OAUTH_CONFIG.clientId,
-                    code: code,
-                    redirect_uri: CODEX_OAUTH_CONFIG.redirectUri,
-                    code_verifier: codeVerifier
-                }).toString(),
-                {
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                        'Accept': 'application/json'
-                    }
-                }
-            );
-
-            return response.data;
-        } catch (error) {
-            logger.error(`${CODEX_OAUTH_CONFIG.logPrefix} Token exchange failed:`, error.response?.data || error.message);
-            throw new Error(`Failed to exchange code for tokens: ${error.response?.data?.error_description || error.message}`);
-        }
-    }
-
-    /**
-     * 刷新 tokens
-     * @param {string} refreshToken
-     * @returns {Promise<Object>}
-     */
-    async refreshTokens(refreshToken) {
-        logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Refreshing access token...`);
-
-        try {
-            const response = await this.httpClient.post(
-                CODEX_OAUTH_CONFIG.tokenUrl,
-                new URLSearchParams({
-                    grant_type: 'refresh_token',
-                    client_id: CODEX_OAUTH_CONFIG.clientId,
-                    refresh_token: refreshToken
-                }).toString(),
-                {
-                    headers: {
-                        'Content-Type': 'application/x-www-form-urlencoded',
-                        'Accept': 'application/json'
-                    }
-                }
-            );
-
-            const tokens = response.data;
-            const claims = this.parseJWT(tokens.id_token);
-
-            return {
-                id_token: tokens.id_token,
-                access_token: tokens.access_token,
-                refresh_token: tokens.refresh_token || refreshToken,
-                account_id: claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub,
-                last_refresh: new Date().toISOString(),
-                email: claims.email,
-                type: 'codex',
-                expired: new Date(Date.now() + (tokens.expires_in || 3600) * 1000).toISOString()
-            };
-        } catch (error) {
-            logger.error(`${CODEX_OAUTH_CONFIG.logPrefix} Token refresh failed:`, error.response?.data || error.message);
-            throw new Error(`Failed to refresh tokens: ${error.response?.data?.error_description || error.message}`);
-        }
-    }
-
-    /**
-     * 解析 JWT token
-     * @param {string} token
-     * @returns {Object}
-     */
-    parseJWT(token) {
-        try {
-            const parts = token.split('.');
-            if (parts.length !== 3) {
-                throw new Error('Invalid JWT token format');
-            }
-
-            // 解码 payload (base64url)
-            const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
-            return JSON.parse(payload);
-        } catch (error) {
-            logger.error(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to parse JWT:`, error.message);
-            throw new Error(`Failed to parse JWT token: ${error.message}`);
-        }
-    }
-
-    /**
-     * 保存凭据到文件
-     * @param {Object} creds
-     * @returns {Promise<Object>}
-     */
-    async saveCredentials(creds) {
-        const email = creds.email || this.config.CODEX_EMAIL || 'default';
-
-        // 优先使用配置中指定的路径，否则保存到 configs/codex 目录
-        let credsPath;
-        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
-            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
-        } else {
-            // 保存到 configs/codex 目录（与其他供应商一致）
-            const projectDir = process.cwd();
-            const targetDir = path.join(projectDir, 'configs', 'codex');
-            await fs.promises.mkdir(targetDir, { recursive: true });
-            const timestamp = Date.now();
-            const filename = `${timestamp}_codex-${email}.json`;
-            credsPath = path.join(targetDir, filename);
-        }
-
-        try {
-            const credsDir = path.dirname(credsPath);
-            await fs.promises.mkdir(credsDir, { recursive: true });
-            await fs.promises.writeFile(credsPath, JSON.stringify(creds, null, 2), { mode: 0o600 });
-
-            const relativePath = path.relative(process.cwd(), credsPath);
-            logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Credentials saved to ${relativePath}`);
-
-            // 返回保存路径供后续使用
-            return { credsPath, relativePath };
-        } catch (error) {
-            logger.error(`${CODEX_OAUTH_CONFIG.logPrefix} Failed to save credentials:`, error.message);
-            throw new Error(`Failed to save credentials: ${error.message}`);
-        }
-    }
-
-    /**
-     * 加载凭据
-     * @param {string} email
-     * @returns {Promise<Object|null>}
-     */
-    async loadCredentials(email) {
-        // 优先使用配置中指定的路径，否则从 configs/codex 目录加载
-        let credsPath;
-        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
-            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
-        } else {
-            // 从 configs/codex 目录加载（与其他供应商一致）
-            const projectDir = process.cwd();
-            const targetDir = path.join(projectDir, 'configs', 'codex');
-
-            // 扫描目录找到匹配的凭据文件
-            try {
-                const files = await fs.promises.readdir(targetDir);
-                const emailPattern = email || 'default';
-                const matchingFile = files
-                    .filter(f => f.includes(`codex-${emailPattern}`) && f.endsWith('.json'))
-                    .sort()
-                    .pop(); // 获取最新的文件
-
-                if (matchingFile) {
-                    credsPath = path.join(targetDir, matchingFile);
-                } else {
-                    return null;
-                }
-            } catch (error) {
-                if (error.code === 'ENOENT') {
-                    return null;
-                }
-                throw error;
-            }
-        }
-
-        try {
-            const data = await fs.promises.readFile(credsPath, 'utf8');
-            return JSON.parse(data);
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                return null; // 文件不存在
-            }
-            throw error;
-        }
-    }
-
-    /**
-     * 检查凭据文件是否存在
-     * @param {string} email
-     * @returns {Promise<boolean>}
-     */
-    async credentialsExist(email) {
-        // 优先使用配置中指定的路径，否则从 configs/codex 目录检查
-        let credsPath;
-        if (this.config.CODEX_OAUTH_CREDS_FILE_PATH) {
-            credsPath = this.config.CODEX_OAUTH_CREDS_FILE_PATH;
-        } else {
-            const projectDir = process.cwd();
-            const targetDir = path.join(projectDir, 'configs', 'codex');
-
-            try {
-                const files = await fs.promises.readdir(targetDir);
-                const emailPattern = email || 'default';
-                const hasMatch = files.some(f =>
-                    f.includes(`codex-${emailPattern}`) && f.endsWith('.json')
-                );
-                return hasMatch;
-            } catch (error) {
-                return false;
-            }
-        }
-
-        try {
-            await fs.promises.access(credsPath);
-            return true;
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * 检查凭据是否已存在（基于 account_id 或 refresh_token）
-     * @param {string} accountId 
-     * @param {string} refreshToken 
-     * @returns {Promise<{isDuplicate: boolean, existingPath?: string}>}
-     */
-    async checkDuplicate(accountId, refreshToken) {
-        const projectDir = process.cwd();
-        const targetDir = path.join(projectDir, 'configs', 'codex');
-
-        try {
-            if (!fs.existsSync(targetDir)) {
-                return { isDuplicate: false };
-            }
-
-            const files = await fs.promises.readdir(targetDir);
-            for (const file of files) {
-                if (file.endsWith('.json')) {
-                    try {
-                        const fullPath = path.join(targetDir, file);
-                        const content = await fs.promises.readFile(fullPath, 'utf8');
-                        const credentials = JSON.parse(content);
-
-                        if ((accountId && credentials.account_id === accountId) || (refreshToken && credentials.refresh_token === refreshToken)) {
-                            const relativePath = path.relative(process.cwd(), fullPath);
-                            return {
-                                isDuplicate: true,
-                                existingPath: relativePath
-                            };
-                        }
-                    } catch (e) {
-                        // 忽略解析错误
-                    }
-                }
-            }
-            return { isDuplicate: false };
-        } catch (error) {
-            logger.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Error checking duplicates:`, error.message);
-            return { isDuplicate: false };
-        }
-    }
-}
-
-/**
- * 批量导入 Codex Token 并生成凭据文件（流式版本）
- * @param {Object[]} tokens - Token 对象数组
- * @param {Function} onProgress - 进度回调函数
- * @param {boolean} skipDuplicateCheck - 是否跳过重复检查
- * @returns {Promise<Object>} 批量处理结果
- */
-export async function batchImportCodexTokensStream(tokens, onProgress = null, skipDuplicateCheck = false) {
-    const auth = new CodexAuth({});
-    const results = {
-        total: tokens.length,
-        success: 0,
-        failed: 0,
-        details: []
-    };
-
-    for (let i = 0; i < tokens.length; i++) {
-        const tokenData = tokens[i];
-        const progressData = {
-            index: i + 1,
-            total: tokens.length,
-            current: null
-        };
-
-        try {
-            // 验证 token 数据
-            if (!tokenData.access_token || !tokenData.id_token) {
-                throw new Error('Token 缺少必需字段 (access_token 或 id_token)');
-            }
-
-            // 解析 JWT 提取账户信息
-            const claims = auth.parseJWT(tokenData.id_token);
-            const accountId = claims['https://api.openai.com/auth']?.chatgpt_account_id || claims.sub;
-            const email = claims.email;
-
-            // 检查重复
-            if (!skipDuplicateCheck) {
-                const duplicateCheck = await auth.checkDuplicate(accountId, tokenData.refresh_token);
-                if (duplicateCheck.isDuplicate) {
-                    progressData.current = {
-                        index: i + 1,
-                        success: false,
-                        error: 'duplicate',
-                        existingPath: duplicateCheck.existingPath
-                    };
-                    results.failed++;
-                    results.details.push(progressData.current);
-                    if (onProgress) {
-                        onProgress({
-                            ...progressData,
-                            successCount: results.success,
-                            failedCount: results.failed
-                        });
-                    }
-                    continue;
-                }
-            }
-
-            // 构建凭据对象
-            const credentials = {
-                id_token: tokenData.id_token,
-                access_token: tokenData.access_token,
-                refresh_token: tokenData.refresh_token,
-                account_id: accountId,
-                last_refresh: new Date().toISOString(),
-                email: email,
-                type: 'codex',
-                expired: new Date(Date.now() + (tokenData.expires_in || 3600) * 1000).toISOString()
-            };
-
-            // 保存凭据
-            const saveResult = await auth.saveCredentials(credentials);
-            const relativePath = saveResult.relativePath;
-
-            logger.info(`${CODEX_OAUTH_CONFIG.logPrefix} Token ${i + 1} imported: ${relativePath}`);
-
-            progressData.current = {
-                index: i + 1,
-                success: true,
-                path: relativePath
-            };
-            results.success++;
-
-            // 自动关联到 Pools
-            await autoLinkProviderConfigs(CONFIG, {
-                onlyCurrentCred: true,
-                credPath: relativePath
-            });
-
-        } catch (error) {
-            logger.error(`${CODEX_OAUTH_CONFIG.logPrefix} Token ${i + 1} import failed:`, error.message);
-
-            progressData.current = {
-                index: i + 1,
-                success: false,
-                error: error.message
-            };
-            results.failed++;
-        }
-
-        results.details.push(progressData.current);
-
-        if (onProgress) {
-            onProgress({
-                ...progressData,
-                successCount: results.success,
-                failedCount: results.failed
-            });
-        }
-    }
-
-    if (results.success > 0) {
-        broadcastEvent('oauth_batch_success', {
-            provider: 'openai-codex-oauth',
-            count: results.success,
-            timestamp: new Date().toISOString()
-        });
-    }
-
-    return results;
-}
-
-/**
- * 带重试的 Codex token 刷新
- * @param {string} refreshToken
- * @param {Object} config
- * @param {number} maxRetries
- * @returns {Promise<Object>}
- */
-export async function refreshCodexTokensWithRetry(refreshToken, config = {}, maxRetries = 3) {
-    const auth = new CodexAuth(config);
-    let lastError;
-
-    for (let i = 0; i < maxRetries; i++) {
-        try {
-            return await auth.refreshTokens(refreshToken);
-        } catch (error) {
-            lastError = error;
-            logger.warn(`${CODEX_OAUTH_CONFIG.logPrefix} Retry ${i + 1}/${maxRetries} failed:`, error.message);
-
-            if (i < maxRetries - 1) {
-                // 指数退避
-                const delay = Math.min(1000 * Math.pow(2, i), 10000);
-                await new Promise(resolve => setTimeout(resolve, delay));
-            }
-        }
-    }
-
-    throw lastError;
-}
-
-/**
- * 处理 Codex OAuth 认证
- * @param {Object} currentConfig - 当前配置
- * @param {Object} options - 选项
- * @returns {Promise<Object>} 返回认证结果
- */
-export async function handleCodexOAuth(currentConfig, options = {}) {
-    const auth = new CodexAuth(currentConfig);
-
-    try {
-        logger.info('[Codex Auth] Generating OAuth URL...');
-
-        // 清理所有旧的会话和服务器
-        if (global.codexOAuthSessions && global.codexOAuthSessions.size > 0) {
-            logger.info('[Codex Auth] Cleaning up old OAuth sessions...');
-            for (const [sessionId, session] of global.codexOAuthSessions.entries()) {
-                try {
-                    // 清理定时器
-                    if (session.pollTimer) {
-                        clearInterval(session.pollTimer);
-                    }
-                    // 不在这里显式关闭 server，由 startCallbackServer 中的 closeActiveServer 处理
-                    global.codexOAuthSessions.delete(sessionId);
-                } catch (error) {
-                    logger.warn(`[Codex Auth] Failed to clean up session ${sessionId}:`, error.message);
-                }
-            }
-        }
-
-        // 生成授权 URL 和启动回调服务器
-        const { authUrl, state, pkce, server } = await auth.generateAuthUrl();
-
-        logger.info('[Codex Auth] OAuth URL generated successfully');
-
-        // 存储 OAuth 会话信息，供后续回调使用
-        if (!global.codexOAuthSessions) {
-            global.codexOAuthSessions = new Map();
-        }
-
-        const sessionId = state; // 使用 state 作为 session ID
-        
-        // 轮询计数器
-        let pollCount = 0;
-        const maxPollCount = 100; // 增加到约 5 分钟 (100 * 3s = 300s)
-        const pollInterval = 3000; // 轮询间隔（毫秒）
-        let pollTimer = null;
-        let isCompleted = false;
-        
-        // 创建会话对象
-        const session = {
-            auth,
-            state,
-            pkce,
-            server,
-            pollTimer: null,
-            createdAt: Date.now()
-        };
-        
-        global.codexOAuthSessions.set(sessionId, session);
-
-        // 启动轮询日志
-        pollTimer = setInterval(() => {
-            pollCount++;
-            if (pollCount <= maxPollCount && !isCompleted) {
-                logger.info(`[Codex Auth] Waiting for callback... (${pollCount}/${maxPollCount})`);
-            }
-            
-            if (pollCount >= maxPollCount && !isCompleted) {
-                clearInterval(pollTimer);
-                const totalSeconds = (maxPollCount * pollInterval) / 1000;
-                logger.info(`[Codex Auth] Polling timeout (${totalSeconds}s), releasing session for next authorization`);
-                
-                // 清理会话
-                if (global.codexOAuthSessions.has(sessionId)) {
-                    global.codexOAuthSessions.delete(sessionId);
-                }
-            }
-        }, pollInterval);
-        
-        // 将 pollTimer 存储到会话中
-        session.pollTimer = pollTimer;
-
-        // 监听回调服务器的 auth-success 事件，自动完成 OAuth 流程
-        server.once('auth-success', async (result) => {
-            isCompleted = true;
-            if (pollTimer) {
-                clearInterval(pollTimer);
-            }
-            
-            try {
-                logger.info('[Codex Auth] Received auth callback, completing OAuth flow...');
-                
-                const session = global.codexOAuthSessions.get(sessionId);
-                if (!session) {
-                    logger.error('[Codex Auth] Session not found');
-                    return;
-                }
-
-                // 完成 OAuth 流程
-                const credentials = await auth.completeOAuthFlow(result.code, result.state, session.state, session.pkce);
-
-                // 清理会话
-                global.codexOAuthSessions.delete(sessionId);
-
-                // 广播认证成功事件
-                broadcastEvent('oauth_success', {
-                    provider: 'openai-codex-oauth',
-                    credPath: credentials.credPath,
-                    relativePath: credentials.relativePath,
-                    timestamp: new Date().toISOString(),
-                    email: credentials.email,
-                    accountId: credentials.account_id
-                });
-
-                // 自动关联新生成的凭据到 Pools
-                await autoLinkProviderConfigs(CONFIG, {
-                    onlyCurrentCred: true,
-                    credPath: credentials.relativePath
-                });
-
-                logger.info('[Codex Auth] OAuth flow completed successfully');
-            } catch (error) {
-                logger.error('[Codex Auth] Failed to complete OAuth flow:', error.message);
-                
-                // 广播认证失败事件
-                broadcastEvent('oauth_error', {
-                    provider: 'openai-codex-oauth',
-                    error: error.message,
-                    timestamp: new Date().toISOString()
-                });
-            }
-        });
-
-        // 监听 auth-error 事件
-        server.once('auth-error', (error) => {
-            isCompleted = true;
-            if (pollTimer) {
-                clearInterval(pollTimer);
-            }
-            
-            logger.error('[Codex Auth] Auth error:', error.message);
-            global.codexOAuthSessions.delete(sessionId);
-            
-            broadcastEvent('oauth_error', {
-                provider: 'openai-codex-oauth',
-                error: error.message,
-                timestamp: new Date().toISOString()
-            });
-        });
-
-        return {
-            success: true,
-            authUrl: authUrl,
-            authInfo: {
-                provider: 'openai-codex-oauth',
-                method: 'oauth2-pkce',
-                sessionId: sessionId,
-                redirectUri: CODEX_OAUTH_CONFIG.redirectUri,
-                port: CODEX_OAUTH_CONFIG.port,
-                instructions: [
-                    '1. 点击下方按钮在浏览器中打开授权链接',
-                    '2. 使用您的 OpenAI 账户登录',
-                    '3. 授权应用访问您的 Codex API',
-                    '4. 授权成功后会自动保存凭据',
-                    '5. 如果浏览器未自动跳转，请手动复制回调 URL'
-                ]
-            }
-        };
-    } catch (error) {
-        logger.error('[Codex Auth] Failed to generate OAuth URL:', error.message);
-
-        return {
-            success: false,
-            error: error.message,
-            authInfo: {
-                provider: 'openai-codex-oauth',
-                method: 'oauth2-pkce',
-                instructions: [
-                    `1. 确保端口 ${CODEX_OAUTH_CONFIG.port} 未被占用`,
-                    '2. 确保可以访问 auth.openai.com',
-                    '3. 确保浏览器可以正常打开',
-                    '4. 如果问题持续，请检查网络连接'
-                ]
-            }
-        };
-    }
-}
-
-/**
- * 处理 Codex OAuth 回调
- * @param {string} code - 授权码
- * @param {string} state - 状态参数
- * @returns {Promise<Object>} 返回认证结果
- */
-export async function handleCodexOAuthCallback(code, state) {
-    try {
-        if (!global.codexOAuthSessions || !global.codexOAuthSessions.has(state)) {
-            throw new Error('Invalid or expired OAuth session');
-        }
-
-        const session = global.codexOAuthSessions.get(state);
-        const { auth, state: expectedState, pkce } = session;
-
-        logger.info('[Codex Auth] Processing OAuth callback...');
-
-        // 完成 OAuth 流程
-        const result = await auth.completeOAuthFlow(code, state, expectedState, pkce);
-
-        // 清理会话
-        global.codexOAuthSessions.delete(state);
-
-        // 广播认证成功事件（与 gemini 格式一致）
-        broadcastEvent('oauth_success', {
-            provider: 'openai-codex-oauth',
-            credPath: result.credPath,
-            relativePath: result.relativePath,
-            timestamp: new Date().toISOString(),
-            email: result.email,
-            accountId: result.account_id
-        });
-
-        // 自动关联新生成的凭据到 Pools
-        await autoLinkProviderConfigs(CONFIG, {
-            onlyCurrentCred: true,
-            credPath: result.relativePath
-        });
-
-        logger.info('[Codex Auth] OAuth callback processed successfully');
-
-        return {
-            success: true,
-            message: 'Codex authentication successful',
-            credentials: result,
-            email: result.email,
-            accountId: result.account_id,
-            credPath: result.credPath,
-            relativePath: result.relativePath
-        };
-    } catch (error) {
-        logger.error('[Codex Auth] OAuth callback failed:', error.message);
-
-        // 广播认证失败事件
-        broadcastEvent('oauth_error', {
-            provider: 'openai-codex-oauth',
-            error: error.message,
-            timestamp: new Date().toISOString()
-        });
-
-        return {
-            success: false,
-            error: error.message
-        };
-    }
-}

src/auth/gemini-oauth.js

@@ -1,504 +0,0 @@
-import { OAuth2Client } from 'google-auth-library';
-import logger from '../utils/logger.js';
-import http from 'http';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { broadcastEvent } from '../services/ui-manager.js';
-import { autoLinkProviderConfigs } from '../services/service-manager.js';
-import { CONFIG } from '../core/config-manager.js';
-import { getGoogleAuthProxyConfig } from '../utils/proxy-utils.js';
-
-/**
- * OAuth 提供商配置
- */
-const OAUTH_PROVIDERS = {
-    'gemini-cli-oauth': {
-        clientId: '681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com',
-        clientSecret: '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',
-        port: 8085,
-        credentialsDir: '.gemini',
-        credentialsFile: 'oauth_creds.json',
-        scope: ['https://www.googleapis.com/auth/cloud-platform'],
-        logPrefix: '[Gemini Auth]'
-    },
-    'gemini-antigravity': {
-        clientId: '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com',
-        clientSecret: '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',
-        port: 8086,
-        credentialsDir: '.antigravity',
-        credentialsFile: 'oauth_creds.json',
-        scope: ['https://www.googleapis.com/auth/cloud-platform'],
-        logPrefix: '[Antigravity Auth]'
-    }
-};
-
-/**
- * 活动的服务器实例管理
- */
-const activeServers = new Map();
-
-/**
- * 生成 HTML 响应页面
- * @param {boolean} isSuccess - 是否成功
- * @param {string} message - 显示消息
- * @returns {string} HTML 内容
- */
-function generateResponsePage(isSuccess, message) {
-    const title = isSuccess ? '授权成功！' : '授权失败';
-    
-    return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${title}</title>
-</head>
-<body>
-    <div class="container">
-        <h1>${title}</h1>
-        <p>${message}</p>
-    </div>
-</body>
-</html>`;
-}
-
-/**
- * 关闭指定端口的活动服务器
- * @param {number} port - 端口号
- * @returns {Promise<void>}
- */
-async function closeActiveServer(provider, port = null) {
-    // 1. 关闭该提供商之前的所有服务器
-    const existing = activeServers.get(provider);
-    if (existing) {
-        // 清理轮询定时器
-        if (existing.pollTimer) {
-            clearInterval(existing.pollTimer);
-            existing.pollTimer = null;
-        }
-
-        try {
-            const closePromise = new Promise((resolve, reject) => {
-                existing.server.close((err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Server close timeout after 2s')), 2000);
-            });
-
-            await Promise.race([closePromise, timeoutPromise]);
-            logger.info(`[OAuth] 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
-        } catch (error) {
-            logger.warn(`[OAuth] 关闭提供商 ${provider} 服务器失败或超时: ${error.message}`);
-        } finally {
-            activeServers.delete(provider);
-        }
-    }
-
-    // 2. 如果指定了端口，检查是否有其他提供商占用了该端口
-    if (port) {
-        for (const [p, info] of activeServers.entries()) {
-            if (info.port === port) {
-                await closeActiveServer(p);
-            }
-        }
-    }
-}
-
-/**
- * 创建 OAuth 回调服务器
- * @param {Object} config - OAuth 提供商配置
- * @param {string} redirectUri - 重定向 URI
- * @param {OAuth2Client} authClient - OAuth2 客户端
- * @param {string} credPath - 凭据保存路径
- * @param {string} provider - 提供商标识
- * @returns {Promise<http.Server>} HTTP 服务器实例
- */
-async function createOAuthCallbackServer(config, redirectUri, authClient, credPath, provider, options = {}) {
-    const port = parseInt(options.port) || config.port;
-    // 先关闭该提供商之前可能运行的所有服务器，或该端口上的旧服务器
-    await closeActiveServer(provider, port);
-    
-    return new Promise((resolve, reject) => {
-        let pollCount = 0;
-        const maxPollCount = 100; // 约 5 分钟 (100 * 3s = 300s)
-        const pollInterval = 3000;
-        let pollTimer = null;
-
-        const clearPollTimer = () => {
-            if (pollTimer) {
-                clearInterval(pollTimer);
-                pollTimer = null;
-            }
-        };
-
-        const server = http.createServer(async (req, res) => {
-            try {
-                const url = new URL(req.url, redirectUri);
-                const code = url.searchParams.get('code');
-                const errorParam = url.searchParams.get('error');
-                
-                if (code) {
-                    clearPollTimer();
-                    logger.info(`${config.logPrefix} 收到来自 Google 的成功回调: ${req.url}`);
-                    
-                    try {
-                        const { tokens } = await authClient.getToken(code);
-                        let finalCredPath = credPath;
-                        
-                        // 如果指定了保存到 configs 目录
-                        if (options.saveToConfigs) {
-                            const providerDir = options.providerDir;
-                            const targetDir = path.join(process.cwd(), 'configs', providerDir);
-                            await fs.promises.mkdir(targetDir, { recursive: true });
-                            const timestamp = Date.now();
-                            const filename = `${timestamp}_oauth_creds.json`;
-                            finalCredPath = path.join(targetDir, filename);
-                        }
-
-                        await fs.promises.mkdir(path.dirname(finalCredPath), { recursive: true });
-                        await fs.promises.writeFile(finalCredPath, JSON.stringify(tokens, null, 2));
-                        logger.info(`${config.logPrefix} 新令牌已接收并保存到文件: ${finalCredPath}`);
-                        
-                        const relativePath = path.relative(process.cwd(), finalCredPath);
-
-                        // 广播授权成功事件
-                        broadcastEvent('oauth_success', {
-                            provider: provider,
-                            credPath: finalCredPath,
-                            relativePath: relativePath,
-                            timestamp: new Date().toISOString()
-                        });
-                        
-                        // 自动关联新生成的凭据到 Pools
-                        await autoLinkProviderConfigs(CONFIG, {
-                            onlyCurrentCred: true,
-                            credPath: relativePath
-                        });
-                        
-                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(true, '您可以关闭此页面'));
-                    } catch (tokenError) {
-                        logger.error(`${config.logPrefix} 获取令牌失败:`, tokenError);
-                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, `获取令牌失败: ${tokenError.message}`));
-                    } finally {
-                        server.close(() => {
-                            activeServers.delete(provider);
-                        });
-                    }
-                } else if (errorParam) {
-                    clearPollTimer();
-                    const errorMessage = `授权失败。Google 返回错误: ${errorParam}`;
-                    logger.error(`${config.logPrefix}`, errorMessage);
-                    
-                    res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end(generateResponsePage(false, errorMessage));
-                    server.close(() => {
-                        activeServers.delete(provider);
-                    });
-                } else {
-                    logger.info(`${config.logPrefix} 忽略无关请求: ${req.url}`);
-                    res.writeHead(204);
-                    res.end();
-                }
-            } catch (error) {
-                clearPollTimer();
-                logger.error(`${config.logPrefix} 处理回调时出错:`, error);
-                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
-                
-                if (server.listening) {
-                    server.close(() => {
-                        activeServers.delete(provider);
-                    });
-                }
-            }
-        });
-        
-        server.on('error', (err) => {
-            clearPollTimer();
-            if (err.code === 'EADDRINUSE') {
-                logger.error(`${config.logPrefix} 端口 ${port} 已被占用`);
-                reject(new Error(`端口 ${port} 已被占用`));
-            } else {
-                logger.error(`${config.logPrefix} 服务器错误:`, err);
-                reject(err);
-            }
-        });
-        
-        const host = '0.0.0.0';
-        server.listen(port, host, () => {
-            logger.info(`${config.logPrefix} OAuth 回调服务器已启动于 ${host}:${port}`);
-            
-            // 启动轮询日志
-            pollTimer = setInterval(() => {
-                pollCount++;
-                if (pollCount <= maxPollCount) {
-                    logger.info(`${config.logPrefix} Waiting for callback... (${pollCount}/${maxPollCount})`);
-                } else {
-                    clearPollTimer();
-                    logger.warn(`${config.logPrefix} Polling timeout, closing server...`);
-                    if (server.listening) {
-                        server.close(() => {
-                            activeServers.delete(provider);
-                        });
-                    }
-                }
-            }, pollInterval);
-
-            activeServers.set(provider, { server, port, pollTimer });
-            resolve(server);
-        });
-    });
-}
-
-/**
- * 处理 Google OAuth 授权（通用函数）
- * @param {string} providerKey - 提供商键名
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-async function handleGoogleOAuth(providerKey, currentConfig, options = {}) {
-    const config = OAUTH_PROVIDERS[providerKey];
-    if (!config) {
-        throw new Error(`未知的提供商: ${providerKey}`);
-    }
-    
-    const port = parseInt(options.port) || config.port;
-    const host = 'localhost';
-    const redirectUri = `http://${host}:${port}`;
-
-    // 获取代理配置
-    const proxyConfig = getGoogleAuthProxyConfig(currentConfig, providerKey);
-
-    // 构建 OAuth2Client 选项
-    const oauth2Options = {
-        clientId: config.clientId,
-        clientSecret: config.clientSecret,
-    };
-
-    if (proxyConfig) {
-        oauth2Options.transporterOptions = proxyConfig;
-        logger.info(`${config.logPrefix} Using proxy for OAuth token exchange`);
-    }
-
-    const authClient = new OAuth2Client(oauth2Options);
-    authClient.redirectUri = redirectUri;
-    
-    const authUrl = authClient.generateAuthUrl({
-        access_type: 'offline',
-        prompt: 'select_account',
-        scope: config.scope
-    });
-    
-    // 启动回调服务器
-    const credPath = path.join(os.homedir(), config.credentialsDir, config.credentialsFile);
-    
-    try {
-        await createOAuthCallbackServer(config, redirectUri, authClient, credPath, providerKey, options);
-    } catch (error) {
-        throw new Error(`启动回调服务器失败: ${error.message}`);
-    }
-    
-    return {
-        authUrl,
-        authInfo: {
-            provider: providerKey,
-            redirectUri: redirectUri,
-            port: port,
-            ...options
-        }
-    };
-}
-
-/**
- * 处理 Gemini CLI OAuth 授权
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-export async function handleGeminiCliOAuth(currentConfig, options = {}) {
-    return handleGoogleOAuth('gemini-cli-oauth', currentConfig, options);
-}
-
-/**
- * 处理 Gemini Antigravity OAuth 授权
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-export async function handleGeminiAntigravityOAuth(currentConfig, options = {}) {
-    return handleGoogleOAuth('gemini-antigravity', currentConfig, options);
-}
-
-/**
- * 检查 Gemini 凭据是否已存在（基于 refresh_token）
- * @param {string} providerType - 提供商类型
- * @param {string} refreshToken - 要检查的 refreshToken
- * @returns {Promise<{isDuplicate: boolean, existingPath?: string}>} 检查结果
- */
-export async function checkGeminiCredentialsDuplicate(providerType, refreshToken) {
-    const config = OAUTH_PROVIDERS[providerType];
-    if (!config) return { isDuplicate: false };
-
-    const providerDir = config.credentialsDir.replace('.', '');
-    const targetDir = path.join(process.cwd(), 'configs', providerDir);
-    
-    try {
-        if (!fs.existsSync(targetDir)) {
-            return { isDuplicate: false };
-        }
-        
-        const files = await fs.promises.readdir(targetDir);
-        for (const file of files) {
-            if (file.endsWith('.json')) {
-                try {
-                    const fullPath = path.join(targetDir, file);
-                    const content = await fs.promises.readFile(fullPath, 'utf8');
-                    const credentials = JSON.parse(content);
-                    
-                    if (credentials.refresh_token === refreshToken) {
-                        const relativePath = path.relative(process.cwd(), fullPath);
-                        return {
-                            isDuplicate: true,
-                            existingPath: relativePath
-                        };
-                    }
-                } catch (e) {
-                    // 忽略解析错误
-                }
-            }
-        }
-        return { isDuplicate: false };
-    } catch (error) {
-        logger.warn(`[Gemini Auth] Error checking duplicates for ${providerType}:`, error.message);
-        return { isDuplicate: false };
-    }
-}
-
-/**
- * 批量导入 Gemini Token 并生成凭据文件（流式版本，支持实时进度回调）
- * @param {string} providerType - 提供商类型 ('gemini-cli-oauth' 或 'gemini-antigravity')
- * @param {Object[]} tokens - Token 对象数组
- * @param {Function} onProgress - 进度回调函数
- * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
- * @returns {Promise<Object>} 批量处理结果
- */
-export async function batchImportGeminiTokensStream(providerType, tokens, onProgress = null, skipDuplicateCheck = false) {
-    const config = OAUTH_PROVIDERS[providerType];
-    if (!config) {
-        throw new Error(`未知的提供商: ${providerType}`);
-    }
-
-    const results = {
-        total: tokens.length,
-        success: 0,
-        failed: 0,
-        details: []
-    };
-    
-    for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        const progressData = {
-            index: i + 1,
-            total: tokens.length,
-            current: null
-        };
-        
-        try {
-            // 验证 token 是否包含必需字段 (通常是 access_token 和 refresh_token)
-            if (!token.access_token || !token.refresh_token) {
-                throw new Error('Token 缺少必需字段 (access_token 或 refresh_token)');
-            }
-
-            // 检查重复
-            if (!skipDuplicateCheck) {
-                const duplicateCheck = await checkGeminiCredentialsDuplicate(providerType, token.refresh_token);
-                if (duplicateCheck.isDuplicate) {
-                    progressData.current = {
-                        index: i + 1,
-                        success: false,
-                        error: 'duplicate',
-                        existingPath: duplicateCheck.existingPath
-                    };
-                    results.failed++;
-                    results.details.push(progressData.current);
-                    if (onProgress) {
-                        onProgress({
-                            ...progressData,
-                            successCount: results.success,
-                            failedCount: results.failed
-                        });
-                    }
-                    continue;
-                }
-            }
-
-            // 生成文件路径
-            const timestamp = Date.now();
-            const providerDir = config.credentialsDir.replace('.', ''); // 去掉开头的点
-            const targetDir = path.join(process.cwd(), 'configs', providerDir);
-            await fs.promises.mkdir(targetDir, { recursive: true });
-            
-            const filename = `${timestamp}_${i}_oauth_creds.json`;
-            const credPath = path.join(targetDir, filename);
-            
-            await fs.promises.writeFile(credPath, JSON.stringify(token, null, 2));
-            
-            const relativePath = path.relative(process.cwd(), credPath);
-            
-            logger.info(`${config.logPrefix} Token ${i + 1} 已导入并保存: ${relativePath}`);
-            
-            progressData.current = {
-                index: i + 1,
-                success: true,
-                path: relativePath
-            };
-            results.success++;
-
-            // 自动关联新生成的凭据到 Pools
-            await autoLinkProviderConfigs(CONFIG, {
-                onlyCurrentCred: true,
-                credPath: relativePath
-            });
-            
-        } catch (error) {
-            logger.error(`${config.logPrefix} Token ${i + 1} 导入失败:`, error.message);
-            
-            progressData.current = {
-                index: i + 1,
-                success: false,
-                error: error.message
-            };
-            results.failed++;
-        }
-        
-        results.details.push(progressData.current);
-
-        // 发送进度更新
-        if (onProgress) {
-            onProgress({
-                ...progressData,
-                successCount: results.success,
-                failedCount: results.failed
-            });
-        }
-    }
-    
-    // 如果有成功的，广播事件
-    if (results.success > 0) {
-        broadcastEvent('oauth_batch_success', {
-            provider: providerType,
-            count: results.success,
-            timestamp: new Date().toISOString()
-        });
-    }
-    
-    return results;
-}

src/auth/iflow-oauth.js

@@ -1,539 +0,0 @@
-import http from 'http';
-import logger from '../utils/logger.js';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import { broadcastEvent } from '../services/ui-manager.js';
-import { autoLinkProviderConfigs } from '../services/service-manager.js';
-import { CONFIG } from '../core/config-manager.js';
-import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
-
-/**
- * iFlow OAuth 配置
- */
-const IFLOW_OAUTH_CONFIG = {
-    // OAuth 端点
-    tokenEndpoint: 'https://iflow.cn/oauth/token',
-    authorizeEndpoint: 'https://iflow.cn/oauth',
-    userInfoEndpoint: 'https://iflow.cn/api/oauth/getUserInfo',
-    successRedirectURL: 'https://iflow.cn/oauth/success',
-    
-    // 客户端凭据
-    clientId: '10009311001',
-    clientSecret: '4Z3YjXycVsQvyGF1etiNlIBB4RsqSDtW',
-    
-    // 本地回调端口
-    callbackPort: 8087,
-    
-    // 凭据存储
-    credentialsDir: '.iflow',
-    credentialsFile: 'oauth_creds.json',
-    
-    // 日志前缀
-    logPrefix: '[iFlow Auth]'
-};
-
-/**
- * 活动的 iFlow 回调服务器管理
- */
-const activeIFlowServers = new Map();
-
-/**
- * 创建带代理支持的 fetch 请求
- * 使用 axios 替代原生 fetch，以正确支持代理配置
- * @param {string} url - 请求 URL
- * @param {Object} options - fetch 选项（兼容 fetch API 格式）
- * @param {string} providerType - 提供商类型，用于获取代理配置
- * @returns {Promise<Object>} 返回类似 fetch Response 的对象
- */
-async function fetchWithProxy(url, options = {}, providerType) {
-    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
-
-    // 构建 axios 配置
-    const axiosConfig = {
-        url,
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        timeout: 30000, // 30 秒超时
-    };
-
-    // 处理请求体
-    if (options.body) {
-        axiosConfig.data = options.body;
-    }
-
-    // 配置代理
-    if (proxyConfig) {
-        axiosConfig.httpAgent = proxyConfig.httpAgent;
-        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
-        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
-        logger.info(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
-    }
-
-    try {
-        const axios = (await import('axios')).default;
-        const response = await axios(axiosConfig);
-        
-        // 返回类似 fetch Response 的对象
-        return {
-            ok: response.status >= 200 && response.status < 300,
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-            json: async () => response.data,
-            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
-        };
-    } catch (error) {
-        // 处理 axios 错误，转换为类似 fetch 的响应格式
-        if (error.response) {
-            // 服务器返回了错误状态码
-            return {
-                ok: false,
-                status: error.response.status,
-                statusText: error.response.statusText,
-                headers: error.response.headers,
-                json: async () => error.response.data,
-                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
-            };
-        }
-        // 网络错误或其他错误
-        throw error;
-    }
-}
-
-/**
- * 生成 HTML 响应页面
- * @param {boolean} isSuccess - 是否成功
- * @param {string} message - 显示消息
- * @returns {string} HTML 内容
- */
-function generateResponsePage(isSuccess, message) {
-    const title = isSuccess ? '授权成功！' : '授权失败';
-    
-    return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${title}</title>
-</head>
-<body>
-    <div class="container">
-        <h1>${title}</h1>
-        <p>${message}</p>
-    </div>
-</body>
-</html>`;
-}
-
-/**
- * 生成 iFlow 授权链接
- * @param {string} state - 状态参数
- * @param {number} port - 回调端口
- * @returns {Object} 包含 authUrl 和 redirectUri
- */
-function generateIFlowAuthorizationURL(state, port) {
-    const redirectUri = `http://localhost:${port}/oauth2callback`;
-    const params = new URLSearchParams({
-        loginMethod: 'phone',
-        type: 'phone',
-        redirect: redirectUri,
-        state: state,
-        client_id: IFLOW_OAUTH_CONFIG.clientId
-    });
-    const authUrl = `${IFLOW_OAUTH_CONFIG.authorizeEndpoint}?${params.toString()}`;
-    return { authUrl, redirectUri };
-}
-
-/**
- * 交换授权码获取 iFlow 令牌
- * @param {string} code - 授权码
- * @param {string} redirectUri - 重定向 URI
- * @returns {Promise<Object>} 令牌数据
- */
-async function exchangeIFlowCodeForTokens(code, redirectUri) {
-    const form = new URLSearchParams({
-        grant_type: 'authorization_code',
-        code: code,
-        redirect_uri: redirectUri,
-        client_id: IFLOW_OAUTH_CONFIG.clientId,
-        client_secret: IFLOW_OAUTH_CONFIG.clientSecret
-    });
-    
-    // 生成 Basic Auth 头
-    const basicAuth = Buffer.from(`${IFLOW_OAUTH_CONFIG.clientId}:${IFLOW_OAUTH_CONFIG.clientSecret}`).toString('base64');
-
-    const response = await fetchWithProxy(IFLOW_OAUTH_CONFIG.tokenEndpoint, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Accept': 'application/json',
-            'Authorization': `Basic ${basicAuth}`
-        },
-        body: form.toString()
-    }, 'openai-iflow');
-
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`iFlow token exchange failed: ${response.status} ${errorText}`);
-    }
-    
-    const tokenData = await response.json();
-    
-    if (!tokenData.access_token) {
-        throw new Error('iFlow token: missing access token in response');
-    }
-    
-    return {
-        accessToken: tokenData.access_token,
-        refreshToken: tokenData.refresh_token,
-        tokenType: tokenData.token_type,
-        scope: tokenData.scope,
-        expiresIn: tokenData.expires_in,
-        expiresAt: new Date(Date.now() + tokenData.expires_in * 1000).toISOString()
-    };
-}
-
-/**
- * 获取 iFlow 用户信息（包含 API Key）
- * @param {string} accessToken - 访问令牌
- * @returns {Promise<Object>} 用户信息
- */
-async function fetchIFlowUserInfo(accessToken) {
-    if (!accessToken || accessToken.trim() === '') {
-        throw new Error('iFlow api key: access token is empty');
-    }
-    
-    const endpoint = `${IFLOW_OAUTH_CONFIG.userInfoEndpoint}?accessToken=${encodeURIComponent(accessToken)}`;
-
-    const response = await fetchWithProxy(endpoint, {
-        method: 'GET',
-        headers: {
-            'Accept': 'application/json'
-        }
-    }, 'openai-iflow');
-    
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`iFlow user info failed: ${response.status} ${errorText}`);
-    }
-    
-    const result = await response.json();
-    
-    if (!result.success) {
-        throw new Error('iFlow api key: request not successful');
-    }
-    
-    if (!result.data || !result.data.apiKey) {
-        throw new Error('iFlow api key: missing api key in response');
-    }
-    
-    // 获取邮箱或手机号作为账户标识
-    let email = (result.data.email || '').trim();
-    if (!email) {
-        email = (result.data.phone || '').trim();
-    }
-    if (!email) {
-        throw new Error('iFlow token: missing account email/phone in user info');
-    }
-    
-    return {
-        apiKey: result.data.apiKey,
-        email: email,
-        phone: result.data.phone || ''
-    };
-}
-
-/**
- * 关闭 iFlow 服务器
- * @param {string} provider - 提供商标识
- * @param {number} port - 端口号（可选）
- */
-async function closeIFlowServer(provider, port = null) {
-    const existing = activeIFlowServers.get(provider);
-    if (existing) {
-        try {
-            const closePromise = new Promise((resolve, reject) => {
-                existing.server.close((err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Server close timeout after 2s')), 2000);
-            });
-
-            await Promise.race([closePromise, timeoutPromise]);
-            logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
-        } catch (error) {
-            logger.warn(`${IFLOW_OAUTH_CONFIG.logPrefix} 关闭提供商 ${provider} 服务器失败或超时: ${error.message}`);
-        } finally {
-            activeIFlowServers.delete(provider);
-        }
-    }
-
-    if (port) {
-        for (const [p, info] of activeIFlowServers.entries()) {
-            if (info.port === port) {
-                await closeIFlowServer(p);
-            }
-        }
-    }
-}
-
-/**
- * 创建 iFlow OAuth 回调服务器
- * @param {number} port - 端口号
- * @param {string} redirectUri - 重定向 URI
- * @param {string} expectedState - 预期的 state 参数
- * @param {Object} options - 额外选项
- * @returns {Promise<http.Server>} HTTP 服务器实例
- */
-function createIFlowCallbackServer(port, redirectUri, expectedState, options = {}) {
-    return new Promise((resolve, reject) => {
-        const server = http.createServer(async (req, res) => {
-            try {
-                const url = new URL(req.url, `http://localhost:${port}`);
-                
-                if (url.pathname === '/oauth2callback') {
-                    const code = url.searchParams.get('code');
-                    const state = url.searchParams.get('state');
-                    const errorParam = url.searchParams.get('error');
-                    
-                    if (errorParam) {
-                        logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 授权失败: ${errorParam}`);
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, `授权失败: ${errorParam}`));
-                        server.close(() => {
-                            activeIFlowServers.delete('openai-iflow');
-                        });
-                        return;
-                    }
-                    
-                    if (state !== expectedState) {
-                        logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} State 验证失败`);
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, 'State 验证失败'));
-                        server.close(() => {
-                            activeIFlowServers.delete('openai-iflow');
-                        });
-                        return;
-                    }
-                    
-                    if (!code) {
-                        logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 缺少授权码`);
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, '缺少授权码'));
-                        server.close(() => {
-                            activeIFlowServers.delete('openai-iflow');
-                        });
-                        return;
-                    }
-                    
-                    logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 收到授权回调，正在交换令牌...`);
-                    
-                    try {
-                        // 1. 交换授权码获取令牌
-                        const tokenData = await exchangeIFlowCodeForTokens(code, redirectUri);
-                        logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 令牌交换成功`);
-                        
-                        // 2. 获取用户信息（包含 API Key）
-                        const userInfo = await fetchIFlowUserInfo(tokenData.accessToken);
-                        logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 用户信息获取成功: ${userInfo.email}`);
-                        
-                        // 3. 组合完整的凭据数据
-                        const credentialsData = {
-                            access_token: tokenData.accessToken,
-                            refresh_token: tokenData.refreshToken,
-                            expiry_date: new Date(tokenData.expiresAt).getTime(),
-                            token_type: tokenData.tokenType,
-                            scope: tokenData.scope,
-                            apiKey: userInfo.apiKey
-                        };
-                        
-                        // 4. 保存凭据
-                        let credPath = path.join(os.homedir(), IFLOW_OAUTH_CONFIG.credentialsDir, IFLOW_OAUTH_CONFIG.credentialsFile);
-                        
-                        if (options.saveToConfigs) {
-                            const providerDir = options.providerDir || 'iflow';
-                            const targetDir = path.join(process.cwd(), 'configs', providerDir);
-                            await fs.promises.mkdir(targetDir, { recursive: true });
-                            const timestamp = Date.now();
-                            const filename = `${timestamp}_oauth_creds.json`;
-                            credPath = path.join(targetDir, filename);
-                        }
-                        
-                        await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
-                        await fs.promises.writeFile(credPath, JSON.stringify(credentialsData, null, 2));
-                        logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 凭据已保存: ${credPath}`);
-                        
-                        const relativePath = path.relative(process.cwd(), credPath);
-                        
-                        // 5. 广播授权成功事件
-                        broadcastEvent('oauth_success', {
-                            provider: 'openai-iflow',
-                            credPath: credPath,
-                            relativePath: relativePath,
-                            email: userInfo.email,
-                            timestamp: new Date().toISOString()
-                        });
-                        
-                        // 6. 自动关联新生成的凭据到 Pools
-                        await autoLinkProviderConfigs(CONFIG, {
-                            onlyCurrentCred: true,
-                            credPath: relativePath
-                        });
-                        
-                        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(true, `授权成功！账户: ${userInfo.email}，您可���关闭此页面`));
-                        
-                    } catch (tokenError) {
-                        logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 令牌处理失败:`, tokenError);
-                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, `令牌处理失败: ${tokenError.message}`));
-                    } finally {
-                        server.close(() => {
-                            activeIFlowServers.delete('openai-iflow');
-                        });
-                    }
-                } else {
-                    // 忽略其他请求
-                    res.writeHead(204);
-                    res.end();
-                }
-            } catch (error) {
-                logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 处理回调出错:`, error);
-                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
-                
-                if (server.listening) {
-                    server.close(() => {
-                        activeIFlowServers.delete('openai-iflow');
-                    });
-                }
-            }
-        });
-        
-        server.on('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 端口 ${port} 已被占用`);
-                reject(new Error(`端口 ${port} 已被占用`));
-            } else {
-                logger.error(`${IFLOW_OAUTH_CONFIG.logPrefix} 服务器错误:`, err);
-                reject(err);
-            }
-        });
-        
-        const host = '0.0.0.0';
-        server.listen(port, host, () => {
-            logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} OAuth 回调服务器已启动于 ${host}:${port}`);
-            resolve(server);
-        });
-        
-        // 10 分钟超时自动关闭
-        setTimeout(() => {
-            if (server.listening) {
-                logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 回调服务器超时，自动关闭`);
-                server.close(() => {
-                    activeIFlowServers.delete('openai-iflow');
-                });
-            }
-        }, 10 * 60 * 1000);
-    });
-}
-
-/**
- * 处理 iFlow OAuth 授权
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- *   - port: 自定义端口号
- *   - saveToConfigs: 是否保存到 configs 目录
- *   - providerDir: 提供商目录名
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-export async function handleIFlowOAuth(currentConfig, options = {}) {
-    const port = parseInt(options.port) || IFLOW_OAUTH_CONFIG.callbackPort;
-    const providerKey = 'openai-iflow';
-    
-    // 生成 state 参数
-    const state = crypto.randomBytes(16).toString('base64url');
-    
-    // 生成授权链接
-    const { authUrl, redirectUri } = generateIFlowAuthorizationURL(state, port);
-    
-    logger.info(`${IFLOW_OAUTH_CONFIG.logPrefix} 生成授权链接: ${authUrl}`);
-    
-    // 关闭之前可能存在的服务器
-    await closeIFlowServer(providerKey, port);
-    
-    // 启动回调服务器
-    try {
-        const server = await createIFlowCallbackServer(port, redirectUri, state, options);
-        activeIFlowServers.set(providerKey, { server, port });
-    } catch (error) {
-        throw new Error(`启动 iFlow 回调服务器失败: ${error.message}`);
-    }
-    
-    return {
-        authUrl,
-        authInfo: {
-            provider: 'openai-iflow',
-            redirectUri: redirectUri,
-            callbackPort: port,
-            state: state,
-            ...options
-        }
-    };
-}
-
-/**
- * 使用 refresh_token 刷新 iFlow 令牌
- * @param {string} refreshToken - 刷新令牌
- * @returns {Promise<Object>} 新的令牌数据
- */
-export async function refreshIFlowTokens(refreshToken) {
-    const form = new URLSearchParams({
-        grant_type: 'refresh_token',
-        refresh_token: refreshToken,
-        client_id: IFLOW_OAUTH_CONFIG.clientId,
-        client_secret: IFLOW_OAUTH_CONFIG.clientSecret
-    });
-    
-    // 生成 Basic Auth 头
-    const basicAuth = Buffer.from(`${IFLOW_OAUTH_CONFIG.clientId}:${IFLOW_OAUTH_CONFIG.clientSecret}`).toString('base64');
-
-    const response = await fetchWithProxy(IFLOW_OAUTH_CONFIG.tokenEndpoint, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            'Accept': 'application/json',
-            'Authorization': `Basic ${basicAuth}`
-        },
-        body: form.toString()
-    }, 'openai-iflow');
-
-    if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`iFlow token refresh failed: ${response.status} ${errorText}`);
-    }
-    
-    const tokenData = await response.json();
-    
-    if (!tokenData.access_token) {
-        throw new Error('iFlow token refresh: missing access token in response');
-    }
-    
-    // 获取用户信息以更新 API Key
-    const userInfo = await fetchIFlowUserInfo(tokenData.access_token);
-    
-    return {
-        access_token: tokenData.access_token,
-        refresh_token: tokenData.refresh_token,
-        expiry_date: Date.now() + tokenData.expires_in * 1000,
-        token_type: tokenData.token_type,
-        scope: tokenData.scope,
-        apiKey: userInfo.apiKey
-    };
-}

src/auth/index.js

@@ -1,35 +0,0 @@
-// Codex OAuth
-export {
-    refreshCodexTokensWithRetry,
-    handleCodexOAuth,
-    handleCodexOAuthCallback,
-    batchImportCodexTokensStream
-} from './codex-oauth.js';
-
-// Gemini OAuth
-export {
-    handleGeminiCliOAuth,
-    handleGeminiAntigravityOAuth,
-    batchImportGeminiTokensStream,
-    checkGeminiCredentialsDuplicate
-} from './gemini-oauth.js';
-
-// Qwen OAuth
-export {
-    handleQwenOAuth
-} from './qwen-oauth.js';
-
-// Kiro OAuth
-export {
-    handleKiroOAuth,
-    checkKiroCredentialsDuplicate,
-    batchImportKiroRefreshTokens,
-    batchImportKiroRefreshTokensStream,
-    importAwsCredentials
-} from './kiro-oauth.js';
-
-// iFlow OAuth
-export {
-    handleIFlowOAuth,
-    refreshIFlowTokens
-} from './iflow-oauth.js';

src/auth/kiro-oauth.js

@@ -1,1149 +0,0 @@
-import http from 'http';
-import logger from '../utils/logger.js';
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import os from 'os';
-import { broadcastEvent } from '../services/ui-manager.js';
-import { autoLinkProviderConfigs } from '../services/service-manager.js';
-import { CONFIG } from '../core/config-manager.js';
-import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
-
-/**
- * Kiro OAuth 配置（支持多种认证方式）
- */
-const KIRO_OAUTH_CONFIG = {
-    // Kiro Auth Service 端点 (用于 Social Auth)
-    authServiceEndpoint: 'https://prod.us-east-1.auth.desktop.kiro.dev',
-    
-    // AWS SSO OIDC 端点 (用于 Builder ID)
-    ssoOIDCEndpoint: 'https://oidc.{{region}}.amazonaws.com',
-    
-    // AWS Builder ID 起始 URL
-    builderIDStartURL: 'https://view.awsapps.com/start',
-    
-    // 本地回调端口范围（用于 Social Auth HTTP 回调）
-    callbackPortStart: 19876,
-    callbackPortEnd: 19880,
-    
-    // 超时配置
-    authTimeout: 10 * 60 * 1000,  // 10 分钟
-    pollInterval: 5000,           // 5 秒
-    
-    // CodeWhisperer Scopes
-    scopes: [
-        'codewhisperer:completions',
-        'codewhisperer:analysis',
-        'codewhisperer:conversations',
-        // 'codewhisperer:transformations',
-        // 'codewhisperer:taskassist'
-    ],
-    
-    // 凭据存储（符合现有规范）
-    credentialsDir: '.kiro',
-    credentialsFile: 'oauth_creds.json',
-    
-    // 日志前缀
-    logPrefix: '[Kiro Auth]'
-};
-
-/**
- * 活动的 Kiro 回调服务器管理
- */
-const activeKiroServers = new Map();
-
-/**
- * 活动的 Kiro 轮询任务管理（用于 Builder ID Device Code）
- */
-const activeKiroPollingTasks = new Map();
-
-/**
- * 创建带代理支持的 fetch 请求
- * 使用 axios 替代原生 fetch，以正确支持代理配置
- * @param {string} url - 请求 URL
- * @param {Object} options - fetch 选项（兼容 fetch API 格式）
- * @param {string} providerType - 提供商类型，用于获取代理配置
- * @returns {Promise<Object>} 返回类似 fetch Response 的对象
- */
-async function fetchWithProxy(url, options = {}, providerType) {
-    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
-
-    // 构建 axios 配置
-    const axiosConfig = {
-        url,
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        timeout: 30000, // 30 秒超时
-    };
-
-    // 处理请求体
-    if (options.body) {
-        axiosConfig.data = options.body;
-    }
-
-    // 配置代理
-    if (proxyConfig) {
-        axiosConfig.httpAgent = proxyConfig.httpAgent;
-        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
-        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
-        logger.info(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
-    }
-
-    try {
-        const axios = (await import('axios')).default;
-        const response = await axios(axiosConfig);
-        
-        // 返回类似 fetch Response 的对象
-        return {
-            ok: response.status >= 200 && response.status < 300,
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-            json: async () => response.data,
-            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
-        };
-    } catch (error) {
-        // 处理 axios 错误，转换为类似 fetch 的响应格式
-        if (error.response) {
-            // 服务器返回了错误状态码
-            return {
-                ok: false,
-                status: error.response.status,
-                statusText: error.response.statusText,
-                headers: error.response.headers,
-                json: async () => error.response.data,
-                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
-            };
-        }
-        // 网络错误或其他错误
-        throw error;
-    }
-}
-
-/**
- * 生成 HTML 响应页面
- * @param {boolean} isSuccess - 是否成功
- * @param {string} message - 显示消息
- * @returns {string} HTML 内容
- */
-function generateResponsePage(isSuccess, message) {
-    const title = isSuccess ? '授权成功！' : '授权失败';
-    
-    return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${title}</title>
-</head>
-<body>
-    <div class="container">
-        <h1>${title}</h1>
-        <p>${message}</p>
-    </div>
-</body>
-</html>`;
-}
-
-/**
- * 生成 PKCE 代码验证器
- * @returns {string} Base64URL 编码的随机字符串
- */
-function generateCodeVerifier() {
-    return crypto.randomBytes(32).toString('base64url');
-}
-
-/**
- * 生成 PKCE 代码挑战
- * @param {string} codeVerifier - 代码验证器
- * @returns {string} Base64URL 编码的 SHA256 哈希
- */
-function generateCodeChallenge(codeVerifier) {
-    const hash = crypto.createHash('sha256');
-    hash.update(codeVerifier);
-    return hash.digest('base64url');
-}
-
-/**
- * 处理 Kiro OAuth 授权（统一入口）
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- *   - method: 'google' | 'github' | 'builder-id'
- *   - saveToConfigs: boolean
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-export async function handleKiroOAuth(currentConfig, options = {}) {
-    const method = options.method || options.authMethod || 'google';  // 默认使用 Google，同时支持 authMethod 参数
-    
-    logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Starting OAuth with method: ${method}`);
-    
-    switch (method) {
-        case 'google':
-            return handleKiroSocialAuth('Google', currentConfig, options);
-        case 'github':
-            return handleKiroSocialAuth('Github', currentConfig, options);
-        case 'builder-id':
-            return handleKiroBuilderIDDeviceCode(currentConfig, options);
-        default:
-            throw new Error(`不支持的认证方式: ${method}`);
-    }
-}
-
-/**
- * Kiro Social Auth (Google/GitHub) - 使用 HTTP localhost 回调
- */
-async function handleKiroSocialAuth(provider, currentConfig, options = {}) {
-    // 生成 PKCE 参数
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = generateCodeChallenge(codeVerifier);
-    const state = crypto.randomBytes(16).toString('base64url');
-    
-    // 启动本地回调服务器并获取端口
-    let handlerPort;
-    const providerKey = 'claude-kiro-oauth';
-    if (options.port) {
-        const port = parseInt(options.port);
-        await closeKiroServer(providerKey, port);
-        const server = await createKiroHttpCallbackServer(port, codeVerifier, state, options);
-        activeKiroServers.set(providerKey, { server, port });
-        handlerPort = port;
-    } else {
-        handlerPort = await startKiroCallbackServer(codeVerifier, state, options);
-    }
-    
-    // 使用 HTTP localhost 作为 redirect_uri
-    const redirectUri = `http://127.0.0.1:${handlerPort}/oauth/callback`;
-    
-    // 构建授权 URL
-    const authUrl = `${KIRO_OAUTH_CONFIG.authServiceEndpoint}/login?` +
-        `idp=${provider}&` +
-        `redirect_uri=${encodeURIComponent(redirectUri)}&` +
-        `code_challenge=${codeChallenge}&` +
-        `code_challenge_method=S256&` +
-        `state=${state}&` +
-        `prompt=select_account`;
-    
-    return {
-        authUrl,
-        authInfo: {
-            provider: 'claude-kiro-oauth',
-            authMethod: 'social',
-            socialProvider: provider,
-            port: handlerPort,
-            redirectUri: redirectUri,
-            state: state,
-            ...options
-        }
-    };
-}
-
-/**
- * Kiro Builder ID - Device Code Flow（类似 Qwen OAuth 模式）
- */
-async function handleKiroBuilderIDDeviceCode(currentConfig, options = {}) {
-    // 停止之前的轮询任务
-    for (const [existingTaskId] of activeKiroPollingTasks.entries()) {
-        if (existingTaskId.startsWith('kiro-')) {
-            stopKiroPollingTask(existingTaskId);
-        }
-    }
-
-    // 获取 Builder ID Start URL（优先使用前端传入的值，否则使用默认值）
-    const builderIDStartURL = options.builderIDStartURL || KIRO_OAUTH_CONFIG.builderIDStartURL;
-    logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Using Builder ID Start URL: ${builderIDStartURL}`);
-
-    // 1. 注册 OIDC 客户端
-    const region = options.region || 'us-east-1';
-    const ssoOIDCEndpoint = KIRO_OAUTH_CONFIG.ssoOIDCEndpoint.replace('{{region}}', region);
-    
-    const regResponse = await fetchWithProxy(`${ssoOIDCEndpoint}/client/register`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': 'KiroIDE'
-        },
-        body: JSON.stringify({
-            clientName: 'Kiro IDE',
-            clientType: 'public',
-            scopes: KIRO_OAUTH_CONFIG.scopes,
-            // grantTypes: ['urn:ietf:params:oauth:grant-type:device_code', 'refresh_token']
-        })
-    }, 'claude-kiro-oauth');
-    
-    if (!regResponse.ok) {
-        throw new Error(`Kiro OAuth 客户端注册失败: ${regResponse.status}`);
-    }
-    
-    const regData = await regResponse.json();
-    
-    // 2. 启动设备授权
-    const authResponse = await fetchWithProxy(`${ssoOIDCEndpoint}/device_authorization`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-            clientId: regData.clientId,
-            clientSecret: regData.clientSecret,
-            startUrl: builderIDStartURL
-        })
-    }, 'claude-kiro-oauth');
-    
-    if (!authResponse.ok) {
-        throw new Error(`Kiro OAuth 设备授权失败: ${authResponse.status}`);
-    }
-    
-    const deviceAuth = await authResponse.json();
-    
-    // 3. 启动后台轮询（类似 Qwen OAuth 的模式）
-    const taskId = `kiro-${deviceAuth.deviceCode.substring(0, 8)}-${Date.now()}`;
-
-    
-    // 异步轮询
-    pollKiroBuilderIDToken(
-        regData.clientId,
-        regData.clientSecret,
-        deviceAuth.deviceCode,
-        5, 
-        300, 
-        taskId,
-        { ...options, region }
-    ).catch(error => {
-        logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} 轮询失败 [${taskId}]:`, error);
-        broadcastEvent('oauth_error', {
-            provider: 'claude-kiro-oauth',
-            error: error.message,
-            timestamp: new Date().toISOString()
-        });
-    });
-    
-    return {
-        authUrl: deviceAuth.verificationUriComplete,
-        authInfo: {
-            provider: 'claude-kiro-oauth',
-            authMethod: 'builder-id',
-            deviceCode: deviceAuth.deviceCode,
-            userCode: deviceAuth.userCode,
-            verificationUri: deviceAuth.verificationUri,
-            verificationUriComplete: deviceAuth.verificationUriComplete,
-            expiresIn: deviceAuth.expiresIn,
-            interval: deviceAuth.interval,
-            ...options
-        }
-    };
-}
-
-/**
- * 轮询获取 Kiro Builder ID Token
- */
-async function pollKiroBuilderIDToken(clientId, clientSecret, deviceCode, interval, expiresIn, taskId, options = {}) {
-    let credPath = path.join(os.homedir(), KIRO_OAUTH_CONFIG.credentialsDir, KIRO_OAUTH_CONFIG.credentialsFile);
-    const maxAttempts = Math.floor(expiresIn / interval);
-    let attempts = 0;
-    
-    const taskControl = { shouldStop: false };
-    activeKiroPollingTasks.set(taskId, taskControl);
-    
-    logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 开始轮询令牌 [${taskId}]`);
-    
-    const poll = async () => {
-        if (taskControl.shouldStop) {
-            throw new Error('轮询任务已被取消');
-        }
-        
-        if (attempts >= maxAttempts) {
-            activeKiroPollingTasks.delete(taskId);
-            throw new Error('授权超时');
-        }
-        
-        attempts++;
-        
-        try {
-            const region = options.region || 'us-east-1';
-            const ssoOIDCEndpoint = KIRO_OAUTH_CONFIG.ssoOIDCEndpoint.replace('{{region}}', region);
-            const response = await fetchWithProxy(`${ssoOIDCEndpoint}/token`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'User-Agent': 'KiroIDE'
-                },
-                body: JSON.stringify({
-                    clientId,
-                    clientSecret,
-                    deviceCode,
-                    grantType: 'urn:ietf:params:oauth:grant-type:device_code'
-                })
-            }, 'claude-kiro-oauth');
-            
-            const data = await response.json();
-            
-            if (response.ok && data.accessToken) {
-                logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 成功获取令牌 [${taskId}]`);
-                
-                // 保存令牌（符合现有规范）
-                if (options.saveToConfigs) {
-                    const timestamp = Date.now();
-                    const folderName = `${timestamp}_kiro-auth-token`;
-                    const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
-                    await fs.promises.mkdir(targetDir, { recursive: true });
-                    credPath = path.join(targetDir, `${folderName}.json`);
-                }
-                
-                const tokenData = {
-                    accessToken: data.accessToken,
-                    refreshToken: data.refreshToken,
-                    expiresAt: new Date(Date.now() + data.expiresIn * 1000).toISOString(),
-                    authMethod: 'builder-id',
-                    clientId,
-                    clientSecret,
-                    idcRegion: options.region || 'us-east-1'
-                };
-                
-                await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
-                await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
-                
-                activeKiroPollingTasks.delete(taskId);
-                
-                // 广播成功事件（符合现有规范）
-                broadcastEvent('oauth_success', {
-                    provider: 'claude-kiro-oauth',
-                    credPath,
-                    relativePath: path.relative(process.cwd(), credPath),
-                    timestamp: new Date().toISOString()
-                });
-                
-                // 自动关联新生成的凭据到 Pools
-                await autoLinkProviderConfigs(CONFIG, {
-                    onlyCurrentCred: true,
-                    credPath: path.relative(process.cwd(), credPath)
-                });
-                
-                return tokenData;
-            }
-            
-            // 检查错误类型
-            if (data.error === 'authorization_pending') {
-                logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 等待用户授权 [${taskId}]... (${attempts}/${maxAttempts})`);
-                await new Promise(resolve => setTimeout(resolve, interval * 1000));
-                return poll();
-            } else if (data.error === 'slow_down') {
-                await new Promise(resolve => setTimeout(resolve, (interval + 5) * 1000));
-                return poll();
-            } else {
-                activeKiroPollingTasks.delete(taskId);
-                throw new Error(`授权失败: ${data.error || '未知错误'}`);
-            }
-        } catch (error) {
-            if (error.message.includes('授权') || error.message.includes('取消')) {
-                throw error;
-            }
-            await new Promise(resolve => setTimeout(resolve, interval * 1000));
-            return poll();
-        }
-    };
-    
-    return poll();
-}
-
-/**
- * 停止 Kiro 轮询任务
- */
-function stopKiroPollingTask(taskId) {
-    const task = activeKiroPollingTasks.get(taskId);
-    if (task) {
-        task.shouldStop = true;
-        activeKiroPollingTasks.delete(taskId);
-        logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 已停止轮询任务: ${taskId}`);
-    }
-}
-
-/**
- * 启动 Kiro 回调服务器（用于 Social Auth HTTP 回调）
- */
-async function startKiroCallbackServer(codeVerifier, expectedState, options = {}) {
-    const portStart = KIRO_OAUTH_CONFIG.callbackPortStart;
-    const portEnd = KIRO_OAUTH_CONFIG.callbackPortEnd;
-    
-    for (let port = portStart; port <= portEnd; port++) {
-    // 关闭已存在的服务器
-    await closeKiroServer(port);
-    
-    try {
-        const server = await createKiroHttpCallbackServer(port, codeVerifier, expectedState, options);
-        activeKiroServers.set('claude-kiro-oauth', { server, port });
-        logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 回调服务器已启动于端口 ${port}`);
-        return port;
-    } catch (err) {
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 端口 ${port} 被占用，尝试下一个...`);
-    }
-    }
-    
-    throw new Error('所有端口都被占用');
-}
-
-/**
- * 关闭 Kiro 服务器
- */
-async function closeKiroServer(provider, port = null) {
-    const existing = activeKiroServers.get(provider);
-    if (existing) {
-        try {
-            const closePromise = new Promise((resolve, reject) => {
-                existing.server.close((err) => {
-                    if (err) reject(err);
-                    else resolve();
-                });
-            });
-
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error('Server close timeout after 2s')), 2000);
-            });
-
-            await Promise.race([closePromise, timeoutPromise]);
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 已关闭提供商 ${provider} 在端口 ${existing.port} 上的旧服务器`);
-        } catch (error) {
-            logger.warn(`${KIRO_OAUTH_CONFIG.logPrefix} 关闭提供商 ${provider} 服务器失败或超时: ${error.message}`);
-        } finally {
-            activeKiroServers.delete(provider);
-        }
-    }
-
-    if (port) {
-        for (const [p, info] of activeKiroServers.entries()) {
-            if (info.port === port) {
-                await closeKiroServer(p);
-            }
-        }
-    }
-}
-
-/**
- * 创建 Kiro HTTP 回调服务器
- */
-function createKiroHttpCallbackServer(port, codeVerifier, expectedState, options = {}) {
-    const redirectUri = `http://127.0.0.1:${port}/oauth/callback`;
-    
-    return new Promise((resolve, reject) => {
-        const server = http.createServer(async (req, res) => {
-            try {
-                const url = new URL(req.url, `http://127.0.0.1:${port}`);
-                
-                if (url.pathname === '/oauth/callback') {
-                    const code = url.searchParams.get('code');
-                    const state = url.searchParams.get('state');
-                    const errorParam = url.searchParams.get('error');
-                    
-                    if (errorParam) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, `授权失败: ${errorParam}`));
-                        return;
-                    }
-                    
-                    if (state !== expectedState) {
-                        res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, 'State 验证失败'));
-                        return;
-                    }
-                    
-                    // 交换 Code 获取 Token（使用动态的 redirect_uri）
-                    const tokenResponse = await fetchWithProxy(`${KIRO_OAUTH_CONFIG.authServiceEndpoint}/oauth/token`, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'User-Agent': 'AIClient-2-API/1.0.0'
-                        },
-                        body: JSON.stringify({
-                            code,
-                            code_verifier: codeVerifier,
-                            redirect_uri: redirectUri
-                        })
-                    }, 'claude-kiro-oauth');
-                    
-                    if (!tokenResponse.ok) {
-                        const errorText = await tokenResponse.text();
-                        logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token exchange failed:`, errorText);
-                        res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                        res.end(generateResponsePage(false, `获取令牌失败: ${tokenResponse.status}`));
-                        return;
-                    }
-                    
-                    const tokenData = await tokenResponse.json();
-                    
-                    // 保存令牌
-                    let credPath = path.join(os.homedir(), KIRO_OAUTH_CONFIG.credentialsDir, KIRO_OAUTH_CONFIG.credentialsFile);
-                    
-                    if (options.saveToConfigs) {
-                        const timestamp = Date.now();
-                        const folderName = `${timestamp}_kiro-auth-token`;
-                        const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
-                        await fs.promises.mkdir(targetDir, { recursive: true });
-                        credPath = path.join(targetDir, `${folderName}.json`);
-                    }
-                    
-                    const saveData = {
-                        accessToken: tokenData.accessToken,
-                        refreshToken: tokenData.refreshToken,
-                        profileArn: tokenData.profileArn,
-                        expiresAt: new Date(Date.now() + (tokenData.expiresIn || 3600) * 1000).toISOString(),
-                        authMethod: 'social',
-                        region: 'us-east-1'
-                    };
-                    
-                    await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
-                    await fs.promises.writeFile(credPath, JSON.stringify(saveData, null, 2));
-                    
-                    logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 令牌已保存: ${credPath}`);
-                    
-                    // 广播成功事件
-                    broadcastEvent('oauth_success', {
-                        provider: 'claude-kiro-oauth',
-                        credPath,
-                        relativePath: path.relative(process.cwd(), credPath),
-                        timestamp: new Date().toISOString()
-                    });
-                    
-                    // 自动关联新生成的凭据到 Pools
-                    await autoLinkProviderConfigs(CONFIG, {
-                        onlyCurrentCred: true,
-                        credPath: path.relative(process.cwd(), credPath)
-                    });
-                    
-                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-                    res.end(generateResponsePage(true, '授权成功！您可以关闭此页面'));
-                    
-                    // 关闭服务器
-                    server.close(() => {
-                        activeKiroServers.delete('claude-kiro-oauth');
-                    });
-                    
-                } else {
-                    res.writeHead(204);
-                    res.end();
-                }
-            } catch (error) {
-                logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} 处理回调出错:`, error);
-                res.writeHead(500, { 'Content-Type': 'text/html; charset=utf-8' });
-                res.end(generateResponsePage(false, `服务器错误: ${error.message}`));
-            }
-        });
-        
-        server.on('error', reject);
-        server.listen(port, '127.0.0.1', () => resolve(server));
-        
-        // 超时自动关闭
-        setTimeout(() => {
-            if (server.listening) {
-                server.close(() => {
-                    activeKiroServers.delete('claude-kiro-oauth');
-                });
-            }
-        }, KIRO_OAUTH_CONFIG.authTimeout);
-    });
-}
-
-/**
- * Kiro Token 刷新常量
- */
-const KIRO_REFRESH_CONSTANTS = {
-    REFRESH_URL: 'https://prod.{{region}}.auth.desktop.kiro.dev/refreshToken',
-    REFRESH_IDC_URL: 'https://oidc.{{region}}.amazonaws.com/token',
-    CONTENT_TYPE_JSON: 'application/json',
-    AUTH_METHOD_SOCIAL: 'social',
-    DEFAULT_PROVIDER: 'Google',
-    REQUEST_TIMEOUT: 30000,
-    DEFAULT_REGION: 'us-east-1',
-    IDC_REGION: 'us-east-1'  // 用于 REFRESH_IDC_URL 的区域配置
-};
-
-/**
- * 通过 refreshToken 获取 accessToken
- * @param {string} refreshToken - Kiro 的 refresh token
- * @param {string} region - AWS 区域 (默认: us-east-1)
- * @returns {Promise<Object>} 包含 accessToken 等信息的对象
- */
-async function refreshKiroToken(refreshToken, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION) {
-    const refreshUrl = KIRO_REFRESH_CONSTANTS.REFRESH_URL.replace('{{region}}', region);
-    
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), KIRO_REFRESH_CONSTANTS.REQUEST_TIMEOUT);
-    
-    try {
-        const response = await fetchWithProxy(refreshUrl, {
-            method: 'POST',
-            headers: {
-                'Content-Type': KIRO_REFRESH_CONSTANTS.CONTENT_TYPE_JSON
-            },
-            body: JSON.stringify({ refreshToken }),
-            signal: controller.signal
-        }, 'claude-kiro-oauth');
-        
-        clearTimeout(timeoutId);
-        
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`HTTP ${response.status}: ${errorText}`);
-        }
-        
-        const data = await response.json();
-        
-        if (!data.accessToken) {
-            throw new Error('Invalid refresh response: Missing accessToken');
-        }
-        
-        const expiresIn = data.expiresIn || 3600;
-        const expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
-        
-        return {
-            accessToken: data.accessToken,
-            refreshToken: data.refreshToken || refreshToken,
-            profileArn: data.profileArn || '',
-            expiresAt: expiresAt,
-            authMethod: KIRO_REFRESH_CONSTANTS.AUTH_METHOD_SOCIAL,
-            provider: KIRO_REFRESH_CONSTANTS.DEFAULT_PROVIDER,
-            region: region
-        };
-    } catch (error) {
-        clearTimeout(timeoutId);
-        if (error.name === 'AbortError') {
-            throw new Error('Request timeout');
-        }
-        throw error;
-    }
-}
-
-/**
- * 检查 Kiro 凭据是否已存在（基于 refreshToken + provider 组合）
- * @param {string} refreshToken - 要检查的 refreshToken
- * @param {string} provider - 提供商名称 (默认: 'claude-kiro-oauth')
- * @returns {Promise<{isDuplicate: boolean, existingPath?: string}>} 检查结果
- */
-export async function checkKiroCredentialsDuplicate(refreshToken, provider = 'claude-kiro-oauth') {
-    const kiroDir = path.join(process.cwd(), 'configs', 'kiro');
-    
-    try {
-        // 检查 configs/kiro 目录是否存在
-        if (!fs.existsSync(kiroDir)) {
-            return { isDuplicate: false };
-        }
-        
-        // 递归扫描所有 JSON 文件
-        const scanDirectory = async (dirPath) => {
-            const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
-            
-            for (const entry of entries) {
-                const fullPath = path.join(dirPath, entry.name);
-                
-                if (entry.isDirectory()) {
-                    const result = await scanDirectory(fullPath);
-                    if (result.isDuplicate) {
-                        return result;
-                    }
-                } else if (entry.isFile() && entry.name.endsWith('.json')) {
-                    try {
-                        const content = await fs.promises.readFile(fullPath, 'utf8');
-                        const credentials = JSON.parse(content);
-                        
-                        // 检查 refreshToken 是否匹配
-                        if (credentials.refreshToken && credentials.refreshToken === refreshToken) {
-                            const relativePath = path.relative(process.cwd(), fullPath);
-                            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Found duplicate refreshToken in: ${relativePath}`);
-                            return {
-                                isDuplicate: true,
-                                existingPath: relativePath
-                            };
-                        }
-                    } catch (parseError) {
-                        // 忽略解析错误的文件
-                    }
-                }
-            }
-            
-            return { isDuplicate: false };
-        };
-        
-        return await scanDirectory(kiroDir);
-        
-    } catch (error) {
-        logger.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Error checking duplicates:`, error.message);
-        return { isDuplicate: false };
-    }
-}
-
-/**
- * 批量导入 Kiro refreshToken 并生成凭据文件
- * @param {string[]} refreshTokens - refreshToken 数组
- * @param {string} region - AWS 区域 (默认: us-east-1)
- * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
- * @returns {Promise<Object>} 批量处理结果
- */
-export async function batchImportKiroRefreshTokens(refreshTokens, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION, skipDuplicateCheck = false) {
-    const results = {
-        total: refreshTokens.length,
-        success: 0,
-        failed: 0,
-        details: []
-    };
-    
-    for (let i = 0; i < refreshTokens.length; i++) {
-        const refreshToken = refreshTokens[i].trim();
-        
-        if (!refreshToken) {
-            results.details.push({
-                index: i + 1,
-                success: false,
-                error: 'Empty token'
-            });
-            results.failed++;
-            continue;
-        }
-        
-        // 检查重复
-        if (!skipDuplicateCheck) {
-            const duplicateCheck = await checkKiroCredentialsDuplicate(refreshToken);
-            if (duplicateCheck.isDuplicate) {
-                results.details.push({
-                    index: i + 1,
-                    success: false,
-                    error: 'duplicate',
-                    existingPath: duplicateCheck.existingPath
-                });
-                results.failed++;
-                continue;
-            }
-        }
-        
-        try {
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 正在刷新第 ${i + 1}/${refreshTokens.length} 个 token...`);
-            
-            const tokenData = await refreshKiroToken(refreshToken, region);
-            
-            // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
-            const timestamp = Date.now();
-            const folderName = `${timestamp}_kiro-auth-token`;
-            const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
-            await fs.promises.mkdir(targetDir, { recursive: true });
-            
-            const credPath = path.join(targetDir, `${folderName}.json`);
-            await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
-            
-            const relativePath = path.relative(process.cwd(), credPath);
-            
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 已保存: ${relativePath}`);
-            
-            results.details.push({
-                index: i + 1,
-                success: true,
-                path: relativePath,
-                expiresAt: tokenData.expiresAt
-            });
-            results.success++;
-            
-        } catch (error) {
-            logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 刷新失败:`, error.message);
-            
-            results.details.push({
-                index: i + 1,
-                success: false,
-                error: error.message
-            });
-            results.failed++;
-        }
-    }
-    
-    // 如果有成功的，广播事件并自动关联
-    if (results.success > 0) {
-        broadcastEvent('oauth_batch_success', {
-            provider: 'claude-kiro-oauth',
-            count: results.success,
-            timestamp: new Date().toISOString()
-        });
-        
-        // 自动关联新生成的凭据到 Pools
-        for (const detail of results.details) {
-            if (detail.success && detail.path) {
-                await autoLinkProviderConfigs(CONFIG, {
-                    onlyCurrentCred: true,
-                    credPath: detail.path
-                });
-            }
-        }
-    }
-    
-    return results;
-}
-
-/**
- * 批量导入 Kiro refreshToken 并生成凭据文件（流式版本，支持实时进度回调）
- * @param {string[]} refreshTokens - refreshToken 数组
- * @param {string} region - AWS 区域 (默认: us-east-1)
- * @param {Function} onProgress - 进度回调函数，每处理完一个 token 调用
- * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
- * @returns {Promise<Object>} 批量处理结果
- */
-export async function batchImportKiroRefreshTokensStream(refreshTokens, region = KIRO_REFRESH_CONSTANTS.DEFAULT_REGION, onProgress = null, skipDuplicateCheck = false) {
-    const results = {
-        total: refreshTokens.length,
-        success: 0,
-        failed: 0,
-        details: []
-    };
-    
-    for (let i = 0; i < refreshTokens.length; i++) {
-        const refreshToken = refreshTokens[i].trim();
-        const progressData = {
-            index: i + 1,
-            total: refreshTokens.length,
-            current: null
-        };
-        
-        if (!refreshToken) {
-            progressData.current = {
-                index: i + 1,
-                success: false,
-                error: 'Empty token'
-            };
-            results.details.push(progressData.current);
-            results.failed++;
-            
-            // 发送进度更新
-            if (onProgress) {
-                onProgress({
-                    ...progressData,
-                    successCount: results.success,
-                    failedCount: results.failed
-                });
-            }
-            continue;
-        }
-        
-        // 检查重复
-        if (!skipDuplicateCheck) {
-            const duplicateCheck = await checkKiroCredentialsDuplicate(refreshToken);
-            if (duplicateCheck.isDuplicate) {
-                progressData.current = {
-                    index: i + 1,
-                    success: false,
-                    error: 'duplicate',
-                    existingPath: duplicateCheck.existingPath
-                };
-                results.details.push(progressData.current);
-                results.failed++;
-                
-                // 发送进度更新
-                if (onProgress) {
-                    onProgress({
-                        ...progressData,
-                        successCount: results.success,
-                        failedCount: results.failed
-                    });
-                }
-                continue;
-            }
-        }
-        
-        try {
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} 正在刷新第 ${i + 1}/${refreshTokens.length} 个 token...`);
-            
-            const tokenData = await refreshKiroToken(refreshToken, region);
-            
-            // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
-            const timestamp = Date.now();
-            const folderName = `${timestamp}_kiro-auth-token`;
-            const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
-            await fs.promises.mkdir(targetDir, { recursive: true });
-            
-            const credPath = path.join(targetDir, `${folderName}.json`);
-            await fs.promises.writeFile(credPath, JSON.stringify(tokenData, null, 2));
-            
-            const relativePath = path.relative(process.cwd(), credPath);
-            
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 已保存: ${relativePath}`);
-            
-            progressData.current = {
-                index: i + 1,
-                success: true,
-                path: relativePath,
-                expiresAt: tokenData.expiresAt
-            };
-            results.details.push(progressData.current);
-            results.success++;
-            
-        } catch (error) {
-            logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} Token ${i + 1} 刷新失败:`, error.message);
-            
-            progressData.current = {
-                index: i + 1,
-                success: false,
-                error: error.message
-            };
-            results.details.push(progressData.current);
-            results.failed++;
-        }
-        
-        // 发送进度更新
-        if (onProgress) {
-            onProgress({
-                ...progressData,
-                successCount: results.success,
-                failedCount: results.failed
-            });
-        }
-    }
-    
-    // 如果有成功的，广播事件并自动关联
-    if (results.success > 0) {
-        broadcastEvent('oauth_batch_success', {
-            provider: 'claude-kiro-oauth',
-            count: results.success,
-            timestamp: new Date().toISOString()
-        });
-        
-        // 自动关联新生成的凭据到 Pools
-        for (const detail of results.details) {
-            if (detail.success && detail.path) {
-                await autoLinkProviderConfigs(CONFIG, {
-                    onlyCurrentCred: true,
-                    credPath: detail.path
-                });
-            }
-        }
-    }
-    
-    return results;
-}
-
-/**
- * 导入 AWS SSO 凭据用于 Kiro (Builder ID 模式)
- * 从用户上传的 AWS SSO cache 文件中导入凭据
- * @param {Object} credentials - 合并后的凭据对象，需包含 clientId 和 clientSecret
- * @param {boolean} skipDuplicateCheck - 是否跳过重复检查 (默认: false)
- * @returns {Promise<Object>} 导入结果
- */
-export async function importAwsCredentials(credentials, skipDuplicateCheck = false) {
-    try {
-        // 验证必需字段 - 需要四个字段都存在
-        const missingFields = [];
-        if (!credentials.clientId) missingFields.push('clientId');
-        if (!credentials.clientSecret) missingFields.push('clientSecret');
-        if (!credentials.accessToken) missingFields.push('accessToken');
-        if (!credentials.refreshToken) missingFields.push('refreshToken');
-        
-        if (missingFields.length > 0) {
-            return {
-                success: false,
-                error: `Missing required fields: ${missingFields.join(', ')}`
-            };
-        }
-        
-        // 检查重复凭据
-        if (!skipDuplicateCheck) {
-            const duplicateCheck = await checkKiroCredentialsDuplicate(credentials.refreshToken);
-            if (duplicateCheck.isDuplicate) {
-                return {
-                    success: false,
-                    error: 'duplicate',
-                    existingPath: duplicateCheck.existingPath
-                };
-            }
-        }
-        
-        logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Importing AWS credentials...`);
-        
-        // 准备凭据数据 - 四个字段都是必需的
-        const credentialsData = {
-            clientId: credentials.clientId,
-            clientSecret: credentials.clientSecret,
-            accessToken: credentials.accessToken,
-            refreshToken: credentials.refreshToken,
-            authMethod: credentials.authMethod || 'builder-id',
-            // region: credentials.region || KIRO_REFRESH_CONSTANTS.DEFAULT_REGION,
-            idcRegion: credentials.idcRegion || KIRO_REFRESH_CONSTANTS.IDC_REGION
-        };
-        
-        // 可选字段
-        if (credentials.expiresAt) {
-            credentialsData.expiresAt = credentials.expiresAt;
-        }
-        if (credentials.startUrl) {
-            credentialsData.startUrl = credentials.startUrl;
-        }
-        if (credentials.registrationExpiresAt) {
-            credentialsData.registrationExpiresAt = credentials.registrationExpiresAt;
-        }
-        
-        // 尝试刷新获取最新的 accessToken
-        try {
-            logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Attempting to refresh token with provided credentials...`);
-            
-            const refreshRegion = credentials.idcRegion || KIRO_REFRESH_CONSTANTS.IDC_REGION;
-            const refreshUrl = KIRO_REFRESH_CONSTANTS.REFRESH_IDC_URL.replace('{{region}}', refreshRegion);
-            
-            const refreshResponse = await fetchWithProxy(refreshUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify({
-                    refreshToken: credentials.refreshToken,
-                    clientId: credentials.clientId,
-                    clientSecret: credentials.clientSecret,
-                    grantType: 'refresh_token'
-                })
-            }, 'claude-kiro-oauth');
-            
-            if (refreshResponse.ok) {
-                const tokenData = await refreshResponse.json();
-                credentialsData.accessToken = tokenData.accessToken;
-                credentialsData.refreshToken = tokenData.refreshToken;
-                const expiresIn = tokenData.expiresIn || 3600;
-                credentialsData.expiresAt = new Date(Date.now() + expiresIn * 1000).toISOString();
-                logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} Token refreshed successfully`);
-            } else {
-                logger.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Token refresh failed, saving original credentials`);
-            }
-        } catch (refreshError) {
-            logger.warn(`${KIRO_OAUTH_CONFIG.logPrefix} Token refresh error:`, refreshError.message);
-            // 继续保存原始凭据
-        }
-        
-        // 生成文件路径: configs/kiro/{timestamp}_kiro-auth-token/{timestamp}_kiro-auth-token.json
-        const timestamp = Date.now();
-        const folderName = `${timestamp}_kiro-auth-token`;
-        const targetDir = path.join(process.cwd(), 'configs', 'kiro', folderName);
-        await fs.promises.mkdir(targetDir, { recursive: true });
-        
-        const credPath = path.join(targetDir, `${folderName}.json`);
-        await fs.promises.writeFile(credPath, JSON.stringify(credentialsData, null, 2));
-        
-        const relativePath = path.relative(process.cwd(), credPath);
-        
-        logger.info(`${KIRO_OAUTH_CONFIG.logPrefix} AWS credentials saved to: ${relativePath}`);
-        
-        // 广播事件
-        broadcastEvent('oauth_success', {
-            provider: 'claude-kiro-oauth',
-            relativePath: relativePath,
-            timestamp: new Date().toISOString()
-        });
-        
-        // 自动关联新生成的凭据到 Pools
-        await autoLinkProviderConfigs(CONFIG, {
-            onlyCurrentCred: true,
-            credPath: relativePath
-        });
-        
-        return {
-            success: true,
-            path: relativePath
-        };
-        
-    } catch (error) {
-        logger.error(`${KIRO_OAUTH_CONFIG.logPrefix} AWS credentials import failed:`, error);
-        return {
-            success: false,
-            error: error.message
-        };
-    }
-}
-
-

src/auth/oauth-handlers.js

@@ -1,27 +0,0 @@
-// OAuth 处理器统一导出文件
-// 此文件已按提供商拆分为多个独立文件，请从 index.js 导入
-
-// 重新导出所有 OAuth 处理函数以保持向后兼容
-export {
-    // Codex OAuth
-    refreshCodexTokensWithRetry,
-    handleCodexOAuth,
-    handleCodexOAuthCallback,
-    batchImportCodexTokensStream,
-    // Gemini OAuth
-    handleGeminiCliOAuth,
-    handleGeminiAntigravityOAuth,
-    batchImportGeminiTokensStream,
-    checkGeminiCredentialsDuplicate,
-    // Qwen OAuth
-    handleQwenOAuth,
-    // Kiro OAuth
-    handleKiroOAuth,
-    checkKiroCredentialsDuplicate,
-    batchImportKiroRefreshTokens,
-    batchImportKiroRefreshTokensStream,
-    importAwsCredentials,
-    // iFlow OAuth
-    handleIFlowOAuth,
-    refreshIFlowTokens,
-} from './index.js';

src/auth/qwen-oauth.js

@@ -1,343 +0,0 @@
-import fs from 'fs';
-import logger from '../utils/logger.js';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import { broadcastEvent } from '../services/ui-manager.js';
-import { autoLinkProviderConfigs } from '../services/service-manager.js';
-import { CONFIG } from '../core/config-manager.js';
-import { getProxyConfigForProvider } from '../utils/proxy-utils.js';
-
-/**
- * Qwen OAuth 配置
- */
-const QWEN_OAUTH_CONFIG = {
-    clientId: 'f0304373b74a44d2b584a3fb70ca9e56',
-    scope: 'openid profile email model.completion',
-    deviceCodeEndpoint: 'https://chat.qwen.ai/api/v1/oauth2/device/code',
-    tokenEndpoint: 'https://chat.qwen.ai/api/v1/oauth2/token',
-    grantType: 'urn:ietf:params:oauth:grant-type:device_code',
-    credentialsDir: '.qwen',
-    credentialsFile: 'oauth_creds.json',
-    logPrefix: '[Qwen Auth]'
-};
-
-/**
- * 活动的轮询任务管理
- */
-const activePollingTasks = new Map();
-
-/**
- * 创建带代理支持的 fetch 请求
- * 使用 axios 替代原生 fetch，以正确支持代理配置
- * @param {string} url - 请求 URL
- * @param {Object} options - fetch 选项（兼容 fetch API 格式）
- * @param {string} providerType - 提供商类型，用于获取代理配置
- * @returns {Promise<Object>} 返回类似 fetch Response 的对象
- */
-async function fetchWithProxy(url, options = {}, providerType) {
-    const proxyConfig = getProxyConfigForProvider(CONFIG, providerType);
-
-    // 构建 axios 配置
-    const axiosConfig = {
-        url,
-        method: options.method || 'GET',
-        headers: options.headers || {},
-        timeout: 30000, // 30 秒超时
-    };
-
-    // 处理请求体
-    if (options.body) {
-        axiosConfig.data = options.body;
-    }
-
-    // 配置代理
-    if (proxyConfig) {
-        axiosConfig.httpAgent = proxyConfig.httpAgent;
-        axiosConfig.httpsAgent = proxyConfig.httpsAgent;
-        axiosConfig.proxy = false; // 禁用 axios 内置代理，使用我们的 agent
-        logger.info(`[OAuth] Using proxy for ${providerType}: ${CONFIG.PROXY_URL}`);
-    }
-
-    try {
-        const axios = (await import('axios')).default;
-        const response = await axios(axiosConfig);
-        
-        // 返回类似 fetch Response 的对象
-        return {
-            ok: response.status >= 200 && response.status < 300,
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-            json: async () => response.data,
-            text: async () => typeof response.data === 'string' ? response.data : JSON.stringify(response.data),
-        };
-    } catch (error) {
-        // 处理 axios 错误，转换为类似 fetch 的响应格式
-        if (error.response) {
-            // 服务器返回了错误状态码
-            return {
-                ok: false,
-                status: error.response.status,
-                statusText: error.response.statusText,
-                headers: error.response.headers,
-                json: async () => error.response.data,
-                text: async () => typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data),
-            };
-        }
-        // 网络错误或其他错误
-        throw error;
-    }
-}
-
-/**
- * 生成 PKCE 代码验证器
- * @returns {string} Base64URL 编码的随机字符串
- */
-function generateCodeVerifier() {
-    return crypto.randomBytes(32).toString('base64url');
-}
-
-/**
- * 生成 PKCE 代码挑战
- * @param {string} codeVerifier - 代码验证器
- * @returns {string} Base64URL 编码的 SHA256 哈希
- */
-function generateCodeChallenge(codeVerifier) {
-    const hash = crypto.createHash('sha256');
-    hash.update(codeVerifier);
-    return hash.digest('base64url');
-}
-
-/**
- * 停止活动的轮询任务
- * @param {string} taskId - 任务标识符
- */
-function stopPollingTask(taskId) {
-    const task = activePollingTasks.get(taskId);
-    if (task) {
-        task.shouldStop = true;
-        activePollingTasks.delete(taskId);
-        logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 已停止轮询任务: ${taskId}`);
-    }
-}
-
-/**
- * 轮询获取 Qwen OAuth 令牌
- * @param {string} deviceCode - 设备代码
- * @param {string} codeVerifier - PKCE 代码验证器
- * @param {number} interval - 轮询间隔（秒）
- * @param {number} expiresIn - 过期时间（秒）
- * @param {string} taskId - 任务标识符
- * @param {Object} options - 额外选项
- * @returns {Promise<Object>} 返回令牌信息
- */
-async function pollQwenToken(deviceCode, codeVerifier, interval = 5, expiresIn = 300, taskId = 'default', options = {}) {
-    let credPath = path.join(os.homedir(), QWEN_OAUTH_CONFIG.credentialsDir, QWEN_OAUTH_CONFIG.credentialsFile);
-    const maxAttempts = Math.floor(expiresIn / interval);
-    let attempts = 0;
-    
-    // 创建任务控制对象
-    const taskControl = { shouldStop: false };
-    activePollingTasks.set(taskId, taskControl);
-    
-    logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 开始轮询令牌 [${taskId}]，间隔 ${interval} 秒，最多尝试 ${maxAttempts} 次`);
-    
-    const poll = async () => {
-        // 检查是否需要停止
-        if (taskControl.shouldStop) {
-            logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询任务 [${taskId}] 已被停止`);
-            throw new Error('轮询任务已被取消');
-        }
-        
-        if (attempts >= maxAttempts) {
-            activePollingTasks.delete(taskId);
-            throw new Error('授权超时，请重新开始授权流程');
-        }
-        
-        attempts++;
-        
-        const bodyData = {
-            client_id: QWEN_OAUTH_CONFIG.clientId,
-            device_code: deviceCode,
-            grant_type: QWEN_OAUTH_CONFIG.grantType,
-            code_verifier: codeVerifier
-        };
-        
-        const formBody = Object.entries(bodyData)
-            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('&');
-        
-        try {
-            const response = await fetchWithProxy(QWEN_OAUTH_CONFIG.tokenEndpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                    'Accept': 'application/json'
-                },
-                body: formBody
-            }, 'openai-qwen-oauth');
-            
-            const data = await response.json();
-            
-            if (response.ok && data.access_token) {
-                // 成功获取令牌
-                logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 成功获取令牌 [${taskId}]`);
-                
-                // 如果指定了保存到 configs 目录
-                if (options.saveToConfigs) {
-                    const targetDir = path.join(process.cwd(), 'configs', options.providerDir);
-                    await fs.promises.mkdir(targetDir, { recursive: true });
-                    const timestamp = Date.now();
-                    const filename = `${timestamp}_oauth_creds.json`;
-                    credPath = path.join(targetDir, filename);
-                }
-
-                // 保存令牌到文件
-                await fs.promises.mkdir(path.dirname(credPath), { recursive: true });
-                await fs.promises.writeFile(credPath, JSON.stringify(data, null, 2));
-                logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 令牌已保存到 ${credPath}`);
-                
-                const relativePath = path.relative(process.cwd(), credPath);
-
-                // 清理任务
-                activePollingTasks.delete(taskId);
-                
-                // 广播授权成功事件
-                broadcastEvent('oauth_success', {
-                    provider: 'openai-qwen-oauth',
-                    credPath: credPath,
-                    relativePath: relativePath,
-                    timestamp: new Date().toISOString()
-                });
-                
-                // 自动关联新生成的凭据到 Pools
-                await autoLinkProviderConfigs(CONFIG, {
-                    onlyCurrentCred: true,
-                    credPath: relativePath
-                });
-                
-                return data;
-            }
-            
-            // 检查错误类型
-            if (data.error === 'authorization_pending') {
-                // 用户尚未完成授权，继续轮询
-                logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 等待用户授权 [${taskId}]... (第 ${attempts}/${maxAttempts} 次尝试)`);
-                await new Promise(resolve => setTimeout(resolve, interval * 1000));
-                return poll();
-            } else if (data.error === 'slow_down') {
-                // 需要降低轮询频率
-                logger.info(`${QWEN_OAUTH_CONFIG.logPrefix} 降低轮询频率`);
-                await new Promise(resolve => setTimeout(resolve, (interval + 5) * 1000));
-                return poll();
-            } else if (data.error === 'expired_token') {
-                activePollingTasks.delete(taskId);
-                throw new Error('设备代码已过期，请重新开始授权流程');
-            } else if (data.error === 'access_denied') {
-                activePollingTasks.delete(taskId);
-                throw new Error('用户拒绝了授权请求');
-            } else {
-                activePollingTasks.delete(taskId);
-                throw new Error(`授权失败: ${data.error || '未知错误'}`);
-            }
-        } catch (error) {
-            if (error.message.includes('授权') || error.message.includes('过期') || error.message.includes('拒绝')) {
-                throw error;
-            }
-            logger.error(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询出错:`, error);
-            // 网络错误，继续重试
-            await new Promise(resolve => setTimeout(resolve, interval * 1000));
-            return poll();
-        }
-    };
-    
-    return poll();
-}
-
-/**
- * 处理 Qwen OAuth 授权（设备授权流程）
- * @param {Object} currentConfig - 当前配置对象
- * @param {Object} options - 额外选项
- * @returns {Promise<Object>} 返回授权URL和相关信息
- */
-export async function handleQwenOAuth(currentConfig, options = {}) {
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = generateCodeChallenge(codeVerifier);
-    
-    const bodyData = {
-        client_id: QWEN_OAUTH_CONFIG.clientId,
-        scope: QWEN_OAUTH_CONFIG.scope,
-        code_challenge: codeChallenge,
-        code_challenge_method: 'S256'
-    };
-    
-    const formBody = Object.entries(bodyData)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-        .join('&');
-    
-    try {
-        const response = await fetchWithProxy(QWEN_OAUTH_CONFIG.deviceCodeEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                'Accept': 'application/json'
-            },
-            body: formBody
-        }, 'openai-qwen-oauth');
-        
-        if (!response.ok) {
-            throw new Error(`Qwen OAuth请求失败: ${response.status} ${response.statusText}`);
-        }
-        
-        const deviceAuth = await response.json();
-        
-        if (!deviceAuth.device_code || !deviceAuth.verification_uri_complete) {
-            throw new Error('Qwen OAuth响应格式错误，缺少必要字段');
-        }
-        
-        // 启动后台轮询获取令牌
-        const interval = 5;
-        // const expiresIn = deviceAuth.expires_in || 1800;
-        const expiresIn = 300;
-        
-        // 生成唯一的任务ID
-        const taskId = `qwen-${deviceAuth.device_code.substring(0, 8)}-${Date.now()}`;
-        
-        // 先停止之前可能存在的所有 Qwen 轮询任务
-        for (const [existingTaskId] of activePollingTasks.entries()) {
-            if (existingTaskId.startsWith('qwen-')) {
-                stopPollingTask(existingTaskId);
-            }
-        }
-        
-        // 不等待轮询完成，立即返回授权信息
-        pollQwenToken(deviceAuth.device_code, codeVerifier, interval, expiresIn, taskId, options)
-            .catch(error => {
-                logger.error(`${QWEN_OAUTH_CONFIG.logPrefix} 轮询失败 [${taskId}]:`, error);
-                // 广播授权失败事件
-                broadcastEvent('oauth_error', {
-                    provider: 'openai-qwen-oauth',
-                    error: error.message,
-                    timestamp: new Date().toISOString()
-                });
-            });
-        
-        return {
-            authUrl: deviceAuth.verification_uri_complete,
-            authInfo: {
-                provider: 'openai-qwen-oauth',
-                deviceCode: deviceAuth.device_code,
-                userCode: deviceAuth.user_code,
-                verificationUri: deviceAuth.verification_uri,
-                verificationUriComplete: deviceAuth.verification_uri_complete,
-                expiresIn: expiresIn,
-                interval: interval,
-                codeVerifier: codeVerifier
-            }
-        };
-    } catch (error) {
-        logger.error(`${QWEN_OAUTH_CONFIG.logPrefix} 请求失败:`, error);
-        throw new Error(`Qwen OAuth 授权失败: ${error.message}`);
-    }
-}

src/convert/convert.js

@@ -1,392 +0,0 @@
-/**
- * 协议转换模块 - 新架构版本
- * 使用重构后的转换器架构
- *
- * 这个文件展示了如何使用新的转换器架构
- * 可以逐步替换原有的 convert.js
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../utils/logger.js';
-import { MODEL_PROTOCOL_PREFIX, getProtocolPrefix } from '../utils/common.js';
-import { ConverterFactory } from '../converters/ConverterFactory.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../providers/openai/openai-responses-core.mjs';
-
-// =============================================================================
-// 初始化：注册所有转换器
-// =============================================================================
-
-// =============================================================================
-// 主转换函数
-// =============================================================================
-
-/**
- * 通用数据转换函数（新架构版本）
- * @param {object} data - 要转换的数据（请求体或响应）
- * @param {string} type - 转换类型：'request', 'response', 'streamChunk', 'modelList'
- * @param {string} fromProvider - 源模型提供商
- * @param {string} toProvider - 目标模型提供商
- * @param {string} [model] - 可选的模型名称（用于响应转换）
- * @returns {object} 转换后的数据
- * @throws {Error} 如果找不到合适的转换函数
- */
-export function convertData(data, type, fromProvider, toProvider, model, requestId) {
-    try {
-        // 获取协议前缀
-        const fromProtocol = getProtocolPrefix(fromProvider);
-        const toProtocol = getProtocolPrefix(toProvider);
-
-        // 如果目标协议为 forward，直接返回原始数据，无需转换
-        if (toProtocol === MODEL_PROTOCOL_PREFIX.FORWARD || fromProtocol === MODEL_PROTOCOL_PREFIX.FORWARD) {
-            logger.info(`[Convert] Target protocol is forward, skipping conversion`);
-            return data;
-        }
-
-        // 从工厂获取转换器
-        const converter = ConverterFactory.getConverter(fromProtocol);
-
-        if (!converter) {
-            throw new Error(`No converter found for protocol: ${fromProtocol}`);
-        }
-
-        // 根据类型调用相应的转换方法
-        switch (type) {
-            case 'request':
-                return converter.convertRequest(data, toProtocol);
-                
-            case 'response':
-                return converter.convertResponse(data, toProtocol, model);
-                
-            case 'streamChunk':
-                return converter.convertStreamChunk(data, toProtocol, model, requestId);
-                
-            case 'modelList':
-                return converter.convertModelList(data, toProtocol);
-                
-            default:
-                throw new Error(`Unsupported conversion type: ${type}`);
-        }
-    } catch (error) {
-        logger.error(`Conversion error: ${error.message}`);
-        throw error;
-    }
-}
-
-// =============================================================================
-// 向后兼容的导出函数
-// =============================================================================
-
-/**
- * 以下函数保持与原有API的兼容性
- * 内部使用新的转换器架构
- */
-
-// OpenAI 相关转换
-export function toOpenAIRequestFromGemini(geminiRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIRequest(geminiRequest);
-}
-
-export function toOpenAIRequestFromClaude(claudeRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIRequest(claudeRequest);
-}
-
-export function toOpenAIChatCompletionFromGemini(geminiResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIResponse(geminiResponse, model);
-}
-
-export function toOpenAIChatCompletionFromClaude(claudeResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIResponse(claudeResponse, model);
-}
-
-export function toOpenAIStreamChunkFromGemini(geminiChunk, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIStreamChunk(geminiChunk, model);
-}
-
-export function toOpenAIStreamChunkFromClaude(claudeChunk, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIStreamChunk(claudeChunk, model);
-}
-
-export function toOpenAIModelListFromGemini(geminiModels) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIModelList(geminiModels);
-}
-
-export function toOpenAIModelListFromClaude(claudeModels) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIModelList(claudeModels);
-}
-
-// Claude 相关转换
-export function toClaudeRequestFromOpenAI(openaiRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toClaudeRequest(openaiRequest);
-}
-
-export function toClaudeRequestFromOpenAIResponses(responsesRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-    return converter.toClaudeRequest(responsesRequest);
-}
-
-export function toClaudeChatCompletionFromOpenAI(openaiResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toClaudeResponse(openaiResponse, model);
-}
-
-export function toClaudeChatCompletionFromGemini(geminiResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toClaudeResponse(geminiResponse, model);
-}
-
-export function toClaudeStreamChunkFromOpenAI(openaiChunk, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toClaudeStreamChunk(openaiChunk, model);
-}
-
-export function toClaudeStreamChunkFromGemini(geminiChunk, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toClaudeStreamChunk(geminiChunk, model);
-}
-
-export function toClaudeModelListFromOpenAI(openaiModels) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toClaudeModelList(openaiModels);
-}
-
-export function toClaudeModelListFromGemini(geminiModels) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toClaudeModelList(geminiModels);
-}
-
-// Gemini 相关转换
-export function toGeminiRequestFromOpenAI(openaiRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toGeminiRequest(openaiRequest);
-}
-
-export function toGeminiRequestFromClaude(claudeRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toGeminiRequest(claudeRequest);
-}
-
-export function toGeminiRequestFromOpenAIResponses(responsesRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-    return converter.toGeminiRequest(responsesRequest);
-}
-
-// OpenAI Responses 相关转换
-export function toOpenAIResponsesFromOpenAI(openaiResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toOpenAIResponsesResponse(openaiResponse, model);
-}
-
-export function toOpenAIResponsesFromClaude(claudeResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIResponsesResponse(claudeResponse, model);
-}
-
-export function toOpenAIResponsesFromGemini(geminiResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIResponsesResponse(geminiResponse, model);
-}
-
-export function toOpenAIResponsesStreamChunkFromOpenAI(openaiChunk, model, requestId) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI);
-    return converter.toOpenAIResponsesStreamChunk(openaiChunk, model, requestId);
-}
-
-export function toOpenAIResponsesStreamChunkFromClaude(claudeChunk, model, requestId) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.CLAUDE);
-    return converter.toOpenAIResponsesStreamChunk(claudeChunk, model, requestId);
-}
-
-export function toOpenAIResponsesStreamChunkFromGemini(geminiChunk, model, requestId) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.GEMINI);
-    return converter.toOpenAIResponsesStreamChunk(geminiChunk, model, requestId);
-}
-
-// 从 OpenAI Responses 转换到其他格式
-export function toOpenAIRequestFromOpenAIResponses(responsesRequest) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-    return converter.toOpenAIRequest(responsesRequest);
-}
-
-export function toOpenAIChatCompletionFromOpenAIResponses(responsesResponse, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-    return converter.toOpenAIResponse(responsesResponse, model);
-}
-
-export function toOpenAIStreamChunkFromOpenAIResponses(responsesChunk, model) {
-    const converter = ConverterFactory.getConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-    return converter.toOpenAIStreamChunk(responsesChunk, model);
-}
-
-// 辅助函数导出
-export async function extractAndProcessSystemMessages(messages) {
-    const { Utils } = await import('../converters/utils.js');
-    return Utils.extractSystemMessages(messages);
-}
-
-export async function extractTextFromMessageContent(content) {
-    const { Utils } = await import('../converters/utils.js');
-    return Utils.extractText(content);
-}
-
-// =============================================================================
-// 工具函数
-// =============================================================================
-
-/**
- * 获取所有已注册的协议
- * @returns {Array<string>} 协议前缀数组
- */
-export function getRegisteredProtocols() {
-    return ConverterFactory.getRegisteredProtocols();
-}
-
-/**
- * 检查协议是否已注册
- * @param {string} protocol - 协议前缀
- * @returns {boolean} 是否已注册
- */
-export function isProtocolRegistered(protocol) {
-    return ConverterFactory.isProtocolRegistered(protocol);
-}
-
-/**
- * 清除所有转换器缓存
- */
-export function clearConverterCache() {
-    ConverterFactory.clearCache();
-}
-
-/**
- * 获取转换器实例（用于高级用法）
- * @param {string} protocol - 协议前缀
- * @returns {BaseConverter} 转换器实例
- */
-export function getConverter(protocol) {
-    return ConverterFactory.getConverter(protocol);
-}
-
-// =============================================================================
-// 辅助函数 - 从原 convert.js 迁移
-// =============================================================================
-
-/**
- * 生成 OpenAI 流式响应的停止块
- * @param {string} model - 模型名称
- * @returns {Object} OpenAI 流式停止块
- */
-export function getOpenAIStreamChunkStop(model) {
-    return {
-        id: `chatcmpl-${uuidv4()}`,
-        object: "chat.completion.chunk",
-        created: Math.floor(Date.now() / 1000),
-        model: model,
-        system_fingerprint: "",
-        choices: [{
-            index: 0,
-            delta: {
-                content: "",
-                reasoning_content: ""
-            },
-            finish_reason: 'stop',
-            message: {
-                content: "",
-                reasoning_content: ""
-            }
-        }],
-        usage:{
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            total_tokens: 0,
-        },
-    };
-}
-
-/**
- * 生成 OpenAI Responses 流式响应的开始事件
- * @param {string} id - 响应 ID
- * @param {string} model - 模型名称
- * @returns {Array} 开始事件数组
- */
-export function getOpenAIResponsesStreamChunkBegin(id, model) {
-    return [
-        generateResponseCreated(id, model),
-        generateResponseInProgress(id),
-        generateOutputItemAdded(id),
-        generateContentPartAdded(id)
-    ];
-}
-
-/**
- * 生成 OpenAI Responses 流式响应的结束事件
- * @param {string} id - 响应 ID
- * @returns {Array} 结束事件数组
- */
-export function getOpenAIResponsesStreamChunkEnd(id) {
-    return [
-        generateOutputTextDone(id),
-        generateContentPartDone(id),
-        generateOutputItemDone(id),
-        generateResponseCompleted(id)
-    ];
-}
-
-// =============================================================================
-// 默认导出
-// =============================================================================
-
-export default {
-    convertData,
-    getRegisteredProtocols,
-    isProtocolRegistered,
-    clearConverterCache,
-    getConverter,
-    // 向后兼容的函数
-    toOpenAIRequestFromGemini,
-    toOpenAIRequestFromClaude,
-    toOpenAIChatCompletionFromGemini,
-    toOpenAIChatCompletionFromClaude,
-    toOpenAIStreamChunkFromGemini,
-    toOpenAIStreamChunkFromClaude,
-    toOpenAIModelListFromGemini,
-    toOpenAIModelListFromClaude,
-    toClaudeRequestFromOpenAI,
-    toClaudeChatCompletionFromOpenAI,
-    toClaudeChatCompletionFromGemini,
-    toClaudeStreamChunkFromOpenAI,
-    toClaudeStreamChunkFromGemini,
-    toClaudeModelListFromOpenAI,
-    toClaudeModelListFromGemini,
-    toGeminiRequestFromOpenAI,
-    toGeminiRequestFromClaude,
-    toOpenAIResponsesFromOpenAI,
-    toOpenAIResponsesFromClaude,
-    toOpenAIResponsesFromGemini,
-    toOpenAIResponsesStreamChunkFromOpenAI,
-    toOpenAIResponsesStreamChunkFromClaude,
-    toOpenAIResponsesStreamChunkFromGemini,
-    toOpenAIRequestFromOpenAIResponses,
-    toOpenAIChatCompletionFromOpenAIResponses,
-    toOpenAIStreamChunkFromOpenAIResponses,
-    toClaudeRequestFromOpenAIResponses,
-    toGeminiRequestFromOpenAIResponses,
-};
-
-

src/converters/BaseConverter.js

@@ -1,115 +0,0 @@
-/**
- * 转换器基类
- * 使用策略模式定义转换器的通用接口
- */
-
-/**
- * 抽象转换器基类
- * 所有具体的协议转换器都应继承此类
- */
-export class BaseConverter {
-    constructor(protocolName) {
-        if (new.target === BaseConverter) {
-            throw new Error('BaseConverter是抽象类，不能直接实例化');
-        }
-        this.protocolName = protocolName;
-    }
-
-    /**
-     * 转换请求
-     * @param {Object} data - 请求数据
-     * @param {string} targetProtocol - 目标协议
-     * @returns {Object} 转换后的请求
-     */
-    convertRequest(data, targetProtocol) {
-        throw new Error('convertRequest方法必须被子类实现');
-    }
-
-    /**
-     * 转换响应
-     * @param {Object} data - 响应数据
-     * @param {string} targetProtocol - 目标协议
-     * @param {string} model - 模型名称
-     * @returns {Object} 转换后的响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        throw new Error('convertResponse方法必须被子类实现');
-    }
-
-    /**
-     * 转换流式响应块
-     * @param {Object} chunk - 流式响应块
-     * @param {string} targetProtocol - 目标协议
-     * @param {string} model - 模型名称
-     * @returns {Object} 转换后的流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model) {
-        throw new Error('convertStreamChunk方法必须被子类实现');
-    }
-
-    /**
-     * 转换模型列表
-     * @param {Object} data - 模型列表数据
-     * @param {string} targetProtocol - 目标协议
-     * @returns {Object} 转换后的模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        throw new Error('convertModelList方法必须被子类实现');
-    }
-
-    /**
-     * 获取协议名称
-     * @returns {string} 协议名称
-     */
-    getProtocolName() {
-        return this.protocolName;
-    }
-}
-
-/**
- * 内容处理器接口
- * 用于处理不同类型的内容（文本、图片、音频等）
- */
-export class ContentProcessor {
-    /**
-     * 处理内容
-     * @param {*} content - 内容数据
-     * @returns {*} 处理后的内容
-     */
-    process(content) {
-        throw new Error('process方法必须被子类实现');
-    }
-}
-
-/**
- * 工具处理器接口
- * 用于处理工具调用相关的转换
- */
-export class ToolProcessor {
-    /**
-     * 处理工具定义
-     * @param {Array} tools - 工具定义数组
-     * @returns {Array} 处理后的工具定义
-     */
-    processToolDefinitions(tools) {
-        throw new Error('processToolDefinitions方法必须被子类实现');
-    }
-
-    /**
-     * 处理工具调用
-     * @param {Object} toolCall - 工具调用数据
-     * @returns {Object} 处理后的工具调用
-     */
-    processToolCall(toolCall) {
-        throw new Error('processToolCall方法必须被子类实现');
-    }
-
-    /**
-     * 处理工具结果
-     * @param {Object} toolResult - 工具结果数据
-     * @returns {Object} 处理后的工具结果
-     */
-    processToolResult(toolResult) {
-        throw new Error('processToolResult方法必须被子类实现');
-    }
-}

src/converters/ConverterFactory.js

@@ -1,183 +0,0 @@
-/**
- * 转换器工厂类
- * 使用工厂模式管理转换器实例的创建和缓存
- */
-
-import { MODEL_PROTOCOL_PREFIX } from '../utils/common.js';
-import logger from '../utils/logger.js';
-
-/**
- * 转换器工厂（单例模式 + 工厂模式）
- */
-export class ConverterFactory {
-    // 私有静态属性：存储转换器实例
-    static #converters = new Map();
-    
-    // 私有静态属性：存储转换器类
-    static #converterClasses = new Map();
-
-    /**
-     * 注册转换器类
-     * @param {string} protocolPrefix - 协议前缀
-     * @param {Class} ConverterClass - 转换器类
-     */
-    static registerConverter(protocolPrefix, ConverterClass) {
-        this.#converterClasses.set(protocolPrefix, ConverterClass);
-    }
-
-    /**
-     * 获取转换器实例（带缓存）
-     * @param {string} protocolPrefix - 协议前缀
-     * @returns {BaseConverter} 转换器实例
-     */
-    static getConverter(protocolPrefix) {
-        // 检查缓存
-        if (this.#converters.has(protocolPrefix)) {
-            return this.#converters.get(protocolPrefix);
-        }
-
-        // 创建新实例
-        const converter = this.createConverter(protocolPrefix);
-        
-        // 缓存实例
-        if (converter) {
-            this.#converters.set(protocolPrefix, converter);
-        }
-
-        return converter;
-    }
-
-    /**
-     * 创建转换器实例
-     * @param {string} protocolPrefix - 协议前缀
-     * @returns {BaseConverter} 转换器实例
-     */
-    static createConverter(protocolPrefix) {
-        const ConverterClass = this.#converterClasses.get(protocolPrefix);
-        
-        if (!ConverterClass) {
-            throw new Error(`No converter registered for protocol: ${protocolPrefix}`);
-        }
-
-        return new ConverterClass();
-    }
-
-    /**
-     * 清除所有缓存的转换器
-     */
-    static clearCache() {
-        this.#converters.clear();
-    }
-
-    /**
-     * 清除特定协议的转换器缓存
-     * @param {string} protocolPrefix - 协议前缀
-     */
-    static clearConverterCache(protocolPrefix) {
-        this.#converters.delete(protocolPrefix);
-    }
-
-    /**
-     * 获取所有已注册的协议
-     * @returns {Array<string>} 协议前缀数组
-     */
-    static getRegisteredProtocols() {
-        return Array.from(this.#converterClasses.keys());
-    }
-
-    /**
-     * 检查协议是否已注册
-     * @param {string} protocolPrefix - 协议前缀
-     * @returns {boolean} 是否已注册
-     */
-    static isProtocolRegistered(protocolPrefix) {
-        return this.#converterClasses.has(protocolPrefix);
-    }
-}
-
-/**
- * 内容处理器工厂
- */
-export class ContentProcessorFactory {
-    static #processors = new Map();
-
-    /**
-     * 获取内容处理器
-     * @param {string} sourceFormat - 源格式
-     * @param {string} targetFormat - 目标格式
-     * @returns {ContentProcessor} 内容处理器实例
-     */
-    static getProcessor(sourceFormat, targetFormat) {
-        const key = `${sourceFormat}_to_${targetFormat}`;
-        
-        if (!this.#processors.has(key)) {
-            this.#processors.set(key, this.createProcessor(sourceFormat, targetFormat));
-        }
-        
-        return this.#processors.get(key);
-    }
-
-    /**
-     * 创建内容处理器
-     * @param {string} sourceFormat - 源格式
-     * @param {string} targetFormat - 目标格式
-     * @returns {ContentProcessor} 内容处理器实例
-     */
-    static createProcessor(sourceFormat, targetFormat) {
-        // 这里返回null，实际使用时需要导入具体的处理器类
-        // 为了避免循环依赖，处理器类应该在使用时动态导入
-        logger.warn(`Content processor for ${sourceFormat} to ${targetFormat} not yet implemented`);
-        return null;
-    }
-
-    /**
-     * 清除所有缓存的处理器
-     */
-    static clearCache() {
-        this.#processors.clear();
-    }
-}
-
-/**
- * 工具处理器工厂
- */
-export class ToolProcessorFactory {
-    static #processors = new Map();
-
-    /**
-     * 获取工具处理器
-     * @param {string} sourceFormat - 源格式
-     * @param {string} targetFormat - 目标格式
-     * @returns {ToolProcessor} 工具处理器实例
-     */
-    static getProcessor(sourceFormat, targetFormat) {
-        const key = `${sourceFormat}_to_${targetFormat}`;
-        
-        if (!this.#processors.has(key)) {
-            this.#processors.set(key, this.createProcessor(sourceFormat, targetFormat));
-        }
-        
-        return this.#processors.get(key);
-    }
-
-    /**
-     * 创建工具处理器
-     * @param {string} sourceFormat - 源格式
-     * @param {string} targetFormat - 目标格式
-     * @returns {ToolProcessor} 工具处理器实例
-     */
-    static createProcessor(sourceFormat, targetFormat) {
-        logger.warn(`Tool processor for ${sourceFormat} to ${targetFormat} not yet implemented`);
-        return null;
-    }
-
-    /**
-     * 清除所有缓存的处理器
-     */
-    static clearCache() {
-        this.#processors.clear();
-    }
-}
-
-// 导出工厂类
-export default ConverterFactory;

src/converters/register-converters.js

@@ -1,29 +0,0 @@
-/**
- * 转换器注册模块
- * 用于注册所有转换器到工厂，避免循环依赖问题
- */
-
-import { MODEL_PROTOCOL_PREFIX } from '../utils/common.js';
-import { ConverterFactory } from './ConverterFactory.js';
-import { OpenAIConverter } from './strategies/OpenAIConverter.js';
-import { OpenAIResponsesConverter } from './strategies/OpenAIResponsesConverter.js';
-import { ClaudeConverter } from './strategies/ClaudeConverter.js';
-import { GeminiConverter } from './strategies/GeminiConverter.js';
-import { CodexConverter } from './strategies/CodexConverter.js';
-import { GrokConverter } from './strategies/GrokConverter.js';
-
-/**
- * 注册所有转换器到工厂
- * 此函数应在应用启动时调用一次
- */
-export function registerAllConverters() {
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.OPENAI, OpenAIConverter);
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES, OpenAIResponsesConverter);
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.CLAUDE, ClaudeConverter);
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.GEMINI, GeminiConverter);
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.CODEX, CodexConverter);
-    ConverterFactory.registerConverter(MODEL_PROTOCOL_PREFIX.GROK, GrokConverter);
-}
-
-// 自动注册所有转换器
-registerAllConverters();

src/converters/strategies/ClaudeConverter.js

@@ -1,2234 +0,0 @@
-/**
- * Claude转换器
- * 处理Claude（Anthropic）协议与其他协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../../utils/logger.js';
-import { BaseConverter } from '../BaseConverter.js';
-import {
-    checkAndAssignOrDefault,
-    cleanJsonSchemaProperties as cleanJsonSchema,
-    determineReasoningEffortFromBudget,
-    OPENAI_DEFAULT_MAX_TOKENS,
-    OPENAI_DEFAULT_TEMPERATURE,
-    OPENAI_DEFAULT_TOP_P,
-    GEMINI_DEFAULT_MAX_TOKENS,
-    GEMINI_DEFAULT_TEMPERATURE,
-    GEMINI_DEFAULT_TOP_P,
-    GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
-    GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT
-} from '../utils.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../../providers/openai/openai-responses-core.mjs';
-
-/**
- * Claude转换器类
- * 实现Claude协议到其他协议的转换
- */
-export class ClaudeConverter extends BaseConverter {
-    constructor() {
-        super('claude');
-    }
-
-    /**
-     * 转换请求
-     */
-    convertRequest(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiRequest(data);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokRequest(data);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexResponse(data, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexStreamChunk(chunk, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIModelList(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiModelList(data);
-            default:
-                return data;
-        }
-    }
-
-    // =========================================================================
-    // Claude -> OpenAI 转换
-    // =========================================================================
-
-    /**
-     * Claude请求 -> OpenAI请求
-     */
-    toOpenAIRequest(claudeRequest) {
-        const openaiMessages = [];
-        let systemMessageContent = '';
-
-        // 添加系统消息
-        if (claudeRequest.system) {
-            systemMessageContent = claudeRequest.system;
-        }
-
-        // 处理消息
-        if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-            const tempOpenAIMessages = [];
-            for (const msg of claudeRequest.messages) {
-                const role = msg.role;
-
-                // 处理用户的工具结果消息
-                if (role === "user" && Array.isArray(msg.content)) {
-                    const hasToolResult = msg.content.some(
-                        item => item && typeof item === 'object' && item.type === "tool_result"
-                    );
-
-                    if (hasToolResult) {
-                        for (const item of msg.content) {
-                            if (item && typeof item === 'object' && item.type === "tool_result") {
-                                const toolUseId = item.tool_use_id || item.id || "";
-                                let contentStr = item.content || "";
-                                if (typeof contentStr === 'object') {
-                                    contentStr = JSON.stringify(contentStr);
-                                } else {
-                                    contentStr = String(contentStr);
-                                }
-                                tempOpenAIMessages.push({
-                                    role: "tool",
-                                    tool_call_id: toolUseId,
-                                    content: contentStr,
-                                });
-                            }
-                        }
-                        continue;
-                    }
-                }
-
-                // 处理assistant消息中的工具调用
-                if (role === "assistant" && Array.isArray(msg.content) && msg.content.length > 0) {
-                    const firstPart = msg.content[0];
-                    if (firstPart.type === "tool_use") {
-                        const funcName = firstPart.name || "";
-                        const funcArgs = firstPart.input || {};
-                        tempOpenAIMessages.push({
-                            role: "assistant",
-                            content: '',
-                            tool_calls: [
-                                {
-                                    id: firstPart.id || `call_${funcName}_1`,
-                                    type: "function",
-                                    function: {
-                                        name: funcName,
-                                        arguments: JSON.stringify(funcArgs)
-                                    },
-                                    index: firstPart.index || 0
-                                }
-                            ]
-                        });
-                        continue;
-                    }
-                }
-
-                // 普通文本消息
-                const contentConverted = this.processClaudeContentToOpenAIContent(msg.content || "");
-                if (contentConverted && (Array.isArray(contentConverted) ? contentConverted.length > 0 : contentConverted.trim().length > 0)) {
-                    tempOpenAIMessages.push({
-                        role: role,
-                        content: contentConverted
-                    });
-                }
-            }
-
-            // OpenAI兼容性校验
-            const validatedMessages = [];
-            for (let idx = 0; idx < tempOpenAIMessages.length; idx++) {
-                const m = tempOpenAIMessages[idx];
-                if (m.role === "assistant" && m.tool_calls) {
-                    const callIds = m.tool_calls.map(tc => tc.id).filter(id => id);
-                    let unmatched = new Set(callIds);
-                    for (let laterIdx = idx + 1; laterIdx < tempOpenAIMessages.length; laterIdx++) {
-                        const later = tempOpenAIMessages[laterIdx];
-                        if (later.role === "tool" && unmatched.has(later.tool_call_id)) {
-                            unmatched.delete(later.tool_call_id);
-                        }
-                        if (unmatched.size === 0) break;
-                    }
-                    if (unmatched.size > 0) {
-                        m.tool_calls = m.tool_calls.filter(tc => !unmatched.has(tc.id));
-                        if (m.tool_calls.length === 0) {
-                            delete m.tool_calls;
-                            if (m.content === null) m.content = "";
-                        }
-                    }
-                }
-                validatedMessages.push(m);
-            }
-            openaiMessages.push(...validatedMessages);
-        }
-
-        const openaiRequest = {
-            model: claudeRequest.model,
-            messages: openaiMessages,
-            max_tokens: checkAndAssignOrDefault(claudeRequest.max_tokens, OPENAI_DEFAULT_MAX_TOKENS),
-            temperature: checkAndAssignOrDefault(claudeRequest.temperature, OPENAI_DEFAULT_TEMPERATURE),
-            top_p: checkAndAssignOrDefault(claudeRequest.top_p, OPENAI_DEFAULT_TOP_P),
-            stream: claudeRequest.stream,
-        };
-
-        // 处理工具
-        if (claudeRequest.tools) {
-            const openaiTools = [];
-            for (const tool of claudeRequest.tools) {
-                openaiTools.push({
-                    type: "function",
-                    function: {
-                        name: tool.name || "",
-                        description: tool.description || "",
-                        parameters: cleanJsonSchema(tool.input_schema || {})
-                    }
-                });
-            }
-            openaiRequest.tools = openaiTools;
-            openaiRequest.tool_choice = "auto";
-        }
-
-        // 处理thinking转换
-        if (claudeRequest.thinking && claudeRequest.thinking.type === "enabled") {
-            const budgetTokens = claudeRequest.thinking.budget_tokens;
-            const reasoningEffort = determineReasoningEffortFromBudget(budgetTokens);
-            openaiRequest.reasoning_effort = reasoningEffort;
-
-            let maxCompletionTokens = null;
-            if (claudeRequest.max_tokens !== undefined) {
-                maxCompletionTokens = claudeRequest.max_tokens;
-                delete openaiRequest.max_tokens;
-            } else {
-                const envMaxTokens = process.env.OPENAI_REASONING_MAX_TOKENS;
-                if (envMaxTokens) {
-                    try {
-                        maxCompletionTokens = parseInt(envMaxTokens, 10);
-                    } catch (e) {
-                        logger.warn(`Invalid OPENAI_REASONING_MAX_TOKENS value '${envMaxTokens}'`);
-                    }
-                }
-                if (!envMaxTokens) {
-                    throw new Error("For OpenAI reasoning models, max_completion_tokens is required.");
-                }
-            }
-            openaiRequest.max_completion_tokens = maxCompletionTokens;
-        }
-
-        // 添加系统消息
-        if (systemMessageContent) {
-            let stringifiedSystemMessageContent = systemMessageContent;
-            if (Array.isArray(systemMessageContent)) {
-                stringifiedSystemMessageContent = systemMessageContent.map(item =>
-                    typeof item === 'string' ? item : item.text).join('\n');
-            }
-            openaiRequest.messages.unshift({ role: 'system', content: stringifiedSystemMessageContent });
-        }
-
-        return openaiRequest;
-    }
-
-    /**
-     * Claude响应 -> OpenAI响应
-     */
-    toOpenAIResponse(claudeResponse, model) {
-        if (!claudeResponse || !claudeResponse.content || claudeResponse.content.length === 0) {
-            return {
-                id: `chatcmpl-${uuidv4()}`,
-                object: "chat.completion",
-                created: Math.floor(Date.now() / 1000),
-                model: model,
-                choices: [{
-                    index: 0,
-                    message: {
-                        role: "assistant",
-                        content: "",
-                    },
-                    finish_reason: "stop",
-                }],
-                usage: {
-                    prompt_tokens: claudeResponse.usage?.input_tokens || 0,
-                    completion_tokens: claudeResponse.usage?.output_tokens || 0,
-                    total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0),
-                },
-            };
-        }
-
-        // Extract thinking blocks into OpenAI-style `reasoning_content`.
-        let reasoningContent = '';
-        if (Array.isArray(claudeResponse.content)) {
-            for (const block of claudeResponse.content) {
-                if (!block || typeof block !== 'object') continue;
-                if (block.type === 'thinking') {
-                    reasoningContent += (block.thinking ?? block.text ?? '');
-                }
-            }
-        }
-
-        // 检查是否包含 tool_use
-        const hasToolUse = claudeResponse.content.some(block => block && block.type === 'tool_use');
-        
-        let message = {
-            role: "assistant",
-            content: null
-        };
-
-        if (hasToolUse) {
-            // 处理包含工具调用的响应
-            const toolCalls = [];
-            let textContent = '';
-
-            for (const block of claudeResponse.content) {
-                if (!block) continue;
-
-                if (block.type === 'text') {
-                    textContent += block.text || '';
-                } else if (block.type === 'tool_use') {
-                    toolCalls.push({
-                        id: block.id || `call_${block.name}_${Date.now()}`,
-                        type: "function",
-                        function: {
-                            name: block.name || '',
-                            arguments: JSON.stringify(block.input || {})
-                        }
-                    });
-                }
-            }
-
-            message.content = textContent || null;
-            if (toolCalls.length > 0) {
-                message.tool_calls = toolCalls;
-            }
-        } else {
-            // 处理普通文本响应
-            message.content = this.processClaudeResponseContent(claudeResponse.content);
-        }
-
-        if (reasoningContent) {
-            message.reasoning_content = reasoningContent;
-        }
-
-        // 处理 finish_reason
-        let finishReason = 'stop';
-        if (claudeResponse.stop_reason === 'end_turn') {
-            finishReason = 'stop';
-        } else if (claudeResponse.stop_reason === 'max_tokens') {
-            finishReason = 'length';
-        } else if (claudeResponse.stop_reason === 'tool_use') {
-            finishReason = 'tool_calls';
-        } else if (claudeResponse.stop_reason) {
-            finishReason = claudeResponse.stop_reason;
-        }
-
-        return {
-            id: `chatcmpl-${uuidv4()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1000),
-            model: model,
-            choices: [{
-                index: 0,
-                message: message,
-                finish_reason: finishReason,
-            }],
-            usage: {
-                prompt_tokens: claudeResponse.usage?.input_tokens || 0,
-                completion_tokens: claudeResponse.usage?.output_tokens || 0,
-                total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0),
-                cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0,
-                prompt_tokens_details: {
-                    cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0
-                }
-            },
-        };
-    }
-
-    /**
-     * Claude流式响应 -> OpenAI流式响应
-     */
-    toOpenAIStreamChunk(claudeChunk, model) {
-        if (!claudeChunk) return null;
-
-        // 处理 Claude 流式事件
-        const chunkId = `chatcmpl-${uuidv4()}`;
-        const timestamp = Math.floor(Date.now() / 1000);
-
-        // message_start 事件
-        if (claudeChunk.type === 'message_start') {
-            return {
-                id: chunkId,
-                object: "chat.completion.chunk",
-                created: timestamp,
-                model: model,
-                system_fingerprint: "",
-                choices: [{
-                    index: 0,
-                    delta: {
-                        role: "assistant",
-                        content: ""
-                    },
-                    finish_reason: null
-                }],
-                usage: {
-                    prompt_tokens: claudeChunk.message?.usage?.input_tokens || 0,
-                    completion_tokens: 0,
-                    total_tokens: claudeChunk.message?.usage?.input_tokens || 0,
-                    cached_tokens: claudeChunk.message?.usage?.cache_read_input_tokens || 0
-                }
-            };
-        }
-
-        // content_block_start 事件
-        if (claudeChunk.type === 'content_block_start') {
-            const contentBlock = claudeChunk.content_block;
-            
-            // 处理 tool_use 类型
-            if (contentBlock && contentBlock.type === 'tool_use') {
-                return {
-                    id: chunkId,
-                    object: "chat.completion.chunk",
-                    created: timestamp,
-                    model: model,
-                    system_fingerprint: "",
-                    choices: [{
-                        index: 0,
-                        delta: {
-                            tool_calls: [{
-                                index: claudeChunk.index || 0,
-                                id: contentBlock.id,
-                                type: "function",
-                                function: {
-                                    name: contentBlock.name,
-                                    arguments: ""
-                                }
-                            }]
-                        },
-                        finish_reason: null
-                    }]
-                };
-            }
-
-            // 处理 text 类型
-            return {
-                id: chunkId,
-                object: "chat.completion.chunk",
-                created: timestamp,
-                model: model,
-                system_fingerprint: "",
-                choices: [{
-                    index: 0,
-                    delta: {
-                        content: ""
-                    },
-                    finish_reason: null
-                }]
-            };
-        }
-
-        // content_block_delta 事件
-        if (claudeChunk.type === 'content_block_delta') {
-            const delta = claudeChunk.delta;
-            
-            // 处理 text_delta
-            if (delta && delta.type === 'text_delta') {
-                return {
-                    id: chunkId,
-                    object: "chat.completion.chunk",
-                    created: timestamp,
-                    model: model,
-                    system_fingerprint: "",
-                    choices: [{
-                        index: 0,
-                        delta: {
-                            content: delta.text || ""
-                        },
-                        finish_reason: null
-                    }]
-                };
-            }
-
-            // 处理 thinking_delta (推理内容)
-            if (delta && delta.type === 'thinking_delta') {
-                return {
-                    id: chunkId,
-                    object: "chat.completion.chunk",
-                    created: timestamp,
-                    model: model,
-                    system_fingerprint: "",
-                    choices: [{
-                        index: 0,
-                        delta: {
-                            reasoning_content: delta.thinking || ""
-                        },
-                        finish_reason: null
-                    }]
-                };
-            }
-
-            // 处理 input_json_delta (tool arguments)
-            if (delta && delta.type === 'input_json_delta') {
-                return {
-                    id: chunkId,
-                    object: "chat.completion.chunk",
-                    created: timestamp,
-                    model: model,
-                    system_fingerprint: "",
-                    choices: [{
-                        index: 0,
-                        delta: {
-                            tool_calls: [{
-                                index: claudeChunk.index || 0,
-                                function: {
-                                    arguments: delta.partial_json || ""
-                                }
-                            }]
-                        },
-                        finish_reason: null
-                    }]
-                };
-            }
-        }
-
-        // content_block_stop 事件
-        if (claudeChunk.type === 'content_block_stop') {
-            return {
-                id: chunkId,
-                object: "chat.completion.chunk",
-                created: timestamp,
-                model: model,
-                system_fingerprint: "",
-                choices: [{
-                    index: 0,
-                    delta: {},
-                    finish_reason: null
-                }]
-            };
-        }
-
-        // message_delta 事件
-        if (claudeChunk.type === 'message_delta') {
-            const stopReason = claudeChunk.delta?.stop_reason;
-            const finishReason = stopReason === 'end_turn' ? 'stop' :
-                                stopReason === 'max_tokens' ? 'length' :
-                                stopReason === 'tool_use' ? 'tool_calls' :
-                                stopReason || 'stop';
-
-            const chunk = {
-                id: chunkId,
-                object: "chat.completion.chunk",
-                created: timestamp,
-                model: model,
-                system_fingerprint: "",
-                choices: [{
-                    index: 0,
-                    delta: {},
-                    finish_reason: finishReason
-                }]
-            };
-
-            if(claudeChunk.usage){
-                chunk.usage = {
-                    prompt_tokens: claudeChunk.usage.input_tokens || 0,
-                    completion_tokens: claudeChunk.usage.output_tokens || 0,
-                    total_tokens: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0),
-                    cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0,
-                    prompt_tokens_details: {
-                        cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0
-                    }
-                };
-            }
-
-            return chunk;
-        }
-
-        // message_stop 事件
-        if (claudeChunk.type === 'message_stop') {
-            return null;
-            // const chunk = {
-            //     id: chunkId,
-            //     object: "chat.completion.chunk",
-            //     created: timestamp,
-            //     model: model,
-            //     system_fingerprint: "",
-            //     choices: [{
-            //         index: 0,
-            //         delta: {},
-            //         finish_reason: 'stop'
-            //     }]
-            // };
-            // return chunk;
-        }
-
-        // 兼容旧格式：如果是字符串，直接作为文本内容
-        if (typeof claudeChunk === 'string') {
-            return {
-                id: chunkId,
-                object: "chat.completion.chunk",
-                created: timestamp,
-                model: model,
-                system_fingerprint: "",
-                choices: [{
-                    index: 0,
-                    delta: {
-                        content: claudeChunk
-                    },
-                    finish_reason: null
-                }]
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * Claude模型列表 -> OpenAI模型列表
-     */
-    toOpenAIModelList(claudeModels) {
-        return {
-            object: "list",
-            data: claudeModels.models.map(m => {
-                const modelId = m.id || m.name;
-                return {
-                    id: modelId,
-                    object: "model",
-                    created: Math.floor(Date.now() / 1000),
-                    owned_by: "anthropic",
-                    display_name: modelId,
-                };
-            }),
-        };
-    }
-
-    /**
-     * 将 Claude 模型列表转换为 Gemini 模型列表
-     */
-    toGeminiModelList(claudeModels) {
-        const models = claudeModels.models || [];
-        return {
-            models: models.map(m => ({
-                name: `models/${m.id || m.name}`,
-                version: m.version || "1.0.0",
-                displayName: m.displayName || m.id || m.name,
-                description: m.description || `A generative model for text and chat generation. ID: ${m.id || m.name}`,
-                inputTokenLimit: m.inputTokenLimit || GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
-                outputTokenLimit: m.outputTokenLimit || GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT,
-                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
-            }))
-        };
-    }
-
-    /**
-     * 处理Claude内容到OpenAI格式
-     */
-    processClaudeContentToOpenAIContent(content) {
-        if (!content) return [];
-        
-        // 如果是字符串，直接转换为 OpenAI 的文本块格式
-        if (typeof content === 'string') {
-            return [{
-                type: 'text',
-                text: content
-            }];
-        }
-
-        if (!Array.isArray(content)) return [];
-        
-        const contentArray = [];
-        
-        content.forEach(block => {
-            if (!block) return;
-            
-            switch (block.type) {
-                case 'text':
-                    if (block.text) {
-                        contentArray.push({
-                            type: 'text',
-                            text: block.text
-                        });
-                    }
-                    break;
-                    
-                case 'image':
-                    if (block.source && block.source.type === 'base64') {
-                        contentArray.push({
-                            type: 'image_url',
-                            image_url: {
-                                url: `data:${block.source.media_type};base64,${block.source.data}`
-                            }
-                        });
-                    }
-                    break;
-                    
-                case 'tool_use':
-                    contentArray.push({
-                        type: 'text',
-                        text: `[Tool use: ${block.name}]`
-                    });
-                    break;
-                    
-                case 'tool_result':
-                    contentArray.push({
-                        type: 'text',
-                        text: typeof block.content === 'string' ? block.content : JSON.stringify(block.content)
-                    });
-                    break;
-                    
-                default:
-                    if (block.text) {
-                        contentArray.push({
-                            type: 'text',
-                            text: block.text
-                        });
-                    }
-            }
-        });
-        
-        return contentArray;
-    }
-
-    /**
-     * 处理Claude响应内容
-     */
-    processClaudeResponseContent(content) {
-        if (!content) return '';
-        
-        if (typeof content === 'string') return content;
-
-        if (!Array.isArray(content)) return '';
-        
-        const contentArray = [];
-        
-        content.forEach(block => {
-            if (!block) return;
-            
-            switch (block.type) {
-                case 'text':
-                    contentArray.push({
-                        type: 'text',
-                        text: block.text || ''
-                    });
-                    break;
-                    
-                case 'image':
-                    if (block.source && block.source.type === 'base64') {
-                        contentArray.push({
-                            type: 'image_url',
-                            image_url: {
-                                url: `data:${block.source.media_type};base64,${block.source.data}`
-                            }
-                        });
-                    }
-                    break;
-                    
-                default:
-                    if (block.text) {
-                        contentArray.push({
-                            type: 'text',
-                            text: block.text
-                        });
-                    }
-            }
-        });
-        
-        return contentArray.length === 1 && contentArray[0].type === 'text'
-            ? contentArray[0].text
-            : contentArray;
-    }
-
-    // =========================================================================
-    // Claude -> Gemini 转换
-    // =========================================================================
-
-    // Gemini Claude thought signature constant
-    static GEMINI_CLAUDE_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
-
-    /**
-     * Claude请求 -> Gemini请求
-     */
-    toGeminiRequest(claudeRequest) {
-        if (!claudeRequest || typeof claudeRequest !== 'object') {
-            logger.warn("Invalid claudeRequest provided to toGeminiRequest.");
-            return { contents: [] };
-        }
-
-        const geminiRequest = {
-            contents: []
-        };
-
-        // 处理系统指令 - 支持数组和字符串格式
-        if (claudeRequest.system) {
-            if (Array.isArray(claudeRequest.system)) {
-                // 数组格式的系统指令
-                const systemParts = [];
-                claudeRequest.system.forEach(systemPrompt => {
-                    if (systemPrompt && systemPrompt.type === 'text' && typeof systemPrompt.text === 'string') {
-                        systemParts.push({ text: systemPrompt.text });
-                    }
-                });
-                if (systemParts.length > 0) {
-                    geminiRequest.systemInstruction = {
-                        role: 'user',
-                        parts: systemParts
-                    };
-                }
-            } else if (typeof claudeRequest.system === 'string') {
-                // 字符串格式的系统指令
-                geminiRequest.systemInstruction = {
-                    parts: [{ text: claudeRequest.system }]
-                };
-            } else if (typeof claudeRequest.system === 'object') {
-                // 对象格式的系统指令
-                geminiRequest.systemInstruction = {
-                    parts: [{ text: JSON.stringify(claudeRequest.system) }]
-                };
-            }
-        }
-
-        // 处理消息
-        if (Array.isArray(claudeRequest.messages)) {
-            claudeRequest.messages.forEach(message => {
-                if (!message || typeof message !== 'object' || !message.role) {
-                    logger.warn("Skipping invalid message in claudeRequest.messages.");
-                    return;
-                }
-
-                const geminiRole = message.role === 'assistant' ? 'model' : 'user';
-                const content = message.content;
-
-                // 处理内容
-                if (Array.isArray(content)) {
-                    const parts = [];
-                    
-                    content.forEach(block => {
-                        if (!block || typeof block !== 'object') return;
-                        
-                        switch (block.type) {
-                            case 'text':
-                                if (typeof block.text === 'string') {
-                                    parts.push({ text: block.text });
-                                }
-                                break;
-                            
-                            // 添加 thinking 块处理
-                            case 'thinking':
-                                if (typeof block.thinking === 'string' && block.thinking.length > 0) {
-                                    const thinkingPart = {
-                                        text: block.thinking,
-                                        thought: true
-                                    };
-                                    // 如果有签名，添加 thoughtSignature
-                                    if (block.signature && block.signature.length >= 50) {
-                                        thinkingPart.thoughtSignature = block.signature;
-                                    }
-                                    parts.push(thinkingPart);
-                                }
-                                break;
-                            
-                            // [FIX] 处理 redacted_thinking 块
-                            case 'redacted_thinking':
-                                // 将 redacted_thinking 转换为普通文本
-                                if (block.data) {
-                                    parts.push({ 
-                                        text: `[Redacted Thinking: ${block.data}]` 
-                                    });
-                                }
-                                break;
-                                
-                            case 'tool_use':
-                                // 转换为 Gemini functionCall 格式
-                                if (block.name && block.input) {
-                                    const args = typeof block.input === 'string'
-                                        ? block.input
-                                        : JSON.stringify(block.input);
-                                    
-                                    // 验证 args 是有效的 JSON 对象
-                                    try {
-                                        const parsedArgs = JSON.parse(args);
-                                        if (parsedArgs && typeof parsedArgs === 'object') {
-                                            parts.push({
-                                                thoughtSignature: ClaudeConverter.GEMINI_CLAUDE_THOUGHT_SIGNATURE,
-                                                functionCall: {
-                                                    name: block.name,
-                                                    args: parsedArgs
-                                                }
-                                            });
-                                        }
-                                    } catch (e) {
-                                        // 如果解析失败，尝试直接使用 input
-                                        if (block.input && typeof block.input === 'object') {
-                                            parts.push({
-                                                thoughtSignature: ClaudeConverter.GEMINI_CLAUDE_THOUGHT_SIGNATURE,
-                                                functionCall: {
-                                                    name: block.name,
-                                                    args: block.input
-                                                }
-                                            });
-                                        }
-                                    }
-                                }
-                                break;
-                                
-                            case 'tool_result':
-                                // 转换为 Gemini functionResponse 格式
-                                // 的实现，正确处理 tool_use_id 到函数名的映射
-                                const toolCallId = block.tool_use_id;
-                                if (toolCallId) {
-                                    // 尝试从之前的 tool_use 块中查找对应的函数名
-                                    // 如果找不到，则从 tool_use_id 中提取
-                                    let funcName = toolCallId;
-                                    
-                                    // 检查是否有缓存的 tool_id -> name 映射
-                                    // 格式通常是 "funcName-uuid" 或 "toolu_xxx"
-                                    if (toolCallId.startsWith('toolu_')) {
-                                        // Claude 格式的 tool_use_id，需要从上下文中查找函数名
-                                        // 这里我们保留原始 ID 作为 name（Gemini 会处理）
-                                        funcName = toolCallId;
-                                    } else {
-                                        const toolCallIdParts = toolCallId.split('-');
-                                        if (toolCallIdParts.length > 1) {
-                                            // 移除最后一个部分（UUID），保留函数名
-                                            funcName = toolCallIdParts.slice(0, -1).join('-');
-                                        }
-                                    }
-                                    
-                                    // 获取响应数据
-                                    let responseData = block.content;
-                                    
-                                    // 的 tool_result_compressor 逻辑
-                                    // 处理嵌套的 content 数组（如图片等）
-                                    if (Array.isArray(responseData)) {
-                                        // 提取文本内容
-                                        const textParts = responseData
-                                            .filter(item => item && item.type === 'text')
-                                            .map(item => item.text)
-                                            .join('\n');
-                                        responseData = textParts || JSON.stringify(responseData);
-                                    } else if (typeof responseData !== 'string') {
-                                        responseData = JSON.stringify(responseData);
-                                    }
-                                    
-                                    parts.push({
-                                        functionResponse: {
-                                            name: funcName,
-                                            response: {
-                                                result: responseData
-                                            }
-                                        }
-                                    });
-                                }
-                                break;
-                                
-                            case 'image':
-                                if (block.source && block.source.type === 'base64') {
-                                    parts.push({
-                                        inlineData: {
-                                            mimeType: block.source.media_type,
-                                            data: block.source.data
-                                        }
-                                    });
-                                }
-                                break;
-                        }
-                    });
-                    
-                    if (parts.length > 0) {
-                        geminiRequest.contents.push({
-                            role: geminiRole,
-                            parts: parts
-                        });
-                    }
-                } else if (typeof content === 'string') {
-                    // 字符串内容
-                    geminiRequest.contents.push({
-                        role: geminiRole,
-                        parts: [{ text: content }]
-                    });
-                }
-            });
-        }
-
-        // 添加生成配置
-        const generationConfig = {};
-        
-        if (claudeRequest.max_tokens !== undefined) {
-            generationConfig.maxOutputTokens = claudeRequest.max_tokens;
-        }
-        if (claudeRequest.temperature !== undefined) {
-            generationConfig.temperature = claudeRequest.temperature;
-        }
-        if (claudeRequest.top_p !== undefined) {
-            generationConfig.topP = claudeRequest.top_p;
-        }
-        if (claudeRequest.top_k !== undefined) {
-            generationConfig.topK = claudeRequest.top_k;
-        }
-        
-        // 处理 thinking 配置 - 转换为 Gemini thinkingBudget
-        if (claudeRequest.thinking && claudeRequest.thinking.type === 'enabled') {
-            if (claudeRequest.thinking.budget_tokens !== undefined) {
-                const budget = claudeRequest.thinking.budget_tokens;
-                if (!generationConfig.thinkingConfig) {
-                    generationConfig.thinkingConfig = {};
-                }
-                generationConfig.thinkingConfig.thinkingBudget = budget;
-                generationConfig.thinkingConfig.include_thoughts = true;
-            }
-        }
-        
-        if (Object.keys(generationConfig).length > 0) {
-            geminiRequest.generationConfig = generationConfig;
-        }
-
-        // 处理工具 - 使用 parametersJsonSchema 格式
-        if (Array.isArray(claudeRequest.tools) && claudeRequest.tools.length > 0) {
-            const functionDeclarations = [];
-            
-            claudeRequest.tools.forEach(tool => {
-                if (!tool || typeof tool !== 'object' || !tool.name) {
-                    logger.warn("Skipping invalid tool declaration in claudeRequest.tools.");
-                    return;
-                }
-
-                // 清理 input_schema
-                let inputSchema = tool.input_schema;
-                if (inputSchema && typeof inputSchema === 'object') {
-                    // 创建副本以避免修改原始对象
-                    inputSchema = JSON.parse(JSON.stringify(inputSchema));
-                    // 清理不需要的字段
-                    delete inputSchema.$schema;
-                    // 清理 URL 格式（Gemini 不支持）
-                    this.cleanUrlFormatFromSchema(inputSchema);
-                }
-
-                const funcDecl = {
-                    name: String(tool.name),
-                    description: String(tool.description || '')
-                };
-                
-                // 使用 parametersJsonSchema 而不是 parameters
-                if (inputSchema) {
-                    funcDecl.parametersJsonSchema = inputSchema;
-                }
-                
-                functionDeclarations.push(funcDecl);
-            });
-            
-            if (functionDeclarations.length > 0) {
-                geminiRequest.tools = [{
-                    functionDeclarations: functionDeclarations
-                }];
-            }
-        }
-
-        // 处理tool_choice
-        if (claudeRequest.tool_choice) {
-            geminiRequest.toolConfig = this.buildGeminiToolConfigFromClaude(claudeRequest.tool_choice);
-        }
-
-        // 添加默认安全设置
-        geminiRequest.safetySettings = this.getDefaultSafetySettings();
-
-        return geminiRequest;
-    }
-
-    /**
-     * 清理 JSON Schema 中的 URL 格式
-     * Gemini 不支持 "format": "uri"
-     */
-    cleanUrlFormatFromSchema(schema) {
-        if (!schema || typeof schema !== 'object') return;
-        
-        // 如果是属性对象，检查并清理 format
-        if (schema.type === 'string' && schema.format === 'uri') {
-            delete schema.format;
-        }
-        
-        // 递归处理 properties
-        if (schema.properties && typeof schema.properties === 'object') {
-            Object.values(schema.properties).forEach(prop => {
-                this.cleanUrlFormatFromSchema(prop);
-            });
-        }
-        
-        // 递归处理 items（数组类型）
-        if (schema.items) {
-            this.cleanUrlFormatFromSchema(schema.items);
-        }
-        
-        // 递归处理 additionalProperties
-        if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-            this.cleanUrlFormatFromSchema(schema.additionalProperties);
-        }
-    }
-
-    /**
-     * 获取默认的 Gemini 安全设置
-     */
-    getDefaultSafetySettings() {
-        return [
-            { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
-            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
-        ];
-    }
-
-    /**
-     * Claude响应 -> Gemini响应
-     */
-    toGeminiResponse(claudeResponse, model) {
-        if (!claudeResponse || !claudeResponse.content || claudeResponse.content.length === 0) {
-            return { candidates: [], usageMetadata: {} };
-        }
-
-        const parts = [];
-
-        // 处理内容块
-        for (const block of claudeResponse.content) {
-            if (!block) continue;
-
-            switch (block.type) {
-                case 'text':
-                    if (block.text) {
-                        parts.push({ text: block.text });
-                    }
-                    break;
-
-                // 添加 thinking 块处理
-                case 'thinking':
-                    if (block.thinking) {
-                        const thinkingPart = {
-                            text: block.thinking,
-                            thought: true
-                        };
-                        // 如果有签名，添加 thoughtSignature
-                        if (block.signature && block.signature.length >= 50) {
-                            thinkingPart.thoughtSignature = block.signature;
-                        }
-                        parts.push(thinkingPart);
-                    }
-                    break;
-
-                case 'tool_use':
-                    // [FIX] 添加 id 和 thoughtSignature 支持
-                    const functionCallPart = {
-                        functionCall: {
-                            name: block.name,
-                            args: block.input || {}
-                        }
-                    };
-                    // 添加 id（如果存在）
-                    if (block.id) {
-                        functionCallPart.functionCall.id = block.id;
-                    }
-                    // 添加签名（如果存在）
-                    if (block.signature && block.signature.length >= 50) {
-                        functionCallPart.thoughtSignature = block.signature;
-                    }
-                    parts.push(functionCallPart);
-                    break;
-
-                case 'image':
-                    if (block.source && block.source.type === 'base64') {
-                        parts.push({
-                            inlineData: {
-                                mimeType: block.source.media_type,
-                                data: block.source.data
-                            }
-                        });
-                    }
-                    break;
-
-                default:
-                    if (block.text) {
-                        parts.push({ text: block.text });
-                    }
-            }
-        }
-
-        // 映射finish_reason
-        const finishReasonMap = {
-            'end_turn': 'STOP',
-            'max_tokens': 'MAX_TOKENS',
-            'tool_use': 'STOP',
-            'stop_sequence': 'STOP'
-        };
-
-        return {
-            candidates: [{
-                content: {
-                    role: 'model',
-                    parts: parts
-                },
-                finishReason: finishReasonMap[claudeResponse.stop_reason] || 'STOP'
-            }],
-            usageMetadata: claudeResponse.usage ? {
-                promptTokenCount: claudeResponse.usage.input_tokens || 0,
-                candidatesTokenCount: claudeResponse.usage.output_tokens || 0,
-                totalTokenCount: (claudeResponse.usage.input_tokens || 0) + (claudeResponse.usage.output_tokens || 0),
-                cachedContentTokenCount: claudeResponse.usage.cache_read_input_tokens || 0,
-                promptTokensDetails: [{
-                    modality: "TEXT",
-                    tokenCount: claudeResponse.usage.input_tokens || 0
-                }],
-                candidatesTokensDetails: [{
-                    modality: "TEXT",
-                    tokenCount: claudeResponse.usage.output_tokens || 0
-                }]
-            } : {}
-        };
-    }
-
-    /**
-     * Claude流式响应 -> Gemini流式响应
-     */
-    toGeminiStreamChunk(claudeChunk, model) {
-        if (!claudeChunk) return null;
-
-        // 处理Claude流式事件
-        if (typeof claudeChunk === 'object' && !Array.isArray(claudeChunk)) {
-            // content_block_start 事件 - 处理 thinking 块开始
-            if (claudeChunk.type === 'content_block_start') {
-                const contentBlock = claudeChunk.content_block;
-                if (contentBlock && contentBlock.type === 'thinking') {
-                    // thinking 块开始，返回空（等待 delta）
-                    return null;
-                }
-                if (contentBlock && contentBlock.type === 'tool_use') {
-                    // tool_use 块开始
-                    return {
-                        candidates: [{
-                            content: {
-                                role: "model",
-                                parts: [{
-                                    functionCall: {
-                                        name: contentBlock.name,
-                                        args: {},
-                                        id: contentBlock.id
-                                    }
-                                }]
-                            }
-                        }]
-                    };
-                }
-            }
-            
-            // content_block_delta 事件
-            if (claudeChunk.type === 'content_block_delta') {
-                const delta = claudeChunk.delta;
-                
-                // 处理 text_delta
-                if (delta && delta.type === 'text_delta') {
-                    return {
-                        candidates: [{
-                            content: {
-                                role: "model",
-                                parts: [{
-                                    text: delta.text || ""
-                                }]
-                            }
-                        }]
-                    };
-                }
-                
-                // [FIX] 处理 thinking_delta - 转换为 Gemini 的 thought 格式
-                if (delta && delta.type === 'thinking_delta') {
-                    return {
-                        candidates: [{
-                            content: {
-                                role: "model",
-                                parts: [{
-                                    text: delta.thinking || "",
-                                    thought: true
-                                }]
-                            }
-                        }]
-                    };
-                }
-                
-                // [FIX] 处理 signature_delta
-                if (delta && delta.type === 'signature_delta') {
-                    // 签名通常与前一个 thinking 块关联
-                    // 在流式场景中，我们可以忽略或记录
-                    return null;
-                }
-                
-                // [FIX] 处理 input_json_delta (tool arguments)
-                if (delta && delta.type === 'input_json_delta') {
-                    // 工具参数增量，Gemini 不支持增量参数，忽略
-                    return null;
-                }
-            }
-            
-            // message_delta 事件 - 流结束
-            if (claudeChunk.type === 'message_delta') {
-                const stopReason = claudeChunk.delta?.stop_reason;
-                const result = {
-                    candidates: [{
-                        finishReason: stopReason === 'end_turn' ? 'STOP' :
-                                    stopReason === 'max_tokens' ? 'MAX_TOKENS' :
-                                    stopReason === 'tool_use' ? 'STOP' :
-                                    'OTHER'
-                    }]
-                };
-                
-                // 添加 usage 信息
-                if (claudeChunk.usage) {
-                    result.usageMetadata = {
-                        promptTokenCount: claudeChunk.usage.input_tokens || 0,
-                        candidatesTokenCount: claudeChunk.usage.output_tokens || 0,
-                        totalTokenCount: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0),
-                        cachedContentTokenCount: claudeChunk.usage.cache_read_input_tokens || 0,
-                        promptTokensDetails: [{
-                            modality: "TEXT",
-                            tokenCount: claudeChunk.usage.input_tokens || 0
-                        }],
-                        candidatesTokensDetails: [{
-                            modality: "TEXT",
-                            tokenCount: claudeChunk.usage.output_tokens || 0
-                        }]
-                    };
-                }
-                
-                return result;
-            }
-        }
-
-        // 向后兼容：处理字符串格式
-        if (typeof claudeChunk === 'string') {
-            return {
-                candidates: [{
-                    content: {
-                        role: "model",
-                        parts: [{
-                            text: claudeChunk
-                        }]
-                    }
-                }]
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * 处理Claude内容到Gemini parts
-     */
-    processClaudeContentToGeminiParts(content) {
-        if (!content) return [];
-
-        if (typeof content === 'string') {
-            return [{ text: content }];
-        }
-
-        if (Array.isArray(content)) {
-            const parts = [];
-
-            content.forEach(block => {
-                if (!block || typeof block !== 'object' || !block.type) {
-                    logger.warn("Skipping invalid content block.");
-                    return;
-                }
-
-                switch (block.type) {
-                    case 'text':
-                        if (typeof block.text === 'string') {
-                            parts.push({ text: block.text });
-                        }
-                        break;
-
-                    case 'image':
-                        if (block.source && typeof block.source === 'object' && 
-                            block.source.type === 'base64' &&
-                            typeof block.source.media_type === 'string' && 
-                            typeof block.source.data === 'string') {
-                            parts.push({
-                                inlineData: {
-                                    mimeType: block.source.media_type,
-                                    data: block.source.data
-                                }
-                            });
-                        }
-                        break;
-
-                    case 'tool_use':
-                        if (typeof block.name === 'string' && 
-                            block.input && typeof block.input === 'object') {
-                            parts.push({
-                                functionCall: {
-                                    name: block.name,
-                                    args: block.input
-                                }
-                            });
-                        }
-                        break;
-
-                    case 'tool_result':
-                        if (typeof block.tool_use_id === 'string') {
-                            parts.push({
-                                functionResponse: {
-                                    name: block.tool_use_id,
-                                    response: { content: block.content }
-                                }
-                            });
-                        }
-                        break;
-
-                    default:
-                        if (typeof block.text === 'string') {
-                            parts.push({ text: block.text });
-                        }
-                }
-            });
-
-            return parts;
-        }
-
-        return [];
-    }
-
-    /**
-     * 构建Gemini工具配置
-     */
-    buildGeminiToolConfigFromClaude(claudeToolChoice) {
-        if (!claudeToolChoice || typeof claudeToolChoice !== 'object' || !claudeToolChoice.type) {
-            logger.warn("Invalid claudeToolChoice provided.");
-            return undefined;
-        }
-
-        switch (claudeToolChoice.type) {
-            case 'auto':
-                return { functionCallingConfig: { mode: 'AUTO' } };
-            case 'none':
-                return { functionCallingConfig: { mode: 'NONE' } };
-            case 'tool':
-                if (claudeToolChoice.name && typeof claudeToolChoice.name === 'string') {
-                    return { 
-                        functionCallingConfig: { 
-                            mode: 'ANY', 
-                            allowedFunctionNames: [claudeToolChoice.name] 
-                        } 
-                    };
-                }
-                logger.warn("Invalid tool name in claudeToolChoice of type 'tool'.");
-                return undefined;
-            default:
-                logger.warn(`Unsupported claudeToolChoice type: ${claudeToolChoice.type}`);
-                return undefined;
-        }
-    }
-
-    // =========================================================================
-    // Claude -> OpenAI Responses 转换
-    // =========================================================================
-
-    /**
-     * Claude请求 -> OpenAI Responses请求
-     */
-    toOpenAIResponsesRequest(claudeRequest) {
-        const responsesRequest = {
-            model: claudeRequest.model,
-            instructions: '',
-            input: [],
-            stream: claudeRequest.stream || false,
-            max_output_tokens: claudeRequest.max_tokens,
-            temperature: claudeRequest.temperature,
-            top_p: claudeRequest.top_p
-        };
-
-        // 处理系统指令
-        if (claudeRequest.system) {
-            if (Array.isArray(claudeRequest.system)) {
-                responsesRequest.instructions = claudeRequest.system.map(s => typeof s === 'string' ? s : s.text).join('\n');
-            } else {
-                responsesRequest.instructions = claudeRequest.system;
-            }
-        }
-
-        // 处理 thinking 配置
-        if (claudeRequest.thinking && claudeRequest.thinking.type === 'enabled') {
-            responsesRequest.reasoning = {
-                effort: determineReasoningEffortFromBudget(claudeRequest.thinking.budget_tokens)
-            };
-        }
-
-        // 处理消息
-        if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-            claudeRequest.messages.forEach(msg => {
-                const role = msg.role;
-                const content = msg.content;
-
-                if (Array.isArray(content)) {
-                    // 检查是否包含 tool_result
-                    const toolResult = content.find(c => c.type === 'tool_result');
-                    if (toolResult) {
-                        responsesRequest.input.push({
-                            type: 'function_call_output',
-                            call_id: toolResult.tool_use_id,
-                            output: typeof toolResult.content === 'string' ? toolResult.content : JSON.stringify(toolResult.content)
-                        });
-                        return;
-                    }
-
-                    // 检查是否包含 tool_use
-                    const toolUse = content.find(c => c.type === 'tool_use');
-                    if (toolUse) {
-                        responsesRequest.input.push({
-                            type: 'function_call',
-                            call_id: toolUse.id,
-                            name: toolUse.name,
-                            arguments: typeof toolUse.input === 'string' ? toolUse.input : JSON.stringify(toolUse.input)
-                        });
-                        return;
-                    }
-
-                    const responsesContent = content.map(c => {
-                        if (c.type === 'text') {
-                            return {
-                                type: role === 'assistant' ? 'output_text' : 'input_text',
-                                text: c.text
-                            };
-                        } else if (c.type === 'image') {
-                            return {
-                                type: 'input_image',
-                                image_url: {
-                                    url: `data:${c.source.media_type};base64,${c.source.data}`
-                                }
-                            };
-                        }
-                        return null;
-                    }).filter(Boolean);
-
-                    if (responsesContent.length > 0) {
-                        responsesRequest.input.push({
-                            type: 'message',
-                            role: role,
-                            content: responsesContent
-                        });
-                    }
-                } else if (typeof content === 'string') {
-                    responsesRequest.input.push({
-                        type: 'message',
-                        role: role,
-                        content: [{
-                            type: role === 'assistant' ? 'output_text' : 'input_text',
-                            text: content
-                        }]
-                    });
-                }
-            });
-        }
-
-        // 处理工具
-        if (claudeRequest.tools && Array.isArray(claudeRequest.tools)) {
-            responsesRequest.tools = claudeRequest.tools.map(tool => ({
-                type: 'function',
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.input_schema || { type: 'object', properties: {} }
-            }));
-        }
-
-        if (claudeRequest.tool_choice) {
-            if (claudeRequest.tool_choice.type === 'auto') {
-                responsesRequest.tool_choice = 'auto';
-            } else if (claudeRequest.tool_choice.type === 'any') {
-                responsesRequest.tool_choice = 'required';
-            } else if (claudeRequest.tool_choice.type === 'tool') {
-                responsesRequest.tool_choice = {
-                    type: 'function',
-                    function: { name: claudeRequest.tool_choice.name }
-                };
-            }
-        }
-
-        return responsesRequest;
-    }
-
-    /**
-     * Claude响应 -> OpenAI Responses响应
-     */
-    toOpenAIResponsesResponse(claudeResponse, model) {
-        const content = this.processClaudeResponseContent(claudeResponse.content);
-        const textContent = typeof content === 'string' ? content : JSON.stringify(content);
-
-        let output = [];
-        output.push({
-            type: "message",
-            id: `msg_${uuidv4().replace(/-/g, '')}`,
-            summary: [],
-            role: "assistant",
-            status: "completed",
-            content: [{
-                annotations: [],
-                logprobs: [],
-                text: textContent,
-                type: "output_text"
-            }]
-        });
-
-        return {
-            background: false,
-            created_at: Math.floor(Date.now() / 1000),
-            error: null,
-            id: `resp_${uuidv4().replace(/-/g, '')}`,
-            incomplete_details: null,
-            max_output_tokens: null,
-            max_tool_calls: null,
-            metadata: {},
-            model: model || claudeResponse.model,
-            object: "response",
-            output: output,
-            parallel_tool_calls: true,
-            previous_response_id: null,
-            prompt_cache_key: null,
-            reasoning: {},
-            safety_identifier: "user-" + uuidv4().replace(/-/g, ''),
-            service_tier: "default",
-            status: "completed",
-            store: false,
-            temperature: 1,
-            text: {
-                format: { type: "text" },
-            },
-            tool_choice: "auto",
-            tools: [],
-            top_logprobs: 0,
-            top_p: 1,
-            truncation: "disabled",
-            usage: {
-                input_tokens: claudeResponse.usage?.input_tokens || 0,
-                input_tokens_details: {
-                    cached_tokens: claudeResponse.usage?.cache_read_input_tokens || 0
-                },
-                output_tokens: claudeResponse.usage?.output_tokens || 0,
-                output_tokens_details: {
-                    reasoning_tokens: 0
-                },
-                total_tokens: (claudeResponse.usage?.input_tokens || 0) + (claudeResponse.usage?.output_tokens || 0)
-            },
-            user: null
-        };
-    }
-
-    /**
-     * Claude流式响应 -> OpenAI Responses流式响应
-     */
-    toOpenAIResponsesStreamChunk(claudeChunk, model, requestId = null) {
-        if (!claudeChunk) return [];
-
-        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
-        const events = [];
-
-        // message_start 事件 - 流开始
-        if (claudeChunk.type === 'message_start') {
-            events.push(
-                generateResponseCreated(responseId, model || 'unknown'),
-                generateResponseInProgress(responseId),
-                generateOutputItemAdded(responseId),
-                generateContentPartAdded(responseId)
-            );
-        }
-
-        // content_block_start 事件
-        if (claudeChunk.type === 'content_block_start') {
-            const contentBlock = claudeChunk.content_block;
-            
-            // 对于 tool_use 类型，添加工具调用项
-            if (contentBlock && contentBlock.type === 'tool_use') {
-                events.push({
-                    item: {
-                        id: contentBlock.id,
-                        type: "function_call",
-                        name: contentBlock.name,
-                        arguments: "",
-                        status: "in_progress"
-                    },
-                    output_index: claudeChunk.index || 0,
-                    sequence_number: 2,
-                    type: "response.output_item.added"
-                });
-            }
-        }
-
-        // content_block_delta 事件
-        if (claudeChunk.type === 'content_block_delta') {
-            const delta = claudeChunk.delta;
-            
-            // 处理文本增量
-            if (delta && delta.type === 'text_delta') {
-                events.push({
-                    delta: delta.text || "",
-                    item_id: `msg_${uuidv4().replace(/-/g, '')}`,
-                    output_index: claudeChunk.index || 0,
-                    sequence_number: 3,
-                    type: "response.output_text.delta"
-                });
-            }
-            // 处理推理内容增量
-            else if (delta && delta.type === 'thinking_delta') {
-                events.push({
-                    delta: delta.thinking || "",
-                    item_id: `thinking_${uuidv4().replace(/-/g, '')}`,
-                    output_index: claudeChunk.index || 0,
-                    sequence_number: 3,
-                    type: "response.reasoning_summary_text.delta"
-                });
-            }
-            // 处理工具调用参数增量
-            else if (delta && delta.type === 'input_json_delta') {
-                events.push({
-                    delta: delta.partial_json || "",
-                    item_id: `call_${uuidv4().replace(/-/g, '')}`,
-                    output_index: claudeChunk.index || 0,
-                    sequence_number: 3,
-                    type: "response.custom_tool_call_input.delta"
-                });
-            }
-        }
-
-        // content_block_stop 事件
-        if (claudeChunk.type === 'content_block_stop') {
-            events.push({
-                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
-                output_index: claudeChunk.index || 0,
-                sequence_number: 4,
-                type: "response.output_item.done"
-            });
-        }
-
-        // message_delta 事件 - 流结束
-        if (claudeChunk.type === 'message_delta') {
-            // events.push(
-            //     generateOutputTextDone(responseId),
-            //     generateContentPartDone(responseId),
-            //     generateOutputItemDone(responseId),
-            //     generateResponseCompleted(responseId)
-            // );
-            
-            // 如果有 usage 信息，更新最后一个事件
-            if (claudeChunk.usage && events.length > 0) {
-                const lastEvent = events[events.length - 1];
-                if (lastEvent.response) {
-                    lastEvent.response.usage = {
-                        input_tokens: claudeChunk.usage.input_tokens || 0,
-                        input_tokens_details: {
-                            cached_tokens: claudeChunk.usage.cache_read_input_tokens || 0
-                        },
-                        output_tokens: claudeChunk.usage.output_tokens || 0,
-                        output_tokens_details: {
-                            reasoning_tokens: 0
-                        },
-                        total_tokens: (claudeChunk.usage.input_tokens || 0) + (claudeChunk.usage.output_tokens || 0)
-                    };
-                }
-            }
-        }
-
-        // message_stop 事件
-        if (claudeChunk.type === 'message_stop') {
-            events.push(
-                generateOutputTextDone(responseId),
-                generateContentPartDone(responseId),
-                generateOutputItemDone(responseId),
-                generateResponseCompleted(responseId)
-            );
-        }
-
-        return events;
-    }
-
-    // =========================================================================
-    // Claude -> Codex 转换
-    // =========================================================================
-
-    /**
-     * 应用简单缩短规则缩短工具名称
-     */
-    _shortenNameIfNeeded(name) {
-        const limit = 64;
-        if (name.length <= limit) {
-            return name;
-        }
-        if (name.startsWith("mcp__")) {
-            const idx = name.lastIndexOf("__");
-            if (idx > 0) {
-                const cand = "mcp__" + name.substring(idx + 2);
-                if (cand.length > limit) {
-                    return cand.substring(0, limit);
-                }
-                return cand;
-            }
-        }
-        return name.substring(0, limit);
-    }
-
-    /**
-     * 构建短名称映射以确保请求内唯一性
-     */
-    _buildShortNameMap(names) {
-        const limit = 64;
-        const used = new Set();
-        const m = {};
-
-        const baseCandidate = (n) => {
-            if (n.length <= limit) {
-                return n;
-            }
-            if (n.startsWith("mcp__")) {
-                const idx = n.lastIndexOf("__");
-                if (idx > 0) {
-                    let cand = "mcp__" + n.substring(idx + 2);
-                    if (cand.length > limit) {
-                        cand = cand.substring(0, limit);
-                    }
-                    return cand;
-                }
-            }
-            return n.substring(0, limit);
-        };
-
-        const makeUnique = (cand) => {
-            if (!used.has(cand)) {
-                return cand;
-            }
-            const base = cand;
-            for (let i = 1; ; i++) {
-                const suffix = "_" + i;
-                const allowed = limit - suffix.length;
-                let tmp = base;
-                if (tmp.length > (allowed < 0 ? 0 : allowed)) {
-                    tmp = tmp.substring(0, allowed < 0 ? 0 : allowed);
-                }
-                tmp = tmp + suffix;
-                if (!used.has(tmp)) {
-                    return tmp;
-                }
-            }
-        };
-
-        for (const n of names) {
-            const cand = baseCandidate(n);
-            const uniq = makeUnique(cand);
-            used.add(uniq);
-            m[n] = uniq;
-        }
-        return m;
-    }
-
-    /**
-     * 标准化工具参数，确保对象 Schema 包含 properties
-     */
-    _normalizeToolParameters(schema) {
-        if (!schema || typeof schema !== 'object') {
-            return { type: 'object', properties: {} };
-        }
-        const result = { ...schema };
-        if (!result.type) {
-            result.type = 'object';
-        }
-        if (result.type === 'object' && !result.properties) {
-            result.properties = {};
-        }
-        return result;
-    }
-
-    /**
-     * Claude请求 -> Codex请求
-     */
-    toCodexRequest(claudeRequest) {
-        const codexRequest = {
-            model: claudeRequest.model,
-            instructions: '',
-            input: [],
-            stream: true,
-            store: false,
-            parallel_tool_calls: true,
-            metadata: claudeRequest.metadata || {},
-            reasoning: {
-                effort: claudeRequest.reasoning?.effort || 'medium',
-                summary: 'auto'
-            },
-            include: ['reasoning.encrypted_content']
-        };
-
-        // 处理系统指令
-        if (claudeRequest.system) {
-            let instructions = '';
-            if (Array.isArray(claudeRequest.system)) {
-                instructions = claudeRequest.system.map(s => typeof s === 'string' ? s : s.text).join('\n');
-            } else {
-                instructions = claudeRequest.system;
-            }
-            codexRequest.instructions = instructions;
-
-            // 处理 Codex 中的系统消息（作为 developer 角色添加到 input）
-            const systemParts = Array.isArray(claudeRequest.system) ? claudeRequest.system : [{ type: 'text', text: claudeRequest.system }];
-            const developerMessage = {
-                type: 'message',
-                role: 'developer',
-                content: []
-            };
-
-            systemParts.forEach(part => {
-                if (part.type === 'text') {
-                    developerMessage.content.push({
-                        type: 'input_text',
-                        text: part.text
-                    });
-                } else if (typeof part === 'string') {
-                    developerMessage.content.push({
-                        type: 'input_text',
-                        text: part
-                    });
-                }
-            });
-
-            if (developerMessage.content.length > 0) {
-                codexRequest.input.push(developerMessage);
-            }
-        }
-
-        // 处理工具并构建短名称映射
-        let shortMap = {};
-        if (claudeRequest.tools && Array.isArray(claudeRequest.tools)) {
-            const toolNames = claudeRequest.tools.map(t => t.name).filter(Boolean);
-            shortMap = this._buildShortNameMap(toolNames);
-
-            codexRequest.tools = claudeRequest.tools.map(tool => {
-                // 特殊处理：将 Claude Web Search 工具映射到 Codex web_search
-                if (tool.type === "web_search_20250305") {
-                    return { type: "web_search" };
-                }
-
-                let name = tool.name;
-                if (shortMap[name]) {
-                    name = shortMap[name];
-                } else {
-                    name = this._shortenNameIfNeeded(name);
-                }
-
-                const convertedTool = {
-                    type: 'function',
-                    name: name,
-                    description: tool.description || '',
-                    parameters: this._normalizeToolParameters(tool.input_schema),
-                    strict: false
-                };
-                
-                // 移除 parameters.$schema
-                if (convertedTool.parameters && convertedTool.parameters.$schema) {
-                    delete convertedTool.parameters.$schema;
-                }
-
-                return convertedTool;
-            });
-            codexRequest.tool_choice = "auto";
-        }
-
-        // 处理消息
-        if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-            for (const msg of claudeRequest.messages) {
-                const role = msg.role;
-                const content = msg.content;
-
-                let currentMessage = {
-                    type: 'message',
-                    role: role,
-                    content: []
-                };
-
-                const flushMessage = () => {
-                    if (currentMessage.content.length > 0) {
-                        codexRequest.input.push({ ...currentMessage });
-                        currentMessage.content = [];
-                    }
-                };
-
-                const appendTextContent = (text) => {
-                    const partType = role === 'assistant' ? 'output_text' : 'input_text';
-                    currentMessage.content.push({
-                        type: partType,
-                        text: text
-                    });
-                };
-
-                const appendImageContent = (data, mediaType) => {
-                    currentMessage.content.push({
-                        type: 'input_image',
-                        image_url: `data:${mediaType};base64,${data}`
-                    });
-                };
-
-                if (Array.isArray(content)) {
-                    for (const block of content) {
-                        switch (block.type) {
-                            case 'text':
-                                appendTextContent(block.text);
-                                break;
-                            case 'image':
-                                if (block.source) {
-                                    const data = block.source.data || block.source.base64 || '';
-                                    const mediaType = block.source.media_type || block.source.mime_type || 'application/octet-stream';
-                                    if (data) {
-                                        appendImageContent(data, mediaType);
-                                    }
-                                }
-                                break;
-                            case 'tool_use':
-                                flushMessage();
-                                let toolName = block.name;
-                                if (shortMap[toolName]) {
-                                    toolName = shortMap[toolName];
-                                } else {
-                                    toolName = this._shortenNameIfNeeded(toolName);
-                                }
-                                codexRequest.input.push({
-                                    type: 'function_call',
-                                    call_id: block.id,
-                                    name: toolName,
-                                    arguments: typeof block.input === 'string' ? block.input : JSON.stringify(block.input || {})
-                                });
-                                break;
-                            case 'tool_result':
-                                flushMessage();
-                                codexRequest.input.push({
-                                    type: 'function_call_output',
-                                    call_id: block.tool_use_id,
-                                    output: typeof block.content === 'string' ? block.content : JSON.stringify(block.content || "")
-                                });
-                                break;
-                        }
-                    }
-                } else if (typeof content === 'string') {
-                    appendTextContent(content);
-                }
-                flushMessage();
-            }
-        }
-
-        // 处理 thinking 转换
-        if (claudeRequest.thinking && claudeRequest.thinking.type === "enabled") {
-            const budgetTokens = claudeRequest.thinking.budget_tokens;
-            codexRequest.reasoning.effort = determineReasoningEffortFromBudget(budgetTokens);
-        } else if (claudeRequest.thinking && claudeRequest.thinking.type === "disabled") {
-             codexRequest.reasoning.effort = determineReasoningEffortFromBudget(0);
-        }
-
-        // 注入 Codex 指令 (对应 末尾的特殊逻辑)
-        // 注意：这里需要检查是否需要注入 "EXECUTE ACCORDING TO THE FOLLOWING INSTRUCTIONS!!!"
-        // 通过 misc.GetCodexInstructionsEnabled() 判断，这里我们参考其逻辑
-        const shouldInjectInstructions = process.env.CODEX_INSTRUCTIONS_ENABLED === 'true'; // 假设环境变量控制
-        if (shouldInjectInstructions && codexRequest.input.length > 0) {
-            const firstInput = codexRequest.input[0];
-            const firstText = firstInput.content && firstInput.content[0] && firstInput.content[0].text;
-            const instructions = "EXECUTE ACCORDING TO THE FOLLOWING INSTRUCTIONS!!!";
-            if (firstText !== instructions) {
-                codexRequest.input.unshift({
-                    type: 'message',
-                    role: 'user',
-                    content: [{
-                        type: 'input_text',
-                        text: instructions
-                    }]
-                });
-            }
-        }
-
-        return codexRequest;
-    }
-
-    /**
-     * Claude请求 -> Grok请求
-     */
-    toGrokRequest(claudeRequest) {
-        // 先转换为 OpenAI 格式，因为 Grok 兼容 OpenAI 格式
-        const openaiRequest = this.toOpenAIRequest(claudeRequest);
-        return {
-            ...openaiRequest,
-            _isConverted: true
-        };
-    }
-
-    /**
-     * Claude响应 -> Codex响应 (实际上是 Codex 转 Claude)
-     */
-    toCodexResponse(codexResponse, model) {
-        const content = [];
-        let stopReason = "end_turn";
-
-        if (codexResponse.response?.output) {
-            codexResponse.response.output.forEach(item => {
-                if (item.type === 'message' && item.content) {
-                    const textPart = item.content.find(c => c.type === 'output_text');
-                    if (textPart) content.push({ type: 'text', text: textPart.text });
-                } else if (item.type === 'reasoning' && item.summary) {
-                    const textPart = item.summary.find(c => c.type === 'summary_text');
-                    if (textPart) content.push({ type: 'thinking', thinking: textPart.text });
-                } else if (item.type === 'function_call') {
-                    stopReason = "tool_use";
-                    content.push({
-                        type: 'tool_use',
-                        id: item.call_id,
-                        name: item.name,
-                        input: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                    });
-                }
-            });
-        }
-
-        return {
-            id: codexResponse.response?.id || `msg_${uuidv4().replace(/-/g, '')}`,
-            type: "message",
-            role: "assistant",
-            model: model,
-            content: content,
-            stop_reason: stopReason,
-            usage: {
-                input_tokens: codexResponse.response?.usage?.input_tokens || 0,
-                output_tokens: codexResponse.response?.usage?.output_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * Claude流式响应 -> Codex流式响应 (实际上是 Codex 转 Claude)
-     */
-    toCodexStreamChunk(codexChunk, model) {
-        const type = codexChunk.type;
-        const resId = codexChunk.response?.id || 'default';
-        
-        if (type === 'response.created') {
-            return {
-                type: "message_start",
-                message: {
-                    id: codexChunk.response.id,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model: model,
-                    usage: { input_tokens: 0, output_tokens: 0 }
-                }
-            };
-        }
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            return {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "thinking_delta", thinking: codexChunk.delta }
-            };
-        }
-
-        if (type === 'response.output_text.delta') {
-            return {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "text_delta", text: codexChunk.delta }
-            };
-        }
-
-        if (type === 'response.output_item.done' && codexChunk.item?.type === 'function_call') {
-            return [
-                {
-                    type: "content_block_start",
-                    index: 0,
-                    content_block: {
-                        type: "tool_use",
-                        id: codexChunk.item.call_id,
-                        name: codexChunk.item.name,
-                        input: {}
-                    }
-                },
-                {
-                    type: "content_block_delta",
-                    index: 0,
-                    delta: {
-                        type: "input_json_delta",
-                        partial_json: typeof codexChunk.item.arguments === 'string' ? codexChunk.item.arguments : JSON.stringify(codexChunk.item.arguments)
-                    }
-                },
-                {
-                    type: "content_block_stop",
-                    index: 0
-                }
-            ];
-        }
-
-        if (type === 'response.completed') {
-            return [
-                {
-                    type: "message_delta",
-                    delta: { stop_reason: "end_turn" },
-                    usage: {
-                        input_tokens: codexChunk.response.usage?.input_tokens || 0,
-                        output_tokens: codexChunk.response.usage?.output_tokens || 0
-                    }
-                },
-                { type: "message_stop" }
-            ];
-        }
-
-        return null;
-    }
-}
-
-export default ClaudeConverter;

src/converters/strategies/CodexConverter.js

@@ -1,1327 +0,0 @@
-/**
- * Codex 转换器
- * 处理 OpenAI 协议与 Codex 协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { BaseConverter } from '../BaseConverter.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../../providers/openai/openai-responses-core.mjs';
-
-export class CodexConverter extends BaseConverter {
-    constructor() {
-        super('codex');
-        this.toolNameMap = new Map(); // 工具名称缩短映射: original -> short
-        this.reverseToolNameMap = new Map(); // 反向映射: short -> original
-        this.streamParams = new Map(); // 用于存储流式状态，key 为响应 ID 或临时标识
-    }
-
-    /**
-     * 转换请求
-     */
-    convertRequest(data, targetProtocol) {
-        throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-    }
-
-    /**
-     * 转换响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return data; // Codex to Codex
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model, requestId) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeStreamChunk(chunk, model, requestId);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return chunk; // Codex to Codex
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        return data;
-    }
-
-    /**
-     * OpenAI Responses → Codex 请求转换
-     */
-    toOpenAIResponsesToCodexRequest(responsesRequest) {
-        let codexRequest = { ...responsesRequest };
-    
-        // 保留监控相关字段
-        if (responsesRequest._monitorRequestId) {
-            codexRequest._monitorRequestId = responsesRequest._monitorRequestId;
-        }
-        if (responsesRequest._requestBaseUrl) {
-            codexRequest._requestBaseUrl = responsesRequest._requestBaseUrl;
-        }
-
-        // 处理 input 字段，如果它是字符串，则转换为消息数组
-        if (codexRequest.input && typeof codexRequest.input === 'string') {
-            const inputText = codexRequest.input;
-            codexRequest.input = [{
-                type: "message",
-                role: "user",
-                content: [{
-                    type: "input_text",
-                    text: inputText
-                }]
-            }];
-        }
-    
-        // 设置Codex特定的字段
-        codexRequest.stream = true;
-        codexRequest.store = false;
-        codexRequest.parallel_tool_calls = true;
-        codexRequest.include = ['reasoning.encrypted_content'];
-        codexRequest.service_tier = responsesRequest.service_tier || 'default';
-        if (codexRequest.service_tier !== 'priority') {
-            delete codexRequest.service_tier;
-        }
-    
-        // 删除Codex不支持的字段
-        delete codexRequest.max_output_tokens;
-        delete codexRequest.max_completion_tokens;
-        delete codexRequest.temperature;
-        delete codexRequest.top_p;
-        delete codexRequest.user;
-        
-        // 添加 reasoning 配置
-        codexRequest.reasoning = {
-          "effort": responsesRequest.reasoning_effort || responsesRequest.reasoning?.effort || "medium",
-          "summary": responsesRequest.reasoning?.summary || "auto"
-        };
-        
-    
-        // 确保 input 数组中的每个项都有 type: "message"，并将系统角色转换为开发者角色
-        if (codexRequest.input && Array.isArray(codexRequest.input)) {
-            codexRequest.input = codexRequest.input.filter(item => {
-                // 如��� instructions 已存在，过滤掉 input 中的 system/developer 消息以避免重复
-                if (codexRequest.instructions && (item.role === 'system' || item.role === 'developer')) {
-                    return false;
-                }
-                return true;
-            }).map(item => {
-                // 如果没有 type 或者 type 不是 message，则添加 type: "message"
-                if (!item.type || item.type !== 'message') {
-                    item = { type: "message", ...item };
-                }
-                
-                // 将系统角色转换为开发者角色
-                if (item.role === 'system') {
-                    item = { ...item, role: 'developer' };
-                }
-                
-                return item;
-            });
-        }
-    
-        return codexRequest;
-    }
-
-    /**
-     * OpenAI → Codex 请求转换
-     */
-    toOpenAIRequestToCodexRequest(data) {
-        // 构建工具名称映射
-        this.buildToolNameMap(data.tools || []);
-
-        const codexRequest = {
-            model: data.model,
-            instructions: this.buildInstructions(data),
-            input: this.convertMessages((data.messages || []).filter(m => m.role !== 'system' && m.role !== 'developer')),
-            stream: true,
-            store: false,
-            metadata: data.metadata || {},
-            reasoning: {
-                effort: data.reasoning_effort || data.reasoning?.effort || 'medium',
-                summary: data.reasoning?.summary || 'auto'
-            },
-            parallel_tool_calls: true,
-            include: ['reasoning.encrypted_content']
-        };
-
-        // 保留监控相关字段
-        if (data._monitorRequestId) {
-            codexRequest._monitorRequestId = data._monitorRequestId;
-        }
-        if (data._requestBaseUrl) {
-            codexRequest._requestBaseUrl = data._requestBaseUrl;
-        }
-
-        codexRequest.service_tier = data.service_tier || 'default';
-        if (codexRequest.service_tier !== 'priority') {
-            delete codexRequest.service_tier;
-        }
-
-        // 处理 OpenAI Responses 特有的 instructions 和 input 字段（如果存在）
-        if (data.instructions && !codexRequest.instructions) {
-            codexRequest.instructions = data.instructions;
-        }
-
-        if (data.input && Array.isArray(data.input) && codexRequest.input.length === 0) {
-             // 如果是 OpenAI Responses 格式的 input
-             for (const item of data.input) {
-                if (item.type === 'message' && item.role !== 'system' && item.role !== 'developer') {
-                    codexRequest.input.push({
-                        type: 'message',
-                        role: item.role === 'system' ? 'developer' : item.role,
-                        content: Array.isArray(item.content) ? item.content.map(c => ({
-                            type: item.role === 'assistant' ? 'output_text' : 'input_text',
-                            text: c.text
-                        })) : [{
-                            type: item.role === 'assistant' ? 'output_text' : 'input_text',
-                            text: item.content
-                        }]
-                    });
-                }
-            }
-        }
-
-        if (data.tools && data.tools.length > 0) {
-            codexRequest.tools = this.convertTools(data.tools);
-        }
-
-        if (data.tool_choice) {
-            codexRequest.tool_choice = this.convertToolChoice(data.tool_choice);
-        }
-
-        if (data.response_format || data.text?.verbosity) {
-            const textObj = {};
-            if (data.response_format) {
-                textObj.format = this.convertResponseFormat(data.response_format);
-            }
-            if (data.text?.verbosity) {
-                textObj.verbosity = data.text.verbosity;
-            }
-            codexRequest.text = textObj;
-        }
-
-        // 在 input 开头注入特殊指令（如果配置允许）
-        // 这里我们默认开启，因为这是为了确保 Codex 遵循指令
-        if (codexRequest.input.length > 0 && codexRequest.instructions) {
-             const firstMsg = codexRequest.input[0];
-             const specialInstruction = "EXECUTE ACCORDING TO THE FOLLOWING INSTRUCTIONS!!!";
-             const firstText = firstMsg.content?.[0]?.text;
-             
-             if (firstMsg.role === 'user' && firstText !== specialInstruction) {
-                 codexRequest.input.unshift({
-                     type: "message",
-                     role: "user",
-                     content: [{
-                         type: "input_text",
-                         text: specialInstruction
-                     }]
-                 });
-             }
-        }
-
-        return codexRequest;
-    }
-
-    /**
-     * 构建指令
-     */
-    buildInstructions(data) {
-        // 首先检查显式的 instructions 字段 (OpenAI Responses)
-        if (data.instructions) return data.instructions;
-
-        const systemMessages = (data.messages || []).filter(m => m.role === 'system');
-        if (systemMessages.length > 0) {
-            return systemMessages.map(m => {
-                if (typeof m.content === 'string') {
-                    return m.content;
-                } else if (Array.isArray(m.content)) {
-                    const textPart = m.content.find(part => part.type === 'text');
-                    return textPart ? textPart.text : '';
-                }
-                return '';
-            }).join('\n').trim();
-        }
-        return '';
-    }
-
-    /**
-     * 转换消息
-     */
-    convertMessages(messages) {
-        const input = [];
-
-        for (const msg of messages) {
-            const role = msg.role;
-
-            if (role === 'tool' || role === 'tool_result') {
-                input.push({
-                    type: 'function_call_output',
-                    call_id: msg.tool_call_id || msg.tool_use_id,
-                    output: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-                });
-            } else {
-                const codexMsg = {
-                    type: 'message',
-                    role: role === 'system' ? 'developer' : (role === 'model' ? 'assistant' : role),
-                    content: this.convertMessageContent(msg.content, role)
-                };
-                
-                if (codexMsg.content.length > 0) {
-                    input.push(codexMsg);
-                }
-
-                if ((role === 'assistant' || role === 'model') && msg.tool_calls) {
-                    for (const toolCall of msg.tool_calls) {
-                        if (toolCall.type === 'function' || toolCall.function) {
-                            const func = toolCall.function || toolCall;
-                            const originalName = func.name;
-                            const shortName = this.toolNameMap.get(originalName) || this.shortenToolName(originalName);
-                            input.push({
-                                type: 'function_call',
-                                call_id: toolCall.id,
-                                name: shortName,
-                                arguments: typeof func.arguments === 'string' ? func.arguments : JSON.stringify(func.arguments)
-                            });
-                        }
-                    }
-                }
-                
-                // 处理 Claude 格式的 tool_use
-                if (role === 'assistant' && Array.isArray(msg.content)) {
-                    for (const part of msg.content) {
-                        if (part.type === 'tool_use') {
-                            const originalName = part.name;
-                            const shortName = this.toolNameMap.get(originalName) || this.shortenToolName(originalName);
-                            input.push({
-                                type: 'function_call',
-                                call_id: part.id,
-                                name: shortName,
-                                arguments: typeof part.input === 'string' ? part.input : JSON.stringify(part.input)
-                            });
-                        }
-                    }
-                }
-            }
-        }
-
-        return input;
-    }
-
-    /**
-     * 转换消息内容
-     */
-    convertMessageContent(content, role) {
-        if (!content) return [];
-
-        const isAssistant = role === 'assistant' || role === 'model';
-
-        if (typeof content === 'string') {
-            return [{
-                type: isAssistant ? 'output_text' : 'input_text',
-                text: content
-            }];
-        }
-
-        if (Array.isArray(content)) {
-            return content.map(part => {
-                if (typeof part === 'string') {
-                    return {
-                        type: isAssistant ? 'output_text' : 'input_text',
-                        text: part
-                    };
-                }
-                if (part.type === 'text') {
-                    return {
-                        type: isAssistant ? 'output_text' : 'input_text',
-                        text: part.text
-                    };
-                } else if ((part.type === 'image_url' || part.type === 'image') && !isAssistant) {
-                    let url = '';
-                    if (part.image_url) {
-                        url = typeof part.image_url === 'string' ? part.image_url : part.image_url.url;
-                    } else if (part.source && part.source.type === 'base64') {
-                        url = `data:${part.source.media_type};base64,${part.source.data}`;
-                    }
-                    return url ? {
-                        type: 'input_image',
-                        image_url: url
-                    } : null;
-                }
-                return null;
-            }).filter(Boolean);
-        }
-
-        return [];
-    }
-
-    /**
-     * 构建工具名称映射
-     */
-    buildToolNameMap(tools) {
-        this.toolNameMap.clear();
-        this.reverseToolNameMap.clear();
-
-        const names = [];
-        for (const t of tools) {
-            if (t.type === 'function' && t.function?.name) {
-                names.push(t.function.name);
-            } else if (t.name) {
-                names.push(t.name);
-            }
-        }
-
-        if (names.length === 0) return;
-
-        const limit = 64;
-        const used = new Set();
-
-        const baseCandidate = (n) => {
-            if (n.length <= limit) return n;
-            if (n.startsWith('mcp__')) {
-                const idx = n.lastIndexOf('__');
-                if (idx > 0) {
-                    let cand = 'mcp__' + n.slice(idx + 2);
-                    return cand.length > limit ? cand.slice(0, limit) : cand;
-                }
-            }
-            return n.slice(0, limit);
-        };
-
-        for (const n of names) {
-            let cand = baseCandidate(n);
-            let uniq = cand;
-            if (used.has(uniq)) {
-                for (let i = 1; ; i++) {
-                    const suffix = '_' + i;
-                    const allowed = limit - suffix.length;
-                    const base = cand.slice(0, Math.max(0, allowed));
-                    const tmp = base + suffix;
-                    if (!used.has(tmp)) {
-                        uniq = tmp;
-                        break;
-                    }
-                }
-            }
-            used.add(uniq);
-            this.toolNameMap.set(n, uniq);
-            this.reverseToolNameMap.set(uniq, n);
-        }
-    }
-
-    /**
-     * 转换工具
-     */
-    convertTools(tools) {
-        return tools.map(tool => {
-            // 处理 Claude 的 web_search
-            if (tool.type === "web_search_20250305") {
-                return { type: "web_search" };
-            }
-
-            if (tool.type !== 'function' && !tool.name) {
-                return tool;
-            }
-
-            const func = tool.function || tool;
-            const originalName = func.name;
-            const shortName = this.toolNameMap.get(originalName) || this.shortenToolName(originalName);
-
-            const result = {
-                type: 'function',
-                name: shortName,
-                description: func.description,
-                parameters: func.parameters || func.input_schema || { type: 'object', properties: {} },
-                strict: func.strict !== undefined ? func.strict : false
-            };
-            
-            // 清理参数
-            if (result.parameters && result.parameters.$schema) {
-                delete result.parameters.$schema;
-            }
-
-            return result;
-        });
-    }
-
-    /**
-     * 转换 tool_choice
-     */
-    convertToolChoice(toolChoice) {
-        if (typeof toolChoice === 'string') {
-            return toolChoice;
-        }
-
-        if (toolChoice.type === 'function') {
-            const name = toolChoice.function?.name;
-            const shortName = name ? (this.toolNameMap.get(name) || this.shortenToolName(name)) : '';
-            return {
-                type: 'function',
-                name: shortName
-            };
-        }
-
-        return toolChoice;
-    }
-
-    /**
-     * 缩短工具名称
-     */
-    shortenToolName(name) {
-        const limit = 64;
-        if (name.length <= limit) return name;
-        if (name.startsWith('mcp__')) {
-            const idx = name.lastIndexOf('__');
-            if (idx > 0) {
-                let cand = 'mcp__' + name.slice(idx + 2);
-                return cand.length > limit ? cand.slice(0, limit) : cand;
-            }
-        }
-        return name.slice(0, limit);
-    }
-
-    /**
-     * 获取原始工具名称
-     */
-    getOriginalToolName(shortName) {
-        return this.reverseToolNameMap.get(shortName) || shortName;
-    }
-
-    /**
-     * 转换响应格式
-     */
-    convertResponseFormat(responseFormat) {
-        if (responseFormat.type === 'json_schema') {
-            return {
-                type: 'json_schema',
-                name: responseFormat.json_schema?.name || 'response',
-                schema: responseFormat.json_schema?.schema || {}
-            };
-        } else if (responseFormat.type === 'json_object') {
-            return {
-                type: 'json_object'
-            };
-        }
-        return responseFormat;
-    }
-
-    /**
-     * Codex → OpenAI 响应转换（非流式）
-     */
-    toOpenAIResponse(rawJSON, model) {
-        const root = typeof rawJSON === 'string' ? JSON.parse(rawJSON) : rawJSON;
-        if (root.type !== 'response.completed') {
-            return null;
-        }
-
-        const response = root.response;
-        const unixTimestamp = response.created_at || Math.floor(Date.now() / 1000);
-
-        const openaiResponse = {
-            id: response.id || `chatcmpl-${Date.now()}`,
-            object: 'chat.completion',
-            created: unixTimestamp,
-            model: response.model || model,
-            choices: [{
-                index: 0,
-                message: {
-                    role: 'assistant',
-                    content: null,
-                    reasoning_content: null,
-                    tool_calls: null
-                },
-                finish_reason: null,
-                native_finish_reason: null
-            }],
-            usage: {
-                prompt_tokens: response.usage?.input_tokens || 0,
-                completion_tokens: response.usage?.output_tokens || 0,
-                total_tokens: response.usage?.total_tokens || 0
-            }
-        };
-
-        if (response.usage?.output_tokens_details?.reasoning_tokens) {
-            openaiResponse.usage.completion_tokens_details = {
-                reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
-            };
-        }
-
-        const output = response.output || [];
-        let contentText = '';
-        let reasoningText = '';
-        const toolCalls = [];
-
-        for (const item of output) {
-            switch (item.type) {
-                case 'reasoning':
-                    if (Array.isArray(item.summary)) {
-                        const summaryItem = item.summary.find(s => s.type === 'summary_text');
-                        if (summaryItem) reasoningText = summaryItem.text;
-                    }
-                    break;
-                case 'message':
-                    if (Array.isArray(item.content)) {
-                        const contentItem = item.content.find(c => c.type === 'output_text');
-                        if (contentItem) contentText = contentItem.text;
-                    }
-                    break;
-                case 'function_call':
-                    toolCalls.push({
-                        id: item.call_id || `call_${Date.now()}_${toolCalls.length}`,
-                        type: 'function',
-                        function: {
-                            name: this.getOriginalToolName(item.name),
-                            arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments)
-                        }
-                    });
-                    break;
-            }
-        }
-
-        if (contentText) openaiResponse.choices[0].message.content = contentText;
-        if (reasoningText) openaiResponse.choices[0].message.reasoning_content = reasoningText;
-        if (toolCalls.length > 0) openaiResponse.choices[0].message.tool_calls = toolCalls;
-
-        if (response.status === 'completed') {
-            openaiResponse.choices[0].finish_reason = toolCalls.length > 0 ? 'tool_calls' : 'stop';
-            openaiResponse.choices[0].native_finish_reason = 'stop';
-        }
-
-        return openaiResponse;
-    }
-
-    /**
-     * Codex → OpenAI Responses 响应转换
-     */
-    toOpenAIResponsesResponse(rawJSON, model) {
-        const root = typeof rawJSON === 'string' ? JSON.parse(rawJSON) : rawJSON;
-        if (root.type !== 'response.completed') {
-            return null;
-        }
-
-        const response = root.response;
-        const unixTimestamp = response.created_at || Math.floor(Date.now() / 1000);
-
-        const output = [];
-
-        if (response.output && Array.isArray(response.output)) {
-            for (const item of response.output) {
-                if (item.type === 'reasoning') {
-                    let reasoningText = '';
-                    if (Array.isArray(item.summary)) {
-                        const summaryItem = item.summary.find(s => s.type === 'summary_text');
-                        if (summaryItem) reasoningText = summaryItem.text;
-                    }
-                    if (reasoningText) {
-                        output.push({
-                            id: `msg_${uuidv4().replace(/-/g, '')}`,
-                            type: "message",
-                            role: "assistant",
-                            status: "completed",
-                            content: [{
-                                type: "reasoning",
-                                text: reasoningText
-                            }]
-                        });
-                    }
-                } else if (item.type === 'message') {
-                    let contentText = '';
-                    if (Array.isArray(item.content)) {
-                        const contentItem = item.content.find(c => c.type === 'output_text');
-                        if (contentItem) contentText = contentItem.text;
-                    }
-                    if (contentText) {
-                        output.push({
-                            id: `msg_${uuidv4().replace(/-/g, '')}`,
-                            type: "message",
-                            role: "assistant",
-                            status: "completed",
-                            content: [{
-                                type: "output_text",
-                                text: contentText,
-                                annotations: []
-                            }]
-                        });
-                    }
-                } else if (item.type === 'function_call') {
-                    output.push({
-                        id: item.call_id || `call_${uuidv4().replace(/-/g, '')}`,
-                        type: "function_call",
-                        name: this.getOriginalToolName(item.name),
-                        arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments),
-                        status: "completed"
-                    });
-                }
-            }
-        }
-
-        return {
-            id: response.id || `resp_${uuidv4().replace(/-/g, '')}`,
-            object: "response",
-            created_at: unixTimestamp,
-            model: response.model || model,
-            status: "completed",
-            output: output,
-            incomplete_details: response.incomplete_details || null,
-            usage: {
-                input_tokens: response.usage?.input_tokens || 0,
-                output_tokens: response.usage?.output_tokens || 0,
-                total_tokens: response.usage?.total_tokens || 0,
-                output_tokens_details: {
-                    reasoning_tokens: response.usage?.output_tokens_details?.reasoning_tokens || 0
-                }
-            }
-        };
-    }
-
-    /**
-     * Codex → Gemini 响应转换
-     */
-    toGeminiResponse(rawJSON, model) {
-        const root = typeof rawJSON === 'string' ? JSON.parse(rawJSON) : rawJSON;
-        if (root.type !== 'response.completed') {
-            return null;
-        }
-
-        const response = root.response;
-        const parts = [];
-
-        if (response.output && Array.isArray(response.output)) {
-            for (const item of response.output) {
-                if (item.type === 'reasoning') {
-                    let reasoningText = '';
-                    if (Array.isArray(item.summary)) {
-                        const summaryItem = item.summary.find(s => s.type === 'summary_text');
-                        if (summaryItem) reasoningText = summaryItem.text;
-                    }
-                    if (reasoningText) {
-                        parts.push({ text: reasoningText, thought: true });
-                    }
-                } else if (item.type === 'message') {
-                    let contentText = '';
-                    if (Array.isArray(item.content)) {
-                        const contentItem = item.content.find(c => c.type === 'output_text');
-                        if (contentItem) contentText = contentItem.text;
-                    }
-                    if (contentText) {
-                        parts.push({ text: contentText });
-                    }
-                } else if (item.type === 'function_call') {
-                    parts.push({
-                        functionCall: {
-                            name: this.getOriginalToolName(item.name),
-                            args: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                        }
-                    });
-                }
-            }
-        }
-
-        return {
-            candidates: [{
-                content: {
-                    role: "model",
-                    parts: parts
-                },
-                finishReason: "STOP"
-            }],
-            usageMetadata: {
-                promptTokenCount: response.usage?.input_tokens || 0,
-                candidatesTokenCount: response.usage?.output_tokens || 0,
-                totalTokenCount: response.usage?.total_tokens || 0
-            },
-            modelVersion: response.model || model,
-            responseId: response.id
-        };
-    }
-
-    /**
-     * Codex → Claude 响应转换
-     */
-    toClaudeResponse(rawJSON, model) {
-        const root = typeof rawJSON === 'string' ? JSON.parse(rawJSON) : rawJSON;
-        if (root.type !== 'response.completed') {
-            return null;
-        }
-
-        const response = root.response;
-        const content = [];
-        let stopReason = "end_turn";
-
-        if (response.output && Array.isArray(response.output)) {
-            for (const item of response.output) {
-                if (item.type === 'reasoning') {
-                    let reasoningText = '';
-                    if (Array.isArray(item.summary)) {
-                        const summaryItem = item.summary.find(s => s.type === 'summary_text');
-                        if (summaryItem) reasoningText = summaryItem.text;
-                    }
-                    if (reasoningText) {
-                        content.push({ type: "thinking", thinking: reasoningText });
-                    }
-                } else if (item.type === 'message') {
-                    let contentText = '';
-                    if (Array.isArray(item.content)) {
-                        const contentItem = item.content.find(c => c.type === 'output_text');
-                        if (contentItem) contentText = contentItem.text;
-                    }
-                    if (contentText) {
-                        content.push({ type: "text", text: contentText });
-                    }
-                } else if (item.type === 'function_call') {
-                    stopReason = "tool_use";
-                    content.push({
-                        type: "tool_use",
-                        id: item.call_id || `call_${uuidv4().replace(/-/g, '')}`,
-                        name: this.getOriginalToolName(item.name),
-                        input: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                    });
-                }
-            }
-        }
-
-        return {
-            id: response.id || `msg_${uuidv4().replace(/-/g, '')}`,
-            type: "message",
-            role: "assistant",
-            model: response.model || model,
-            content: content,
-            stop_reason: stopReason,
-            usage: {
-                input_tokens: response.usage?.input_tokens || 0,
-                output_tokens: response.usage?.output_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * Codex → OpenAI 流式响应块转换
-     */
-    toOpenAIStreamChunk(chunk, model) {
-        const type = chunk.type;
-        // 使用固定的 key 来存储当前流的状态
-        const stateKey = 'openai_stream_current';
-        
-        if (!this.streamParams.has(stateKey)) {
-            this.streamParams.set(stateKey, {
-                model: model,
-                createdAt: Math.floor(Date.now() / 1000),
-                responseID: chunk.response?.id || `chatcmpl-${Date.now()}`,
-                functionCallIndex: 0,  // 初始值为 0，第一个 function_call 的 index 为 0
-                isFirstChunk: true  // 标记是否是第一个内容 chunk
-            });
-        }
-        const state = this.streamParams.get(stateKey);
-
-        // 构建模板时使用当前状态中的值
-        const buildTemplate = () => ({
-            id: state.responseID,
-            object: 'chat.completion.chunk',
-            created: state.createdAt,
-            model: state.model,
-            choices: [{
-                index: 0,
-                delta: {
-                    role: 'assistant',
-                    content: null,
-                    reasoning_content: null,
-                    tool_calls: null
-                },
-                finish_reason: null,
-                native_finish_reason: null
-            }]
-        });
-
-        if (type === 'response.created') {
-            // 更新状态中的 responseID
-            state.responseID = chunk.response.id;
-            state.createdAt = chunk.response.created_at || state.createdAt;
-            state.model = chunk.response.model || state.model;
-            // 重置 functionCallIndex，确保每个新请求从 0 开始
-            state.functionCallIndex = 0;
-            state.isFirstChunk = true;
-            // response.created 不发送 chunk，等待第一个内容 chunk
-            return null;
-        }
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            const results = [];
-            // 如果是第一个内容 chunk，先发送带 role 的 chunk
-            if (state.isFirstChunk) {
-                const firstTemplate = buildTemplate();
-                firstTemplate.choices[0].delta = {
-                    role: 'assistant',
-                    content: null,
-                    reasoning_content: chunk.delta,
-                    tool_calls: null
-                };
-                results.push(firstTemplate);
-                state.isFirstChunk = false;
-            } else {
-                const template = buildTemplate();
-                template.choices[0].delta = {
-                    role: 'assistant',
-                    content: null,
-                    reasoning_content: chunk.delta,
-                    tool_calls: null
-                };
-                results.push(template);
-            }
-            return results.length === 1 ? results[0] : results;
-        }
-
-        if (type === 'response.reasoning_summary_text.done') {
-            const template = buildTemplate();
-            template.choices[0].delta = {
-                role: 'assistant',
-                content: null,
-                reasoning_content: '\n\n',
-                tool_calls: null
-            };
-            return template;
-        }
-
-        if (type === 'response.output_text.delta') {
-            const results = [];
-            // 如果是第一个内容 chunk，先发送带 role 的 chunk
-            if (state.isFirstChunk) {
-                const firstTemplate = buildTemplate();
-                firstTemplate.choices[0].delta = {
-                    role: 'assistant',
-                    content: chunk.delta,
-                    reasoning_content: null,
-                    tool_calls: null
-                };
-                results.push(firstTemplate);
-                state.isFirstChunk = false;
-            } else {
-                const template = buildTemplate();
-                template.choices[0].delta = {
-                    role: 'assistant',
-                    content: chunk.delta,
-                    reasoning_content: null,
-                    tool_calls: null
-                };
-                results.push(template);
-            }
-            return results.length === 1 ? results[0] : results;
-        }
-
-        if (type === 'response.output_item.done' && chunk.item?.type === 'function_call') {
-            const currentIndex = state.functionCallIndex;
-            state.functionCallIndex++;  // 递增，为下一个 function_call 准备
-            const template = buildTemplate();
-            template.choices[0].delta = {
-                role: 'assistant',
-                content: null,
-                reasoning_content: null,
-                tool_calls: [{
-                    index: currentIndex,
-                    id: chunk.item.call_id,
-                    type: 'function',
-                    function: {
-                        name: this.getOriginalToolName(chunk.item.name),
-                        arguments: typeof chunk.item.arguments === 'string' ? chunk.item.arguments : JSON.stringify(chunk.item.arguments)
-                    }
-                }]
-            };
-            return template;
-        }
-
-        if (type === 'response.completed') {
-            const template = buildTemplate();
-            const finishReason = state.functionCallIndex > 0 ? 'tool_calls' : 'stop';
-            template.choices[0].delta = {
-                role: null,
-                content: null,
-                reasoning_content: null,
-                tool_calls: null
-            };
-            template.choices[0].finish_reason = finishReason;
-            template.choices[0].native_finish_reason = finishReason;
-            template.usage = {
-                prompt_tokens: chunk.response.usage?.input_tokens || 0,
-                completion_tokens: chunk.response.usage?.output_tokens || 0,
-                total_tokens: chunk.response.usage?.total_tokens || 0
-            };
-            if (chunk.response.usage?.output_tokens_details?.reasoning_tokens) {
-                template.usage.completion_tokens_details = {
-                    reasoning_tokens: chunk.response.usage.output_tokens_details.reasoning_tokens
-                };
-            }
-            // 完成后清理状态
-            this.streamParams.delete(stateKey);
-            return template;
-        }
-
-        return null;
-    }
-
-    /**
-     * Codex → OpenAI Responses 流式响应转换
-     */
-    toOpenAIResponsesStreamChunk(chunk, model) {
-        if(true){
-            return chunk;
-        }
-
-        const type = chunk.type;
-        const resId = chunk.response?.id || 'default';
-        
-        if (!this.streamParams.has(resId)) {
-            this.streamParams.set(resId, {
-                model: model,
-                createdAt: Math.floor(Date.now() / 1000),
-                responseID: resId,
-                functionCallIndex: -1,
-                eventsSent: new Set()
-            });
-        }
-        const state = this.streamParams.get(resId);
-        const events = [];
-
-        if (type === 'response.created') {
-            state.responseID = chunk.response.id;
-            state.model = chunk.response.model || state.model;
-            events.push(
-                generateResponseCreated(state.responseID, state.model),
-                generateResponseInProgress(state.responseID)
-            );
-            return events;
-        }
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            events.push({
-                type: "response.reasoning_summary_text.delta",
-                response_id: state.responseID,
-                delta: chunk.delta
-            });
-            return events;
-        }
-
-        if (type === 'response.output_text.delta') {
-            if (!state.eventsSent.has('output_item_added')) {
-                events.push(generateOutputItemAdded(state.responseID));
-                state.eventsSent.add('output_item_added');
-            }
-            if (!state.eventsSent.has('content_part_added')) {
-                events.push(generateContentPartAdded(state.responseID));
-                state.eventsSent.add('content_part_added');
-            }
-            events.push({
-                type: "response.output_text.delta",
-                response_id: state.responseID,
-                delta: chunk.delta
-            });
-            return events;
-        }
-
-        if (type === 'response.output_item.done' && chunk.item?.type === 'function_call') {
-            events.push({
-                type: "response.output_item.added",
-                response_id: state.responseID,
-                item: {
-                    id: chunk.item.call_id,
-                    type: "function_call",
-                    name: this.getOriginalToolName(chunk.item.name),
-                    arguments: typeof chunk.item.arguments === 'string' ? chunk.item.arguments : JSON.stringify(chunk.item.arguments),
-                    status: "completed"
-                }
-            });
-            events.push({
-                type: "response.output_item.done",
-                response_id: state.responseID,
-                item_id: chunk.item.call_id
-            });
-            return events;
-        }
-
-        if (type === 'response.completed') {
-            events.push(
-                generateOutputTextDone(state.responseID),
-                generateContentPartDone(state.responseID),
-                generateOutputItemDone(state.responseID)
-            );
-            const completedEvent = generateResponseCompleted(state.responseID);
-            completedEvent.response.usage = {
-                input_tokens: chunk.response.usage?.input_tokens || 0,
-                output_tokens: chunk.response.usage?.output_tokens || 0,
-                total_tokens: chunk.response.usage?.total_tokens || 0
-            };
-            events.push(completedEvent);
-            this.streamParams.delete(resId);
-            return events;
-        }
-
-        return null;
-    }
-
-    /**
-     * Codex → Gemini 流式响应转换
-     */
-    toGeminiStreamChunk(chunk, model) {
-        const type = chunk.type;
-        const resId = chunk.response?.id || 'default';
-        
-        if (!this.streamParams.has(resId)) {
-            this.streamParams.set(resId, {
-                model: model,
-                createdAt: Math.floor(Date.now() / 1000),
-                responseID: resId
-            });
-        }
-        const state = this.streamParams.get(resId);
-
-        const template = {
-            candidates: [{
-                content: {
-                    role: "model",
-                    parts: []
-                }
-            }],
-            modelVersion: state.model,
-            responseId: state.responseID
-        };
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            template.candidates[0].content.parts.push({ text: chunk.delta, thought: true });
-            return template;
-        }
-
-        if (type === 'response.output_text.delta') {
-            template.candidates[0].content.parts.push({ text: chunk.delta });
-            return template;
-        }
-
-        if (type === 'response.output_item.done' && chunk.item?.type === 'function_call') {
-            template.candidates[0].content.parts.push({
-                functionCall: {
-                    name: this.getOriginalToolName(chunk.item.name),
-                    args: typeof chunk.item.arguments === 'string' ? JSON.parse(chunk.item.arguments) : chunk.item.arguments
-                }
-            });
-            return template;
-        }
-
-        if (type === 'response.completed') {
-            template.candidates[0].finishReason = "STOP";
-            template.usageMetadata = {
-                promptTokenCount: chunk.response.usage?.input_tokens || 0,
-                candidatesTokenCount: chunk.response.usage?.output_tokens || 0,
-                totalTokenCount: chunk.response.usage?.total_tokens || 0
-            };
-            this.streamParams.delete(resId);
-            return template;
-        }
-
-        return null;
-    }
-
-    /**
-     * Codex → Claude 流式响应转换
-     */
-    toClaudeStreamChunk(chunk, model, requestId) {
-        const type = chunk.type;
-
-        // 使用 requestId 作为流状态的隔离 key（并发安全）。
-        // 每个请求在 handleStreamRequest 中生成唯一 requestId，
-        // 确保同一单例 converter 上的并发流状态完全独立。
-        const stateKey = requestId || chunk.response?.id || 'default';
-
-        // response.created 携带 response.id，用它来初始化该请求的流状态
-        if (type === 'response.created') {
-            const resId = chunk.response.id;
-            this.streamParams.set(stateKey, {
-                model: model,
-                createdAt: Math.floor(Date.now() / 1000),
-                responseID: resId,
-                blockIndex: 0,
-                blockStarted: false,
-                currentBlockType: null,
-            });
-            const state = this.streamParams.get(stateKey);
-            return {
-                type: "message_start",
-                message: {
-                    id: state.responseID,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model: state.model,
-                    usage: { input_tokens: 0, output_tokens: 0 }
-                }
-            };
-        }
-
-        if (!this.streamParams.has(stateKey)) {
-            // 如果还没有状态（比如没有收到 response.created 就收到了其他事件），
-            // 用 chunk 中能拿到的信息初始化
-            this.streamParams.set(stateKey, {
-                model: model,
-                createdAt: Math.floor(Date.now() / 1000),
-                responseID: chunk.response?.id || stateKey,
-                blockIndex: 0,
-                blockStarted: false,
-                currentBlockType: null,
-            });
-        }
-        const state = this.streamParams.get(stateKey);
-
-        // response.output_item.added 不产生 Claude 输出
-        if (type === 'response.output_item.added') {
-            return null;
-        }
-
-        if (type === 'response.created') {
-            // 已在上方处理，不应到达此处
-            return null;
-        }
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            const events = [];
-            // If switching from a different block type, close the previous block first
-            if (state.blockStarted && state.currentBlockType !== 'thinking') {
-                events.push({ type: "content_block_stop", index: state.blockIndex });
-                state.blockIndex++;
-                state.blockStarted = false;
-            }
-            // Emit content_block_start on first delta for this thinking block
-            if (!state.blockStarted) {
-                events.push({
-                    type: "content_block_start",
-                    index: state.blockIndex,
-                    content_block: { type: "thinking", thinking: "" }
-                });
-                state.blockStarted = true;
-                state.currentBlockType = 'thinking';
-            }
-            events.push({
-                type: "content_block_delta",
-                index: state.blockIndex,
-                delta: { type: "thinking_delta", thinking: chunk.delta }
-            });
-            return events;
-        }
-
-        if (type === 'response.output_text.delta') {
-            const events = [];
-            // If switching from a different block type, close the previous block first
-            if (state.blockStarted && state.currentBlockType !== 'text') {
-                events.push({ type: "content_block_stop", index: state.blockIndex });
-                state.blockIndex++;
-                state.blockStarted = false;
-            }
-            // Emit content_block_start on first delta for this text block
-            if (!state.blockStarted) {
-                events.push({
-                    type: "content_block_start",
-                    index: state.blockIndex,
-                    content_block: { type: "text", text: "" }
-                });
-                state.blockStarted = true;
-                state.currentBlockType = 'text';
-            }
-            events.push({
-                type: "content_block_delta",
-                index: state.blockIndex,
-                delta: { type: "text_delta", text: chunk.delta }
-            });
-            return events;
-        }
-
-        if (type === 'response.output_item.done' && chunk.item?.type === 'function_call') {
-            const events = [];
-            // Close any open text/thinking block before tool_use
-            if (state.blockStarted) {
-                events.push({ type: "content_block_stop", index: state.blockIndex });
-                state.blockIndex++;
-                state.blockStarted = false;
-                state.currentBlockType = null;
-            }
-            events.push(
-                {
-                    type: "content_block_start",
-                    index: state.blockIndex,
-                    content_block: {
-                        type: "tool_use",
-                        id: chunk.item.call_id,
-                        name: this.getOriginalToolName(chunk.item.name),
-                        input: {}
-                    }
-                },
-                {
-                    type: "content_block_delta",
-                    index: state.blockIndex,
-                    delta: {
-                        type: "input_json_delta",
-                        partial_json: typeof chunk.item.arguments === 'string' ? chunk.item.arguments : JSON.stringify(chunk.item.arguments)
-                    }
-                },
-                {
-                    type: "content_block_stop",
-                    index: state.blockIndex
-                }
-            );
-            state.blockIndex++;
-            return events;
-        }
-
-        if (type === 'response.completed') {
-            const events = [];
-            // Close any open content block before ending the message
-            if (state.blockStarted) {
-                events.push({ type: "content_block_stop", index: state.blockIndex });
-            }
-            events.push(
-                {
-                    type: "message_delta",
-                    delta: { stop_reason: "end_turn" },
-                    usage: {
-                        input_tokens: chunk.response.usage?.input_tokens || 0,
-                        output_tokens: chunk.response.usage?.output_tokens || 0
-                    }
-                },
-                { type: "message_stop" }
-            );
-            // 清理该请求的流状态
-            this.streamParams.delete(stateKey);
-            return events;
-        }
-
-        return null;
-    }
-
-}

src/converters/strategies/GeminiConverter.js

@@ -1,1529 +0,0 @@
-/**
- * Gemini转换器
- * 处理Gemini（Google）协议与其他协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { BaseConverter } from '../BaseConverter.js';
-import {
-    checkAndAssignOrDefault,
-    OPENAI_DEFAULT_MAX_TOKENS,
-    OPENAI_DEFAULT_TEMPERATURE,
-    OPENAI_DEFAULT_TOP_P,
-    CLAUDE_DEFAULT_MAX_TOKENS,
-    CLAUDE_DEFAULT_TEMPERATURE,
-    CLAUDE_DEFAULT_TOP_P
-} from '../utils.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../../providers/openai/openai-responses-core.mjs';
-
-/**
- * 修复 Gemini 返回的工具参数名称问题
- * Gemini 有时会使用不同的参数名称，需要映射到 Claude Code 期望的格式
- */
-function remapFunctionCallArgs(toolName, args) {
-    if (!args || typeof args !== 'object') return args;
-    
-    const remappedArgs = { ...args };
-    const toolNameLower = toolName.toLowerCase();
-    
-    // [IMPORTANT] Claude Code CLI 的 EnterPlanMode 工具禁止携带任何参数
-    if (toolName === 'EnterPlanMode') {
-        return {};
-    }
-    
-    switch (toolNameLower) {
-        case 'grep':
-        case 'search':
-        case 'search_code_definitions':
-        case 'search_code_snippets':
-            // [FIX] Gemini hallucination: maps parameter description to "description" field
-            if (remappedArgs.description && !remappedArgs.pattern) {
-                remappedArgs.pattern = remappedArgs.description;
-                delete remappedArgs.description;
-            }
-            
-            // Gemini uses "query", Claude Code expects "pattern"
-            if (remappedArgs.query && !remappedArgs.pattern) {
-                remappedArgs.pattern = remappedArgs.query;
-                delete remappedArgs.query;
-            }
-            
-            // [CRITICAL FIX] Claude Code uses "path" (string), NOT "paths" (array)!
-            if (!remappedArgs.path) {
-                if (remappedArgs.paths) {
-                    if (Array.isArray(remappedArgs.paths)) {
-                        remappedArgs.path = remappedArgs.paths[0] || '.';
-                    } else if (typeof remappedArgs.paths === 'string') {
-                        remappedArgs.path = remappedArgs.paths;
-                    } else {
-                        remappedArgs.path = '.';
-                    }
-                    delete remappedArgs.paths;
-                } else {
-                    // Default to current directory if missing
-                    remappedArgs.path = '.';
-                }
-            }
-            // Note: We keep "-n" and "output_mode" if present as they are valid in Grep schema
-            break;
-            
-        case 'glob':
-            // [FIX] Gemini hallucination: maps parameter description to "description" field
-            if (remappedArgs.description && !remappedArgs.pattern) {
-                remappedArgs.pattern = remappedArgs.description;
-                delete remappedArgs.description;
-            }
-            
-            // Gemini uses "query", Claude Code expects "pattern"
-            if (remappedArgs.query && !remappedArgs.pattern) {
-                remappedArgs.pattern = remappedArgs.query;
-                delete remappedArgs.query;
-            }
-            
-            // [CRITICAL FIX] Claude Code uses "path" (string), NOT "paths" (array)!
-            // [NOTE] 与 grep 不同，glob 不添加默认 path（参考 Rust 代码）
-            if (!remappedArgs.path) {
-                if (remappedArgs.paths) {
-                    if (Array.isArray(remappedArgs.paths)) {
-                        remappedArgs.path = remappedArgs.paths[0] || '.';
-                    } else if (typeof remappedArgs.paths === 'string') {
-                        remappedArgs.path = remappedArgs.paths;
-                    } else {
-                        remappedArgs.path = '.';
-                    }
-                    delete remappedArgs.paths;
-                }
-                // [FIX] glob 不添加默认 path，与 Rust 代码保持一致
-            }
-            break;
-            
-        case 'read':
-            // Gemini might use "path" vs "file_path"
-            if (remappedArgs.path && !remappedArgs.file_path) {
-                remappedArgs.file_path = remappedArgs.path;
-                delete remappedArgs.path;
-            }
-            break;
-            
-        case 'ls':
-            // LS tool: ensure "path" parameter exists
-            if (!remappedArgs.path) {
-                remappedArgs.path = '.';
-            }
-            break;
-            
-        default:
-            // [NEW] [Issue #785] Generic Property Mapping for all tools
-            // If a tool has "paths" (array of 1) but no "path", convert it.
-            // [FIX] 与 Rust 代码保持一致：只在 paths.length === 1 时转换，不删除原始 paths
-            if (!remappedArgs.path && remappedArgs.paths) {
-                if (Array.isArray(remappedArgs.paths) && remappedArgs.paths.length === 1) {
-                    const pathValue = remappedArgs.paths[0];
-                    if (typeof pathValue === 'string') {
-                        remappedArgs.path = pathValue;
-                        // [FIX] Rust 代码中不删除 paths，这里也不删除
-                    }
-                }
-            }
-            break;
-    }
-    
-    return remappedArgs;
-}
-
-/**
- * [FIX] 规范化工具名称
- * Gemini 有时会返回 "search" 而不是 "Grep"
- */
-function normalizeToolName(name) {
-    if (!name) return name;
-    
-    const nameLower = name.toLowerCase();
-    if (nameLower === 'search') {
-        return 'Grep';
-    }
-    return name;
-}
-
-/**
- * Gemini转换器类
- * 实现Gemini协议到其他协议的转换
- */
-export class GeminiConverter extends BaseConverter {
-    constructor() {
-        super('gemini');
-    }
-
-    /**
-     * 转换请求
-     */
-    convertRequest(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeRequest(data);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokRequest(data);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexResponse(data, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexStreamChunk(chunk, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIModelList(data);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeModelList(data);
-            default:
-                return data;
-        }
-    }
-
-    // =========================================================================
-    // Gemini -> OpenAI 转换
-    // =========================================================================
-
-    /**
-     * Gemini请求 -> OpenAI请求
-     */
-    toOpenAIRequest(geminiRequest) {
-        const openaiRequest = {
-            messages: [],
-            model: geminiRequest.model,
-            max_tokens: checkAndAssignOrDefault(geminiRequest.max_tokens, OPENAI_DEFAULT_MAX_TOKENS),
-            temperature: checkAndAssignOrDefault(geminiRequest.temperature, OPENAI_DEFAULT_TEMPERATURE),
-            top_p: checkAndAssignOrDefault(geminiRequest.top_p, OPENAI_DEFAULT_TOP_P),
-        };
-
-        // 处理系统指令
-        if (geminiRequest.systemInstruction && Array.isArray(geminiRequest.systemInstruction.parts)) {
-            const systemContent = this.processGeminiPartsToOpenAIContent(geminiRequest.systemInstruction.parts);
-            if (systemContent) {
-                openaiRequest.messages.push({
-                    role: 'system',
-                    content: systemContent
-                });
-            }
-        }
-
-        // 处理内容
-        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
-            geminiRequest.contents.forEach(content => {
-                if (content && Array.isArray(content.parts)) {
-                    const openaiContent = this.processGeminiPartsToOpenAIContent(content.parts);
-                    if (openaiContent && openaiContent.length > 0) {
-                        const openaiRole = content.role === 'model' ? 'assistant' : content.role;
-                        openaiRequest.messages.push({
-                            role: openaiRole,
-                            content: openaiContent
-                        });
-                    }
-                }
-            });
-        }
-
-        return openaiRequest;
-    }
-
-    /**
-     * Gemini响应 -> OpenAI响应
-     */
-    toOpenAIResponse(geminiResponse, model) {
-        const content = this.processGeminiResponseContent(geminiResponse);
-        
-        // 提取 tool_calls
-        const toolCalls = [];
-        let finishReason = "stop";
-        
-        if (geminiResponse && geminiResponse.candidates) {
-            for (const candidate of geminiResponse.candidates) {
-                if (candidate.content && candidate.content.parts) {
-                    for (const part of candidate.content.parts) {
-                        if (part.functionCall) {
-                            toolCalls.push({
-                                id: part.functionCall.id || `call_${uuidv4()}`,
-                                type: 'function',
-                                function: {
-                                    name: part.functionCall.name,
-                                    arguments: typeof part.functionCall.args === 'string' 
-                                        ? part.functionCall.args 
-                                        : JSON.stringify(part.functionCall.args)
-                                }
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        
-        // 如果有工具调用，设置 finish_reason 为 tool_calls
-        if (toolCalls.length > 0) {
-            finishReason = "tool_calls";
-        }
-        
-        const message = {
-            role: "assistant",
-            content: content
-        };
-        
-        // 只有在有 tool_calls 时才添加该字段
-        if (toolCalls.length > 0) {
-            message.tool_calls = toolCalls;
-        }
-        
-        return {
-            id: `chatcmpl-${uuidv4()}`,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1000),
-            model: model,
-            choices: [{
-                index: 0,
-                message: message,
-                finish_reason: finishReason,
-            }],
-            usage: geminiResponse.usageMetadata ? {
-                prompt_tokens: geminiResponse.usageMetadata.promptTokenCount || 0,
-                completion_tokens: geminiResponse.usageMetadata.candidatesTokenCount || 0,
-                total_tokens: geminiResponse.usageMetadata.totalTokenCount || 0,
-                cached_tokens: geminiResponse.usageMetadata.cachedContentTokenCount || 0,
-                prompt_tokens_details: {
-                    cached_tokens: geminiResponse.usageMetadata.cachedContentTokenCount || 0
-                },
-                completion_tokens_details: {
-                    reasoning_tokens: geminiResponse.usageMetadata.thoughtsTokenCount || 0
-                }
-            } : {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
-                cached_tokens: 0,
-                prompt_tokens_details: {
-                    cached_tokens: 0
-                },
-                completion_tokens_details: {
-                    reasoning_tokens: 0
-        }
-            },
-        };
-    }
-
-    /**
-     * Gemini流式响应 -> OpenAI流式响应
-     */
-    toOpenAIStreamChunk(geminiChunk, model) {
-        if (!geminiChunk) return null;
-
-        const candidate = geminiChunk.candidates?.[0];
-        if (!candidate) return null;
-
-        let content = '';
-        const toolCalls = [];
-        
-        // 从parts中提取文本和tool calls
-        const parts = candidate.content?.parts;
-        if (parts && Array.isArray(parts)) {
-            for (const part of parts) {
-                if (part.text) {
-                    content += part.text;
-                }
-                if (part.functionCall) {
-                    toolCalls.push({
-                        index: toolCalls.length,
-                        id: part.functionCall.id || `call_${uuidv4()}`,
-                        type: 'function',
-                        function: {
-                            name: part.functionCall.name,
-                            arguments: typeof part.functionCall.args === 'string' 
-                                ? part.functionCall.args 
-                                : JSON.stringify(part.functionCall.args)
-                        }
-                    });
-                }
-                // thoughtSignature is ignored (internal Gemini data)
-            }
-        }
-
-        // 处理finishReason
-        let finishReason = null;
-        if (candidate.finishReason) {
-            const finishReasonMap = {
-                'FINISH_REASON_UNSPECIFIED': 'stop',
-                'STOP': 'stop',
-                'MAX_TOKENS': 'length',
-                'SAFETY': 'content_filter',
-                'RECITATION': 'content_filter',
-                'OTHER': 'stop',
-                'BLOCKLIST': 'content_filter',
-                'PROHIBITED_CONTENT': 'content_filter',
-                'SPII': 'content_filter',
-                'MALFORMED_FUNCTION_CALL': 'stop',
-                'MODEL_ARMOR': 'content_filter',
-            };
-            finishReason = finishReasonMap[candidate.finishReason] || 'stop';
-        }
-
-        // [FIX] 适配 Gemini 流式：Gemini 的最后一条流式消息通常不带 functionCall
-        // 如果当前 chunk 包含工具调用，直接将其标记为 tool_calls
-        if (toolCalls.length > 0) {
-            finishReason = 'tool_calls';
-        }
-
-        // 构建delta对象
-        const delta = {};
-        if (content) delta.content = content;
-        if (toolCalls.length > 0) delta.tool_calls = toolCalls;
-
-        // Don't return empty delta chunks
-        if (Object.keys(delta).length === 0 && !finishReason) {
-            return null;
-        }
-
-        const chunk = {
-            id: `chatcmpl-${uuidv4()}`,
-            object: "chat.completion.chunk",
-            created: Math.floor(Date.now() / 1000),
-            model: model,
-            choices: [{
-                index: 0,
-                delta: delta,
-                finish_reason: finishReason,
-            }],
-        };
-
-        if(geminiChunk.usageMetadata){
-            chunk.usage = {
-                prompt_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
-                completion_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
-                total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0,
-                cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
-                prompt_tokens_details: {
-                    cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
-                },
-                completion_tokens_details: {
-                    reasoning_tokens: geminiChunk.usageMetadata.thoughtsTokenCount || 0
-                }
-            };
-        }
-
-        return chunk;
-    }
-
-    /**
-     * Gemini模型列表 -> OpenAI模型列表
-     */
-    toOpenAIModelList(geminiModels) {
-        return {
-            object: "list",
-            data: geminiModels.models.map(m => {
-                const modelId = m.name.startsWith('models/') ? m.name.substring(7) : m.name;
-                return {
-                    id: modelId,
-                    object: "model",
-                    created: Math.floor(Date.now() / 1000),
-                    owned_by: "google",
-                    display_name: m.displayName || modelId,
-                };
-            }),
-        };
-    }
-
-    /**
-     * 处理Gemini parts到OpenAI内容
-     */
-    processGeminiPartsToOpenAIContent(parts) {
-        if (!parts || !Array.isArray(parts)) return '';
-        
-        const contentArray = [];
-        
-        parts.forEach(part => {
-            if (!part) return;
-            
-            if (typeof part.text === 'string') {
-                contentArray.push({
-                    type: 'text',
-                    text: part.text
-                });
-            }
-            
-            if (part.inlineData) {
-                const { mimeType, data } = part.inlineData;
-                if (mimeType && data) {
-                    contentArray.push({
-                        type: 'image_url',
-                        image_url: {
-                            url: `data:${mimeType};base64,${data}`
-                        }
-                    });
-                }
-            }
-            
-            if (part.fileData) {
-                const { mimeType, fileUri } = part.fileData;
-                if (mimeType && fileUri) {
-                    if (mimeType.startsWith('image/')) {
-                        contentArray.push({
-                            type: 'image_url',
-                            image_url: {
-                                url: fileUri
-                            }
-                        });
-                    } else if (mimeType.startsWith('audio/')) {
-                        contentArray.push({
-                            type: 'text',
-                            text: `[Audio file: ${fileUri}]`
-                        });
-                    }
-                }
-            }
-        });
-        
-        return contentArray.length === 1 && contentArray[0].type === 'text'
-            ? contentArray[0].text
-            : contentArray;
-    }
-
-    /**
-     * 处理Gemini响应内容
-     */
-    processGeminiResponseContent(geminiResponse) {
-        if (!geminiResponse || !geminiResponse.candidates) return '';
-        
-        const contents = [];
-        
-        geminiResponse.candidates.forEach(candidate => {
-            if (candidate.content && candidate.content.parts) {
-                candidate.content.parts.forEach(part => {
-                    if (part.text) {
-                        contents.push(part.text);
-                    }
-                });
-            }
-        });
-        
-        return contents.join('\n');
-    }
-
-    // =========================================================================
-    // Gemini -> Claude 转换
-    // =========================================================================
-
-    /**
-     * Gemini请求 -> Claude请求
-     */
-    toClaudeRequest(geminiRequest) {
-        const claudeRequest = {
-            model: geminiRequest.model || 'claude-3-opus',
-            messages: [],
-            max_tokens: checkAndAssignOrDefault(geminiRequest.generationConfig?.maxOutputTokens, CLAUDE_DEFAULT_MAX_TOKENS),
-            temperature: checkAndAssignOrDefault(geminiRequest.generationConfig?.temperature, CLAUDE_DEFAULT_TEMPERATURE),
-            top_p: checkAndAssignOrDefault(geminiRequest.generationConfig?.topP, CLAUDE_DEFAULT_TOP_P),
-        };
-
-        // 处理系统指令
-        if (geminiRequest.systemInstruction && geminiRequest.systemInstruction.parts) {
-            const systemText = geminiRequest.systemInstruction.parts
-                .filter(p => p.text)
-                .map(p => p.text)
-                .join('\n');
-            if (systemText) {
-                claudeRequest.system = systemText;
-            }
-        }
-
-        // 处理内容
-        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
-            geminiRequest.contents.forEach(content => {
-                if (!content || !content.parts) return;
-
-                const role = content.role === 'model' ? 'assistant' : 'user';
-                const claudeContent = this.processGeminiPartsToClaudeContent(content.parts);
-
-                if (claudeContent.length > 0) {
-                    claudeRequest.messages.push({
-                        role: role,
-                        content: claudeContent
-                    });
-                }
-            });
-        }
-
-        // 处理工具
-        if (geminiRequest.tools && geminiRequest.tools[0]?.functionDeclarations) {
-            claudeRequest.tools = geminiRequest.tools[0].functionDeclarations.map(func => ({
-                name: func.name,
-                description: func.description || '',
-                input_schema: func.parameters || { type: 'object', properties: {} }
-            }));
-        }
-
-        return claudeRequest;
-    }
-
-    /**
-     * Gemini响应 -> Claude响应
-     */
-    toClaudeResponse(geminiResponse, model) {
-        if (!geminiResponse || !geminiResponse.candidates || geminiResponse.candidates.length === 0) {
-            return {
-                id: `msg_${uuidv4()}`,
-                type: "message",
-                role: "assistant",
-                content: [],
-                model: model,
-                stop_reason: "end_turn",
-                stop_sequence: null,
-                usage: {
-                    input_tokens: geminiResponse?.usageMetadata?.promptTokenCount || 0,
-                    output_tokens: geminiResponse?.usageMetadata?.candidatesTokenCount || 0
-                }
-            };
-        }
-
-        const candidate = geminiResponse.candidates[0];
-        const { content, hasToolUse } = this.processGeminiResponseToClaudeContent(geminiResponse);
-        const finishReason = candidate.finishReason;
-        let stopReason = "end_turn";
-
-        // - 如果有工具调用，stop_reason 应该是 "tool_use"
-        if (hasToolUse) {
-            stopReason = 'tool_use';
-        } else if (finishReason) {
-            switch (finishReason) {
-                case 'STOP':
-                    stopReason = 'end_turn';
-                    break;
-                case 'MAX_TOKENS':
-                    stopReason = 'max_tokens';
-                    break;
-                case 'SAFETY':
-                    stopReason = 'safety';
-                    break;
-                case 'RECITATION':
-                    stopReason = 'recitation';
-                    break;
-                case 'OTHER':
-                    stopReason = 'other';
-                    break;
-                default:
-                    stopReason = 'end_turn';
-            }
-        }
-
-        return {
-            id: `msg_${uuidv4()}`,
-            type: "message",
-            role: "assistant",
-            content: content,
-            model: model,
-            stop_reason: stopReason,
-            stop_sequence: null,
-            usage: {
-                input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: geminiResponse.usageMetadata?.cachedContentTokenCount || 0,
-                output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0
-            }
-        };
-    }
-
-    /**
-     * Gemini流式响应 -> Claude流式响应
-     */
-    toClaudeStreamChunk(geminiChunk, model) {
-        if (!geminiChunk) return null;
-
-        // 处理完整的Gemini chunk对象
-        if (typeof geminiChunk === 'object' && !Array.isArray(geminiChunk)) {
-            const candidate = geminiChunk.candidates?.[0];
-            
-            if (candidate) {
-                const parts = candidate.content?.parts;
-                
-                // thinking 和 text 块
-                if (parts && Array.isArray(parts)) {
-                    const results = [];
-                    let hasToolUse = false;
-                    
-                    for (const part of parts) {
-                        if (!part) continue;
-                        
-                        if (typeof part.text === 'string') {
-                            if (part.thought === true) {
-                                // [FIX] 这是一个 thinking 块
-                                const thinkingResult = {
-                                    type: "content_block_delta",
-                                    index: 0,
-                                    delta: {
-                                        type: "thinking_delta",
-                                        thinking: part.text
-                                    }
-                                };
-                                results.push(thinkingResult);
-                                
-                                // 如果有签名，发送 signature_delta
-                                // [FIX] 同时检查 thoughtSignature 和 thought_signature
-                                const rawSignature = part.thoughtSignature || part.thought_signature;
-                                if (rawSignature) {
-                                    let signature = rawSignature;
-                                    try {
-                                        const decoded = Buffer.from(signature, 'base64').toString('utf-8');
-                                        if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
-                                            signature = decoded;
-                                        }
-                                    } catch (e) {
-                                        // 解码失败，保持原样
-                                    }
-                                    results.push({
-                                        type: "content_block_delta",
-                                        index: 0,
-                                        delta: {
-                                            type: "signature_delta",
-                                            signature: signature
-                                        }
-                                    });
-                                }
-                            } else {
-                                // 普通文本
-                                results.push({
-                                    type: "content_block_delta",
-                                    index: 0,
-                                    delta: {
-                                        type: "text_delta",
-                                        text: part.text
-                                    }
-                                });
-                            }
-                        }
-                        
-                        // [FIX] 处理 functionCall
-                        if (part.functionCall) {
-                            hasToolUse = true;
-                            // [FIX] 规范化工具名称和参数映射
-                            const toolName = normalizeToolName(part.functionCall.name);
-                            const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
-                            
-                            // 发送 tool_use 开始
-                            const toolId = part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`;
-                            results.push({
-                                type: "content_block_start",
-                                index: 0,
-                                content_block: {
-                                    type: "tool_use",
-                                    id: toolId,
-                                    name: toolName,
-                                    input: {}
-                                }
-                            });
-                            // 发送参数
-                            results.push({
-                                type: "content_block_delta",
-                                index: 0,
-                                delta: {
-                                    type: "input_json_delta",
-                                    partial_json: JSON.stringify(remappedArgs)
-                                }
-                            });
-                        }
-                    }
-                    
-                    // [FIX] 如果有工具���用，添加 message_delta 事件设置 stop_reason 为 tool_use
-                    if (hasToolUse && candidate.finishReason) {
-                        const messageDelta = {
-                            type: "message_delta",
-                            delta: {
-                                stop_reason: 'tool_use'
-                            }
-                        };
-                        if (geminiChunk.usageMetadata) {
-                            messageDelta.usage = {
-                                input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
-                                cache_creation_input_tokens: 0,
-                                cache_read_input_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
-                                output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0
-                            };
-                        }
-                        results.push(messageDelta);
-                    }
-                    
-                    // 如果有多个结果，返回数组；否则返回单个或 null
-                    if (results.length > 1) {
-                        return results;
-                    } else if (results.length === 1) {
-                        return results[0];
-                    }
-                }
-                
-                // 处理finishReason
-                if (candidate.finishReason) {
-                    const result = {
-                        type: "message_delta",
-                        delta: {
-                            stop_reason: candidate.finishReason === 'STOP' ? 'end_turn' :
-                                       candidate.finishReason === 'MAX_TOKENS' ? 'max_tokens' :
-                                       candidate.finishReason.toLowerCase()
-                        }
-                    };
-                    
-                    // 添加 usage 信息
-                    if (geminiChunk.usageMetadata) {
-                        result.usage = {
-                            input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
-                            cache_creation_input_tokens: 0,
-                            cache_read_input_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0,
-                            output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
-                            prompt_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
-                            completion_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
-                            total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0,
-                            cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
-                        };
-                    }
-                    
-                    return result;
-                }
-            }
-        }
-
-        // 向后兼容：处理字符串格式
-        if (typeof geminiChunk === 'string') {
-            return {
-                type: "content_block_delta",
-                index: 0,
-                delta: {
-                    type: "text_delta",
-                    text: geminiChunk
-                }
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * Gemini模型列表 -> Claude模型列表
-     */
-    toClaudeModelList(geminiModels) {
-        return {
-            models: geminiModels.models.map(m => ({
-                name: m.name.startsWith('models/') ? m.name.substring(7) : m.name,
-                description: "",
-            })),
-        };
-    }
-
-    /**
-     * 处理Gemini parts到Claude内容
-     */
-    processGeminiPartsToClaudeContent(parts) {
-        if (!parts || !Array.isArray(parts)) return [];
-
-        const content = [];
-
-        parts.forEach(part => {
-            if (!part) return;
-
-            // 处理 thinking 块
-            // Gemini 使用 thought: true 和 thoughtSignature 表示思考内容
-            // [FIX] 同时支持 thoughtSignature 和 thought_signature（Gemini CLI 可能使用下划线格式）
-            if (part.text) {
-                if (part.thought === true) {
-                    // 这是一个 thinking 块
-                    const thinkingBlock = {
-                        type: 'thinking',
-                        thinking: part.text
-                    };
-                    // 处理签名 - 可能是 Base64 编码的
-                    // [FIX] 同时检查 thoughtSignature 和 thought_signature
-                    const rawSignature = part.thoughtSignature || part.thought_signature;
-                    if (rawSignature) {
-                        let signature = rawSignature;
-                        // 尝试 Base64 解码
-                        try {
-                            const decoded = Buffer.from(signature, 'base64').toString('utf-8');
-                            // 检查解码后是否是有效的 UTF-8 字符串
-                            if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
-                                signature = decoded;
-                            }
-                        } catch (e) {
-                            // 解码失败，保持原样
-                        }
-                        thinkingBlock.signature = signature;
-                    }
-                    content.push(thinkingBlock);
-                } else {
-                    // 普通文本
-                    content.push({
-                        type: 'text',
-                        text: part.text
-                    });
-                }
-            }
-
-            if (part.inlineData) {
-                content.push({
-                    type: 'image',
-                    source: {
-                        type: 'base64',
-                        media_type: part.inlineData.mimeType,
-                        data: part.inlineData.data
-                    }
-                });
-            }
-
-            if (part.functionCall) {
-                // [FIX] 规范化工具名称和参数映射
-                const toolName = normalizeToolName(part.functionCall.name);
-                const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
-                
-                // [FIX] 使用 Gemini 提供的 id，如果没有则生成
-                const toolUseBlock = {
-                    type: 'tool_use',
-                    id: part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`,
-                    name: toolName,
-                    input: remappedArgs
-                };
-                // [FIX] 如果有签名，添加到 tool_use 块
-                // [FIX] 同时检查 thoughtSignature 和 thought_signature
-                const rawSignature = part.thoughtSignature || part.thought_signature;
-                if (rawSignature) {
-                    let signature = rawSignature;
-                    try {
-                        const decoded = Buffer.from(signature, 'base64').toString('utf-8');
-                        if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
-                            signature = decoded;
-                        }
-                    } catch (e) {
-                        // 解码失败，保持原样
-                    }
-                    toolUseBlock.signature = signature;
-                }
-                content.push(toolUseBlock);
-            }
-
-            if (part.functionResponse) {
-                // [FIX] 正确处理 functionResponse
-                let responseContent = part.functionResponse.response;
-                // 如果 response 是对象且有 result 字段，提取它
-                if (responseContent && typeof responseContent === 'object' && responseContent.result !== undefined) {
-                    responseContent = responseContent.result;
-                }
-                content.push({
-                    type: 'tool_result',
-                    tool_use_id: part.functionResponse.name,
-                    content: typeof responseContent === 'string' ? responseContent : JSON.stringify(responseContent)
-                });
-            }
-        });
-
-        return content;
-    }
-
-    /**
-     * 处理Gemini响应到Claude内容
-     * @returns {{ content: Array, hasToolUse: boolean }}
-     */
-    processGeminiResponseToClaudeContent(geminiResponse) {
-        if (!geminiResponse || !geminiResponse.candidates || geminiResponse.candidates.length === 0) {
-            return { content: [], hasToolUse: false };
-        }
-
-        const content = [];
-        let hasToolUse = false;
-
-        for (const candidate of geminiResponse.candidates) {
-            if (candidate.finishReason && candidate.finishReason !== 'STOP') {
-                if (candidate.finishMessage) {
-                    content.push({
-                        type: 'text',
-                        text: `Error: ${candidate.finishMessage}`
-                    });
-                }
-                continue;
-            }
-
-            if (candidate.content && candidate.content.parts) {
-                for (const part of candidate.content.parts) {
-                    // 处理 thinking 块
-                    if (part.text) {
-                        if (part.thought === true) {
-                            // 这是一个 thinking 块
-                            const thinkingBlock = {
-                                type: 'thinking',
-                                thinking: part.text
-                            };
-                            // 处理签名
-                            // [FIX] 同时检查 thoughtSignature 和 thought_signature
-                            const rawSignature = part.thoughtSignature || part.thought_signature;
-                            if (rawSignature) {
-                                let signature = rawSignature;
-                                try {
-                                    const decoded = Buffer.from(signature, 'base64').toString('utf-8');
-                                    if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
-                                        signature = decoded;
-                                    }
-                                } catch (e) {
-                                    // 解码失败，保持原样
-                                }
-                                thinkingBlock.signature = signature;
-                            }
-                            content.push(thinkingBlock);
-                        } else {
-                            // 普通文本
-                            content.push({
-                                type: 'text',
-                                text: part.text
-                            });
-                        }
-                    } else if (part.inlineData) {
-                        content.push({
-                            type: 'image',
-                            source: {
-                                type: 'base64',
-                                media_type: part.inlineData.mimeType,
-                                data: part.inlineData.data
-                            }
-                        });
-                    } else if (part.functionCall) {
-                        hasToolUse = true;
-                        // [FIX] 规范化工具名称和参数映射
-                        const toolName = normalizeToolName(part.functionCall.name);
-                        const remappedArgs = remapFunctionCallArgs(toolName, part.functionCall.args || {});
-                        
-                        // [FIX] 使用 Gemini 提供的 id
-                        const toolUseBlock = {
-                            type: 'tool_use',
-                            id: part.functionCall.id || `${toolName}-${uuidv4().split('-')[0]}`,
-                            name: toolName,
-                            input: remappedArgs
-                        };
-                        // 添加签名（如果存在）
-                        // [FIX] 同时检查 thoughtSignature 和 thought_signature
-                        const rawSignature = part.thoughtSignature || part.thought_signature;
-                        if (rawSignature) {
-                            let signature = rawSignature;
-                            try {
-                                const decoded = Buffer.from(signature, 'base64').toString('utf-8');
-                                if (decoded && decoded.length > 0 && !decoded.includes('\ufffd')) {
-                                    signature = decoded;
-                                }
-                            } catch (e) {
-                                // 解码失败，保持原样
-                            }
-                            toolUseBlock.signature = signature;
-                        }
-                        content.push(toolUseBlock);
-                    }
-                }
-            }
-        }
-
-        return { content, hasToolUse };
-    }
-
-    // =========================================================================
-    // Gemini -> OpenAI Responses 转换
-    // =========================================================================
-
-    /**
-     * Gemini请求 -> OpenAI Responses请求
-     */
-    toOpenAIResponsesRequest(geminiRequest) {
-        const responsesRequest = {
-            model: geminiRequest.model,
-            instructions: '',
-            input: [],
-            stream: geminiRequest.stream || false,
-            max_output_tokens: geminiRequest.generationConfig?.maxOutputTokens,
-            temperature: geminiRequest.generationConfig?.temperature,
-            top_p: geminiRequest.generationConfig?.topP
-        };
-
-        // 处理系统指令
-        if (geminiRequest.systemInstruction && geminiRequest.systemInstruction.parts) {
-            responsesRequest.instructions = geminiRequest.systemInstruction.parts
-                .filter(p => p.text)
-                .map(p => p.text)
-                .join('\n');
-        }
-
-        // 处理内容
-        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
-            geminiRequest.contents.forEach(content => {
-                const role = content.role === 'model' ? 'assistant' : 'user';
-                const parts = content.parts || [];
-                
-                parts.forEach(part => {
-                    if (part.text) {
-                        responsesRequest.input.push({
-                            type: 'message',
-                            role: role,
-                            content: [{
-                                type: role === 'assistant' ? 'output_text' : 'input_text',
-                                text: part.text
-                            }]
-                        });
-                    }
-                    
-                    if (part.functionCall) {
-                        responsesRequest.input.push({
-                            type: 'function_call',
-                            call_id: part.functionCall.id || `call_${uuidv4().replace(/-/g, '').slice(0, 24)}`,
-                            name: part.functionCall.name,
-                            arguments: typeof part.functionCall.args === 'string' 
-                                ? part.functionCall.args 
-                                : JSON.stringify(part.functionCall.args)
-                        });
-                    }
-                    
-                    if (part.functionResponse) {
-                        responsesRequest.input.push({
-                            type: 'function_call_output',
-                            call_id: part.functionResponse.name, // Gemini 通常使用 name 作为关联
-                            output: typeof part.functionResponse.response?.result === 'string'
-                                ? part.functionResponse.response.result
-                                : JSON.stringify(part.functionResponse.response || {})
-                        });
-                    }
-
-                    if (part.inlineData) {
-                        responsesRequest.input.push({
-                            type: 'message',
-                            role: role,
-                            content: [{
-                                type: 'input_image',
-                                image_url: {
-                                    url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
-                                }
-                            }]
-                        });
-                    }
-                });
-            });
-        }
-
-        // 处理工具
-        if (geminiRequest.tools && geminiRequest.tools[0]?.functionDeclarations) {
-            responsesRequest.tools = geminiRequest.tools[0].functionDeclarations.map(fn => ({
-                type: 'function',
-                name: fn.name,
-                description: fn.description,
-                parameters: fn.parameters || fn.parametersJsonSchema || { type: 'object', properties: {} }
-            }));
-        }
-
-        return responsesRequest;
-    }
-
-    /**
-     * Gemini响应 -> OpenAI Responses响应
-     */
-    toOpenAIResponsesResponse(geminiResponse, model) {
-        const content = this.processGeminiResponseContent(geminiResponse);
-        const textContent = typeof content === 'string' ? content : JSON.stringify(content);
-
-        let output = [];
-        output.push({
-            id: `msg_${uuidv4().replace(/-/g, '')}`,
-            summary: [],
-            type: "message",
-            role: "assistant",
-            status: "completed",
-            content: [{
-                annotations: [],
-                logprobs: [],
-                text: textContent,
-                type: "output_text"
-            }]
-        });
-
-        return {
-            background: false,
-            created_at: Math.floor(Date.now() / 1000),
-            error: null,
-            id: `resp_${uuidv4().replace(/-/g, '')}`,
-            incomplete_details: null,
-            max_output_tokens: null,
-            max_tool_calls: null,
-            metadata: {},
-            model: model,
-            object: "response",
-            output: output,
-            parallel_tool_calls: true,
-            previous_response_id: null,
-            prompt_cache_key: null,
-            reasoning: {},
-            safety_identifier: "user-" + uuidv4().replace(/-/g, ''),
-            service_tier: "default",
-            status: "completed",
-            store: false,
-            temperature: 1,
-            text: {
-                format: { type: "text" },
-            },
-            tool_choice: "auto",
-            tools: [],
-            top_logprobs: 0,
-            top_p: 1,
-            truncation: "disabled",
-            usage: {
-                input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
-                input_tokens_details: {
-                    cached_tokens: geminiResponse.usageMetadata?.cachedContentTokenCount || 0
-                },
-                output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0,
-                output_tokens_details: {
-                    reasoning_tokens: geminiResponse.usageMetadata?.thoughtsTokenCount || 0
-                },
-                total_tokens: geminiResponse.usageMetadata?.totalTokenCount || 0
-            },
-            user: null
-        };
-    }
-
-    /**
-     * Gemini流式响应 -> OpenAI Responses流式响应
-     */
-    toOpenAIResponsesStreamChunk(geminiChunk, model, requestId = null) {
-        if (!geminiChunk) return [];
-
-        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
-        const events = [];
-
-        // 处理完整的Gemini chunk对象
-        if (typeof geminiChunk === 'object' && !Array.isArray(geminiChunk)) {
-            const candidate = geminiChunk.candidates?.[0];
-            
-            if (candidate) {
-                const parts = candidate.content?.parts;
-                
-                // 第一个chunk - 检测是否是开始（有role）
-                if (candidate.content?.role === 'model' && parts && parts.length > 0) {
-                    // 只在第一次有内容时发送开始事件
-                    const hasContent = parts.some(part => part && typeof part.text === 'string' && part.text.length > 0);
-                    if (hasContent) {
-                        events.push(
-                            generateResponseCreated(responseId, model || 'unknown'),
-                            generateResponseInProgress(responseId),
-                            generateOutputItemAdded(responseId),
-                            generateContentPartAdded(responseId)
-                        );
-                    }
-                }
-                
-                // 提取文本内容
-                if (parts && Array.isArray(parts)) {
-                    const textParts = parts.filter(part => part && typeof part.text === 'string');
-                    if (textParts.length > 0) {
-                        const text = textParts.map(part => part.text).join('');
-                        events.push({
-                            delta: text,
-                            item_id: `msg_${uuidv4().replace(/-/g, '')}`,
-                            output_index: 0,
-                            sequence_number: 3,
-                            type: "response.output_text.delta"
-                        });
-                    }
-                }
-                
-                // 处理finishReason
-                if (candidate.finishReason) {
-                    events.push(
-                        generateOutputTextDone(responseId),
-                        generateContentPartDone(responseId),
-                        generateOutputItemDone(responseId),
-                        generateResponseCompleted(responseId)
-                    );
-                    
-                    // 如果有 usage 信息，更新最后一个事件
-                    if (geminiChunk.usageMetadata && events.length > 0) {
-                        const lastEvent = events[events.length - 1];
-                        if (lastEvent.response) {
-                            lastEvent.response.usage = {
-                                input_tokens: geminiChunk.usageMetadata.promptTokenCount || 0,
-                                input_tokens_details: {
-                                    cached_tokens: geminiChunk.usageMetadata.cachedContentTokenCount || 0
-                                },
-                                output_tokens: geminiChunk.usageMetadata.candidatesTokenCount || 0,
-                                output_tokens_details: {
-                                    reasoning_tokens: geminiChunk.usageMetadata.thoughtsTokenCount || 0
-                                },
-                                total_tokens: geminiChunk.usageMetadata.totalTokenCount || 0
-                            };
-                        }
-                    }
-                }
-            }
-        }
-
-        // 向后兼容：处理字符串格式
-        if (typeof geminiChunk === 'string') {
-            events.push({
-                delta: geminiChunk,
-                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
-                output_index: 0,
-                sequence_number: 3,
-                type: "response.output_text.delta"
-            });
-        }
-
-        return events;
-    }
-
-    // =========================================================================
-    // Gemini -> Codex 转换
-    // =========================================================================
-
-    /**
-     * Gemini请求 -> Codex请求
-     */
-    toCodexRequest(geminiRequest) {
-        // 使用 CodexConverter 进行转换，因为 CodexConverter.js 中已经实现了 OpenAI -> Codex 的逻辑
-        // 我们需要先将 Gemini 转为 OpenAI 格式，再转为 Codex 格式
-        const openaiRequest = this.toOpenAIRequest(geminiRequest);
-        
-        // 注意：这里我们直接在 GeminiConverter 中实现逻辑，避免循环依赖
-        const codexRequest = {
-            model: openaiRequest.model,
-            instructions: '',
-            input: [],
-            stream: geminiRequest.stream || false,
-            store: false,
-            reasoning: {
-                effort: 'medium',
-                summary: 'auto'
-            },
-            parallel_tool_calls: true,
-            include: ['reasoning.encrypted_content']
-        };
-
-        // 处理系统指令
-        if (geminiRequest.systemInstruction && geminiRequest.systemInstruction.parts) {
-            codexRequest.instructions = geminiRequest.systemInstruction.parts
-                .filter(p => p.text)
-                .map(p => p.text)
-                .join('\n');
-        }
-
-        // 处理内容
-        if (geminiRequest.contents && Array.isArray(geminiRequest.contents)) {
-            const pendingCallIDs = [];
-            
-            geminiRequest.contents.forEach(content => {
-                const role = content.role === 'model' ? 'assistant' : 'user';
-                const parts = content.parts || [];
-                
-                parts.forEach(part => {
-                    if (part.text) {
-                        codexRequest.input.push({
-                            type: 'message',
-                            role: role,
-                            content: [{
-                                type: role === 'assistant' ? 'output_text' : 'input_text',
-                                text: part.text
-                            }]
-                        });
-                    }
-                    
-                    if (part.functionCall) {
-                        const callId = `call_${uuidv4().replace(/-/g, '').slice(0, 24)}`;
-                        pendingCallIDs.push(callId);
-                        codexRequest.input.push({
-                            type: 'function_call',
-                            call_id: callId,
-                            name: part.functionCall.name,
-                            arguments: typeof part.functionCall.args === 'string' 
-                                ? part.functionCall.args 
-                                : JSON.stringify(part.functionCall.args)
-                        });
-                    }
-                    
-                    if (part.functionResponse) {
-                        const callId = pendingCallIDs.shift() || `call_${uuidv4().replace(/-/g, '').slice(0, 24)}`;
-                        codexRequest.input.push({
-                            type: 'function_call_output',
-                            call_id: callId,
-                            output: typeof part.functionResponse.response?.result === 'string'
-                                ? part.functionResponse.response.result
-                                : JSON.stringify(part.functionResponse.response || {})
-                        });
-                    }
-                });
-            });
-        }
-
-        // 处理工具
-        if (geminiRequest.tools && geminiRequest.tools[0]?.functionDeclarations) {
-            codexRequest.tools = geminiRequest.tools[0].functionDeclarations.map(fn => ({
-                type: 'function',
-                name: fn.name,
-                description: fn.description,
-                parameters: fn.parameters || { type: 'object', properties: {} }
-            }));
-        }
-
-        return codexRequest;
-    }
-
-    /**
-     * Gemini请求 -> Grok请求
-     */
-    toGrokRequest(geminiRequest) {
-        // 先转换为 OpenAI 格式
-        const openaiRequest = this.toOpenAIRequest(geminiRequest);
-        return {
-            ...openaiRequest,
-            _isConverted: true
-        };
-    }
-
-    /**
-     * Gemini响应 -> Codex响应 (实际上是 Codex 转 Gemini)
-     */
-    toCodexResponse(geminiResponse, model) {
-        // 这里实际上是实现 Codex -> Gemini 的非流式转换
-        // 为了保持接口一致，我们按照其他 Converter 的命名习惯
-        const parts = [];
-        if (geminiResponse.response?.output) {
-            geminiResponse.response.output.forEach(item => {
-                if (item.type === 'message' && item.content) {
-                    const textPart = item.content.find(c => c.type === 'output_text');
-                    if (textPart) parts.push({ text: textPart.text });
-                } else if (item.type === 'reasoning' && item.summary) {
-                    const textPart = item.summary.find(c => c.type === 'summary_text');
-                    if (textPart) parts.push({ text: textPart.text, thought: true });
-                } else if (item.type === 'function_call') {
-                    parts.push({
-                        functionCall: {
-                            name: item.name,
-                            args: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                        }
-                    });
-                }
-            });
-        }
-
-        return {
-            candidates: [{
-                content: {
-                    role: 'model',
-                    parts: parts
-                },
-                finishReason: 'STOP'
-            }],
-            usageMetadata: {
-                promptTokenCount: geminiResponse.response?.usage?.input_tokens || 0,
-                candidatesTokenCount: geminiResponse.response?.usage?.output_tokens || 0,
-                totalTokenCount: geminiResponse.response?.usage?.total_tokens || 0
-            },
-            modelVersion: model,
-            responseId: geminiResponse.response?.id
-        };
-    }
-
-    /**
-     * Gemini流式响应 -> Codex流式响应 (实际上是 Codex 转 Gemini)
-     */
-    toCodexStreamChunk(codexChunk, model) {
-        const type = codexChunk.type;
-        const resId = codexChunk.response?.id || 'default';
-        
-        const template = {
-            candidates: [{
-                content: {
-                    role: "model",
-                    parts: []
-                }
-            }],
-            modelVersion: model,
-            responseId: resId
-        };
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            template.candidates[0].content.parts.push({ text: codexChunk.delta, thought: true });
-            return template;
-        }
-
-        if (type === 'response.output_text.delta') {
-            template.candidates[0].content.parts.push({ text: codexChunk.delta });
-            return template;
-        }
-
-        if (type === 'response.output_item.done' && codexChunk.item?.type === 'function_call') {
-            template.candidates[0].content.parts.push({
-                functionCall: {
-                    name: codexChunk.item.name,
-                    args: typeof codexChunk.item.arguments === 'string' ? JSON.parse(codexChunk.item.arguments) : codexChunk.item.arguments
-                }
-            });
-            return template;
-        }
-
-        if (type === 'response.completed') {
-            template.candidates[0].finishReason = "STOP";
-            template.usageMetadata = {
-                promptTokenCount: codexChunk.response.usage?.input_tokens || 0,
-                candidatesTokenCount: codexChunk.response.usage?.output_tokens || 0,
-                totalTokenCount: codexChunk.response.usage?.total_tokens || 0
-            };
-            return template;
-        }
-
-        return null;
-    }
-}
-
-export default GeminiConverter;

src/converters/strategies/GrokConverter.js

@@ -1,1153 +0,0 @@
-/**
- * Grok转换器
- * 处理Grok协议与其他协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../../utils/logger.js';
-import { BaseConverter } from '../BaseConverter.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-
-/**
- * Grok转换器类
- * 实现Grok协议到其他协议的转换
- */
-export class GrokConverter extends BaseConverter {
-    // 静态属性，确保所有实例共享最新的基础 URL 和 UUID 配置
-    static sharedRequestBaseUrl = "";
-    static sharedUuid = null;
-
-    constructor() {
-        super('grok');
-        // 用于跟踪每个请求的状态
-        this.requestStates = new Map();
-    }
-
-    /**
-     * 设置请求的基础 URL
-     */
-    setRequestBaseUrl(baseUrl) {
-        if (baseUrl) {
-            GrokConverter.sharedRequestBaseUrl = baseUrl;
-        }
-    }
-
-    /**
-     * 设置账号的 UUID
-     */
-    setUuid(uuid) {
-        if (uuid) {
-            GrokConverter.sharedUuid = uuid;
-        }
-    }
-
-    /**
-     * 为 assets.grok.com 域名的资源 URL 添加 uuid 参数，并转换为本地代理 URL
-     */
-    _appendSsoToken(url, state = null) {
-        const requestBaseUrl = state?.requestBaseUrl || GrokConverter.sharedRequestBaseUrl;
-        const uuid = state?.uuid || GrokConverter.sharedUuid;
-
-        if (!url || !uuid) return url;
-        
-        // 检查是否为 assets.grok.com 域名或相对路径
-        const isGrokAsset = url.includes('assets.grok.com') || (!url.startsWith('http') && !url.startsWith('data:'));
-        
-        if (!isGrokAsset) return url;
-
-        // 构造完整的原始 URL
-        let originalUrl = url;
-        if (!url.startsWith('http')) {
-            originalUrl = `https://assets.grok.com${url.startsWith('/') ? '' : '/'}${url}`;
-        }
-
-        // 返回本地代理接口 URL
-        // 使用 uuid 以提高安全性，防止 token 泄露在链接中
-        const authParam = `uuid=${encodeURIComponent(uuid)}`;
-
-        const proxyPath = `/api/grok/assets?url=${encodeURIComponent(originalUrl)}&${authParam}`;
-        if (requestBaseUrl) {
-            return `${requestBaseUrl}${proxyPath}`;
-        }
-        return proxyPath;
-    }
-
-    /**
-     * 在文本中查找并替换所有 assets.grok.com 的资源链接为绝对代理链接
-     */
-    _processGrokAssetsInText(text, state = null) {
-        const uuid = state?.uuid || GrokConverter.sharedUuid;
-        if (!text || !uuid) return text;
-        
-        // 更宽松的正则匹配 assets.grok.com 的 URL
-        const grokUrlRegex = /https?:\/\/assets\.grok\.com\/[^\s\)\"\'\>]+/g;
-        
-        return text.replace(grokUrlRegex, (url) => {
-            return this._appendSsoToken(url, state);
-        });
-    }
-
-    /**
-     * 获取或初始化请求状态
-     */
-    _getState(requestId) {
-        if (!this.requestStates.has(requestId)) {
-            this.requestStates.set(requestId, {
-                think_opened: false,
-                image_think_active: false,
-                video_think_active: false,
-                role_sent: false,
-                tool_buffer: "",
-                last_is_thinking: false,
-                fingerprint: "",
-                content_buffer: "", // 用于缓存内容以解析工具调用
-                has_tool_call: false,
-                rollout_id: "",
-                in_tool_call: false, // 是否处于 <tool_call> 块内
-                requestBaseUrl: "",
-                uuid: null,
-                pending_text_buffer: "" // 用于处理流式输出中被截断的 URL
-            });
-        }
-        return this.requestStates.get(requestId);
-    }
-
-    /**
-     * 构建工具系统提示词 (build_tool_prompt)
-     */
-    buildToolPrompt(tools, toolChoice = "auto", parallelToolCalls = true) {
-        if (!tools || tools.length === 0 || toolChoice === "none") {
-            return "";
-        }
-
-        const lines = [
-            "# Available Tools",
-            "",
-            "You have access to the following tools. To call a tool, output a <tool_call> block with a JSON object containing \"name\" and \"arguments\".",
-            "",
-            "Format:",
-            "<tool_call>",
-            '{"name": "function_name", "arguments": {"param": "value"}}',
-            "</tool_call>",
-            "",
-        ];
-
-        if (parallelToolCalls) {
-            lines.push("You may make multiple tool calls in a single response by using multiple <tool_call> blocks.");
-            lines.push("");
-        }
-
-        lines.push("## Tool Definitions");
-        lines.push("");
-        for (const tool of tools) {
-            if (tool.type !== "function") continue;
-            const func = tool.function || {};
-            lines.push(`### ${func.name}`);
-            if (func.description) lines.push(func.description);
-            if (func.parameters) lines.push(`Parameters: ${JSON.stringify(func.parameters)}`);
-            lines.push("");
-        }
-
-        if (toolChoice === "required") {
-            lines.push("IMPORTANT: You MUST call at least one tool in your response. Do not respond with only text.");
-        } else if (typeof toolChoice === 'object' && toolChoice.function?.name) {
-            lines.push(`IMPORTANT: You MUST call the tool "${toolChoice.function.name}" in your response.`);
-        } else {
-            lines.push("Decide whether to call a tool based on the user's request. If you don't need a tool, respond normally with text only.");
-        }
-
-        lines.push("");
-        lines.push("When you call a tool, you may include text before or after the <tool_call> blocks, but the tool call blocks must be valid JSON.");
-
-        return lines.join("\n");
-    }
-
-    /**
-     * 格式化工具历史 (format_tool_history)
-     */
-    formatToolHistory(messages) {
-        const result = [];
-        for (const msg of messages) {
-            const role = msg.role;
-            const content = msg.content;
-            const toolCalls = msg.tool_calls;
-
-            if (role === "assistant" && toolCalls && toolCalls.length > 0) {
-                const parts = [];
-                if (content) parts.push(typeof content === 'string' ? content : JSON.stringify(content));
-                for (const tc of toolCalls) {
-                    const func = tc.function || {};
-                    parts.push(`<tool_call>{"name":"${func.name}","arguments":${func.arguments || "{}"}}</tool_call>`);
-                }
-                result.push({ role: "assistant", content: parts.join("\n") });
-            } else if (role === "tool") {
-                const toolName = msg.name || "unknown";
-                const callId = msg.tool_call_id || "";
-                const contentStr = typeof content === 'string' ? content : JSON.stringify(content);
-                result.push({
-                    role: "user",
-                    content: `tool (${toolName}, ${callId}): ${contentStr}`
-                });
-            } else {
-                result.push(msg);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * 解析工具调用 (parse_tool_calls)
-     */
-    parseToolCalls(content) {
-        if (!content) return { text: content, toolCalls: null };
-
-        const toolCallRegex = /<tool_call>\s*(.*?)\s*<\/tool_call>/gs;
-        const matches = [...content.matchAll(toolCallRegex)];
-        
-        if (matches.length === 0) return { text: content, toolCalls: null };
-
-        const toolCalls = [];
-        for (const match of matches) {
-            try {
-                const parsed = JSON.parse(match[1].trim());
-                if (parsed.name) {
-                    let args = parsed.arguments || {};
-                    const argumentsStr = typeof args === 'string' ? args : JSON.stringify(args);
-                    
-                    toolCalls.push({
-                        id: `call_${uuidv4().replace(/-/g, '').slice(0, 24)}`,
-                        type: "function",
-                        function: {
-                            name: parsed.name,
-                            arguments: argumentsStr
-                        }
-                    });
-                }
-            } catch (e) {
-                // 忽略解析失败的块
-            }
-        }
-
-        if (toolCalls.length === 0) return { text: content, toolCalls: null };
-
-        // 提取文本内容
-        let text = content;
-        for (const match of matches) {
-            text = text.replace(match[0], "");
-        }
-        text = text.trim() || null;
-
-        return { text, toolCalls };
-    }
-
-    /**
-     * 转换请求
-     */
-    convertRequest(data, targetProtocol) {
-        switch (targetProtocol) {
-            default:
-                return data;
-        }
-    }
-
-    /**
-     * 转换响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexResponse(data, model);
-            default:
-                return data;
-        }
-    }
-
-    /**
-     * 转换流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexStreamChunk(chunk, model);
-            default:
-                return chunk;
-        }
-    }
-
-    /**
-     * 转换模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIModelList(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiModelList(data);
-            default:
-                return data;
-        }
-    }
-
-    /**
-     * 构建工具覆盖配置 (build_tool_overrides)
-     */
-    buildToolOverrides(tools) {
-        if (!tools || !Array.isArray(tools)) {
-            return {};
-        }
-
-        const toolOverrides = {};
-        for (const tool of tools) {
-            if (tool.type !== "function") continue;
-            const func = tool.function || {};
-            const name = func.name;
-            if (!name) continue;
-            
-            toolOverrides[name] = {
-                "enabled": true,
-                "description": func.description || "",
-                "parameters": func.parameters || {}
-            };
-        }
-
-        return toolOverrides;
-    }
-
-    /**
-     * 递归收集响应中的图片 URL
-     */
-    _collectImages(obj) {
-        const urls = [];
-        const seen = new Set();
-
-        const add = (url) => {
-            if (!url || seen.has(url)) return;
-            seen.add(url);
-            urls.push(url);
-        };
-
-        const walk = (value) => {
-            if (value && typeof value === 'object') {
-                if (Array.isArray(value)) {
-                    value.forEach(walk);
-                } else {
-                    for (const [key, item] of Object.entries(value)) {
-                        if (key === "generatedImageUrls" || key === "imageUrls" || key === "imageURLs") {
-                            if (Array.isArray(item)) {
-                                item.forEach(url => typeof url === 'string' && add(url));
-                            } else if (typeof item === 'string') {
-                                add(item);
-                            }
-                            continue;
-                        }
-                        walk(item);
-                    }
-                }
-            }
-        };
-
-        walk(obj);
-        return urls;
-    }
-
-    /**
-     * 渲染图片为 Markdown
-     */
-    _renderImage(url, imageId = "image", state = null) {
-        let finalUrl = url;
-        if (!url.startsWith('http')) {
-            finalUrl = `https://assets.grok.com${url.startsWith('/') ? '' : '/'}${url}`;
-        }
-        finalUrl = this._appendSsoToken(finalUrl, state);
-        return `![${imageId}](${finalUrl})`;
-    }
-
-    /**
-     * 渲染视频为 Markdown/HTML (render_video)
-     */
-    _renderVideo(videoUrl, thumbnailImageUrl = "", state = null) {
-        let finalVideoUrl = videoUrl;
-        if (!videoUrl.startsWith('http')) {
-            finalVideoUrl = `https://assets.grok.com${videoUrl.startsWith('/') ? '' : '/'}${videoUrl}`;
-        }
-        
-        let finalThumbUrl = thumbnailImageUrl;
-        if (thumbnailImageUrl && !thumbnailImageUrl.startsWith('http')) {
-            finalThumbUrl = `https://assets.grok.com${thumbnailImageUrl.startsWith('/') ? '' : '/'}${thumbnailImageUrl}`;
-        }
-
-        const defaultThumb = 'https://assets.grok.com/favicon.ico';
-        return `\n[![video](${finalThumbUrl || defaultThumb})](${finalVideoUrl})\n[Play Video](${finalVideoUrl})\n`;
-    }
-
-    /**
-     * 提取工具卡片文本 (extract_tool_text)
-     */
-    _extractToolText(raw, rolloutId = "") {
-        if (!raw) return "";
-        
-        const nameMatch = raw.match(/<xai:tool_name>(.*?)<\/xai:tool_name>/s);
-        const argsMatch = raw.match(/<xai:tool_args>(.*?)<\/xai:tool_args>/s);
-
-        let name = nameMatch ? nameMatch[1].replace(/<!\[CDATA\[(.*?)\]\]>/gs, "$1").trim() : "";
-        let args = argsMatch ? argsMatch[1].replace(/<!\[CDATA\[(.*?)\]\]>/gs, "$1").trim() : "";
-
-        let payload = null;
-        if (args) {
-            try {
-                payload = JSON.parse(args);
-            } catch (e) {
-                payload = null;
-            }
-        }
-
-        let label = name;
-        let text = args;
-        const prefix = rolloutId ? `[${rolloutId}]` : "";
-
-        if (name === "web_search") {
-            label = `${prefix}[WebSearch]`;
-            if (payload && typeof payload === 'object') {
-                text = payload.query || payload.q || "";
-            }
-        } else if (name === "search_images") {
-            label = `${prefix}[SearchImage]`;
-            if (payload && typeof payload === 'object') {
-                text = payload.image_description || payload.description || payload.query || "";
-            }
-        } else if (name === "chatroom_send") {
-            label = `${prefix}[AgentThink]`;
-            if (payload && typeof payload === 'object') {
-                text = payload.message || "";
-            }
-        }
-
-        if (label && text) return `${label} ${text}`.trim();
-        if (label) return label;
-        if (text) return text;
-        return raw.replace(/<[^>]+>/g, "").trim();
-    }
-
-    /**
-     * 过滤特殊标签
-     */
-    _filterToken(token, requestId = "") {
-        if (!token) return token;
-        
-        let filtered = token;
-
-        // 移除 xai:tool_usage_card 及其内容，不显示工具调用的过程输出
-        filtered = filtered.replace(/<xai:tool_usage_card[^>]*>.*?<\/xai:tool_usage_card>/gs, "");
-        filtered = filtered.replace(/<xai:tool_usage_card[^>]*\/>/gs, "");
-        
-        // 移除其他内部标签
-        const tagsToFilter = ["rolloutId", "responseId", "isThinking"];
-        for (const tag of tagsToFilter) {
-            const pattern = new RegExp(`<${tag}[^>]*>.*?<\\/${tag}>|<${tag}[^>]*\\/>`, 'gs');
-            filtered = filtered.replace(pattern, "");
-        }
-
-        return filtered;
-    }
-
-    /**
-     * Grok响应 -> OpenAI响应
-     */
-    toOpenAIResponse(grokResponse, model) {
-        if (!grokResponse) return null;
-
-        const responseId = grokResponse.responseId || `chatcmpl-${uuidv4()}`;
-        let content = grokResponse.message || "";
-        const modelHash = grokResponse.llmInfo?.modelHash || "";
-        
-        const state = this._getState(this._formatResponseId(responseId));
-        if (grokResponse._requestBaseUrl) {
-            state.requestBaseUrl = grokResponse._requestBaseUrl;
-        }
-        if (grokResponse._uuid) {
-            state.uuid = grokResponse._uuid;
-        }
-
-        // 过滤内容并处理其中的 Grok 资源链接
-        content = this._filterToken(content, responseId);
-        content = this._processGrokAssetsInText(content, state);
-
-        // 收集图片并追加
-        const imageUrls = this._collectImages(grokResponse);
-        if (imageUrls.length > 0) {
-            content += "\n";
-            for (const url of imageUrls) {
-                content += this._renderImage(url, "image", state) + "\n";
-            }
-        }
-
-        // 处理视频 (非流式模式)
-        if (grokResponse.finalVideoUrl) {
-            content += this._renderVideo(grokResponse.finalVideoUrl, grokResponse.finalThumbnailUrl, state);
-        }
-
-        // 解析工具调用
-        const { text, toolCalls } = this.parseToolCalls(content);
-
-        const result = {
-            id: responseId,
-            object: "chat.completion",
-            created: Math.floor(Date.now() / 1000),
-            model: model,
-            system_fingerprint: modelHash,
-            choices: [{
-                index: 0,
-                message: {
-                    role: "assistant",
-                    content: text,
-                },
-                finish_reason: toolCalls ? "tool_calls" : "stop",
-            }],
-            usage: {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
-            },
-        };
-
-        if (toolCalls) {
-            result.choices[0].message.tool_calls = toolCalls;
-        }
-
-        return result;
-    }
-
-    _formatResponseId(id) {
-        if (!id) return `chatcmpl-${uuidv4()}`;
-        if (id.startsWith('chatcmpl-')) return id;
-        return `chatcmpl-${id}`;
-    }
-
-    /**
-     * Grok流式响应块 -> OpenAI流式响应块
-     */
-    toOpenAIStreamChunk(grokChunk, model) {
-        if (!grokChunk || !grokChunk.result || !grokChunk.result.response) {
-            return null;
-        }
-
-        const resp = grokChunk.result.response;
-        const rawResponseId = resp.responseId || "";
-        const responseId = this._formatResponseId(rawResponseId);
-        const state = this._getState(responseId);
-        
-        // 从响应块中同步 uuid 和基础 URL
-        if (resp._requestBaseUrl) {
-            state.requestBaseUrl = resp._requestBaseUrl;
-        }
-        if (resp._uuid) {
-            state.uuid = resp._uuid;
-        }
-
-        if (resp.llmInfo?.modelHash && !state.fingerprint) {
-            state.fingerprint = resp.llmInfo.modelHash;
-        }
-        if (resp.rolloutId) {
-            state.rollout_id = String(resp.rolloutId);
-        }
-
-        const chunks = [];
-
-        // 0. 发送角色信息（仅第一次）
-        if (!state.role_sent) {
-            chunks.push({
-                id: responseId,
-                object: "chat.completion.chunk",
-                created: Math.floor(Date.now() / 1000),
-                model: model,
-                system_fingerprint: state.fingerprint,
-                choices: [{
-                    index: 0,
-                    delta: { role: "assistant", content: "" },
-                    finish_reason: null
-                }]
-            });
-            state.role_sent = true;
-        }
-
-        // 处理结束标志
-        if (resp.isDone) {
-            let finalContent = "";
-            // 处理剩余的缓冲区
-            if (state.pending_text_buffer) {
-                finalContent += this._processGrokAssetsInText(state.pending_text_buffer, state);
-                state.pending_text_buffer = "";
-            }
-
-            // 处理 buffer 中的工具调用
-            const { text, toolCalls } = this.parseToolCalls(state.content_buffer);
-            
-            if (toolCalls) {
-                chunks.push({
-                    id: responseId,
-                    object: "chat.completion.chunk",
-                    created: Math.floor(Date.now() / 1000),
-                    model: model,
-                    system_fingerprint: state.fingerprint,
-                    choices: [{
-                        index: 0,
-                        delta: { 
-                            content: (finalContent + (text || "")).trim() || null,
-                            tool_calls: toolCalls 
-                        },
-                        finish_reason: "tool_calls"
-                    }]
-                });
-            } else {
-                chunks.push({
-                    id: responseId,
-                    object: "chat.completion.chunk",
-                    created: Math.floor(Date.now() / 1000),
-                    model: model,
-                    system_fingerprint: state.fingerprint,
-                    choices: [{
-                        index: 0,
-                        delta: { content: finalContent || null },
-                        finish_reason: "stop"
-                    }]
-                });
-            }
-
-            // 清理状态
-            this.requestStates.delete(responseId);
-            return chunks;
-        }
-
-        let deltaContent = "";
-        let deltaReasoning = "";
-
-        // 1. 处理图片生成进度
-        if (resp.streamingImageGenerationResponse) {
-            const img = resp.streamingImageGenerationResponse;
-            state.image_think_active = true;
-            /* 
-            if (!state.think_opened) {
-                deltaReasoning += "<think>\n";
-                state.think_opened = true;
-            }
-            */
-            const idx = (img.imageIndex || 0) + 1;
-            const progress = img.progress || 0;
-            deltaReasoning += `正在生成第${idx}张图片中，当前进度${progress}%\n`;
-        }
-
-        // 2. 处理视频生成进度 (VideoStreamProcessor)
-        if (resp.streamingVideoGenerationResponse) {
-            const vid = resp.streamingVideoGenerationResponse;
-            state.video_think_active = true;
-            /*
-            if (!state.think_opened) {
-                deltaReasoning += "<think>\n";
-                state.think_opened = true;
-            }
-            */
-            const progress = vid.progress || 0;
-            deltaReasoning += `正在生成视频中，当前进度${progress}%\n`;
-
-            if (progress === 100 && vid.videoUrl) {
-                /*
-                if (state.think_opened) {
-                    deltaContent += "\n</think>\n";
-                    state.think_opened = false;
-                }
-                */
-                state.video_think_active = false;
-                deltaContent += this._renderVideo(vid.videoUrl, vid.thumbnailImageUrl, state);
-            }
-        }
-
-        // 3. 处理模型响应（通常包含完整消息或图片）
-        if (resp.modelResponse) {
-            const mr = resp.modelResponse;
-            /*
-            if ((state.image_think_active || state.video_think_active) && state.think_opened) {
-                deltaContent += "\n</think>\n";
-                state.think_opened = false;
-            }
-            */
-            state.image_think_active = false;
-            state.video_think_active = false;
-
-            const imageUrls = this._collectImages(mr);
-            for (const url of imageUrls) {
-                deltaContent += this._renderImage(url, "image", state) + "\n";
-            }
-
-            if (mr.metadata?.llm_info?.modelHash) {
-                state.fingerprint = mr.metadata.llm_info.modelHash;
-            }
-        }
-
-        // 4. 处理卡片附件
-        if (resp.cardAttachment) {
-            const card = resp.cardAttachment;
-            if (card.jsonData) {
-                try {
-                    const cardData = JSON.parse(card.jsonData);
-                    let original = cardData.image?.original;
-                    const title = cardData.image?.title || "image";
-                    if (original) {
-                        // 确保是绝对路径
-                        if (!original.startsWith('http')) {
-                            original = `https://assets.grok.com${original.startsWith('/') ? '' : '/'}${original}`;
-                        }
-                        original = this._appendSsoToken(original, state);
-                        deltaContent += `![${title}](${original})\n`;
-                    }
-                } catch (e) {
-                    // 忽略 JSON 解析错误
-                }
-            }
-        }
-
-        // 5. 处理普通 Token 和 思考状态
-        if (resp.token !== undefined && resp.token !== null) {
-            const token = resp.token;
-            const filtered = this._filterToken(token, responseId);
-            const isThinking = !!resp.isThinking;
-            const inThink = isThinking || state.image_think_active || state.video_think_active;
-
-            if (inThink) {
-                deltaReasoning += filtered;
-            } else {
-                // 将新 token 加入待处理缓冲区，解决 URL 被截断的问题
-                state.pending_text_buffer += filtered;
-                
-                let outputFromBuffer = "";
-                
-                // 启发式逻辑：检查缓冲区是否包含完整的 URL
-                if (state.pending_text_buffer.includes("https://assets.grok.com")) {
-                    const lastUrlIndex = state.pending_text_buffer.lastIndexOf("https://assets.grok.com");
-                    const textAfterUrl = state.pending_text_buffer.slice(lastUrlIndex);
-                    
-                    // 检查 URL 是否结束（空格、右括号、引号、换行、大于号等）
-                    const terminatorMatch = textAfterUrl.match(/[\s\)\"\'\>\n]/);
-                    if (terminatorMatch) {
-                        // URL 已结束，可以安全地处理并输出缓冲区
-                        outputFromBuffer = this._processGrokAssetsInText(state.pending_text_buffer, state);
-                        state.pending_text_buffer = "";
-                    } else if (state.pending_text_buffer.length > 1000) {
-                        // 缓冲区过长，强制处理输出，避免过度延迟
-                        outputFromBuffer = this._processGrokAssetsInText(state.pending_text_buffer, state);
-                        state.pending_text_buffer = "";
-                    }
-                } else {
-                    // 不包含 Grok URL，直接输出
-                    outputFromBuffer = state.pending_text_buffer;
-                    state.pending_text_buffer = "";
-                }
-
-                if (outputFromBuffer) {
-                    // 工具调用抑制逻辑：不向客户端输出 <tool_call> 块及其内容
-                    let outputToken = outputFromBuffer;
-                    
-                    // 简单的状态切换检测
-                    if (outputToken.includes('<tool_call>')) {
-                        state.in_tool_call = true;
-                        state.has_tool_call = true;
-                        // 移除标签之后的部分（如果有）
-                        outputToken = outputToken.split('<tool_call>')[0];
-                    } else if (state.in_tool_call && outputToken.includes('</tool_call>')) {
-                        state.in_tool_call = false;
-                        // 只保留标签之后的部分
-                        outputToken = outputToken.split('</tool_call>')[1] || "";
-                    } else if (state.in_tool_call) {
-                        // 处于块内，完全抑制
-                        outputToken = "";
-                    }
-
-                    deltaContent += outputToken;
-                }
-                
-                // 将内容加入 buffer 用于最终解析工具调用
-                state.content_buffer += filtered;
-            }
-            state.last_is_thinking = isThinking;
-        }
-
-        if (deltaContent || deltaReasoning) {
-            const delta = {};
-            if (deltaContent) delta.content = deltaContent;
-            if (deltaReasoning) delta.reasoning_content = deltaReasoning;
-
-            chunks.push({
-                id: responseId,
-                object: "chat.completion.chunk",
-                created: Math.floor(Date.now() / 1000),
-                model: model,
-                system_fingerprint: state.fingerprint,
-                choices: [{
-                    index: 0,
-                    delta: delta,
-                    finish_reason: null
-                }]
-            });
-        }
-
-        return chunks.length > 0 ? chunks : null;
-    }
-
-    /**
-     * Grok响应 -> Gemini响应
-     */
-    toGeminiResponse(grokResponse, model) {
-        const openaiRes = this.toOpenAIResponse(grokResponse, model);
-        if (!openaiRes) return null;
-
-        const choice = openaiRes.choices[0];
-        const message = choice.message;
-        const parts = [];
-
-        if (message.reasoning_content) {
-            parts.push({ text: message.reasoning_content, thought: true });
-        }
-
-        if (message.content) {
-            parts.push({ text: message.content });
-        }
-
-        if (message.tool_calls) {
-            for (const tc of message.tool_calls) {
-                parts.push({
-                    functionCall: {
-                        name: tc.function.name,
-                        args: typeof tc.function.arguments === 'string' ? JSON.parse(tc.function.arguments) : tc.function.arguments
-                    }
-                });
-            }
-        }
-
-        return {
-            candidates: [{
-                content: {
-                    role: 'model',
-                    parts: parts
-                },
-                finishReason: choice.finish_reason === 'tool_calls' ? 'STOP' : (choice.finish_reason === 'length' ? 'MAX_TOKENS' : 'STOP')
-            }],
-            usageMetadata: {
-                promptTokenCount: openaiRes.usage.prompt_tokens,
-                candidatesTokenCount: openaiRes.usage.completion_tokens,
-                totalTokenCount: openaiRes.usage.total_tokens
-            }
-        };
-    }
-
-    /**
-     * Grok流式响应块 -> Gemini流式响应块
-     */
-    toGeminiStreamChunk(grokChunk, model) {
-        const openaiChunks = this.toOpenAIStreamChunk(grokChunk, model);
-        if (!openaiChunks) return null;
-
-        const geminiChunks = [];
-        for (const oachunk of openaiChunks) {
-            const choice = oachunk.choices[0];
-            const delta = choice.delta;
-            const parts = [];
-
-            if (delta.reasoning_content) {
-                parts.push({ text: delta.reasoning_content, thought: true });
-            }
-            if (delta.content) {
-                parts.push({ text: delta.content });
-            }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    parts.push({
-                        functionCall: {
-                            name: tc.function.name,
-                            args: typeof tc.function.arguments === 'string' ? JSON.parse(tc.function.arguments) : tc.function.arguments
-                        }
-                    });
-                }
-            }
-
-            if (parts.length > 0 || choice.finish_reason) {
-                const gchunk = {
-                    candidates: [{
-                        content: {
-                            role: 'model',
-                            parts: parts
-                        }
-                    }]
-                };
-                if (choice.finish_reason) {
-                    gchunk.candidates[0].finishReason = choice.finish_reason === 'length' ? 'MAX_TOKENS' : 'STOP';
-                }
-                geminiChunks.push(gchunk);
-            }
-        }
-
-        return geminiChunks.length > 0 ? geminiChunks : null;
-    }
-
-    /**
-     * Grok响应 -> OpenAI Responses响应
-     */
-    toOpenAIResponsesResponse(grokResponse, model) {
-        const openaiRes = this.toOpenAIResponse(grokResponse, model);
-        if (!openaiRes) return null;
-
-        const choice = openaiRes.choices[0];
-        const message = choice.message;
-        const output = [];
-
-        const content = [];
-        if (message.content) {
-            content.push({
-                type: "output_text",
-                text: message.content
-            });
-        }
-
-        output.push({
-            id: `msg_${uuidv4().replace(/-/g, '')}`,
-            type: "message",
-            role: "assistant",
-            status: "completed",
-            content: content
-        });
-
-        if (message.tool_calls) {
-            for (const tc of message.tool_calls) {
-                output.push({
-                    id: tc.id,
-                    type: "function_call",
-                    name: tc.function.name,
-                    arguments: tc.function.arguments,
-                    status: "completed"
-                });
-            }
-        }
-
-        return {
-            id: `resp_${uuidv4().replace(/-/g, '')}`,
-            object: "response",
-            created_at: Math.floor(Date.now() / 1000),
-            status: "completed",
-            model: model,
-            output: output,
-            usage: {
-                input_tokens: openaiRes.usage.prompt_tokens,
-                output_tokens: openaiRes.usage.completion_tokens,
-                total_tokens: openaiRes.usage.total_tokens
-            }
-        };
-    }
-
-    /**
-     * Grok流式响应块 -> OpenAI Responses流式响应块
-     */
-    toOpenAIResponsesStreamChunk(grokChunk, model) {
-        const openaiChunks = this.toOpenAIStreamChunk(grokChunk, model);
-        if (!openaiChunks) return null;
-
-        const events = [];
-        for (const oachunk of openaiChunks) {
-            const choice = oachunk.choices[0];
-            const delta = choice.delta;
-
-            if (delta.role === 'assistant') {
-                events.push({ type: "response.created", response: { id: oachunk.id, model: model } });
-            }
-
-            if (delta.reasoning_content) {
-                events.push({
-                    type: "response.reasoning_summary_text.delta",
-                    delta: delta.reasoning_content,
-                    response_id: oachunk.id
-                });
-            }
-
-            if (delta.content) {
-                events.push({
-                    type: "response.output_text.delta",
-                    delta: delta.content,
-                    response_id: oachunk.id
-                });
-            }
-
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    if (tc.function?.name) {
-                        events.push({
-                            type: "response.output_item.added",
-                            item: { id: tc.id, type: "function_call", name: tc.function.name, arguments: "" },
-                            response_id: oachunk.id
-                        });
-                    }
-                    if (tc.function?.arguments) {
-                        events.push({
-                            type: "response.custom_tool_call_input.delta",
-                            delta: tc.function.arguments,
-                            item_id: tc.id,
-                            response_id: oachunk.id
-                        });
-                    }
-                }
-            }
-
-            if (choice.finish_reason) {
-                events.push({ type: "response.completed", response: { id: oachunk.id, status: "completed" } });
-            }
-        }
-
-        return events;
-    }
-
-    /**
-     * Grok响应 -> Codex响应
-     */
-    toCodexResponse(grokResponse, model) {
-        const openaiRes = this.toOpenAIResponse(grokResponse, model);
-        if (!openaiRes) return null;
-
-        const choice = openaiRes.choices[0];
-        const message = choice.message;
-        const output = [];
-
-        if (message.content) {
-            output.push({
-                type: "message",
-                role: "assistant",
-                content: [{ type: "output_text", text: message.content }]
-            });
-        }
-
-        if (message.reasoning_content) {
-            output.push({
-                type: "reasoning",
-                summary: [{ type: "summary_text", text: message.reasoning_content }]
-            });
-        }
-
-        if (message.tool_calls) {
-            for (const tc of message.tool_calls) {
-                output.push({
-                    type: "function_call",
-                    call_id: tc.id,
-                    name: tc.function.name,
-                    arguments: tc.function.arguments
-                });
-            }
-        }
-
-        return {
-            response: {
-                id: openaiRes.id,
-                output: output,
-                usage: {
-                    input_tokens: openaiRes.usage.prompt_tokens,
-                    output_tokens: openaiRes.usage.completion_tokens,
-                    total_tokens: openaiRes.usage.total_tokens
-                }
-            }
-        };
-    }
-
-    /**
-     * Grok流式响应块 -> Codex流式响应块
-     */
-    toCodexStreamChunk(grokChunk, model) {
-        const openaiChunks = this.toOpenAIStreamChunk(grokChunk, model);
-        if (!openaiChunks) return null;
-
-        const codexChunks = [];
-        for (const oachunk of openaiChunks) {
-            const choice = oachunk.choices[0];
-            const delta = choice.delta;
-
-            if (delta.role === 'assistant') {
-                codexChunks.push({ type: "response.created", response: { id: oachunk.id } });
-            }
-
-            if (delta.reasoning_content) {
-                codexChunks.push({
-                    type: "response.reasoning_summary_text.delta",
-                    delta: delta.reasoning_content,
-                    response: { id: oachunk.id }
-                });
-            }
-
-            if (delta.content) {
-                codexChunks.push({
-                    type: "response.output_text.delta",
-                    delta: delta.content,
-                    response: { id: oachunk.id }
-                });
-            }
-
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    if (tc.function?.arguments) {
-                        codexChunks.push({
-                            type: "response.custom_tool_call_input.delta",
-                            delta: tc.function.arguments,
-                            item_id: tc.id,
-                            response: { id: oachunk.id }
-                        });
-                    }
-                }
-            }
-
-            if (choice.finish_reason) {
-                codexChunks.push({ type: "response.completed", response: { id: oachunk.id, usage: oachunk.usage } });
-            }
-        }
-
-        return codexChunks.length > 0 ? codexChunks : null;
-    }
-
-    /**
-     * Grok模型列表 -> OpenAI模型列表
-     */
-    toOpenAIModelList(grokModels) {
-        const models = Array.isArray(grokModels) ? grokModels : (grokModels?.models || grokModels?.data || []);
-        return {
-            object: "list",
-            data: models.map(m => ({
-                id: m.id || m.name || (typeof m === 'string' ? m : ''),
-                object: "model",
-                created: Math.floor(Date.now() / 1000),
-                owned_by: "xai",
-                display_name: m.display_name || m.name || m.id || (typeof m === 'string' ? m : ''),
-            })),
-        };
-    }
-
-    /**
-     * Grok模���列表 -> Gemini模型列表
-     */
-    toGeminiModelList(grokModels) {
-        const models = Array.isArray(grokModels) ? grokModels : (grokModels?.models || grokModels?.data || []);
-        return {
-            models: models.map(m => ({
-                name: `models/${m.id || m.name || (typeof m === 'string' ? m : '')}`,
-                version: "1.0",
-                displayName: m.display_name || m.name || m.id || (typeof m === 'string' ? m : ''),
-                description: m.description || `Grok model: ${m.name || m.id || (typeof m === 'string' ? m : '')}`,
-                inputTokenLimit: 131072,
-                outputTokenLimit: 8192,
-                supportedGenerationMethods: ["generateContent", "streamGenerateContent"]
-            }))
-        };
-    }
-}

src/converters/strategies/OpenAIConverter.js

@@ -1,1769 +0,0 @@
-/**
- * OpenAI转换器
- * 处理OpenAI协议与其他协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../../utils/logger.js';
-import { BaseConverter } from '../BaseConverter.js';
-import { CodexConverter } from './CodexConverter.js';
-import {
-    extractAndProcessSystemMessages as extractSystemMessages,
-    extractTextFromMessageContent as extractText,
-    safeParseJSON,
-    checkAndAssignOrDefault,
-    extractThinkingFromOpenAIText,
-    mapFinishReason,
-    cleanJsonSchemaProperties as cleanJsonSchema,
-    CLAUDE_DEFAULT_MAX_TOKENS,
-    CLAUDE_DEFAULT_TEMPERATURE,
-    CLAUDE_DEFAULT_TOP_P,
-    GEMINI_DEFAULT_MAX_TOKENS,
-    GEMINI_DEFAULT_TEMPERATURE,
-    GEMINI_DEFAULT_TOP_P,
-    OPENAI_DEFAULT_INPUT_TOKEN_LIMIT,
-    OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT
-} from '../utils.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../../providers/openai/openai-responses-core.mjs';
-
-/**
- * OpenAI转换器类
- * 实现OpenAI协议到其他协议的转换
- */
-export class OpenAIConverter extends BaseConverter {
-    constructor() {
-        super('openai');
-        // 创建 CodexConverter 实例用于委托
-        this.codexConverter = new CodexConverter();
-    }
-
-    /**
-     * 转换请求
-     */
-    convertRequest(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiRequest(data);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokRequest(data);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换响应
-     */
-    convertResponse(data, targetProtocol, model) {
-        // OpenAI作为源格式时，通常不需要转换响应
-        // 因为其他协议会转换到OpenAI格式
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokResponse(data, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换流式响应块
-     */
-    convertStreamChunk(chunk, targetProtocol, model) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES:
-                return this.toOpenAIResponsesStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokStreamChunk(chunk, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${targetProtocol}`);
-        }
-    }
-
-    /**
-     * 转换模型列表
-     */
-    convertModelList(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeModelList(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiModelList(data);
-            default:
-                return this.ensureDisplayName(data);
-        }
-    }
-
-    /**
-     * Ensure display_name field exists in OpenAI model list
-     */
-    ensureDisplayName(openaiModels) {
-        if (!openaiModels || !openaiModels.data) {
-            return openaiModels;
-        }
-
-        return {
-            ...openaiModels,
-            data: openaiModels.data.map(model => ({
-                ...model,
-                display_name: model.display_name || model.id,
-            })),
-        };
-    }
-
-    // =========================================================================
-    // OpenAI -> Claude 转换
-    // =========================================================================
-
-    /**
-     * OpenAI请求 -> Claude请求
-     */
-    toClaudeRequest(openaiRequest) {
-        const messages = openaiRequest.messages || [];
-        const { systemInstruction, nonSystemMessages } = extractSystemMessages(messages);
-
-        const claudeMessages = [];
-
-        for (const message of nonSystemMessages) {
-            const role = message.role === 'assistant' ? 'assistant' : 'user';
-            let content = [];
-
-            if (message.role === 'tool') {
-                // 工具结果消息
-                let toolContent = message.content;
-                if (typeof toolContent === 'object' && toolContent !== null) {
-                    toolContent = JSON.stringify(toolContent);
-                }
-                content.push({
-                    type: 'tool_result',
-                    tool_use_id: message.tool_call_id || message.tool_use_id,
-                    content: toolContent
-                });
-                claudeMessages.push({ role: 'user', content: content });
-            } else if (message.role === 'assistant' && (message.tool_calls?.length || message.function_calls?.length)) {
-                // 助手工具调用消息 - 支持tool_calls和function_calls
-                const calls = message.tool_calls || message.function_calls || [];
-                const toolUseBlocks = calls.map(tc => ({
-                    type: 'tool_use',
-                    id: tc.id,
-                    name: tc.function.name,
-                    input: safeParseJSON(tc.function.arguments)
-                }));
-                claudeMessages.push({ role: 'assistant', content: toolUseBlocks });
-            } else {
-                // 普通消息
-                if (typeof message.content === 'string') {
-                    if (message.content) {
-                        content.push({ type: 'text', text: message.content.trim() });
-                    }
-                } else if (Array.isArray(message.content)) {
-                    message.content.forEach(item => {
-                        if (!item) return;
-                        switch (item.type) {
-                            case 'text':
-                                if (item.text) {
-                                    content.push({ type: 'text', text: item.text.trim() });
-                                }
-                                break;
-                            case 'image_url':
-                                if (item.image_url) {
-                                    const imageUrl = typeof item.image_url === 'string'
-                                        ? item.image_url
-                                        : item.image_url.url;
-                                    if (imageUrl.startsWith('data:')) {
-                                        const [header, data] = imageUrl.split(',');
-                                        const mediaType = header.match(/data:([^;]+)/)?.[1] || 'image/jpeg';
-                                        content.push({
-                                            type: 'image',
-                                            source: {
-                                                type: 'base64',
-                                                media_type: mediaType,
-                                                data: data
-                                            }
-                                        });
-                                    } else {
-                                        content.push({ type: 'text', text: `[Image: ${imageUrl}]` });
-                                    }
-                                }
-                                break;
-                            case 'audio':
-                                if (item.audio_url) {
-                                    const audioUrl = typeof item.audio_url === 'string'
-                                        ? item.audio_url
-                                        : item.audio_url.url;
-                                    content.push({ type: 'text', text: `[Audio: ${audioUrl}]` });
-                                }
-                                break;
-                            case 'input_audio':
-                                // OpenAI 官方 input_audio 格式
-                                if (item.input_audio) {
-                                    // Claude 不直接支持音频输入，转换为文本描述
-                                    content.push({ type: 'text', text: `[Audio Input: ${item.input_audio.format || 'audio'}]` });
-                                }
-                                break;
-                            case 'tool_use':
-                                content.push({
-                                    type: 'tool_use',
-                                    id: item.id,
-                                    name: item.name,
-                                    input: typeof item.input === 'string' ? safeParseJSON(item.input) : (item.input || {})
-                                });
-                                break;
-                            case 'tool_result': {
-                                let resultContent = item.content;
-                                if (typeof resultContent === 'object' && resultContent !== null) {
-                                    resultContent = JSON.stringify(resultContent);
-                                }
-                                content.push({
-                                    type: 'tool_result',
-                                    tool_use_id: item.tool_use_id || item.id,
-                                    content: resultContent
-                                });
-                                break;
-                            }
-                        }
-                    });
-                }
-                if (content.length > 0) {
-                    claudeMessages.push({ role: role, content: content });
-                }
-            }
-        }
-        // 合并相邻相同 role 的消息
-        const mergedClaudeMessages = [];
-        for (let i = 0; i < claudeMessages.length; i++) {
-            const currentMessage = claudeMessages[i];
-
-            if (mergedClaudeMessages.length === 0) {
-                mergedClaudeMessages.push(currentMessage);
-            } else {
-                const lastMessage = mergedClaudeMessages[mergedClaudeMessages.length - 1];
-
-                // 如果当前消息的 role 与上一条消息的 role 相同，则合并 content 数组
-                if (lastMessage.role === currentMessage.role) {
-                    lastMessage.content = lastMessage.content.concat(currentMessage.content);
-                } else {
-                    mergedClaudeMessages.push(currentMessage);
-                }
-            }
-        }
-
-        // 清理最后一条 assistant 消息的尾部空白
-        if (mergedClaudeMessages.length > 0) {
-            const lastMessage = mergedClaudeMessages[mergedClaudeMessages.length - 1];
-            if (lastMessage.role === 'assistant' && Array.isArray(lastMessage.content)) {
-                // 从后往前找到最后一个 text 类型的内容块
-                for (let i = lastMessage.content.length - 1; i >= 0; i--) {
-                    const contentBlock = lastMessage.content[i];
-                    if (contentBlock.type === 'text' && contentBlock.text) {
-                        // 移除尾部空白字符
-                        contentBlock.text = contentBlock.text.trimEnd();
-                        break;
-                    }
-                }
-            }
-        }
-
-
-        const claudeRequest = {
-            model: openaiRequest.model,
-            messages: mergedClaudeMessages,
-            max_tokens: checkAndAssignOrDefault(openaiRequest.max_tokens, CLAUDE_DEFAULT_MAX_TOKENS),
-            temperature: checkAndAssignOrDefault(openaiRequest.temperature, CLAUDE_DEFAULT_TEMPERATURE),
-            top_p: checkAndAssignOrDefault(openaiRequest.top_p, CLAUDE_DEFAULT_TOP_P),
-        };
-
-        if (systemInstruction) {
-            claudeRequest.system = extractText(systemInstruction.parts[0].text);
-        }
-
-        if (openaiRequest.tools?.length) {
-            claudeRequest.tools = openaiRequest.tools
-                .filter(t => t && ((t.function && t.function.name) || t.name))
-                .map(t => {
-                    if (t.function) {
-                        return {
-                            name: t.function.name,
-                            description: t.function.description || '',
-                            input_schema: t.function.parameters || { type: 'object', properties: {} }
-                        };
-                    }
-                    return {
-                        name: t.name,
-                        description: t.description || '',
-                        input_schema: t.input_schema || { type: 'object', properties: {} }
-                    };
-                });
-            if (claudeRequest.tools.length > 0) {
-                claudeRequest.tool_choice = this.buildClaudeToolChoice(openaiRequest.tool_choice);
-            }
-        }
-
-        // Optional passthrough: request-side "thinking" controls for Claude/Kiro.
-        // OpenAI-compatible clients can provide these via `extra_body.anthropic.thinking`.
-        // We intentionally keep normalization minimal here; provider implementations
-        // (e.g. Kiro) clamp budgets and apply defaults.
-        const extThinking = openaiRequest?.extra_body?.anthropic?.thinking;
-        if (extThinking && typeof extThinking === 'object' && !Array.isArray(extThinking)) {
-            const type = String(extThinking.type || '').toLowerCase().trim();
-            if (type === 'enabled') {
-                const thinkingCfg = { type: 'enabled' };
-                if (extThinking.budget_tokens !== undefined) {
-                    const n = parseInt(extThinking.budget_tokens, 10);
-                    if (Number.isFinite(n)) {
-                        thinkingCfg.budget_tokens = n;
-                    }
-                }
-                claudeRequest.thinking = thinkingCfg;
-            } else if (type === 'adaptive') {
-                const effortRaw = typeof extThinking.effort === 'string' ? extThinking.effort : '';
-                const effort = effortRaw.toLowerCase().trim();
-                const normalizedEffort = (effort === 'low' || effort === 'medium' || effort === 'high') ? effort : 'high';
-                claudeRequest.thinking = { type: 'adaptive', effort: normalizedEffort };
-            } else if (type === 'disabled') {
-                // Explicitly disabled: omit thinking config.
-            }
-        }
-
-        return claudeRequest;
-    }
-
-    /**
-     * OpenAI响应 -> Claude响应
-     */
-    toClaudeResponse(openaiResponse, model) {
-        if (!openaiResponse || !openaiResponse.choices || openaiResponse.choices.length === 0) {
-            return {
-                id: `msg_${uuidv4()}`,
-                type: "message",
-                role: "assistant",
-                content: [],
-                model: model,
-                stop_reason: "end_turn",
-                stop_sequence: null,
-                usage: {
-                    input_tokens: openaiResponse?.usage?.prompt_tokens || 0,
-                    output_tokens: openaiResponse?.usage?.completion_tokens || 0
-                }
-            };
-        }
-
-        const choice = openaiResponse.choices[0];
-        const contentList = [];
-
-        // 处理工具调用 - 支持tool_calls和function_calls
-        const toolCalls = choice.message?.tool_calls || choice.message?.function_calls || [];
-        for (const toolCall of toolCalls.filter(tc => tc && typeof tc === 'object')) {
-            if (toolCall.function) {
-                const func = toolCall.function;
-                const argStr = func.arguments || "{}";
-                let argObj;
-                try {
-                    argObj = typeof argStr === 'string' ? JSON.parse(argStr) : argStr;
-                } catch (e) {
-                    argObj = {};
-                }
-                contentList.push({
-                    type: "tool_use",
-                    id: toolCall.id || "",
-                    name: func.name || "",
-                    input: argObj,
-                });
-            }
-        }
-
-        // 处理reasoning_content（推理内容）
-        const reasoningContent = choice.message?.reasoning_content || "";
-        if (reasoningContent) {
-            contentList.push({
-                type: "thinking",
-                thinking: reasoningContent
-            });
-        }
-
-        // 处理文本内容
-        const contentText = choice.message?.content || "";
-        if (contentText) {
-            const extractedContent = extractThinkingFromOpenAIText(contentText);
-            if (Array.isArray(extractedContent)) {
-                contentList.push(...extractedContent);
-            } else {
-                contentList.push({ type: "text", text: extractedContent });
-            }
-        }
-
-        // 映射结束原因
-        const stopReason = mapFinishReason(
-            choice.finish_reason || "stop",
-            "openai",
-            "anthropic"
-        );
-
-        return {
-            id: `msg_${uuidv4()}`,
-            type: "message",
-            role: "assistant",
-            content: contentList,
-            model: model,
-            stop_reason: stopReason,
-            stop_sequence: null,
-            usage: {
-                input_tokens: openaiResponse.usage?.prompt_tokens || 0,
-                cache_creation_input_tokens: 0,
-                cache_read_input_tokens: openaiResponse.usage?.prompt_tokens_details?.cached_tokens || 0,
-                output_tokens: openaiResponse.usage?.completion_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * OpenAI流式响应 -> Claude流式响应
-     *
-     * 这个方法实现了与 ClaudeConverter.toOpenAIStreamChunk 相反的转换逻辑
-     * 将 OpenAI 的流式 chunk 转换为 Claude 的流式事件
-     */
-    toClaudeStreamChunk(openaiChunk, model) {
-        if (!openaiChunk) return null;
-
-        // 处理 OpenAI chunk 对象
-        if (typeof openaiChunk === 'object' && !Array.isArray(openaiChunk)) {
-            const choice = openaiChunk.choices?.[0];
-            if (!choice) {
-                return null;
-            }
-
-            const delta = choice.delta;
-            const finishReason = choice.finish_reason;
-            const events = [];
-
-            // 注释部分是为了兼容claude code，但是不兼容cherry studio
-            // 1. 处理 role (对应 message_start) 
-            // if (delta?.role === "assistant") {
-            //     events.push({
-            //         type: "message_start",
-            //         message: {
-            //             id: openaiChunk.id || `msg_${uuidv4()}`,
-            //             type: "message",
-            //             role: "assistant",
-            //             content: [],
-            //             model: model || openaiChunk.model || "unknown",
-            //             stop_reason: null,
-            //             stop_sequence: null,
-            //             usage: {
-            //                 input_tokens: openaiChunk.usage?.prompt_tokens || 0,
-            //                 output_tokens: 0
-            //             }
-            //         }
-            //     });
-            //     events.push({
-            //         type: "content_block_start",
-            //         index: 0,
-            //         content_block: {
-            //             type: "text",
-            //             text: ""
-            //         }
-            //     });
-            // }
-
-            // 2. 处理 tool_calls (对应 content_block_start 和 content_block_delta)
-            // if (delta?.tool_calls) {
-            //     const toolCalls = delta.tool_calls;
-            //     for (const toolCall of toolCalls) {
-            //         // 如果有 function.name，说明是工具调用开始
-            //         if (toolCall.function?.name) {
-            //             events.push({
-            //                 type: "content_block_start",
-            //                 index: toolCall.index || 0,
-            //                 content_block: {
-            //                     type: "tool_use",
-            //                     id: toolCall.id || `tool_${uuidv4()}`,
-            //                     name: toolCall.function.name,
-            //                     input: {}
-            //                 }
-            //             });
-            //         }
-
-            //         // 如果有 function.arguments，说明是参数增量
-            //         if (toolCall.function?.arguments) {
-            //             events.push({
-            //                 type: "content_block_delta",
-            //                 index: toolCall.index || 0,
-            //                 delta: {
-            //                     type: "input_json_delta",
-            //                     partial_json: toolCall.function.arguments
-            //                 }
-            //             });
-            //         }
-            //     }
-            // }
-
-            // 3. 处理 reasoning_content (对应 thinking 类型的 content_block)
-            if (delta?.reasoning_content) {
-                // 注意：这里可能需要先发送 content_block_start，但由于状态管理复杂，
-                // 我们假设调用方会处理这个逻辑
-                events.push({
-                    type: "content_block_delta",
-                    index: 0,
-                    delta: {
-                        type: "thinking_delta",
-                        thinking: delta.reasoning_content
-                    }
-                });
-            }
-
-            // 4. 处理普通文本 content (对应 text 类型的 content_block)
-            if (delta?.content) {
-                events.push({
-                    type: "content_block_delta",
-                    index: 0,
-                    delta: {
-                        type: "text_delta",
-                        text: delta.content
-                    }
-                });
-            }
-
-            // 5. 处理 finish_reason (对应 message_delta 和 message_stop)
-            if (finishReason) {
-                // 映射 finish_reason
-                const stopReason = finishReason === "stop" ? "end_turn" :
-                    finishReason === "length" ? "max_tokens" :
-                        "end_turn";
-
-                events.push({
-                    type: "content_block_stop",
-                    index: 0
-                });
-                // 发送 message_delta
-                events.push({
-                    type: "message_delta",
-                    delta: {
-                        stop_reason: stopReason,
-                        stop_sequence: null
-                    },
-                    usage: {
-                        input_tokens: openaiChunk.usage?.prompt_tokens || 0,
-                        cache_creation_input_tokens: 0,
-                        cache_read_input_tokens: openaiChunk.usage?.prompt_tokens_details?.cached_tokens || 0,
-                        output_tokens: openaiChunk.usage?.completion_tokens || 0
-                    }
-                });
-
-                // 发送 message_stop
-                events.push({
-                    type: "message_stop"
-                });
-            }
-
-            return events.length > 0 ? events : null;
-        }
-
-        // 向后兼容：处理字符串格式
-        if (typeof openaiChunk === 'string') {
-            return {
-                type: "content_block_delta",
-                index: 0,
-                delta: {
-                    type: "text_delta",
-                    text: openaiChunk
-                }
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * OpenAI模型列表 -> Claude模型列表
-     */
-    toClaudeModelList(openaiModels) {
-        return {
-            models: openaiModels.data.map(m => ({
-                name: m.id,
-                description: "",
-            })),
-        };
-    }
-
-    /**
-     * 将 OpenAI 模型列表转换为 Gemini 模型列表
-     */
-    toGeminiModelList(openaiModels) {
-        const models = openaiModels.data || [];
-        return {
-            models: models.map(m => ({
-                name: `models/${m.id}`,
-                version: m.version || "1.0.0",
-                displayName: m.displayName || m.id,
-                description: m.description || `A generative model for text and chat generation. ID: ${m.id}`,
-                inputTokenLimit: m.inputTokenLimit || OPENAI_DEFAULT_INPUT_TOKEN_LIMIT,
-                outputTokenLimit: m.outputTokenLimit || OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT,
-                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
-            }))
-        };
-    }
-
-    /**
-     * 构建Claude工具选择
-     */
-    buildClaudeToolChoice(toolChoice) {
-        if (typeof toolChoice === 'string') {
-            const mapping = { auto: 'auto', none: 'none', required: 'any' };
-            return { type: mapping[toolChoice] };
-        }
-        if (typeof toolChoice === 'object') {
-            // Claude 原生格式：{ type, name }
-            if (toolChoice.type && toolChoice.name) {
-                return { type: toolChoice.type, name: toolChoice.name };
-            }
-            // OpenAI 格式：{ function: { name } }
-            if (toolChoice.function) {
-                return { type: 'tool', name: toolChoice.function.name };
-            }
-        }
-        return undefined;
-    }
-
-    // =========================================================================
-    // OpenAI -> Gemini 转换
-    // =========================================================================
-
-    // Gemini Openai thought signature constant
-    static GEMINI_OPENAI_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
-    /**
-     * OpenAI请求 -> Gemini请求
-     */
-    toGeminiRequest(openaiRequest) {
-        const messages = openaiRequest.messages || [];
-        const model = openaiRequest.model || '';
-        
-        // 构建 tool_call_id -> function_name 映射
-        const tcID2Name = {};
-        for (const message of messages) {
-            if (message.role === 'assistant' && message.tool_calls) {
-                for (const tc of message.tool_calls) {
-                    if (tc.type === 'function' && tc.id && tc.function?.name) {
-                        tcID2Name[tc.id] = tc.function.name;
-                    }
-                }
-            }
-            // Claude 格式：content 数组中的 tool_use
-            if (message.role === 'assistant' && Array.isArray(message.content)) {
-                for (const item of message.content) {
-                    if (item && item.type === 'tool_use' && item.id && item.name) {
-                        tcID2Name[item.id] = item.name;
-                    }
-                }
-            }
-        }
-
-        // 构建 tool_call_id -> response 映射
-        const toolResponses = {};
-        for (const message of messages) {
-            if (message.role === 'tool' && message.tool_call_id) {
-                toolResponses[message.tool_call_id] = message.content;
-            }
-            // Claude 格式：user content 数组中的 tool_result
-            if (message.role === 'user' && Array.isArray(message.content)) {
-                for (const item of message.content) {
-                    if (item && item.type === 'tool_result' && item.tool_use_id) {
-                        toolResponses[item.tool_use_id] = item.content;
-                    }
-                }
-            }
-        }
-
-        const processedMessages = [];
-        let systemInstruction = null;
-
-        for (let i = 0; i < messages.length; i++) {
-            const message = messages[i];
-            const role = message.role;
-            const content = message.content;
-
-            if (role === 'system' || role === 'developer') {
-                // system -> system_instruction
-                if (messages.length > 1) {
-                    if (typeof content === 'string') {
-                        systemInstruction = {
-                            role: 'user',
-                            parts: [{ text: content }]
-                        };
-                    } else if (Array.isArray(content)) {
-                        const parts = content
-                            .filter(item => item.type === 'text' && item.text)
-                            .map(item => ({ text: item.text }));
-                        if (parts.length > 0) {
-                            systemInstruction = {
-                                role: 'user',
-                                parts: parts
-                            };
-                        }
-                    } else if (typeof content === 'object' && content.type === 'text') {
-                        systemInstruction = {
-                            role: 'user',
-                            parts: [{ text: content.text }]
-                        };
-                    }
-                } else {
-                    // 只有一条 system 消息时，作为 user 消息处理
-                    const node = { role: 'user', parts: [] };
-                    if (typeof content === 'string') {
-                        node.parts.push({ text: content });
-                    } else if (Array.isArray(content)) {
-                        for (const item of content) {
-                            if (item.type === 'text' && item.text) {
-                                node.parts.push({ text: item.text });
-                            }
-                        }
-                    }
-                    if (node.parts.length > 0) {
-                        processedMessages.push(node);
-                    }
-                }
-            } else if (role === 'user') {
-                // user -> user content
-                const node = { role: 'user', parts: [] };
-                if (typeof content === 'string') {
-                    node.parts.push({ text: content });
-                } else if (Array.isArray(content)) {
-                    for (const item of content) {
-                        if (!item) continue;
-                        switch (item.type) {
-                            case 'text':
-                                if (item.text) {
-                                    node.parts.push({ text: item.text });
-                                }
-                                break;
-                            case 'image_url':
-                                if (item.image_url) {
-                                    const imageUrl = typeof item.image_url === 'string'
-                                        ? item.image_url
-                                        : item.image_url.url;
-                                    if (imageUrl && imageUrl.startsWith('data:')) {
-                                        const commaIndex = imageUrl.indexOf(',');
-                                        if (commaIndex > 5) {
-                                            const header = imageUrl.substring(5, commaIndex);
-                                            const semicolonIndex = header.indexOf(';');
-                                            if (semicolonIndex > 0) {
-                                                const mimeType = header.substring(0, semicolonIndex);
-                                                const data = imageUrl.substring(commaIndex + 1);
-                                                node.parts.push({
-                                                    inlineData: {
-                                                        mimeType: mimeType,
-                                                        data: data
-                                                    },
-                                                    thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
-                                                });
-                                            }
-                                        }
-                                    } else if (imageUrl) {
-                                        node.parts.push({
-                                            fileData: {
-                                                mimeType: 'image/jpeg',
-                                                fileUri: imageUrl
-                                            }
-                                        });
-                                    }
-                                }
-                                break;
-                            case 'file':
-                                if (item.file) {
-                                    const filename = item.file.filename || '';
-                                    const fileData = item.file.file_data || '';
-                                    const ext = filename.includes('.')
-                                        ? filename.split('.').pop().toLowerCase()
-                                        : '';
-                                    const mimeTypes = {
-                                        'pdf': 'application/pdf',
-                                        'txt': 'text/plain',
-                                        'html': 'text/html',
-                                        'css': 'text/css',
-                                        'js': 'application/javascript',
-                                        'json': 'application/json',
-                                        'xml': 'application/xml',
-                                        'csv': 'text/csv',
-                                        'md': 'text/markdown',
-                                        'py': 'text/x-python',
-                                        'java': 'text/x-java',
-                                        'c': 'text/x-c',
-                                        'cpp': 'text/x-c++',
-                                        'h': 'text/x-c',
-                                        'hpp': 'text/x-c++',
-                                        'go': 'text/x-go',
-                                        'rs': 'text/x-rust',
-                                        'ts': 'text/typescript',
-                                        'tsx': 'text/typescript',
-                                        'jsx': 'text/javascript',
-                                        'png': 'image/png',
-                                        'jpg': 'image/jpeg',
-                                        'jpeg': 'image/jpeg',
-                                        'gif': 'image/gif',
-                                        'webp': 'image/webp',
-                                        'svg': 'image/svg+xml',
-                                        'mp3': 'audio/mpeg',
-                                        'wav': 'audio/wav',
-                                        'mp4': 'video/mp4',
-                                        'webm': 'video/webm'
-                                    };
-                                    const mimeType = mimeTypes[ext];
-                                    if (mimeType && fileData) {
-                                        node.parts.push({
-                                            inlineData: {
-                                                mimeType: mimeType,
-                                                data: fileData
-                                            }
-                                        });
-                                    }
-                                }
-                                break;
-                        }
-                    }
-                }
-                if (node.parts.length > 0) {
-                    processedMessages.push(node);
-                }
-            } else if (role === 'assistant') {
-                // assistant -> model content
-                const node = { role: 'model', parts: [] };
-                
-                // 处理文本内容
-                const functionCallIds = [];
-                if (typeof content === 'string' && content) {
-                    node.parts.push({ text: content });
-                } else if (Array.isArray(content)) {
-                    for (const item of content) {
-                        if (!item) continue;
-                        if (item.type === 'text' && item.text) {
-                            node.parts.push({ text: item.text });
-                        } else if (item.type === 'tool_use') {
-                            // Claude 格式 tool_use -> Gemini functionCall
-                            const fid = item.id || '';
-                            const fname = item.name || '';
-                            const argsObj = typeof item.input === 'string' ? (() => { try { return JSON.parse(item.input); } catch(e) { return {}; } })() : (item.input || {});
-                            node.parts.push({
-                                functionCall: {
-                                    name: fname,
-                                    args: argsObj
-                                },
-                                thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
-                            });
-                            if (fid) functionCallIds.push(fid);
-                        } else if (item.type === 'image_url' && item.image_url) {
-                            const imageUrl = typeof item.image_url === 'string'
-                                ? item.image_url
-                                : item.image_url.url;
-                            if (imageUrl && imageUrl.startsWith('data:')) {
-                                const commaIndex = imageUrl.indexOf(',');
-                                if (commaIndex > 5) {
-                                    const header = imageUrl.substring(5, commaIndex);
-                                    const semicolonIndex = header.indexOf(';');
-                                    if (semicolonIndex > 0) {
-                                        const mimeType = header.substring(0, semicolonIndex);
-                                        const data = imageUrl.substring(commaIndex + 1);
-                                        node.parts.push({
-                                            inlineData: {
-                                                mimeType: mimeType,
-                                                data: data
-                                            },
-                                            thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                // 处理 OpenAI 格式 tool_calls -> functionCall
-                if (message.tool_calls && Array.isArray(message.tool_calls)) {
-                    for (const tc of message.tool_calls) {
-                        if (tc.type !== 'function') continue;
-                        const fid = tc.id || '';
-                        const fname = tc.function?.name || '';
-                        const fargs = tc.function?.arguments || '{}';
-
-                        let argsObj;
-                        try {
-                            argsObj = typeof fargs === 'string' ? JSON.parse(fargs) : fargs;
-                        } catch (e) {
-                            argsObj = {};
-                        }
-
-                        node.parts.push({
-                            functionCall: {
-                                name: fname,
-                                args: argsObj
-                            },
-                            thoughtSignature: OpenAIConverter.GEMINI_OPENAI_THOUGHT_SIGNATURE
-                        });
-
-                        if (fid) {
-                            functionCallIds.push(fid);
-                        }
-                    }
-                }
-
-                // 添加 model 消息
-                if (node.parts.length > 0) {
-                    processedMessages.push(node);
-                }
-
-                // 添加对应的 functionResponse（作为 user 消息）
-                if (functionCallIds.length > 0) {
-                    const toolNode = { role: 'user', parts: [] };
-                    for (const fid of functionCallIds) {
-                        const name = tcID2Name[fid];
-                        if (name) {
-                            let resp = toolResponses[fid] || '{}';
-                            if (typeof resp !== 'string') {
-                                resp = JSON.stringify(resp);
-                            }
-                            toolNode.parts.push({
-                                functionResponse: {
-                                    name: name,
-                                    response: {
-                                        result: resp
-                                    }
-                                }
-                            });
-                        }
-                    }
-                    if (toolNode.parts.length > 0) {
-                        processedMessages.push(toolNode);
-                    }
-                }
-            } else if (role === 'tool') {
-                // 处理独立的 tool role 消息（OpenAI 格式）
-                // 转换为 Gemini 的 functionResponse 格式
-                const toolNode = { role: 'user', parts: [] };
-                
-                // 从 tool_call_id 查找对应的函数名
-                const toolCallId = message.tool_call_id;
-                const functionName = tcID2Name[toolCallId];
-                
-                if (functionName) {
-                    let responseContent = message.content;
-                    if (typeof responseContent !== 'string') {
-                        responseContent = JSON.stringify(responseContent);
-                    }
-                    
-                    toolNode.parts.push({
-                        functionResponse: {
-                            name: functionName,
-                            response: {
-                                result: responseContent
-                            }
-                        }
-                    });
-                    
-                    if (toolNode.parts.length > 0) {
-                        processedMessages.push(toolNode);
-                    }
-                }
-            }
-            // 其他 role 类型跳过
-        }
-
-        // 构建 Gemini 请求
-        const geminiRequest = {
-            contents: processedMessages.filter(item => item.parts && item.parts.length > 0)
-        };
-
-        // 添加 model
-        if (model) {
-            geminiRequest.model = model;
-        }
-
-        // 添加 system_instruction
-        if (systemInstruction) {
-            geminiRequest.system_instruction = systemInstruction;
-        }
-
-        // 处理 reasoning_effort -> thinkingConfig
-        if (openaiRequest.reasoning_effort) {
-            const effort = String(openaiRequest.reasoning_effort).toLowerCase().trim();
-            if (this.modelSupportsThinking(model)) {
-                if (this.isGemini3Model(model)) {
-                    // Gemini 3 模型使用 thinkingLevel
-                    if (effort === 'none') {
-                        // 不添加 thinkingConfig
-                    } else if (effort === 'auto') {
-                        geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                        geminiRequest.generationConfig.thinkingConfig = {
-                            includeThoughts: true
-                        };
-                    } else {
-                        const level = this.validateGemini3ThinkingLevel(model, effort);
-                        if (level) {
-                            geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                            geminiRequest.generationConfig.thinkingConfig = {
-                                thinkingLevel: level
-                            };
-                        }
-                    }
-                } else if (!this.modelUsesThinkingLevels(model)) {
-                    // 使用 thinkingBudget 的模型
-                    geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                    geminiRequest.generationConfig.thinkingConfig = this.applyReasoningEffortToGemini(effort);
-                }
-            }
-        }
-
-        // 处理 extra_body.google.thinking_config（Cherry Studio 扩展）
-        if (!openaiRequest.reasoning_effort && openaiRequest.extra_body?.google?.thinking_config) {
-            const tc = openaiRequest.extra_body.google.thinking_config;
-            if (this.modelSupportsThinking(model) && !this.modelUsesThinkingLevels(model)) {
-                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                geminiRequest.generationConfig.thinkingConfig = geminiRequest.generationConfig.thinkingConfig || {};
-                
-                let setBudget = false;
-                let budget = 0;
-                
-                if (tc.thinkingBudget !== undefined) {
-                    budget = parseInt(tc.thinkingBudget, 10);
-                    geminiRequest.generationConfig.thinkingConfig.thinkingBudget = budget;
-                    setBudget = true;
-                } else if (tc.thinking_budget !== undefined) {
-                    budget = parseInt(tc.thinking_budget, 10);
-                    geminiRequest.generationConfig.thinkingConfig.thinkingBudget = budget;
-                    setBudget = true;
-                }
-                
-                if (tc.includeThoughts !== undefined) {
-                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = tc.includeThoughts;
-                } else if (tc.include_thoughts !== undefined) {
-                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = tc.include_thoughts;
-                } else if (setBudget && budget !== 0) {
-                    geminiRequest.generationConfig.thinkingConfig.includeThoughts = true;
-                }
-            }
-        }
-
-        // 处理 modalities -> responseModalities
-        if (openaiRequest.modalities && Array.isArray(openaiRequest.modalities)) {
-            const responseMods = [];
-            for (const m of openaiRequest.modalities) {
-                const mod = String(m).toLowerCase();
-                if (mod === 'text') {
-                    responseMods.push('TEXT');
-                } else if (mod === 'image') {
-                    responseMods.push('IMAGE');
-                }
-            }
-            if (responseMods.length > 0) {
-                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                geminiRequest.generationConfig.responseModalities = responseMods;
-            }
-        }
-
-        // 处理 image_config（OpenRouter 风格）
-        if (openaiRequest.image_config) {
-            const imgCfg = openaiRequest.image_config;
-            if (imgCfg.aspect_ratio) {
-                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                geminiRequest.generationConfig.imageConfig = geminiRequest.generationConfig.imageConfig || {};
-                geminiRequest.generationConfig.imageConfig.aspectRatio = imgCfg.aspect_ratio;
-            }
-            if (imgCfg.image_size) {
-                geminiRequest.generationConfig = geminiRequest.generationConfig || {};
-                geminiRequest.generationConfig.imageConfig = geminiRequest.generationConfig.imageConfig || {};
-                geminiRequest.generationConfig.imageConfig.imageSize = imgCfg.image_size;
-            }
-        }
-
-        // 处理 tools -> functionDeclarations
-        if (openaiRequest.tools?.length) {
-            const functionDeclarations = [];
-            let hasGoogleSearch = false;
-            
-            for (const t of openaiRequest.tools) {
-                if (!t || typeof t !== 'object') continue;
-                
-                if (t.type === 'function' && t.function) {
-                    const func = t.function;
-                    let fnDecl = {
-                        name: String(func.name || ''),
-                        description: String(func.description || '')
-                    };
-
-                    // 处理 parameters -> parametersJsonSchema
-                    if (func.parameters) {
-                        fnDecl.parametersJsonSchema = cleanJsonSchema(func.parameters);
-                    } else {
-                        fnDecl.parametersJsonSchema = {
-                            type: 'object',
-                            properties: {}
-                        };
-                    }
-
-                    functionDeclarations.push(fnDecl);
-                } else if (t.name) {
-                    functionDeclarations.push({
-                        name: String(t.name),
-                        description: String(t.description || ''),
-                        parametersJsonSchema: cleanJsonSchema(t.input_schema || { type: 'object', properties: {} })
-                    });
-                }
-                
-                // 处�� google_search 工具
-                if (t.google_search) {
-                    hasGoogleSearch = true;
-                }
-            }
-            
-            if (functionDeclarations.length > 0 || hasGoogleSearch) {
-                geminiRequest.tools = [{}];
-                if (functionDeclarations.length > 0) {
-                    geminiRequest.tools[0].functionDeclarations = functionDeclarations;
-                }
-                if (hasGoogleSearch) {
-                    const googleSearchTool = openaiRequest.tools.find(t => t.google_search);
-                    geminiRequest.tools[0].googleSearch = googleSearchTool.google_search;
-                }
-            }
-        }
-
-        // 处理 tool_choice
-        if (openaiRequest.tool_choice) {
-            geminiRequest.toolConfig = this.buildGeminiToolConfig(openaiRequest.tool_choice);
-        }
-
-        // 构建 generationConfig
-        const config = this.buildGeminiGenerationConfig(openaiRequest, model);
-        if (Object.keys(config).length) {
-            geminiRequest.generationConfig = {
-                ...config,
-                ...(geminiRequest.generationConfig || {})
-            };
-        }
-
-        // 添加默认安全设置
-        geminiRequest.safetySettings = this.getDefaultSafetySettings();
-
-        return geminiRequest;
-    }
-
-    /**
-     * 检查模型是否支持 thinking
-     */
-    modelSupportsThinking(model) {
-        if (!model) return false;
-        const m = model.toLowerCase();
-        return m.includes('2.5') || m.includes('thinking') || m.includes('2.0-flash-thinking');
-    }
-
-    /**
-     * 检查是否是 Gemini 3 模型
-     */
-    isGemini3Model(model) {
-        if (!model) return false;
-        const m = model.toLowerCase();
-        return m.includes('gemini-3') || m.includes('gemini3');
-    }
-
-    /**
-     * 检查模型是否使用 thinking levels（而不是 budget）
-     */
-    modelUsesThinkingLevels(model) {
-        if (!model) return false;
-        // Gemini 3 模型使用 levels，其他使用 budget
-        return this.isGemini3Model(model);
-    }
-
-    /**
-     * 验证 Gemini 3 thinking level
-     */
-    validateGemini3ThinkingLevel(model, effort) {
-        const validLevels = ['low', 'medium', 'high'];
-        if (validLevels.includes(effort)) {
-            return effort.toUpperCase();
-        }
-        return null;
-    }
-
-    /**
-     * 将 reasoning_effort 转换为 Gemini thinkingConfig
-     */
-    applyReasoningEffortToGemini(effort) {
-        const effortToBudget = {
-            'low': 1024,
-            'medium': 8192,
-            'high': 24576
-        };
-        const budget = effortToBudget[effort] || effortToBudget['medium'];
-        return {
-            thinkingBudget: budget,
-            includeThoughts: true
-        };
-    }
-
-    /**
-     * 获取默认安全设置
-     */
-    getDefaultSafetySettings() {
-        return [
-            { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
-            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
-            { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
-        ];
-    }
-
-    /**
-     * 处理OpenAI内容到Gemini parts
-     */
-    processOpenAIContentToGeminiParts(content) {
-        if (!content) return [];
-        if (typeof content === 'string') return [{ text: content }];
-
-        if (Array.isArray(content)) {
-            const parts = [];
-
-            for (const item of content) {
-                if (!item) continue;
-
-                if (item.type === 'text' && item.text) {
-                    parts.push({ text: item.text });
-                } else if (item.type === 'image_url' && item.image_url) {
-                    const imageUrl = typeof item.image_url === 'string'
-                        ? item.image_url
-                        : item.image_url.url;
-
-                    if (imageUrl.startsWith('data:')) {
-                        const [header, data] = imageUrl.split(',');
-                        const mimeType = header.match(/data:([^;]+)/)?.[1] || 'image/jpeg';
-                        parts.push({ inlineData: { mimeType, data } });
-                    } else {
-                        parts.push({
-                            fileData: { mimeType: 'image/jpeg', fileUri: imageUrl }
-                        });
-                    }
-                }
-            }
-
-            return parts;
-        }
-
-        return [];
-    }
-
-    /**
-     * 构建Gemini工具配置
-     */
-    buildGeminiToolConfig(toolChoice) {
-        if (typeof toolChoice === 'string' && ['none', 'auto'].includes(toolChoice)) {
-            return { functionCallingConfig: { mode: toolChoice.toUpperCase() } };
-        }
-        if (typeof toolChoice === 'object' && toolChoice.function) {
-            return { functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [toolChoice.function.name] } };
-        }
-        return null;
-    }
-
-    /**
-     * 构建Gemini生成配置
-     */
-    buildGeminiGenerationConfig({ temperature, max_tokens, top_p, stop, tools, response_format }, model) {
-        const config = {};
-        config.temperature = checkAndAssignOrDefault(temperature, GEMINI_DEFAULT_TEMPERATURE);
-        config.maxOutputTokens = checkAndAssignOrDefault(max_tokens, GEMINI_DEFAULT_MAX_TOKENS);
-        config.topP = checkAndAssignOrDefault(top_p, GEMINI_DEFAULT_TOP_P);
-        if (stop !== undefined) config.stopSequences = Array.isArray(stop) ? stop : [stop];
-
-        // Handle response_format
-        if (response_format) {
-            if (response_format.type === 'json_object') {
-                config.responseMimeType = 'application/json';
-            } else if (response_format.type === 'json_schema' && response_format.json_schema) {
-                config.responseMimeType = 'application/json';
-                if (response_format.json_schema.schema) {
-                    config.responseSchema = response_format.json_schema.schema;
-                }
-            }
-        }
-
-        // Gemini 2.5 and thinking models require responseModalities: ["TEXT"]
-        // But this parameter cannot be added when using tools (causes 400 error)
-        const hasTools = tools && Array.isArray(tools) && tools.length > 0;
-        if (!hasTools && model && (model.includes('2.5') || model.includes('thinking') || model.includes('2.0-flash-thinking'))) {
-            logger.info(`[OpenAI->Gemini] Adding responseModalities: ["TEXT"] for model: ${model}`);
-            config.responseModalities = ["TEXT"];
-        } else if (hasTools && model && (model.includes('2.5') || model.includes('thinking') || model.includes('2.0-flash-thinking'))) {
-            logger.info(`[OpenAI->Gemini] Skipping responseModalities for model ${model} because tools are present`);
-        }
-
-        return config;
-    }
-    /**
-     * 将OpenAI响应转换为Gemini响应格式
-     */
-    toGeminiResponse(openaiResponse, model) {
-        if (!openaiResponse || !openaiResponse.choices || !openaiResponse.choices[0]) {
-            return { candidates: [], usageMetadata: {} };
-        }
-
-        const choice = openaiResponse.choices[0];
-        const message = choice.message || {};
-        const parts = [];
-
-        // 处理文本内容
-        if (message.content) {
-            parts.push({ text: message.content });
-        }
-
-        // 处理工具调用
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            for (const toolCall of message.tool_calls) {
-                if (toolCall.type === 'function') {
-                    parts.push({
-                        functionCall: {
-                            name: toolCall.function.name,
-                            args: typeof toolCall.function.arguments === 'string'
-                                ? JSON.parse(toolCall.function.arguments)
-                                : toolCall.function.arguments
-                        }
-                    });
-                }
-            }
-        }
-
-        // 映射finish_reason
-        const finishReasonMap = {
-            'stop': 'STOP',
-            'length': 'MAX_TOKENS',
-            'tool_calls': 'STOP',
-            'content_filter': 'SAFETY'
-        };
-
-        return {
-            candidates: [{
-                content: {
-                    role: 'model',
-                    parts: parts
-                },
-                finishReason: finishReasonMap[choice.finish_reason] || 'STOP'
-            }],
-            usageMetadata: openaiResponse.usage ? {
-                promptTokenCount: openaiResponse.usage.prompt_tokens || 0,
-                candidatesTokenCount: openaiResponse.usage.completion_tokens || 0,
-                totalTokenCount: openaiResponse.usage.total_tokens || 0,
-                cachedContentTokenCount: openaiResponse.usage.prompt_tokens_details?.cached_tokens || 0,
-                promptTokensDetails: [{
-                    modality: "TEXT",
-                    tokenCount: openaiResponse.usage.prompt_tokens || 0
-                }],
-                candidatesTokensDetails: [{
-                    modality: "TEXT",
-                    tokenCount: openaiResponse.usage.completion_tokens || 0
-                }],
-                thoughtsTokenCount: openaiResponse.usage.completion_tokens_details?.reasoning_tokens || 0
-            } : {}
-        };
-    }
-
-    /**
-     * 将OpenAI流式响应块转换为Gemini流式响应格式
-     */
-    toGeminiStreamChunk(openaiChunk, model) {
-        if (!openaiChunk || !openaiChunk.choices || !openaiChunk.choices[0]) {
-            return null;
-        }
-
-        const choice = openaiChunk.choices[0];
-        const delta = choice.delta || {};
-        const parts = [];
-
-        // 处理文本内容
-        if (delta.content) {
-            parts.push({ text: delta.content });
-        }
-
-        // 处理工具调用
-        if (delta.tool_calls && delta.tool_calls.length > 0) {
-            for (const toolCall of delta.tool_calls) {
-                if (toolCall.function) {
-                    const functionCall = {
-                        name: toolCall.function.name || '',
-                        args: {}
-                    };
-
-                    if (toolCall.function.arguments) {
-                        try {
-                            functionCall.args = typeof toolCall.function.arguments === 'string'
-                                ? JSON.parse(toolCall.function.arguments)
-                                : toolCall.function.arguments;
-                        } catch (e) {
-                            // 部分参数，保持为字符串
-                            functionCall.args = { partial: toolCall.function.arguments };
-                        }
-                    }
-
-                    parts.push({ functionCall });
-                }
-            }
-        }
-
-        const result = {
-            candidates: [{
-                content: {
-                    role: 'model',
-                    parts: parts
-                }
-            }]
-        };
-        
-        return result;
-    }
-
-    // =========================================================================
-    // OpenAI -> Grok 转换
-    // =========================================================================
-
-    /**
-     * OpenAI请求 -> Grok请求
-     */
-    toGrokRequest(openaiRequest) {
-        // 我们需要 GrokConverter 来处理复杂的仿真逻辑
-        const { ConverterFactory } = (import.meta.url ? { ConverterFactory: null } : { ConverterFactory: null }); // 这是一个占位，实际会从全局获取
-        
-        // 直接返回结构化数据，由 GrokApiService.buildPayload 最终处理
-        // 这样可以保留原始的 messages, tools, tool_choice 以进行高质量仿真
-        return {
-            ...openaiRequest,
-            // 保持原始结构以便 GrokApiService 处理
-            _isConverted: true 
-        };
-    }
-
-    /**
-     * OpenAI响应 -> Grok响应（通常不使用）
-     */
-    toGrokResponse(openaiResponse, model) {
-        return openaiResponse;
-    }
-
-    /**
-     * OpenAI流式响应 -> Grok流式响应（通常不使用）
-     */
-    toGrokStreamChunk(openaiChunk, model) {
-        return openaiChunk;
-    }
-
-    /**
-     * OpenAI模型列表 -> Grok模型列表（通常不使用）
-     */
-    toGrokModelList(openaiModels) {
-        return openaiModels;
-    }
-
-    /**
-     * 将 OpenAI 模型列表转换为 Gemini 模型列表
-     */
-    toCodexRequest(openaiRequest) {
-        return this.codexConverter.toOpenAIRequestToCodexRequest(openaiRequest);
-    }
-
-    /**
-     * 将OpenAI请求转换为OpenAI Responses格式
-     */
-    toOpenAIResponsesRequest(openaiRequest) {
-        const responsesRequest = {
-            model: openaiRequest.model,
-            instructions: '',
-            input: [],
-            stream: openaiRequest.stream || false,
-            max_output_tokens: openaiRequest.max_tokens,
-            temperature: openaiRequest.temperature,
-            top_p: openaiRequest.top_p,
-            parallel_tool_calls: openaiRequest.parallel_tool_calls,
-            tool_choice: openaiRequest.tool_choice
-        };
-
-        const { systemInstruction, nonSystemMessages } = extractSystemMessages(openaiRequest.messages || []);
-
-        if (systemInstruction) {
-            responsesRequest.instructions = extractText(systemInstruction.parts[0].text);
-        }
-
-        if (openaiRequest.reasoning_effort) {
-            responsesRequest.reasoning = {
-                effort: openaiRequest.reasoning_effort
-            };
-        }
-
-        // 转换messages到input
-        for (const msg of nonSystemMessages) {
-            if (msg.role === 'tool') {
-                responsesRequest.input.push({
-                    type: 'function_call_output',
-                    call_id: msg.tool_call_id,
-                    output: msg.content
-                });
-            } else if (msg.role === 'assistant' && msg.tool_calls?.length) {
-                for (const tc of msg.tool_calls) {
-                    responsesRequest.input.push({
-                        type: 'function_call',
-                        call_id: tc.id,
-                        name: tc.function.name,
-                        arguments: tc.function.arguments
-                    });
-                }
-            } else {
-                let content = [];
-                if (typeof msg.content === 'string') {
-                    content.push({
-                        type: msg.role === 'assistant' ? 'output_text' : 'input_text',
-                        text: msg.content
-                    });
-                } else if (Array.isArray(msg.content)) {
-                    msg.content.forEach(c => {
-                        if (c.type === 'text') {
-                            content.push({
-                                type: msg.role === 'assistant' ? 'output_text' : 'input_text',
-                                text: c.text
-                            });
-                        } else if (c.type === 'image_url') {
-                            content.push({
-                                type: 'input_image',
-                                image_url: c.image_url
-                            });
-                        }
-                    });
-                }
-
-                if (content.length > 0) {
-                    responsesRequest.input.push({
-                        type: 'message',
-                        role: msg.role,
-                        content: content
-                    });
-                }
-            }
-        }
-
-        // 处理工具
-        if (openaiRequest.tools) {
-            responsesRequest.tools = openaiRequest.tools.map(t => ({
-                type: t.type || 'function',
-                name: t.function?.name,
-                description: t.function?.description,
-                parameters: t.function?.parameters
-            }));
-        }
-
-        return responsesRequest;
-    }
-
-    /**
-     * 将OpenAI响应转换为OpenAI Responses格式
-     */
-    toOpenAIResponsesResponse(openaiResponse, model) {
-        if (!openaiResponse || !openaiResponse.choices || !openaiResponse.choices[0]) {
-            return {
-                id: `resp_${Date.now()}`,
-                object: 'response',
-                created_at: Math.floor(Date.now() / 1000),
-                status: 'completed',
-                model: model || 'unknown',
-                output: [],
-                usage: {
-                    input_tokens: 0,
-                    output_tokens: 0,
-                    total_tokens: 0
-                }
-            };
-        }
-
-        const choice = openaiResponse.choices[0];
-        const message = choice.message || {};
-        const output = [];
-
-        // 构建message输出
-        const messageContent = [];
-        if (message.content) {
-            messageContent.push({
-                type: 'output_text',
-                text: message.content
-            });
-        }
-
-        output.push({
-            type: 'message',
-            id: `msg_${Date.now()}`,
-            status: 'completed',
-            role: 'assistant',
-            content: messageContent
-        });
-
-        return {
-            id: openaiResponse.id || `resp_${Date.now()}`,
-            object: 'response',
-            created_at: openaiResponse.created || Math.floor(Date.now() / 1000),
-            status: choice.finish_reason === 'stop' ? 'completed' : 'in_progress',
-            model: model || openaiResponse.model || 'unknown',
-            output: output,
-            usage: openaiResponse.usage ? {
-                input_tokens: openaiResponse.usage.prompt_tokens || 0,
-                input_tokens_details: {
-                    cached_tokens: openaiResponse.usage.prompt_tokens_details?.cached_tokens || 0
-                },
-                output_tokens: openaiResponse.usage.completion_tokens || 0,
-                output_tokens_details: {
-                    reasoning_tokens: openaiResponse.usage.completion_tokens_details?.reasoning_tokens || 0
-                },
-                total_tokens: openaiResponse.usage.total_tokens || 0
-            } : {
-                input_tokens: 0,
-                input_tokens_details: {
-                    cached_tokens: 0
-                },
-                output_tokens: 0,
-                output_tokens_details: {
-                    reasoning_tokens: 0
-                },
-                total_tokens: 0
-            }
-        };
-    }
-
-    /**
-     * 将OpenAI流式响应转换为OpenAI Responses流式格式
-     * 参考 ClaudeConverter.toOpenAIResponsesStreamChunk 的实现逻辑
-     */
-    toOpenAIResponsesStreamChunk(openaiChunk, model, requestId = null) {
-        if (!openaiChunk || !openaiChunk.choices || !openaiChunk.choices[0]) {
-            return [];
-        }
-
-        const responseId = requestId || `resp_${uuidv4().replace(/-/g, '')}`;
-        const choice = openaiChunk.choices[0];
-        const delta = choice.delta || {};
-        const events = [];
-
-        // 第一个chunk - role为assistant时调用 getOpenAIResponsesStreamChunkBegin
-        if (delta.role === 'assistant') {
-            events.push(
-                generateResponseCreated(responseId, model || openaiChunk.model || 'unknown'),
-                generateResponseInProgress(responseId),
-                generateOutputItemAdded(responseId),
-                generateContentPartAdded(responseId)
-            );
-        }
-
-        // 处理 reasoning_content（推理内容）
-        if (delta.reasoning_content) {
-            events.push({
-                delta: delta.reasoning_content,
-                item_id: `thinking_${uuidv4().replace(/-/g, '')}`,
-                output_index: 0,
-                sequence_number: 3,
-                type: "response.reasoning_summary_text.delta"
-            });
-        }
-
-        // 处理 tool_calls（工具调用）
-        if (delta.tool_calls && delta.tool_calls.length > 0) {
-            for (const toolCall of delta.tool_calls) {
-                const outputIndex = toolCall.index || 0;
-
-                // 如果有 function.name，说明是工具调用开始
-                if (toolCall.function && toolCall.function.name) {
-                    events.push({
-                        item: {
-                            id: toolCall.id || `call_${uuidv4().replace(/-/g, '')}`,
-                            type: "function_call",
-                            name: toolCall.function.name,
-                            arguments: "",
-                            status: "in_progress"
-                        },
-                        output_index: outputIndex,
-                        sequence_number: 2,
-                        type: "response.output_item.added"
-                    });
-                }
-
-                // 如果有 function.arguments，说明是参数增量
-                if (toolCall.function && toolCall.function.arguments) {
-                    events.push({
-                        delta: toolCall.function.arguments,
-                        item_id: toolCall.id || `call_${uuidv4().replace(/-/g, '')}`,
-                        output_index: outputIndex,
-                        sequence_number: 3,
-                        type: "response.custom_tool_call_input.delta"
-                    });
-                }
-            }
-        }
-
-        // 处理普通文本内容
-        if (delta.content) {
-            events.push({
-                delta: delta.content,
-                item_id: `msg_${uuidv4().replace(/-/g, '')}`,
-                output_index: 0,
-                sequence_number: 3,
-                type: "response.output_text.delta"
-            });
-        }
-
-        // 处理完成状态 - 调用 getOpenAIResponsesStreamChunkEnd
-        if (choice.finish_reason) {
-            events.push(
-                generateOutputTextDone(responseId),
-                generateContentPartDone(responseId),
-                generateOutputItemDone(responseId),
-                generateResponseCompleted(responseId)
-            );
-
-            // 如果有 usage 信息，更新最后一个事件
-            if (openaiChunk.usage && events.length > 0) {
-                const lastEvent = events[events.length - 1];
-                if (lastEvent.response) {
-                    lastEvent.response.usage = {
-                        input_tokens: openaiChunk.usage.prompt_tokens || 0,
-                        input_tokens_details: {
-                            cached_tokens: openaiChunk.usage.prompt_tokens_details?.cached_tokens || 0
-                        },
-                        output_tokens: openaiChunk.usage.completion_tokens || 0,
-                        output_tokens_details: {
-                            reasoning_tokens: openaiChunk.usage.completion_tokens_details?.reasoning_tokens || 0
-                        },
-                        total_tokens: openaiChunk.usage.total_tokens || 0
-                    };
-                }
-            }
-        }
-
-        return events;
-    }
-
-}
-
-export default OpenAIConverter;

src/converters/strategies/OpenAIResponsesConverter.js

@@ -1,1032 +0,0 @@
-/**
- * OpenAI Responses API 转换器
- * 处理 OpenAI Responses API 格式与其他协议之间的转换
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import { BaseConverter } from '../BaseConverter.js';
-import { CodexConverter } from './CodexConverter.js';
-import { MODEL_PROTOCOL_PREFIX } from '../../utils/common.js';
-import {
-    extractAndProcessSystemMessages as extractSystemMessages,
-    extractTextFromMessageContent as extractText,
-    CLAUDE_DEFAULT_MAX_TOKENS,
-    GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
-    GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT
-} from '../utils.js';
-import {
-    generateResponseCreated,
-    generateResponseInProgress,
-    generateOutputItemAdded,
-    generateContentPartAdded,
-    generateOutputTextDone,
-    generateContentPartDone,
-    generateOutputItemDone,
-    generateResponseCompleted
-} from '../../providers/openai/openai-responses-core.mjs';
-
-/**
- * OpenAI Responses API 转换器类
- * 支持 OpenAI Responses 格式与 OpenAI、Claude、Gemini 之间的转换
- */
-export class OpenAIResponsesConverter extends BaseConverter {
-    constructor() {
-        super(MODEL_PROTOCOL_PREFIX.OPENAI_RESPONSES);
-        this.codexConverter = new CodexConverter();
-    }
-
-    // =============================================================================
-    // 请求转换
-    // =============================================================================
-
-    /**
-     * 转换请求到目标协议
-     */
-    convertRequest(data, toProtocol) {
-        switch (toProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiRequest(data);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexRequest(data);
-            case MODEL_PROTOCOL_PREFIX.GROK:
-                return this.toGrokRequest(data);
-            default:
-                throw new Error(`Unsupported target protocol: ${toProtocol}`);
-        }
-    }
-
-    /**
-     * 转换响应到目标协议
-     */
-    convertResponse(data, toProtocol, model) {
-        switch (toProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiResponse(data, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexResponse(data, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${toProtocol}`);
-        }
-    }
-
-    /**
-     * 转换流式响应块到目标协议
-     */
-    convertStreamChunk(chunk, toProtocol, model) {
-        switch (toProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiStreamChunk(chunk, model);
-            case MODEL_PROTOCOL_PREFIX.CODEX:
-                return this.toCodexStreamChunk(chunk, model);
-            default:
-                throw new Error(`Unsupported target protocol: ${toProtocol}`);
-        }
-    }
-
-    /**
-     * 转换模型列表到目标协议
-     */
-    convertModelList(data, targetProtocol) {
-        switch (targetProtocol) {
-            case MODEL_PROTOCOL_PREFIX.OPENAI:
-                return this.toOpenAIModelList(data);
-            case MODEL_PROTOCOL_PREFIX.CLAUDE:
-                return this.toClaudeModelList(data);
-            case MODEL_PROTOCOL_PREFIX.GEMINI:
-                return this.toGeminiModelList(data);
-            default:
-                return data;
-        }
-    }
-
-    // =============================================================================
-    // 转换到 OpenAI 格式
-    // =============================================================================
-
-    /**
-     * 将 OpenAI Responses 请求转换为标准 OpenAI 请求
-     */
-    toOpenAIRequest(responsesRequest) {
-        const openaiRequest = {
-            model: responsesRequest.model,
-            messages: [],
-            stream: responsesRequest.stream || false
-        };
-
-        // 复制其他参数
-        if (responsesRequest.temperature !== undefined) {
-            openaiRequest.temperature = responsesRequest.temperature;
-        }
-        if (responsesRequest.max_output_tokens !== undefined) {
-            openaiRequest.max_tokens = responsesRequest.max_output_tokens;
-        } else if (responsesRequest.max_tokens !== undefined) {
-            openaiRequest.max_tokens = responsesRequest.max_tokens;
-        }
-        if (responsesRequest.top_p !== undefined) {
-            openaiRequest.top_p = responsesRequest.top_p;
-        }
-        if (responsesRequest.parallel_tool_calls !== undefined) {
-            openaiRequest.parallel_tool_calls = responsesRequest.parallel_tool_calls;
-        }
-
-        // OpenAI Responses API 使用 instructions 和 input 字段
-        // 需要转换为标准的 messages 格式
-        if (responsesRequest.instructions) {
-            // instructions 作为系统消息
-            openaiRequest.messages.push({
-                role: 'system',
-                content: responsesRequest.instructions
-            });
-        }
-
-        // input 包含用户消息和历史对话
-        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
-            responsesRequest.input.forEach(item => {
-                const itemType = item.type || (item.role ? 'message' : '');
-                
-                switch (itemType) {
-                    case 'message':
-                        // 提取消息内容
-                        let content = '';
-                        if (Array.isArray(item.content)) {
-                            content = item.content
-                                .filter(c => c.type === 'input_text' || c.type === 'output_text')
-                                .map(c => c.text)
-                                .join('\n');
-                        } else if (typeof item.content === 'string') {
-                            content = item.content;
-                        }
-                        
-                        if (content || (item.role === 'assistant' || item.role === 'developer')) {
-                            openaiRequest.messages.push({
-                                role: item.role === 'developer' ? 'assistant' : item.role,
-                                content: content
-                            });
-                        }
-                        break;
-                    
-                    case 'function_call':
-                        openaiRequest.messages.push({
-                            role: 'assistant',
-                            tool_calls: [{
-                                id: item.call_id,
-                                type: 'function',
-                                function: {
-                                    name: item.name,
-                                    arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments)
-                                }
-                            }]
-                        });
-                        break;
-                    
-                    case 'function_call_output':
-                        openaiRequest.messages.push({
-                            role: 'tool',
-                            tool_call_id: item.call_id,
-                            content: item.output
-                        });
-                        break;
-                }
-            });
-        }
-
-        // 如果有标准的 messages 字段，也支持
-        if (responsesRequest.messages && Array.isArray(responsesRequest.messages)) {
-            responsesRequest.messages.forEach(msg => {
-                openaiRequest.messages.push({
-                    role: msg.role,
-                    content: msg.content
-                });
-            });
-        }
-
-        // 处理工具
-        if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
-            openaiRequest.tools = responsesRequest.tools
-                .map(tool => {
-                    if (tool.type && tool.type !== 'function') {
-                        return null;
-                    }
-                    
-                    const name = tool.name || (tool.function && tool.function.name);
-                    const description = tool.description || (tool.function && tool.function.description);
-                    const parameters = tool.parameters || (tool.function && tool.function.parameters) || tool.parametersJsonSchema || { type: 'object', properties: {} };
-
-                    // 如果没有名称，则该工具无效，稍后过滤掉
-                    if (!name) {
-                        return null;
-                    }
-
-                    return {
-                        type: 'function',
-                        function: {
-                            name: name,
-                            description: description,
-                            parameters: parameters
-                        }
-                    };
-                })
-                .filter(tool => tool !== null);
-        }
-
-        if (responsesRequest.tool_choice) {
-            openaiRequest.tool_choice = responsesRequest.tool_choice;
-        }
-
-        return openaiRequest;
-    }
-
-    /**
-     * 将 OpenAI Responses 响应转换为标准 OpenAI 响应
-     */
-    toOpenAIResponse(responsesResponse, model) {
-        const choices = [];
-        let usage = {
-            prompt_tokens: 0,
-            completion_tokens: 0,
-            total_tokens: 0,
-            prompt_tokens_details: { cached_tokens: 0 },
-            completion_tokens_details: { reasoning_tokens: 0 }
-        };
-
-        if (responsesResponse.output && Array.isArray(responsesResponse.output)) {
-            responsesResponse.output.forEach((item, index) => {
-                if (item.type === 'message') {
-                    const content = item.content
-                        ?.filter(c => c.type === 'output_text')
-                        .map(c => c.text)
-                        .join('') || '';
-                    
-                    choices.push({
-                        index: index,
-                        message: {
-                            role: 'assistant',
-                            content: content
-                        },
-                        finish_reason: responsesResponse.status === 'completed' ? 'stop' : null
-                    });
-                } else if (item.type === 'function_call') {
-                    choices.push({
-                        index: index,
-                        message: {
-                            role: 'assistant',
-                            tool_calls: [{
-                                id: item.call_id,
-                                type: 'function',
-                                function: {
-                                    name: item.name,
-                                    arguments: item.arguments
-                                }
-                            }]
-                        },
-                        finish_reason: 'tool_calls'
-                    });
-                }
-            });
-        }
-
-        if (responsesResponse.usage) {
-            usage = {
-                prompt_tokens: responsesResponse.usage.input_tokens || 0,
-                completion_tokens: responsesResponse.usage.output_tokens || 0,
-                total_tokens: responsesResponse.usage.total_tokens || 0,
-                prompt_tokens_details: {
-                    cached_tokens: responsesResponse.usage.input_tokens_details?.cached_tokens || 0
-                },
-                completion_tokens_details: {
-                    reasoning_tokens: responsesResponse.usage.output_tokens_details?.reasoning_tokens || 0
-                }
-            };
-        }
-
-        return {
-            id: responsesResponse.id || `chatcmpl-${Date.now()}`,
-            object: 'chat.completion',
-            created: responsesResponse.created_at || Math.floor(Date.now() / 1000),
-            model: model || responsesResponse.model,
-            choices: choices.length > 0 ? choices : [{
-                index: 0,
-                message: {
-                    role: 'assistant',
-                    content: ''
-                },
-                finish_reason: 'stop'
-            }],
-            usage: usage
-        };
-    }
-
-    /**
-     * 将 OpenAI Responses 流式块转换为标准 OpenAI 流式块
-     */
-    toOpenAIStreamChunk(responsesChunk, model) {
-        const resId = responsesChunk.response?.id || responsesChunk.id || `chatcmpl-${Date.now()}`;
-        const created = responsesChunk.response?.created_at || responsesChunk.created || Math.floor(Date.now() / 1000);
-        
-        const delta = {};
-        let finish_reason = null;
-
-        if (responsesChunk.type === 'response.output_text.delta') {
-            delta.content = responsesChunk.delta;
-        } else if (responsesChunk.type === 'response.function_call_arguments.delta') {
-            delta.tool_calls = [{
-                index: responsesChunk.output_index || 0,
-                function: {
-                    arguments: responsesChunk.delta
-                }
-            }];
-        } else if (responsesChunk.type === 'response.output_item.added' && responsesChunk.item?.type === 'function_call') {
-            delta.tool_calls = [{
-                index: responsesChunk.output_index || 0,
-                id: responsesChunk.item.call_id,
-                type: 'function',
-                function: {
-                    name: responsesChunk.item.name,
-                    arguments: ''
-                }
-            }];
-        } else if (responsesChunk.type === 'response.completed') {
-            finish_reason = 'stop';
-        }
-
-        return {
-            id: resId,
-            object: 'chat.completion.chunk',
-            created: created,
-            model: model || responsesChunk.response?.model || responsesChunk.model,
-            choices: [{
-                index: 0,
-                delta: delta,
-                finish_reason: finish_reason
-            }]
-        };
-    }
-
-    // =============================================================================
-    // 转换到 Claude 格式
-    // =============================================================================
-
-    /**
-     * 将 OpenAI Responses 请求转换为 Claude 请求
-     */
-    toClaudeRequest(responsesRequest) {
-        const claudeRequest = {
-            model: responsesRequest.model,
-            messages: [],
-            max_tokens: responsesRequest.max_output_tokens || responsesRequest.max_tokens || CLAUDE_DEFAULT_MAX_TOKENS,
-            stream: responsesRequest.stream || false
-        };
-
-        // 处理 instructions 作为系统消息
-        if (responsesRequest.instructions) {
-            claudeRequest.system = responsesRequest.instructions;
-        }
-
-        // 处理 reasoning effort
-        if (responsesRequest.reasoning?.effort) {
-            const effort = String(responsesRequest.reasoning.effort || '').toLowerCase().trim();
-            let budgetTokens = 20000;
-            if (effort === 'low') budgetTokens = 2048;
-            else if (effort === 'medium') budgetTokens = 8192;
-            else if (effort === 'high') budgetTokens = 20000;
-            claudeRequest.thinking = {
-                type: 'enabled',
-                budget_tokens: budgetTokens
-            };
-        }
-
-        // 处理 input 数组中的消息
-        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
-            responsesRequest.input.forEach(item => {
-                const itemType = item.type || (item.role ? 'message' : '');
-                
-                switch (itemType) {
-                    case 'message':
-                        const content = [];
-                        if (Array.isArray(item.content)) {
-                            item.content.forEach(c => {
-                                if (c.type === 'input_text' || c.type === 'output_text') {
-                                    content.push({ type: 'text', text: c.text });
-                                } else if (c.type === 'input_image') {
-                                    const url = c.image_url?.url || c.url;
-                                    if (url && url.startsWith('data:')) {
-                                        const [mediaInfo, data] = url.split(';base64,');
-                                        const mediaType = mediaInfo.replace('data:', '');
-                                        content.push({
-                                            type: 'image',
-                                            source: {
-                                                type: 'base64',
-                                                media_type: mediaType,
-                                                data: data
-                                            }
-                                        });
-                                    }
-                                }
-                            });
-                        } else if (typeof item.content === 'string') {
-                            content.push({ type: 'text', text: item.content });
-                        }
-                        
-                        if (content.length > 0) {
-                            claudeRequest.messages.push({
-                                role: item.role === 'assistant' ? 'assistant' : 'user',
-                                content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
-                            });
-                        }
-                        break;
-                    
-                    case 'function_call':
-                        claudeRequest.messages.push({
-                            role: 'assistant',
-                            content: [{
-                                type: 'tool_use',
-                                id: item.call_id || `toolu_${uuidv4().replace(/-/g, '')}`,
-                                name: item.name,
-                                input: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                            }]
-                        });
-                        break;
-                    
-                    case 'function_call_output':
-                        claudeRequest.messages.push({
-                            role: 'user',
-                            content: [{
-                                type: 'tool_result',
-                                tool_use_id: item.call_id,
-                                content: item.output
-                            }]
-                        });
-                        break;
-                }
-            });
-        }
-
-        // 处理工具
-        if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
-            claudeRequest.tools = responsesRequest.tools.map(tool => ({
-                name: tool.name,
-                description: tool.description,
-                input_schema: tool.parameters || tool.parametersJsonSchema || { type: 'object', properties: {} }
-            }));
-        }
-
-        if (responsesRequest.tool_choice) {
-            if (typeof responsesRequest.tool_choice === 'string') {
-                if (responsesRequest.tool_choice === 'auto') {
-                    claudeRequest.tool_choice = { type: 'auto' };
-                } else if (responsesRequest.tool_choice === 'required') {
-                    claudeRequest.tool_choice = { type: 'any' };
-                }
-            } else if (responsesRequest.tool_choice.type === 'function') {
-                claudeRequest.tool_choice = {
-                    type: 'tool',
-                    name: responsesRequest.tool_choice.function.name
-                };
-            }
-        }
-
-        return claudeRequest;
-    }
-
-    /**
-     * 将 OpenAI Responses 响应转换为 Claude 响应
-     */
-    toClaudeResponse(responsesResponse, model) {
-        const content = [];
-        let stop_reason = 'end_turn';
-
-        if (responsesResponse.output && Array.isArray(responsesResponse.output)) {
-            responsesResponse.output.forEach(item => {
-                if (item.type === 'message') {
-                    const text = item.content
-                        ?.filter(c => c.type === 'output_text')
-                        .map(c => c.text)
-                        .join('') || '';
-                    if (text) {
-                        content.push({ type: 'text', text: text });
-                    }
-                } else if (item.type === 'function_call') {
-                    content.push({
-                        type: 'tool_use',
-                        id: item.call_id,
-                        name: item.name,
-                        input: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                    });
-                    stop_reason = 'tool_use';
-                }
-            });
-        }
-
-        return {
-            id: responsesResponse.id || `msg_${Date.now()}`,
-            type: 'message',
-            role: 'assistant',
-            content: content,
-            model: model || responsesResponse.model,
-            stop_reason: stop_reason,
-            usage: {
-                input_tokens: responsesResponse.usage?.input_tokens || 0,
-                output_tokens: responsesResponse.usage?.output_tokens || 0,
-                total_tokens: responsesResponse.usage?.total_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * 将 OpenAI Responses 流式块转换为 Claude 流式块
-     */
-    toClaudeStreamChunk(responsesChunk, model) {
-        if (responsesChunk.type === 'response.created') {
-            return {
-                type: 'message_start',
-                message: {
-                    id: responsesChunk.response.id,
-                    type: 'message',
-                    role: 'assistant',
-                    content: [],
-                    model: model || responsesChunk.response.model
-                }
-            };
-        }
-
-        if (responsesChunk.type === 'response.output_text.delta') {
-            return {
-                type: 'content_block_delta',
-                index: 0,
-                delta: {
-                    type: 'text_delta',
-                    text: responsesChunk.delta
-                }
-            };
-        }
-
-        if (responsesChunk.type === 'response.function_call_arguments.delta') {
-            return {
-                type: 'content_block_delta',
-                index: responsesChunk.output_index || 0,
-                delta: {
-                    type: 'input_json_delta',
-                    partial_json: responsesChunk.delta
-                }
-            };
-        }
-
-        if (responsesChunk.type === 'response.output_item.added' && responsesChunk.item?.type === 'function_call') {
-            return {
-                type: 'content_block_start',
-                index: responsesChunk.output_index || 0,
-                content_block: {
-                    type: 'tool_use',
-                    id: responsesChunk.item.call_id,
-                    name: responsesChunk.item.name,
-                    input: {}
-                }
-            };
-        }
-
-        if (responsesChunk.type === 'response.completed') {
-            return {
-                type: 'message_stop'
-            };
-        }
-
-        return null;
-    }
-
-    // =============================================================================
-    // 转换到 Gemini 格式
-    // =============================================================================
-
-    /**
-     * 将 OpenAI Responses 请求转换为 Gemini 请求
-     */
-    toGeminiRequest(responsesRequest) {
-        const geminiRequest = {
-            contents: [],
-            generationConfig: {}
-        };
-
-        // 处理 instructions 作为系统指令
-        if (responsesRequest.instructions) {
-            geminiRequest.systemInstruction = {
-                parts: [{
-                    text: responsesRequest.instructions
-                }]
-            };
-        }
-
-        // 处理 input 数组中的消息
-        if (responsesRequest.input && Array.isArray(responsesRequest.input)) {
-            responsesRequest.input.forEach(item => {
-                const itemType = item.type || (item.role ? 'message' : '');
-                
-                switch (itemType) {
-                    case 'message':
-                        const parts = [];
-                        if (Array.isArray(item.content)) {
-                            item.content.forEach(c => {
-                                if (c.type === 'input_text' || c.type === 'output_text') {
-                                    parts.push({ text: c.text });
-                                } else if (c.type === 'input_image') {
-                                    const url = c.image_url?.url || c.url;
-                                    if (url && url.startsWith('data:')) {
-                                        const [mediaInfo, data] = url.split(';base64,');
-                                        const mimeType = mediaInfo.replace('data:', '');
-                                        parts.push({
-                                            inlineData: {
-                                                mimeType: mimeType,
-                                                data: data
-                                            }
-                                        });
-                                    }
-                                }
-                            });
-                        } else if (typeof item.content === 'string') {
-                            parts.push({ text: item.content });
-                        }
-                        
-                        if (parts.length > 0) {
-                            geminiRequest.contents.push({
-                                role: item.role === 'assistant' ? 'model' : 'user',
-                                parts: parts
-                            });
-                        }
-                        break;
-                    
-                    case 'function_call':
-                        geminiRequest.contents.push({
-                            role: 'model',
-                            parts: [{
-                                functionCall: {
-                                    name: item.name,
-                                    args: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                                }
-                            }]
-                        });
-                        break;
-                    
-                    case 'function_call_output':
-                        geminiRequest.contents.push({
-                            role: 'user', // Gemini function response role is user or tool? usually user/model
-                            parts: [{
-                                functionResponse: {
-                                    name: item.name,
-                                    response: { content: item.output }
-                                }
-                            }]
-                        });
-                        break;
-                }
-            });
-        }
-
-        // 设置生成配置
-        if (responsesRequest.temperature !== undefined) {
-            geminiRequest.generationConfig.temperature = responsesRequest.temperature;
-        }
-        if (responsesRequest.max_output_tokens !== undefined) {
-            geminiRequest.generationConfig.maxOutputTokens = responsesRequest.max_output_tokens;
-        } else if (responsesRequest.max_tokens !== undefined) {
-            geminiRequest.generationConfig.maxOutputTokens = responsesRequest.max_tokens;
-        }
-        if (responsesRequest.top_p !== undefined) {
-            geminiRequest.generationConfig.topP = responsesRequest.top_p;
-        }
-
-        // 处理工具
-        if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
-            geminiRequest.tools = [{
-                functionDeclarations: responsesRequest.tools
-                    .filter(tool => !tool.type || tool.type === 'function')
-                    .map(tool => ({
-                        name: tool.name,
-                        description: tool.description,
-                        parameters: tool.parameters || tool.parametersJsonSchema || { type: 'object', properties: {} }
-                    }))
-            }];
-        }
-
-        return geminiRequest;
-    }
-
-    /**
-     * 将 OpenAI Responses 响应转换为 Gemini 响应
-     */
-    toGeminiResponse(responsesResponse, model) {
-        const parts = [];
-        let finishReason = 'STOP';
-
-        if (responsesResponse.output && Array.isArray(responsesResponse.output)) {
-            responsesResponse.output.forEach(item => {
-                if (item.type === 'message') {
-                    const text = item.content
-                        ?.filter(c => c.type === 'output_text')
-                        .map(c => c.text)
-                        .join('') || '';
-                    if (text) {
-                        parts.push({ text: text });
-                    }
-                } else if (item.type === 'function_call') {
-                    parts.push({
-                        functionCall: {
-                            name: item.name,
-                            args: typeof item.arguments === 'string' ? JSON.parse(item.arguments) : item.arguments
-                        }
-                    });
-                }
-            });
-        }
-
-        return {
-            candidates: [{
-                content: {
-                    parts: parts,
-                    role: 'model'
-                },
-                finishReason: finishReason,
-                index: 0
-            }],
-            usageMetadata: {
-                promptTokenCount: responsesResponse.usage?.input_tokens || 0,
-                candidatesTokenCount: responsesResponse.usage?.output_tokens || 0,
-                totalTokenCount: responsesResponse.usage?.total_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * 将 OpenAI Responses 流式块转换为 Gemini 流式块
-     */
-    toGeminiStreamChunk(responsesChunk, model) {
-        if (responsesChunk.type === 'response.output_text.delta') {
-            return {
-                candidates: [{
-                    content: {
-                        parts: [{ text: responsesChunk.delta }],
-                        role: 'model'
-                    },
-                    index: 0
-                }]
-            };
-        }
-
-        if (responsesChunk.type === 'response.function_call_arguments.delta') {
-            // Gemini 不太支持流式 functionCall 参数，这里只能简单映射
-            return {
-                candidates: [{
-                    content: {
-                        parts: [{ 
-                            functionCall: { 
-                                name: '', // 无法在 delta 中获取名称
-                                args: responsesChunk.delta 
-                            } 
-                        }],
-                        role: 'model'
-                    },
-                    index: 0
-                }]
-            };
-        }
-
-        return null;
-    }
-
-    /**
-     * OpenAI Responses → Codex 请求转换
-     */
-    toCodexRequest(responsesRequest) {
-        return this.codexConverter.toOpenAIResponsesToCodexRequest(responsesRequest);
-    }
-
-    /**
-     * OpenAI Responses → Grok 请求转换
-     */
-    toGrokRequest(responsesRequest) {
-        // 先转换为 OpenAI 格式
-        const openaiRequest = this.toOpenAIRequest(responsesRequest);
-        return {
-            ...openaiRequest,
-            _isConverted: true
-        };
-    }
-
-    // =============================================================================
-    // 辅助方法
-    // =============================================================================
-
-    /**
-     * 映射完成原因
-     */
-    mapFinishReason(reason) {
-        const reasonMap = {
-            'stop': 'STOP',
-            'length': 'MAX_TOKENS',
-            'content_filter': 'SAFETY',
-            'end_turn': 'STOP'
-        };
-        return reasonMap[reason] || 'STOP';
-    }
-
-    /**
-     * 将 OpenAI Responses 模型列表转换为标准 OpenAI 模型列表
-     */
-    toOpenAIModelList(responsesModels) {
-        // OpenAI Responses 格式的模型列表已经是标准 OpenAI 格式
-        // 如果输入已经是标准格式,直接返回
-        if (responsesModels.object === 'list' && responsesModels.data) {
-            return responsesModels;
-        }
-
-        // 如果是其他格式,转换为标准格式
-        return {
-            object: "list",
-            data: (responsesModels.models || responsesModels.data || []).map(m => ({
-                id: m.id || m.name,
-                object: "model",
-                created: m.created || Math.floor(Date.now() / 1000),
-                owned_by: m.owned_by || "openai",
-            })),
-        };
-    }
-
-    /**
-     * 将 OpenAI Responses 模型列表转换为 Claude 模型列表
-     */
-    toClaudeModelList(responsesModels) {
-        const models = responsesModels.data || responsesModels.models || [];
-        return {
-            models: models.map(m => ({
-                name: m.id || m.name,
-                description: m.description || "",
-            })),
-        };
-    }
-
-    /**
-     * 将 OpenAI Responses 模型列表转换为 Gemini 模型列表
-     */
-    toGeminiModelList(responsesModels) {
-        const models = responsesModels.data || responsesModels.models || [];
-        return {
-            models: models.map(m => ({
-                name: `models/${m.id || m.name}`,
-                version: m.version || "1.0.0",
-                displayName: m.displayName || m.id || m.name,
-                description: m.description || `A generative model for text and chat generation. ID: ${m.id || m.name}`,
-                inputTokenLimit: m.inputTokenLimit || GEMINI_DEFAULT_INPUT_TOKEN_LIMIT,
-                outputTokenLimit: m.outputTokenLimit || GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT,
-                supportedGenerationMethods: m.supportedGenerationMethods || ["generateContent", "streamGenerateContent"]
-            }))
-        };
-    }
-
-
-    /**
-     * OpenAI Responses → Codex 响应转换 (实际上是 Codex 转 OpenAI Responses)
-     */
-    toCodexResponse(codexResponse, model) {
-        const output = [];
-        const responseData = codexResponse.response || codexResponse;
-
-        if (responseData.output && Array.isArray(responseData.output)) {
-            responseData.output.forEach(item => {
-                if (item.type === 'message' && item.content) {
-                    const content = item.content.map(c => ({
-                        type: c.type === 'output_text' ? 'output_text' : 'input_text',
-                        text: c.text,
-                        annotations: []
-                    }));
-                    output.push({
-                        id: item.id || `msg_${uuidv4().replace(/-/g, '')}`,
-                        type: "message",
-                        role: item.role || "assistant",
-                        status: item.status || "completed",
-                        content: content
-                    });
-                } else if (item.type === 'reasoning') {
-                    output.push({
-                        id: item.id || `rs_${uuidv4().replace(/-/g, '')}`,
-                        type: "reasoning",
-                        status: item.status || "completed",
-                        summary: item.summary || []
-                    });
-                } else if (item.type === 'function_call') {
-                    output.push({
-                        id: item.id || `fc_${uuidv4().replace(/-/g, '')}`,
-                        call_id: item.call_id,
-                        type: "function_call",
-                        name: item.name,
-                        arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments),
-                        status: item.status || "completed"
-                    });
-                }
-            });
-        }
-
-        return {
-            id: responseData.id || `resp_${uuidv4().replace(/-/g, '')}`,
-            object: "response",
-            created_at: responseData.created_at || Math.floor(Date.now() / 1000),
-            model: model || responseData.model,
-            status: responseData.status || "completed",
-            output: output,
-            usage: {
-                input_tokens: responseData.usage?.input_tokens || 0,
-                output_tokens: responseData.usage?.output_tokens || 0,
-                total_tokens: responseData.usage?.total_tokens || 0
-            }
-        };
-    }
-
-    /**
-     * OpenAI Responses → Codex 流式响应转换 (实际上是 Codex 转 OpenAI Responses)
-     */
-    toCodexStreamChunk(codexChunk, model) {
-        const type = codexChunk.type;
-        const resId = codexChunk.response?.id || 'default';
-        const events = [];
-
-        if (type === 'response.created') {
-            events.push(
-                generateResponseCreated(resId, model || codexChunk.response?.model),
-                generateResponseInProgress(resId)
-            );
-            return events;
-        }
-
-        if (type === 'response.reasoning_summary_text.delta') {
-            events.push({
-                type: "response.reasoning_summary_text.delta",
-                response_id: resId,
-                item_id: codexChunk.item_id,
-                output_index: codexChunk.output_index,
-                summary_index: codexChunk.summary_index,
-                delta: codexChunk.delta
-            });
-            return events;
-        }
-
-        if (type === 'response.output_text.delta') {
-            events.push({
-                type: "response.output_text.delta",
-                response_id: resId,
-                item_id: codexChunk.item_id,
-                output_index: codexChunk.output_index,
-                content_index: codexChunk.content_index,
-                delta: codexChunk.delta
-            });
-            return events;
-        }
-
-        if (type === 'response.function_call_arguments.delta') {
-            events.push({
-                type: "response.function_call_arguments.delta",
-                response_id: resId,
-                item_id: codexChunk.item_id,
-                output_index: codexChunk.output_index,
-                delta: codexChunk.delta
-            });
-            return events;
-        }
-
-        if (type === 'response.output_item.added') {
-            events.push({
-                type: "response.output_item.added",
-                response_id: resId,
-                output_index: codexChunk.output_index,
-                item: codexChunk.item
-            });
-            return events;
-        }
-
-        if (type === 'response.completed') {
-            const completedEvent = generateResponseCompleted(resId);
-            completedEvent.response = {
-                ...completedEvent.response,
-                ...codexChunk.response
-            };
-            events.push(completedEvent);
-            return events;
-        }
-
-        // 透传其他 response.* 事件
-        if (type && type.startsWith('response.')) {
-            return [codexChunk];
-        }
-
-        return null;
-    }
-
-}

src/converters/utils.js

@@ -1,369 +0,0 @@
-/**
- * 转换器公共工具函数模块
- * 提供各种协议转换所需的通用辅助函数
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import logger from '../utils/logger.js';
-
-// =============================================================================
-// 常量定义
-// =============================================================================
-
-// 通用默认值
-export const DEFAULT_MAX_TOKENS = 8192;
-export const DEFAULT_TEMPERATURE = 1;
-export const DEFAULT_TOP_P = 0.95;
-
-// =============================================================================
-// OpenAI 相关常量
-// =============================================================================
-export const OPENAI_DEFAULT_MAX_TOKENS = 128000;
-export const OPENAI_DEFAULT_TEMPERATURE = 1;
-export const OPENAI_DEFAULT_TOP_P = 0.95;
-export const OPENAI_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
-export const OPENAI_DEFAULT_OUTPUT_TOKEN_LIMIT = 128000;
-
-// =============================================================================
-// Claude 相关常量
-// =============================================================================
-export const CLAUDE_DEFAULT_MAX_TOKENS = 200000;
-export const CLAUDE_DEFAULT_TEMPERATURE = 1;
-export const CLAUDE_DEFAULT_TOP_P = 0.95;
-
-// =============================================================================
-// Gemini 相关常量
-// =============================================================================
-export const GEMINI_DEFAULT_MAX_TOKENS = 65534;
-export const GEMINI_DEFAULT_TEMPERATURE = 1;
-export const GEMINI_DEFAULT_TOP_P = 0.95;
-export const GEMINI_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
-export const GEMINI_DEFAULT_OUTPUT_TOKEN_LIMIT = 65534;
-
-// =============================================================================
-// OpenAI Responses 相关常量
-// =============================================================================
-export const OPENAI_RESPONSES_DEFAULT_MAX_TOKENS = 128000;
-export const OPENAI_RESPONSES_DEFAULT_TEMPERATURE = 1;
-export const OPENAI_RESPONSES_DEFAULT_TOP_P = 0.95;
-export const OPENAI_RESPONSES_DEFAULT_INPUT_TOKEN_LIMIT = 32768;
-export const OPENAI_RESPONSES_DEFAULT_OUTPUT_TOKEN_LIMIT = 128000;
-
-// =============================================================================
-// 通用辅助函数
-// =============================================================================
-
-/**
- * 判断值是否为 undefined 或 0，并返回默认值
- * @param {*} value - 要检查的值
- * @param {*} defaultValue - 默认值
- * @returns {*} 处理后的值
- */
-export function checkAndAssignOrDefault(value, defaultValue) {
-    if (value !== undefined && value !== 0) {
-        return value;
-    }
-    return defaultValue;
-}
-
-/**
- * 生成唯一ID
- * @param {string} prefix - ID前缀
- * @returns {string} 生成的ID
- */
-export function generateId(prefix = '') {
-    return prefix ? `${prefix}_${uuidv4()}` : uuidv4();
-}
-
-/**
- * 安全解析JSON字符串
- * @param {string} str - JSON字符串
- * @returns {*} 解析后的对象或原始字符串
- */
-export function safeParseJSON(str) {
-    if (!str) {
-        return str;
-    }
-    let cleanedStr = str;
-
-    // 处理可能被截断的转义序列
-    if (cleanedStr.endsWith('\\') && !cleanedStr.endsWith('\\\\')) {
-        cleanedStr = cleanedStr.substring(0, cleanedStr.length - 1);
-    } else if (cleanedStr.endsWith('\\u') || cleanedStr.endsWith('\\u0') || cleanedStr.endsWith('\\u00')) {
-        const idx = cleanedStr.lastIndexOf('\\u');
-        cleanedStr = cleanedStr.substring(0, idx);
-    }
-
-    try {
-        return JSON.parse(cleanedStr || '{}');
-    } catch (e) {
-        return str;
-    }
-}
-
-/**
- * 提取消息内容中的文本
- * @param {string|Array} content - 消息内容
- * @returns {string} 提取的文本
- */
-export function extractTextFromMessageContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return content
-            .filter(part => part.type === 'text' && part.text)
-            .map(part => part.text)
-            .join('\n');
-    }
-    return '';
-}
-
-/**
- * 提取并处理系统消息
- * @param {Array} messages - 消息数组
- * @returns {{systemInstruction: Object|null, nonSystemMessages: Array}}
- */
-export function extractAndProcessSystemMessages(messages) {
-    const systemContents = [];
-    const nonSystemMessages = [];
-
-    for (const message of messages) {
-        if (message.role === 'system') {
-            systemContents.push(extractTextFromMessageContent(message.content));
-        } else {
-            nonSystemMessages.push(message);
-        }
-    }
-
-    let systemInstruction = null;
-    if (systemContents.length > 0) {
-        systemInstruction = {
-            parts: [{
-                text: systemContents.join('\n')
-            }]
-        };
-    }
-    return { systemInstruction, nonSystemMessages };
-}
-
-/**
- * 清理JSON Schema属性（移除Gemini不支持的属性）
- * Google Gemini API 只支持有限的 JSON Schema 属性，不支持以下属性：
- * - exclusiveMinimum, exclusiveMaximum, minimum, maximum
- * - minLength, maxLength, minItems, maxItems
- * - pattern, format, default, const
- * - additionalProperties, $schema, $ref, $id
- * - allOf, anyOf, oneOf, not
- * @param {Object} schema - JSON Schema
- * @returns {Object} 清理后的JSON Schema
- */
-export function cleanJsonSchemaProperties(schema) {
-    if (!schema || typeof schema !== 'object') {
-        return schema;
-    }
-
-    // 如果是数组，递归处理每个元素
-    if (Array.isArray(schema)) {
-        return schema.map(item => cleanJsonSchemaProperties(item));
-    }
-
-    // Gemini 支持的 JSON Schema 属性白名单
-    const allowedKeys = [
-        "type",
-        "description",
-        "properties",
-        "required",
-        "enum",
-        "items",
-        "nullable"
-    ];
-
-    const sanitized = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (allowedKeys.includes(key)) {
-            // 对于需要递归处理的属性
-            if (key === 'properties' && typeof value === 'object' && value !== null) {
-                const cleanProperties = {};
-                for (const [propName, propSchema] of Object.entries(value)) {
-                    cleanProperties[propName] = cleanJsonSchemaProperties(propSchema);
-                }
-                sanitized[key] = cleanProperties;
-            } else if (key === 'items') {
-                sanitized[key] = cleanJsonSchemaProperties(value);
-            } else if (key === 'type') {
-                // Google Gemini API 不支持数组形式的 type (如 ["string", "null"])
-                // 必须是单个字符串，且通常需要大写 (STRING, NUMBER, OBJECT, ARRAY, BOOLEAN, INTEGER)
-                if (Array.isArray(value)) {
-                    // 如果包含 null，设置 nullable 为 true
-                    if (value.includes('null')) {
-                        sanitized.nullable = true;
-                    }
-                    // 取第一个非 null 类型
-                    const actualType = value.find(t => t !== 'null');
-                    if (actualType) {
-                        sanitized[key] = actualType.toUpperCase();
-                    }
-                } else if (typeof value === 'string') {
-                    sanitized[key] = value.toUpperCase();
-                }
-            } else {
-                sanitized[key] = value;
-            }
-        }
-        // 其他属性（如 exclusiveMinimum, minimum, maximum, pattern 等）被忽略
-    }
-
-    return sanitized;
-}
-
-/**
- * 映射结束原因
- * @param {string} reason - 结束原因
- * @param {string} sourceFormat - 源格式
- * @param {string} targetFormat - 目标格式
- * @returns {string} 映射后的结束原因
- */
-export function mapFinishReason(reason, sourceFormat, targetFormat) {
-    const reasonMappings = {
-        openai: {
-            anthropic: {
-                stop: "end_turn",
-                length: "max_tokens",
-                content_filter: "stop_sequence",
-                tool_calls: "tool_use"
-            }
-        },
-        gemini: {
-            anthropic: {
-                STOP: "end_turn",
-                MAX_TOKENS: "max_tokens",
-                SAFETY: "stop_sequence",
-                RECITATION: "stop_sequence",
-                stop: "end_turn",
-                length: "max_tokens",
-                safety: "stop_sequence",
-                recitation: "stop_sequence",
-                other: "end_turn"
-            }
-        }
-    };
-
-    try {
-        return reasonMappings[sourceFormat][targetFormat][reason] || "end_turn";
-    } catch (e) {
-        return "end_turn";
-    }
-}
-
-/**
- * 根据budget_tokens智能判断OpenAI reasoning_effort等级
- * @param {number|null} budgetTokens - Anthropic thinking的budget_tokens值
- * @returns {string} OpenAI reasoning_effort等级
- */
-export function determineReasoningEffortFromBudget(budgetTokens) {
-    if (budgetTokens === null || budgetTokens === undefined) {
-        logger.info("No budget_tokens provided, defaulting to reasoning_effort='high'");
-        return "high";
-    }
-
-    const LOW_THRESHOLD = 50;
-    const HIGH_THRESHOLD = 200;
-
-    logger.debug(`Threshold configuration: low <= ${LOW_THRESHOLD}, medium <= ${HIGH_THRESHOLD}, high > ${HIGH_THRESHOLD}`);
-
-    let effort;
-    if (budgetTokens <= LOW_THRESHOLD) {
-        effort = "low";
-    } else if (budgetTokens <= HIGH_THRESHOLD) {
-        effort = "medium";
-    } else {
-        effort = "high";
-    }
-
-    logger.info(`🎯 Budget tokens ${budgetTokens} -> reasoning_effort '${effort}' (thresholds: low<=${LOW_THRESHOLD}, high<=${HIGH_THRESHOLD})`);
-    return effort;
-}
-
-/**
- * 从OpenAI文本中提取thinking内容
- * @param {string} text - 文本内容
- * @returns {string|Array} 提取后的内容
- */
-export function extractThinkingFromOpenAIText(text) {
-    const thinkingPattern = /<thinking>\s*(.*?)\s*<\/thinking>/gs;
-    const matches = [...text.matchAll(thinkingPattern)];
-
-    const contentBlocks = [];
-    let lastEnd = 0;
-
-    for (const match of matches) {
-        const beforeText = text.substring(lastEnd, match.index).trim();
-        if (beforeText) {
-            contentBlocks.push({
-                type: "text",
-                text: beforeText
-            });
-        }
-
-        const thinkingText = match[1].trim();
-        if (thinkingText) {
-            contentBlocks.push({
-                type: "thinking",
-                thinking: thinkingText
-            });
-        }
-
-        lastEnd = match.index + match[0].length;
-    }
-
-    const afterText = text.substring(lastEnd).trim();
-    if (afterText) {
-        contentBlocks.push({
-            type: "text",
-            text: afterText
-        });
-    }
-
-    if (contentBlocks.length === 0) {
-        return text;
-    }
-
-    if (contentBlocks.length === 1 && contentBlocks[0].type === "text") {
-        return contentBlocks[0].text;
-    }
-
-    return contentBlocks;
-}
-
-// =============================================================================
-// 工具状态管理器（单例模式）
-// =============================================================================
-
-/**
- * 全局工具状态管理器
- */
-class ToolStateManager {
-    constructor() {
-        if (ToolStateManager.instance) {
-            return ToolStateManager.instance;
-        }
-        ToolStateManager.instance = this;
-        this._toolMappings = {};
-        return this;
-    }
-
-    storeToolMapping(funcName, toolId) {
-        this._toolMappings[funcName] = toolId;
-    }
-
-    getToolId(funcName) {
-        return this._toolMappings[funcName] || null;
-    }
-
-    clearMappings() {
-        this._toolMappings = {};
-    }
-}
-
-export const toolStateManager = new ToolStateManager();

src/core/config-manager.js

@@ -1,249 +0,0 @@
-import * as fs from 'fs';
-import { promises as pfs } from 'fs';
-import { INPUT_SYSTEM_PROMPT_FILE, MODEL_PROVIDER } from '../utils/common.js';
-import logger from '../utils/logger.js';
-
-export let CONFIG = {}; // Make CONFIG exportable
-export let PROMPT_LOG_FILENAME = ''; // Make PROMPT_LOG_FILENAME exportable
-
-const ALL_MODEL_PROVIDERS = Object.values(MODEL_PROVIDER);
-
-function normalizeConfiguredProviders(config) {
-    const fallbackProvider = MODEL_PROVIDER.GEMINI_CLI;
-    const dedupedProviders = [];
-
-    const addProvider = (value) => {
-        if (typeof value !== 'string') {
-            return;
-        }
-        const trimmed = value.trim();
-        if (!trimmed) {
-            return;
-        }
-        const matched = ALL_MODEL_PROVIDERS.find((provider) => provider.toLowerCase() === trimmed.toLowerCase());
-        if (!matched) {
-            logger.warn(`[Config Warning] Unknown model provider '${trimmed}'. This entry will be ignored.`);
-            return;
-        }
-        if (!dedupedProviders.includes(matched)) {
-            dedupedProviders.push(matched);
-        }
-    };
-
-    const rawValue = config.MODEL_PROVIDER;
-    if (Array.isArray(rawValue)) {
-        rawValue.forEach((entry) => addProvider(typeof entry === 'string' ? entry : String(entry)));
-    } else if (typeof rawValue === 'string') {
-        rawValue.split(',').forEach(addProvider);
-    } else if (rawValue != null) {
-        addProvider(String(rawValue));
-    }
-
-    if (dedupedProviders.length === 0) {
-        dedupedProviders.push(fallbackProvider);
-    }
-
-    config.DEFAULT_MODEL_PROVIDERS = dedupedProviders;
-    config.MODEL_PROVIDER = dedupedProviders[0];
-}
-
-/**
- * Initializes the server configuration from config.json and command-line arguments.
- * @param {string[]} args - Command-line arguments.
- * @param {string} [configFilePath='configs/config.json'] - Path to the configuration file.
- * @returns {Object} The initialized configuration object.
- */
-export async function initializeConfig(args = process.argv.slice(2), configFilePath = 'configs/config.json') {
-    const defaultConfig = {
-        REQUIRED_API_KEY: "123456",
-        SERVER_PORT: 3000,
-        HOST: '0.0.0.0',
-        MODEL_PROVIDER: MODEL_PROVIDER.GEMINI_CLI,
-        SYSTEM_PROMPT_FILE_PATH: INPUT_SYSTEM_PROMPT_FILE, // Default value
-        SYSTEM_PROMPT_MODE: 'append',
-        PROXY_URL: null, // HTTP/HTTPS/SOCKS5 代理地址，如 http://127.0.0.1:7890 或 socks5://127.0.0.1:1080
-        PROXY_ENABLED_PROVIDERS: [], // 启用代理的提供商列表，如 ['gemini-cli-oauth', 'claude-kiro-oauth']
-        PROMPT_LOG_BASE_NAME: "prompt_log",
-        PROMPT_LOG_MODE: "none",
-        REQUEST_MAX_RETRIES: 3,
-        REQUEST_BASE_DELAY: 1000,
-        CREDENTIAL_SWITCH_MAX_RETRIES: 5, // 坏凭证切换最大重试次数（用于认证错误后切换凭证）
-        CRON_NEAR_MINUTES: 15,
-        CRON_REFRESH_TOKEN: false,
-        LOGIN_EXPIRY: 3600, // 登录过期时间（秒），默认1小时
-        LOGIN_MAX_ATTEMPTS: 5, // 最大失败重试次数
-        LOGIN_LOCKOUT_DURATION: 1800, // 锁定持续时间（秒），默认30分钟
-        LOGIN_MIN_INTERVAL: 5000, // 两次尝试之间的最小间隔（毫秒），默认1秒
-        PROVIDER_POOLS_FILE_PATH: null, // 新增号池配置文件路径
-        MAX_ERROR_COUNT: 10, // 提供商最大错误次数
-        providerFallbackChain: {}, // 跨类型 Fallback 链配置
-        LOG_ENABLED: true,
-        LOG_OUTPUT_MODE: "all",
-        LOG_LEVEL: "info",
-        LOG_DIR: "logs",
-        LOG_INCLUDE_REQUEST_ID: true,
-        LOG_INCLUDE_TIMESTAMP: true,
-        LOG_MAX_FILE_SIZE: 10485760,
-        LOG_MAX_FILES: 10,
-        TLS_SIDECAR_ENABLED: false, // 启用 Go uTLS sidecar（需要编译 tls-sidecar 二进制）
-        TLS_SIDECAR_ENABLED_PROVIDERS: [], // 启用 TLS Sidecar 的提供商列表
-        TLS_SIDECAR_PORT: 9090,     // sidecar 监听端口
-        TLS_SIDECAR_BINARY_PATH: null, // 自定义二进制路径（默认自动搜索）
-        TLS_SIDECAR_PROXY_URL: null    // TLS Sidecar 专用的上游代理地址
-    };
-
-    let currentConfig = { ...defaultConfig };
-
-    try {
-        const configData = fs.readFileSync(configFilePath, 'utf8');
-        const loadedConfig = JSON.parse(configData);
-        Object.assign(currentConfig, loadedConfig);
-        logger.info('[Config] Loaded configuration from configs/config.json');
-    } catch (error) {
-        if (error.code !== 'ENOENT') {
-            logger.error('[Config Error] Failed to load configs/config.json:', error.message);
-        } else {
-            logger.info('[Config] configs/config.json not found, using default configuration.');
-        }
-    }
-
-
-    // CLI argument definitions: { flag, configKey, type, validValues? }
-    // type: 'string' | 'int' | 'bool' | 'enum'
-    const cliArgDefs = [
-        { flag: '--api-key',              configKey: 'REQUIRED_API_KEY',       type: 'string' },
-        { flag: '--log-prompts',          configKey: 'PROMPT_LOG_MODE',        type: 'enum', validValues: ['console', 'file'] },
-        { flag: '--port',                 configKey: 'SERVER_PORT',            type: 'int' },
-        { flag: '--model-provider',       configKey: 'MODEL_PROVIDER',         type: 'string' },
-        { flag: '--system-prompt-file',   configKey: 'SYSTEM_PROMPT_FILE_PATH', type: 'string' },
-        { flag: '--system-prompt-mode',   configKey: 'SYSTEM_PROMPT_MODE',     type: 'enum', validValues: ['overwrite', 'append'] },
-        { flag: '--host',                 configKey: 'HOST',                   type: 'string' },
-        { flag: '--prompt-log-base-name', configKey: 'PROMPT_LOG_BASE_NAME',   type: 'string' },
-        { flag: '--cron-near-minutes',    configKey: 'CRON_NEAR_MINUTES',      type: 'int' },
-        { flag: '--cron-refresh-token',   configKey: 'CRON_REFRESH_TOKEN',     type: 'bool' },
-        { flag: '--provider-pools-file',  configKey: 'PROVIDER_POOLS_FILE_PATH', type: 'string' },
-        { flag: '--max-error-count',      configKey: 'MAX_ERROR_COUNT',        type: 'int' },
-        { flag: '--login-max-attempts',   configKey: 'LOGIN_MAX_ATTEMPTS',     type: 'int' },
-        { flag: '--login-lockout-duration', configKey: 'LOGIN_LOCKOUT_DURATION', type: 'int' },
-        { flag: '--login-min-interval',   configKey: 'LOGIN_MIN_INTERVAL',     type: 'int' },
-    ];
-
-    // Parse command-line arguments using definitions
-    const flagMap = new Map(cliArgDefs.map(def => [def.flag, def]));
-    for (let i = 0; i < args.length; i++) {
-        const def = flagMap.get(args[i]);
-        if (!def) continue;
-
-        if (i + 1 >= args.length) {
-            logger.warn(`[Config Warning] ${def.flag} flag requires a value.`);
-            continue;
-        }
-
-        const rawValue = args[++i];
-        switch (def.type) {
-            case 'string':
-                currentConfig[def.configKey] = rawValue;
-                break;
-            case 'int':
-                currentConfig[def.configKey] = parseInt(rawValue, 10);
-                break;
-            case 'bool':
-                currentConfig[def.configKey] = rawValue.toLowerCase() === 'true';
-                break;
-            case 'enum':
-                if (def.validValues.includes(rawValue)) {
-                    currentConfig[def.configKey] = rawValue;
-                } else {
-                    logger.warn(`[Config Warning] Invalid value for ${def.flag}. Expected one of: ${def.validValues.join(', ')}.`);
-                }
-                break;
-        }
-    }
-
-    normalizeConfiguredProviders(currentConfig);
-
-    if (!currentConfig.SYSTEM_PROMPT_FILE_PATH) {
-        currentConfig.SYSTEM_PROMPT_FILE_PATH = INPUT_SYSTEM_PROMPT_FILE;
-    }
-    currentConfig.SYSTEM_PROMPT_CONTENT = await getSystemPromptFileContent(currentConfig.SYSTEM_PROMPT_FILE_PATH);
-
-    // 加载号池配置
-    if (!currentConfig.PROVIDER_POOLS_FILE_PATH) {
-        currentConfig.PROVIDER_POOLS_FILE_PATH = 'configs/provider_pools.json';
-    }
-    if (currentConfig.PROVIDER_POOLS_FILE_PATH) {
-        try {
-            const poolsData = await pfs.readFile(currentConfig.PROVIDER_POOLS_FILE_PATH, 'utf8');
-            currentConfig.providerPools = JSON.parse(poolsData);
-            logger.info(`[Config] Loaded provider pools from ${currentConfig.PROVIDER_POOLS_FILE_PATH}`);
-        } catch (error) {
-            logger.error(`[Config Error] Failed to load provider pools from ${currentConfig.PROVIDER_POOLS_FILE_PATH}: ${error.message}`);
-            currentConfig.providerPools = {};
-        }
-    } else {
-        currentConfig.providerPools = {};
-    }
-
-    // Set PROMPT_LOG_FILENAME based on the determined config
-    if (currentConfig.PROMPT_LOG_MODE === 'file') {
-        const now = new Date();
-        const pad = (num) => String(num).padStart(2, '0');
-        const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
-        PROMPT_LOG_FILENAME = `${currentConfig.PROMPT_LOG_BASE_NAME}-${timestamp}.log`;
-    } else {
-        PROMPT_LOG_FILENAME = ''; // Clear if not logging to file
-    }
-
-    // Assign to the exported CONFIG
-    Object.assign(CONFIG, currentConfig);
-
-    // Initialize logger
-    logger.initialize({
-        enabled: CONFIG.LOG_ENABLED ?? true,
-        outputMode: CONFIG.LOG_OUTPUT_MODE || "all",
-        logLevel: CONFIG.LOG_LEVEL || "info",
-        logDir: CONFIG.LOG_DIR || "logs",
-        includeRequestId: CONFIG.LOG_INCLUDE_REQUEST_ID ?? true,
-        includeTimestamp: CONFIG.LOG_INCLUDE_TIMESTAMP ?? true,
-        maxFileSize: CONFIG.LOG_MAX_FILE_SIZE || 10485760,
-        maxFiles: CONFIG.LOG_MAX_FILES || 10
-    });
-
-    // Cleanup old logs periodically
-    logger.cleanupOldLogs();
-
-    return CONFIG;
-}
-
-/**
- * Gets system prompt content from the specified file path.
- * @param {string} filePath - Path to the system prompt file.
- * @returns {Promise<string|null>} File content, or null if the file does not exist, is empty, or an error occurs.
- */
-export async function getSystemPromptFileContent(filePath) {
-    try {
-        await pfs.access(filePath, pfs.constants.F_OK);
-    } catch (error) {
-        if (error.code === 'ENOENT') {
-            logger.warn(`[System Prompt] Specified system prompt file not found: ${filePath}`);
-        } else {
-            logger.error(`[System Prompt] Error accessing system prompt file ${filePath}: ${error.message}`);
-        }
-        return null;
-    }
-
-    try {
-        const content = await pfs.readFile(filePath, 'utf8');
-        if (!content.trim()) {
-            return null;
-        }
-        logger.info(`[System Prompt] Loaded system prompt from ${filePath}`);
-        return content;
-    } catch (error) {
-        logger.error(`[System Prompt] Error reading system prompt file ${filePath}: ${error.message}`);
-        return null;
-    }
-}
-
-export { ALL_MODEL_PROVIDERS };
-

src/core/master.js

@@ -1,395 +0,0 @@
-/**
- * 主进程 (Master Process)
- * 
- * 负责管理子进程的生命周期，包括：
- * - 启动子进程
- * - 监控子进程状态
- * - 处理子进程重启请求
- * - 提供 IPC 通信
- * 
- * 使用方式：
- * node src/core/master.js [原有的命令行参数]
- */
-
-import { fork } from 'child_process';
-import logger from '../utils/logger.js';
-import * as http from 'http';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { isRetryableNetworkError } from '../utils/common.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 子进程实例
-let workerProcess = null;
-
-// 子进程状态
-let workerStatus = {
-    pid: null,
-    startTime: null,
-    restartCount: 0,
-    lastRestartTime: null,
-    isRestarting: false
-};
-
-// 配置
-const config = {
-    workerScript: path.join(__dirname, '../services/api-server.js'),
-    maxRestartAttempts: 10,
-    restartDelay: 1000, // 重启延迟（毫秒）
-    masterPort: parseInt(process.env.MASTER_PORT) || 3100, // 主进程管理端口
-    args: process.argv.slice(2) // 传递给子进程的参数
-};
-
-/**
- * 启动子进程
- */
-function startWorker() {
-    if (workerProcess) {
-        logger.info('[Master] Worker process already running, PID:', workerProcess.pid);
-        return;
-    }
-
-    logger.info('[Master] Starting worker process...');
-    logger.info('[Master] Worker script:', config.workerScript);
-    logger.info('[Master] Worker args:', config.args.join(' '));
-
-    workerProcess = fork(config.workerScript, config.args, {
-        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-        env: {
-            ...process.env,
-            IS_WORKER_PROCESS: 'true'
-        }
-    });
-
-    workerStatus.pid = workerProcess.pid;
-    workerStatus.startTime = new Date().toISOString();
-
-    logger.info('[Master] Worker process started, PID:', workerProcess.pid);
-
-    // 监听子进程消息
-    workerProcess.on('message', (message) => {
-        logger.info('[Master] Received message from worker:', message);
-        handleWorkerMessage(message);
-    });
-
-    // 监听子进程退出
-    workerProcess.on('exit', (code, signal) => {
-        logger.info(`[Master] Worker process exited with code ${code}, signal ${signal}`);
-        workerProcess = null;
-        workerStatus.pid = null;
-
-        // 如果不是主动重启导致的退出，尝试自动重启
-        if (!workerStatus.isRestarting && code !== 0) {
-            logger.info('[Master] Worker crashed, attempting auto-restart...');
-            scheduleRestart();
-        }
-    });
-
-    // 监听子进程错误
-    workerProcess.on('error', (error) => {
-        logger.error('[Master] Worker process error:', error.message);
-    });
-}
-
-/**
- * 停止子进程
- * @param {boolean} graceful - 是否优雅关闭
- * @returns {Promise<void>}
- */
-function stopWorker(graceful = true) {
-    return new Promise((resolve) => {
-        if (!workerProcess) {
-            logger.info('[Master] No worker process to stop');
-            resolve();
-            return;
-        }
-
-        logger.info('[Master] Stopping worker process, PID:', workerProcess.pid);
-
-        const timeout = setTimeout(() => {
-            if (workerProcess) {
-                logger.info('[Master] Force killing worker process...');
-                workerProcess.kill('SIGKILL');
-            }
-            resolve();
-        }, 5000); // 5秒超时后强制杀死
-
-        workerProcess.once('exit', () => {
-            clearTimeout(timeout);
-            workerProcess = null;
-            workerStatus.pid = null;
-            logger.info('[Master] Worker process stopped');
-            resolve();
-        });
-
-        if (graceful) {
-            // 发送优雅关闭信号
-            workerProcess.send({ type: 'shutdown' });
-            workerProcess.kill('SIGTERM');
-        } else {
-            workerProcess.kill('SIGKILL');
-        }
-    });
-}
-
-/**
- * 重启子进程
- * @returns {Promise<Object>}
- */
-async function restartWorker() {
-    if (workerStatus.isRestarting) {
-        logger.info('[Master] Restart already in progress');
-        return { success: false, message: 'Restart already in progress' };
-    }
-
-    workerStatus.isRestarting = true;
-    workerStatus.restartCount++;
-    workerStatus.lastRestartTime = new Date().toISOString();
-
-    logger.info('[Master] Restarting worker process...');
-
-    try {
-        await stopWorker(true);
-        
-        // 等待一小段时间确保端口释放
-        await new Promise(resolve => setTimeout(resolve, config.restartDelay));
-        
-        startWorker();
-        workerStatus.isRestarting = false;
-
-        return {
-            success: true,
-            message: 'Worker restarted successfully',
-            pid: workerStatus.pid,
-            restartCount: workerStatus.restartCount
-        };
-    } catch (error) {
-        workerStatus.isRestarting = false;
-        logger.error('[Master] Failed to restart worker:', error.message);
-        return {
-            success: false,
-            message: 'Failed to restart worker: ' + error.message
-        };
-    }
-}
-
-/**
- * 计划重启（用于崩溃后自动重启）
- */
-function scheduleRestart() {
-    if (workerStatus.restartCount >= config.maxRestartAttempts) {
-        logger.error('[Master] Max restart attempts reached, giving up');
-        return;
-    }
-
-    const delay = Math.min(config.restartDelay * Math.pow(2, workerStatus.restartCount), 30000);
-    logger.info(`[Master] Scheduling restart in ${delay}ms...`);
-
-    setTimeout(() => {
-        restartWorker();
-    }, delay);
-}
-
-/**
- * 处理来自子进程的消息
- * @param {Object} message - 消息对象
- */
-function handleWorkerMessage(message) {
-    if (!message || !message.type) return;
-
-    switch (message.type) {
-        case 'ready':
-            logger.info('[Master] Worker is ready');
-            break;
-        case 'restart_request':
-            logger.info('[Master] Worker requested restart');
-            restartWorker();
-            break;
-        case 'status':
-            logger.info('[Master] Worker status:', message.data);
-            break;
-        default:
-            logger.info('[Master] Unknown message type:', message.type);
-    }
-}
-
-/**
- * 获取状态信息
- * @returns {Object}
- */
-function getStatus() {
-    return {
-        master: {
-            pid: process.pid,
-            uptime: process.uptime(),
-            memoryUsage: process.memoryUsage()
-        },
-        worker: {
-            pid: workerStatus.pid,
-            startTime: workerStatus.startTime,
-            restartCount: workerStatus.restartCount,
-            lastRestartTime: workerStatus.lastRestartTime,
-            isRestarting: workerStatus.isRestarting,
-            isRunning: workerProcess !== null
-        }
-    };
-}
-
-/**
- * 创建主进程管理 HTTP 服务器
- */
-function createMasterServer() {
-    const server = http.createServer(async (req, res) => {
-        const url = new URL(req.url, `http://${req.headers.host}`);
-        const path = url.pathname;
-        const method = req.method;
-
-        // 设置 CORS 头
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-
-        if (method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-
-        // 状态端点
-        if (method === 'GET' && path === '/master/status') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(getStatus()));
-            return;
-        }
-
-        // 重启端点
-        if (method === 'POST' && path === '/master/restart') {
-            logger.info('[Master] Restart requested via API');
-            const result = await restartWorker();
-            res.writeHead(result.success ? 200 : 500, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(result));
-            return;
-        }
-
-        // 停止端点
-        if (method === 'POST' && path === '/master/stop') {
-            logger.info('[Master] Stop requested via API');
-            await stopWorker(true);
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, message: 'Worker stopped' }));
-            return;
-        }
-
-        // 启动端点
-        if (method === 'POST' && path === '/master/start') {
-            logger.info('[Master] Start requested via API');
-            if (workerProcess) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ success: false, message: 'Worker already running' }));
-                return;
-            }
-            startWorker();
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ success: true, message: 'Worker started', pid: workerStatus.pid }));
-            return;
-        }
-
-        // 健康检查
-        if (method === 'GET' && path === '/master/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({
-                status: 'healthy',
-                workerRunning: workerProcess !== null,
-                timestamp: new Date().toISOString()
-            }));
-            return;
-        }
-
-        // 404
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not Found' }));
-    });
-
-    server.listen(config.masterPort, () => {
-        logger.info(`[Master] Management server listening on port ${config.masterPort}`);
-        logger.info(`[Master] Available endpoints:`);
-        logger.info(`  GET  /master/status  - Get master and worker status`);
-        logger.info(`  GET  /master/health  - Health check`);
-        logger.info(`  POST /master/restart - Restart worker process`);
-        logger.info(`  POST /master/stop    - Stop worker process`);
-        logger.info(`  POST /master/start   - Start worker process`);
-    });
-
-    return server;
-}
-
-/**
- * 处理进程信号
- */
-function setupSignalHandlers() {
-    // 优雅关闭
-    process.on('SIGTERM', async () => {
-        logger.info('[Master] Received SIGTERM, shutting down...');
-        await stopWorker(true);
-        process.exit(0);
-    });
-
-    process.on('SIGINT', async () => {
-        logger.info('[Master] Received SIGINT, shutting down...');
-        await stopWorker(true);
-        process.exit(0);
-    });
-
-    // 未捕获的异常
-    process.on('uncaughtException', (error) => {
-        logger.error('[Master] Uncaught exception:', error);
-        
-        // 检查是否为可重试的网络错误
-        if (isRetryableNetworkError(error)) {
-            logger.warn('[Master] Network error detected, continuing operation...');
-            return; // 不退出程序，继续运行
-        }
-        
-        // 对于其他严重错误，记录但不退出（由主进程管理子进程）
-        logger.error('[Master] Fatal error detected in master process');
-    });
-
-    process.on('unhandledRejection', (reason, promise) => {
-        logger.error('[Master] Unhandled rejection at:', promise, 'reason:', reason);
-        
-        // 检查是否为可重试的网络错误
-        if (reason && isRetryableNetworkError(reason)) {
-            logger.warn('[Master] Network error in promise rejection, continuing operation...');
-            return; // 不退出程序，继续运行
-        }
-    });
-}
-
-/**
- * 主函数
- */
-async function main() {
-    logger.info('='.repeat(50));
-    logger.info('[Master] AIClient2API Master Process');
-    logger.info('[Master] PID:', process.pid);
-    logger.info('[Master] Node version:', process.version);
-    logger.info('[Master] Working directory:', process.cwd());
-    logger.info('='.repeat(50));
-
-    // 设置信号处理
-    setupSignalHandlers();
-
-    // 创建管理服务器
-    createMasterServer();
-
-    // 启动子进程
-    startWorker();
-}
-
-// 启动主进程
-main().catch(error => {
-    logger.error('[Master] Failed to start:', error);
-    process.exit(1);
-});

src/core/plugin-manager.js

@@ -1,549 +0,0 @@
-/**
- * 插件管理器 - 可插拔插件系统核心
- * 
- * 功能：
- * 1. 插件注册与加载
- * 2. 生命周期管理（init/destroy）
- * 3. 扩展点管理（中间件、路由、钩子）
- * 4. 插件配置管理
- */
-
-import { promises as fs } from 'fs';
-import logger from '../utils/logger.js';
-import { existsSync } from 'fs';
-import path from 'path';
-
-// 插件配置文件路径
-const PLUGINS_CONFIG_FILE = path.join(process.cwd(), 'configs', 'plugins.json');
-
-// 默认禁用的插件列表
-const DEFAULT_DISABLED_PLUGINS = ['api-potluck', 'ai-monitor'];
-
-/**
- * 插件类型常量
- */
-export const PLUGIN_TYPE = {
-    AUTH: 'auth',           // 认证插件，参与认证流程
-    MIDDLEWARE: 'middleware' // 普通中间件，不参与认证
-};
-
-/**
- * 插件接口定义（JSDoc 类型）
- * @typedef {Object} Plugin
- * @property {string} name - 插件名称（唯一标识）
- * @property {string} version - 插件版本
- * @property {string} [description] - 插件描述
- * @property {string} [type] - 插件类型：'auth'（认证插件）或 'middleware'（普通中间件，默认）
- * @property {boolean} [enabled] - 是否启用（默认 true）
- * @property {number} [_priority] - 优先级，数字越小越先执行（默认 100）
- * @property {boolean} [_builtin] - 是否为内置插件（内置插件最后执行）
- * @property {Function} [init] - 初始化钩子 (config) => Promise<void>
- * @property {Function} [destroy] - 销毁钩子 () => Promise<void>
- * @property {Function} [middleware] - 请求中间件 (req, res, requestUrl, config) => Promise<{handled: boolean, data?: Object}>
- * @property {Function} [authenticate] - 认证方法（仅 type='auth' 时有效）(req, res, requestUrl, config) => Promise<{handled: boolean, authorized: boolean|null, error?: Object, data?: Object}>
- * @property {Array<{method: string, path: string|RegExp, handler: Function}>} [routes] - 路由定义
- * @property {string[]} [staticPaths] - 静态文件路径（相对于 static 目录）
- * @property {Object} [hooks] - 钩子函数
- * @property {Function} [hooks.onBeforeRequest] - 请求前钩子 (req, config) => Promise<void>
- * @property {Function} [hooks.onAfterResponse] - 响应后钩子 (req, res, config) => Promise<void>
- * @property {Function} [hooks.onContentGenerated] - 内容生成后钩子 (config) => Promise<void>
- */
-
-/**
- * 插件管理器类
- */
-class PluginManager {
-    constructor() {
-        /** @type {Map<string, Plugin>} */
-        this.plugins = new Map();
-        /** @type {Object} */
-        this.pluginsConfig = { plugins: {} };
-        /** @type {boolean} */
-        this.initialized = false;
-    }
-
-    /**
-     * 加载插件配置文件
-     * 永远生成默认配置，如果本地文件存在则合并，但不覆盖 enabled 字段
-     */
-    async loadConfig() {
-        try {
-            // 1. 永远生成默认配置
-            const defaultConfig = await this.generateDefaultConfig();
-            
-            // 2. 如果本地文件存在，读取并合并
-            if (existsSync(PLUGINS_CONFIG_FILE)) {
-                const content = await fs.readFile(PLUGINS_CONFIG_FILE, 'utf8');
-                const localConfig = JSON.parse(content);
-                
-                // 3. 合并配置：遍历默认配置中的所有插件
-                for (const [pluginName, defaultPluginConfig] of Object.entries(defaultConfig.plugins)) {
-                    const localPluginConfig = localConfig.plugins?.[pluginName];
-                    
-                    if (localPluginConfig) {
-                        // 本地配置存在，合并但保留本地的 enabled 字段
-                        defaultConfig.plugins[pluginName] = {
-                            ...defaultPluginConfig,
-                            ...localPluginConfig,
-                            enabled: localPluginConfig.enabled // 保留本地的 enabled 字段
-                        };
-                    }
-                    // 如果本地配置不存在该插件，使用默认配置
-                }
-            }
-            
-            this.pluginsConfig = defaultConfig;
-            await this.saveConfig();
-        } catch (error) {
-            logger.error('[PluginManager] Failed to load config:', error.message);
-            this.pluginsConfig = { plugins: {} };
-        }
-    }
-
-    /**
-     * 扫描 plugins 目录生成默认配置
-     * @returns {Promise<Object>} 默认插件配置
-     */
-    async generateDefaultConfig() {
-        const defaultConfig = { plugins: {} };
-        const pluginsDir = path.join(process.cwd(), 'src', 'plugins');
-        
-        try {
-            if (!existsSync(pluginsDir)) {
-                return defaultConfig;
-            }
-            
-            const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
-            
-            for (const entry of entries) {
-                if (!entry.isDirectory()) continue;
-                
-                const pluginPath = path.join(pluginsDir, entry.name, 'index.js');
-                if (!existsSync(pluginPath)) continue;
-                
-                try {
-                    // 动态导入插件以获取其元信息
-                    const pluginModule = await import(`file://${pluginPath}`);
-                    const plugin = pluginModule.default || pluginModule;
-                    
-                    if (plugin && plugin.name) {
-                        // 检查是否在默认禁用列表中
-                        const enabled = !DEFAULT_DISABLED_PLUGINS.includes(plugin.name);
-                        defaultConfig.plugins[plugin.name] = {
-                            enabled: enabled,
-                            description: plugin.description || ''
-                        };
-                        logger.info(`[PluginManager] Found plugin for default config: ${plugin.name}`);
-                    }
-                } catch (importError) {
-                    // 如果导入失败，使用目录名作为插件名
-                    // 检查是否在默认禁用列表中
-                    const enabled = !DEFAULT_DISABLED_PLUGINS.includes(entry.name);
-                    defaultConfig.plugins[entry.name] = {
-                        enabled: enabled,
-                        description: ''
-                    };
-                    logger.warn(`[PluginManager] Could not import plugin ${entry.name}, using directory name:`, importError.message);
-                }
-            }
-        } catch (error) {
-            logger.error('[PluginManager] Failed to scan plugins directory:', error.message);
-        }
-        
-        return defaultConfig;
-    }
-
-    /**
-     * 保存插件配置文件
-     */
-    async saveConfig() {
-        try {
-            const dir = path.dirname(PLUGINS_CONFIG_FILE);
-            if (!existsSync(dir)) {
-                await fs.mkdir(dir, { recursive: true });
-            }
-            await fs.writeFile(PLUGINS_CONFIG_FILE, JSON.stringify(this.pluginsConfig, null, 2), 'utf8');
-        } catch (error) {
-            logger.error('[PluginManager] Failed to save config:', error.message);
-        }
-    }
-
-    /**
-     * 注册插件
-     * @param {Plugin} plugin - 插件对象
-     */
-    register(plugin) {
-        if (!plugin.name) {
-            throw new Error('Plugin must have a name');
-        }
-        if (this.plugins.has(plugin.name)) {
-            logger.warn(`[PluginManager] Plugin "${plugin.name}" is already registered, skipping`);
-            return;
-        }
-        this.plugins.set(plugin.name, plugin);
-        logger.info(`[PluginManager] Registered plugin: ${plugin.name} v${plugin.version || '1.0.0'}`);
-    }
-
-    /**
-     * 初始化所有已启用的插件
-     * @param {Object} config - 服务器配置
-     */
-    async initAll(config) {
-        await this.loadConfig();
-        
-        for (const [name, plugin] of this.plugins) {
-            const pluginConfig = this.pluginsConfig.plugins[name] || {};
-            const enabled = pluginConfig.enabled !== false; // 默认启用
-            
-            if (!enabled) {
-                logger.info(`[PluginManager] Plugin "${name}" is disabled, skipping init`);
-                continue;
-            }
-
-            try {
-                if (typeof plugin.init === 'function') {
-                    await plugin.init(config);
-                    logger.info(`[PluginManager] Initialized plugin: ${name}`);
-                }
-                plugin._enabled = true;
-            } catch (error) {
-                logger.error(`[PluginManager] Failed to init plugin "${name}":`, error.message);
-                plugin._enabled = false;
-            }
-        }
-        
-        this.initialized = true;
-    }
-
-    /**
-     * 销毁所有插件
-     */
-    async destroyAll() {
-        for (const [name, plugin] of this.plugins) {
-            if (!plugin._enabled) continue;
-            
-            try {
-                if (typeof plugin.destroy === 'function') {
-                    await plugin.destroy();
-                    logger.info(`[PluginManager] Destroyed plugin: ${name}`);
-                }
-            } catch (error) {
-                logger.error(`[PluginManager] Failed to destroy plugin "${name}":`, error.message);
-            }
-        }
-        this.initialized = false;
-    }
-
-    /**
-     * 检查插件是否启用
-     * @param {string} name - 插件名称
-     * @returns {boolean}
-     */
-    isEnabled(name) {
-        const plugin = this.plugins.get(name);
-        return plugin && plugin._enabled === true;
-    }
-
-    /**
-     * 获取所有启用的插件（按优先级排序）
-     * 优先级数字越小越先执行，内置插件（_builtin: true）最后执行
-     * @returns {Plugin[]}
-     */
-    getEnabledPlugins() {
-        return Array.from(this.plugins.values())
-            .filter(p => p._enabled)
-            .sort((a, b) => {
-                // 内置插件排在最后
-                const aBuiltin = a._builtin ? 1 : 0;
-                const bBuiltin = b._builtin ? 1 : 0;
-                if (aBuiltin !== bBuiltin) return aBuiltin - bBuiltin;
-                
-                // 按优先级排序（数字越小越先执行）
-                const aPriority = a._priority || 100;
-                const bPriority = b._priority || 100;
-                return aPriority - bPriority;
-            });
-    }
-
-    /**
-     * 获取所有认证插件（按优先级排序）
-     * @returns {Plugin[]}
-     */
-    getAuthPlugins() {
-        return this.getEnabledPlugins().filter(p =>
-            p.type === PLUGIN_TYPE.AUTH && typeof p.authenticate === 'function'
-        );
-    }
-
-    /**
-     * 获取所有普通中间件插件（按优先级排序）
-     * @returns {Plugin[]}
-     */
-    getMiddlewarePlugins() {
-        return this.getEnabledPlugins().filter(p =>
-            p.type !== PLUGIN_TYPE.AUTH && typeof p.middleware === 'function'
-        );
-    }
-
-    /**
-     * 执行认证流程
-     * 只有 type='auth' 的插件会参与认证
-     *
-     * 认证插件返回值说明：
-     * - { handled: true } - 请求已被处理（如发送了错误响应），停止后续处理
-     * - { authorized: true, data: {...} } - 认证成功，可附带数据
-     * - { authorized: false } - 认证失败，已发送错误响应
-     * - { authorized: null } - 此插件不处理该请求，继续下一个认证插件
-     *
-     * @param {http.IncomingMessage} req - HTTP 请求
-     * @param {http.ServerResponse} res - HTTP 响应
-     * @param {URL} requestUrl - 解析后的 URL
-     * @param {Object} config - 服务器配置
-     * @returns {Promise<{handled: boolean, authorized: boolean}>}
-     */
-    async executeAuth(req, res, requestUrl, config) {
-        const authPlugins = this.getAuthPlugins();
-        
-        for (const plugin of authPlugins) {
-            try {
-                const result = await plugin.authenticate(req, res, requestUrl, config);
-                
-                if (!result) continue;
-                
-                // 如果请求已被处理（如发送了错误响应），停止执行
-                if (result.handled) {
-                    return { handled: true, authorized: false };
-                }
-                
-                // 如果认证失败，停止执行
-                if (result.authorized === false) {
-                    return { handled: true, authorized: false };
-                }
-                
-                // 如果认证成功，合并数据并返回
-                if (result.authorized === true) {
-                    if (result.data) {
-                        Object.assign(config, result.data);
-                    }
-                    return { handled: false, authorized: true };
-                }
-                
-                // authorized === null 表示此插件不处理，继续下一个
-            } catch (error) {
-                logger.error(`[PluginManager] Auth error in plugin "${plugin.name}":`, error.message);
-            }
-        }
-        
-        // 没有任何认证插件处理，返回未授权
-        return { handled: false, authorized: false };
-    }
-
-    /**
-     * 执行普通中间件
-     * 只有 type!='auth' 的插件会执行
-     *
-     * 中间件返回值说明：
-     * - { handled: true } - 请求已被处理，停止后续处理
-     * - { handled: false, data: {...} } - 继续处理，可附带数据
-     * - null/undefined - 继续执行下一个中间件
-     *
-     * @param {http.IncomingMessage} req - HTTP 请求
-     * @param {http.ServerResponse} res - HTTP 响应
-     * @param {URL} requestUrl - 解析后的 URL
-     * @param {Object} config - 服务器配置
-     * @returns {Promise<{handled: boolean}>}
-     */
-    async executeMiddleware(req, res, requestUrl, config) {
-        const middlewarePlugins = this.getMiddlewarePlugins();
-        
-        for (const plugin of middlewarePlugins) {
-            try {
-                const result = await plugin.middleware(req, res, requestUrl, config);
-                
-                if (!result) continue;
-                
-                // 如果请求已被处理，停止执行
-                if (result.handled) {
-                    return { handled: true };
-                }
-                
-                // 合并数据
-                if (result.data) {
-                    Object.assign(config, result.data);
-                }
-            } catch (error) {
-                logger.error(`[PluginManager] Middleware error in plugin "${plugin.name}":`, error.message);
-            }
-        }
-        
-        return { handled: false };
-    }
-
-    /**
-     * 执行所有插件的路由处理
-     * @param {string} method - HTTP 方法
-     * @param {string} path - 请求路径
-     * @param {http.IncomingMessage} req - HTTP 请求
-     * @param {http.ServerResponse} res - HTTP 响应
-     * @returns {Promise<boolean>} - 是否已处理
-     */
-    async executeRoutes(method, path, req, res) {
-        for (const plugin of this.getEnabledPlugins()) {
-            if (!Array.isArray(plugin.routes)) continue;
-            
-            for (const route of plugin.routes) {
-                const methodMatch = route.method === '*' || route.method.toUpperCase() === method;
-                if (!methodMatch) continue;
-                
-                let pathMatch = false;
-                if (route.path instanceof RegExp) {
-                    pathMatch = route.path.test(path);
-                } else if (typeof route.path === 'string') {
-                    pathMatch = path === route.path || path.startsWith(route.path + '/');
-                }
-                
-                if (pathMatch) {
-                    try {
-                        const handled = await route.handler(method, path, req, res);
-                        if (handled) return true;
-                    } catch (error) {
-                        logger.error(`[PluginManager] Route error in plugin "${plugin.name}":`, error.message);
-                    }
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * 获取所有插件的静态文件路径
-     * @returns {string[]}
-     */
-    getStaticPaths() {
-        const paths = [];
-        for (const plugin of this.getEnabledPlugins()) {
-            if (Array.isArray(plugin.staticPaths)) {
-                paths.push(...plugin.staticPaths);
-            }
-        }
-        return paths;
-    }
-
-    /**
-     * 检查路径是否是插件静态文件
-     * @param {string} path - 请求路径
-     * @returns {boolean}
-     */
-    isPluginStaticPath(path) {
-        const staticPaths = this.getStaticPaths();
-        return staticPaths.some(sp => path === sp || path === '/' + sp);
-    }
-
-    /**
-     * 执行钩子函数
-     * @param {string} hookName - 钩子名称
-     * @param  {...any} args - 钩子参数
-     */
-    async executeHook(hookName, ...args) {
-        for (const plugin of this.getEnabledPlugins()) {
-            if (!plugin.hooks || typeof plugin.hooks[hookName] !== 'function') continue;
-            
-            try {
-                await plugin.hooks[hookName](...args);
-            } catch (error) {
-                logger.error(`[PluginManager] Hook "${hookName}" error in plugin "${plugin.name}":`, error.message);
-            }
-        }
-    }
-
-    /**
-     * 获取插件列表（用于 API）
-     * @returns {Object[]}
-     */
-    getPluginList() {
-        const list = [];
-        for (const [name, plugin] of this.plugins) {
-            const pluginConfig = this.pluginsConfig.plugins[name] || {};
-            list.push({
-                name: plugin.name,
-                version: plugin.version || '1.0.0',
-                description: plugin.description || pluginConfig.description || '',
-                enabled: plugin._enabled === true,
-                hasMiddleware: typeof plugin.middleware === 'function',
-                hasRoutes: Array.isArray(plugin.routes) && plugin.routes.length > 0,
-                hasHooks: plugin.hooks && Object.keys(plugin.hooks).length > 0
-            });
-        }
-        return list;
-    }
-
-    /**
-     * 启用/禁用插件
-     * @param {string} name - 插件名称
-     * @param {boolean} enabled - 是否启用
-     */
-    async setPluginEnabled(name, enabled) {
-        if (!this.pluginsConfig.plugins[name]) {
-            this.pluginsConfig.plugins[name] = {};
-        }
-        this.pluginsConfig.plugins[name].enabled = enabled;
-        await this.saveConfig();
-        
-        const plugin = this.plugins.get(name);
-        if (plugin) {
-            plugin._enabled = enabled;
-        }
-    }
-}
-
-// 单例实例
-const pluginManager = new PluginManager();
-
-/**
- * 自动发现并加载插件
- * 扫描 src/plugins/ 目录下的所有插件
- */
-export async function discoverPlugins() {
-    const pluginsDir = path.join(process.cwd(), 'src', 'plugins');
-    
-    try {
-        if (!existsSync(pluginsDir)) {
-            await fs.mkdir(pluginsDir, { recursive: true });
-            logger.info('[PluginManager] Created plugins directory');
-        }
-        
-        const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
-        
-        for (const entry of entries) {
-            if (!entry.isDirectory()) continue;
-            
-            const pluginPath = path.join(pluginsDir, entry.name, 'index.js');
-            if (!existsSync(pluginPath)) continue;
-            
-            try {
-                // 动态导入插件
-                const pluginModule = await import(`file://${pluginPath}`);
-                const plugin = pluginModule.default || pluginModule;
-                
-                if (plugin && plugin.name) {
-                    pluginManager.register(plugin);
-                }
-            } catch (error) {
-                logger.error(`[PluginManager] Failed to load plugin from ${entry.name}:`, error.message);
-            }
-        }
-    } catch (error) {
-        logger.error('[PluginManager] Failed to discover plugins:', error.message);
-    }
-}
-
-/**
- * 获取插件管理器实例
- * @returns {PluginManager}
- */
-export function getPluginManager() {
-    return pluginManager;
-}
-
-// 导出类和实例
-export { PluginManager, pluginManager };

src/handlers/request-handler.js

@@ -1,271 +0,0 @@
-import deepmerge from 'deepmerge';
-import logger from '../utils/logger.js';
-import { handleError, getClientIp } from '../utils/common.js';
-import { handleUIApiRequests, serveStaticFiles } from '../services/ui-manager.js';
-import { handleAPIRequests } from '../services/api-manager.js';
-import { getApiService, getProviderStatus } from '../services/service-manager.js';
-import { getProviderPoolManager } from '../services/service-manager.js';
-import { MODEL_PROVIDER } from '../utils/common.js';
-import { getRegisteredProviders } from '../providers/adapter.js';
-import { countTokensAnthropic } from '../utils/token-utils.js';
-import { PROMPT_LOG_FILENAME } from '../core/config-manager.js';
-import { getPluginManager } from '../core/plugin-manager.js';
-import { randomUUID } from 'crypto';
-import { handleGrokAssetsProxy } from '../utils/grok-assets-proxy.js';
-
-/**
- * Generate a short unique request ID (8 characters)
- */
-function generateRequestId() {
-    return randomUUID().slice(0, 8);
-}
-
-/**
- * Parse request body as JSON
- */
-function parseRequestBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = '';
-        req.on('data', chunk => { body += chunk.toString(); });
-        req.on('end', () => {
-            try {
-                resolve(body ? JSON.parse(body) : {});
-            } catch (e) {
-                reject(new Error('Invalid JSON in request body'));
-            }
-        });
-        req.on('error', reject);
-    });
-}
-
-/**
- * Main request handler. It authenticates the request, determines the endpoint type,
- * and delegates to the appropriate specialized handler function.
- * @param {Object} config - The server configuration
- * @param {Object} providerPoolManager - The provider pool manager instance
- * @returns {Function} - The request handler function
- */
-export function createRequestHandler(config, providerPoolManager) {
-    return async function requestHandler(req, res) {
-        // Generate unique request ID and set it in logger context
-        const clientIp = getClientIp(req);
-        const requestId = `${clientIp}:${generateRequestId()}`;
-
-        return logger.runWithContext(requestId, async () => {
-            // Deep copy the config for each request to allow dynamic modification
-            const currentConfig = deepmerge({}, config);
-            
-            // 计算当前请求的基础 URL
-            const protocol = req.socket.encrypted || req.headers['x-forwarded-proto'] === 'https' ? 'https' : 'http';
-            const host = req.headers.host;
-            currentConfig.requestBaseUrl = `${protocol}://${host}`;
-            
-            const requestUrl = new URL(req.url, `http://${req.headers.host}`);
-            let path = requestUrl.pathname;
-            const method = req.method;
-
-            try {
-                // Set CORS headers for all requests
-                res.setHeader('Access-Control-Allow-Origin', '*');
-                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
-                res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-goog-api-key, Model-Provider, X-Requested-With, Accept, Origin');
-                res.setHeader('Access-Control-Max-Age', '86400'); // 24 hours cache for preflight
-
-                // Handle CORS preflight requests
-                if (method === 'OPTIONS') {
-                    res.writeHead(204);
-                    res.end();
-                    return;
-                }
-
-                // Serve static files for UI (除了登录页面需要认证)
-                // 检查是否是插件静态文件
-                const pluginManager = getPluginManager();
-                const isPluginStatic = pluginManager.isPluginStaticPath(path);
-                if (path.startsWith('/static/') || path === '/' || path === '/favicon.ico' || path === '/index.html' || path.startsWith('/app/') || path.startsWith('/components/') || path === '/login.html' || isPluginStatic) {
-                    const served = await serveStaticFiles(path, res);
-                    if (served) return;
-                }
-
-                // 执行插件路由
-                const pluginRouteHandled = await pluginManager.executeRoutes(method, path, req, res);
-                if (pluginRouteHandled) return;
-
-                const uiHandled = await handleUIApiRequests(method, path, req, res, currentConfig, providerPoolManager);
-                if (uiHandled) return;
-
-                // logger.info(`\n${new Date().toLocaleString()}`);
-                logger.info(`[Server] Received request: ${req.method} http://${req.headers.host}${req.url}`);
-
-                // Health check endpoint
-                if (method === 'GET' && path === '/health') {
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({
-                        status: 'healthy',
-                        timestamp: new Date().toISOString(),
-                        provider: currentConfig.MODEL_PROVIDER
-                    }));
-                    return true;
-                }
-
-                // Grok assets proxy endpoint
-                if (method === 'GET' && path === '/api/grok/assets') {
-                    await handleGrokAssetsProxy(req, res, currentConfig, providerPoolManager);
-                    return true;
-                }
-
-                // providers health endpoint
-                // url params: provider[string], customName[string], unhealthRatioThreshold[float]
-                // 支持provider, customName过滤记录 
-                // 支持unhealthRatioThreshold控制不健康比例的阈值, 当unhealthyRatio超过阈值返回summaryHealthy: false
-                if (method === 'GET' && path === '/provider_health') {
-                    try {
-                        const provider = requestUrl.searchParams.get('provider');
-                        const customName = requestUrl.searchParams.get('customName');
-                        let unhealthRatioThreshold = requestUrl.searchParams.get('unhealthRatioThreshold');
-                        unhealthRatioThreshold = unhealthRatioThreshold === null ? 0.0001 : parseFloat(unhealthRatioThreshold);
-                        let provideStatus = await getProviderStatus(currentConfig, { provider, customName });
-                        let summaryHealth = true;
-                        if (!isNaN(unhealthRatioThreshold)) {
-                            summaryHealth = provideStatus.unhealthyRatio <= unhealthRatioThreshold;
-                        }
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            timestamp: new Date().toISOString(),
-                            items: provideStatus.providerPoolsSlim,
-                            count: provideStatus.count,
-                            unhealthyCount: provideStatus.unhealthyCount,
-                            unhealthyRatio: provideStatus.unhealthyRatio,
-                            unhealthySummeryMessage: provideStatus.unhealthySummeryMessage,
-                            summaryHealth
-                        }));
-                        return true;
-                    } catch (error) {
-                        logger.info(`[Server] req provider_health error: ${error.message}`);
-                        handleError(res, { statusCode: 500, message: `Failed to get providers health: ${error.message}` }, currentConfig.MODEL_PROVIDER);
-                        return;
-                    }
-                }
-
-
-                // Handle API requests
-                // Allow overriding MODEL_PROVIDER via request header
-                const modelProviderHeader = req.headers['model-provider'];
-                if (modelProviderHeader) {
-                    const registeredProviders = getRegisteredProviders();
-                    if (registeredProviders.includes(modelProviderHeader)) {
-                        currentConfig.MODEL_PROVIDER = modelProviderHeader;
-                        logger.info(`[Config] MODEL_PROVIDER overridden by header to: ${currentConfig.MODEL_PROVIDER}`);
-                    } else {
-                        logger.warn(`[Config] Provider ${modelProviderHeader} in header is not available.`);
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: { message: `Provider ${modelProviderHeader} is not available.` } }));
-                        return;
-                    }
-                }
-                
-                // Check if the first path segment matches a MODEL_PROVIDER and switch if it does
-                const pathSegments = path.split('/').filter(segment => segment.length > 0);
-                
-                if (pathSegments.length > 0) {
-                    const firstSegment = pathSegments[0];
-                    const registeredProviders = getRegisteredProviders();
-                    const isValidProvider = registeredProviders.includes(firstSegment);
-                    const isAutoMode = firstSegment === MODEL_PROVIDER.AUTO;
-
-                    if (firstSegment && (isValidProvider || isAutoMode)) {
-                        currentConfig.MODEL_PROVIDER = firstSegment;
-                        logger.info(`[Config] MODEL_PROVIDER overridden by path segment to: ${currentConfig.MODEL_PROVIDER}`);
-                        pathSegments.shift();
-                        path = '/' + pathSegments.join('/');
-                        requestUrl.pathname = path;
-                    } else if (firstSegment && Object.values(MODEL_PROVIDER).includes(firstSegment)) {
-                        // 如果在 MODEL_PROVIDER 中但没注册适配器，拦截并报错
-                        logger.warn(`[Config] Provider ${firstSegment} is recognized but no adapter is registered.`);
-                        res.writeHead(400, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: { message: `Provider ${firstSegment} is not available.` } }));
-                        return;
-                    } else if (firstSegment && !isValidProvider) {
-                        logger.info(`[Config] Ignoring invalid MODEL_PROVIDER in path segment: ${firstSegment}`);
-                    }
-                }
-
-                // 1. 执行认证流程（只有 type='auth' 的插件参与）
-                const authResult = await pluginManager.executeAuth(req, res, requestUrl, currentConfig);
-                if (authResult.handled) {
-                    // 认证插件已处理请求（如发送了错误响应）
-                    return;
-                }
-                if (!authResult.authorized) {
-                    // 没有认证插件授权，返回 401
-                    res.writeHead(401, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: { message: 'Unauthorized: API key is invalid or missing.' } }));
-                    return;
-                }
-                
-                // 2. 执行普通中间件（type!='auth' 的插件）
-                const middlewareResult = await pluginManager.executeMiddleware(req, res, requestUrl, currentConfig);
-                if (middlewareResult.handled) {
-                    // 中间件已处理请求
-                    return;
-                }
-
-                // Handle count_tokens requests (Anthropic API compatible)
-                if (path.includes('/count_tokens') && method === 'POST') {
-                    try {
-                        const body = await parseRequestBody(req);
-                        logger.info(`[Server] Handling count_tokens request for model: ${body.model}`);
-
-                        // Use common utility method directly
-                        try {
-                            const result = countTokensAnthropic(body);
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify(result));
-                        } catch (tokenError) {
-                            logger.warn(`[Server] Common countTokens failed, falling back: ${tokenError.message}`);
-                            // Last resort: return 0
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ input_tokens: 0 }));
-                        }
-                        return true;
-                    } catch (error) {
-                        logger.error(`[Server] count_tokens error: ${error.message}`);
-                        handleError(res, { statusCode: 500, message: `Failed to count tokens: ${error.message}` }, currentConfig.MODEL_PROVIDER);
-                        return;
-                    }
-                }
-
-                // 获取或选择 API Service 实例
-                let apiService;
-                // try {
-                //     apiService = await getApiService(currentConfig);
-                // } catch (error) {
-                //     handleError(res, { statusCode: 500, message: `Failed to get API service: ${error.message}` }, currentConfig.MODEL_PROVIDER);
-                //     const poolManager = getProviderPoolManager();
-                //     if (poolManager) {
-                //         poolManager.markProviderUnhealthy(currentConfig.MODEL_PROVIDER, {
-                //             uuid: currentConfig.uuid
-                //         });
-                //     }
-                //     return;
-                // }
-
-                try {
-                    // Handle API requests
-                    const apiHandled = await handleAPIRequests(method, path, req, res, currentConfig, apiService, providerPoolManager, PROMPT_LOG_FILENAME);
-                    if (apiHandled) return;
-
-                    // Fallback for unmatched routes
-                    res.writeHead(404, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: { message: 'Not Found' } }));
-                } catch (error) {
-                    handleError(res, error, currentConfig.MODEL_PROVIDER);
-                }
-            } finally {
-                // Clear request context after request is complete
-                logger.clearRequestContext(requestId);
-            }
-        });
-    };
-
-}

src/plugins/ai-monitor/index.js

@@ -1,145 +0,0 @@
-import logger from '../../utils/logger.js';
-
-/**
- * AI 接口监控插件
- * 功能：
- * 1. 捕获 AI 接口的请求参数（转换前和转换后）
- * 2. 捕获 AI 接口的响应结果（转换前和转换后，流式响应聚合输出）
- */
-const aiMonitorPlugin = {
-    name: 'ai-monitor',
-    version: '1.0.0',
-    description: 'AI 接口监控插件 - 捕获请求和响应参数（全链路协议转换监控，流式聚合输出，用于调试和分析）',
-    type: 'middleware',
-    _priority: 100,
-
-    // 用于存储流式响应的中间状态
-    streamCache: new Map(),
-
-    async init(config) {
-        logger.info('[AI Monitor Plugin] Initialized');
-    },
-
-    /**
-     * 中间件：初始化请求上下文
-     */
-    async middleware(req, res, requestUrl, config) {
-        const aiPaths = ['/v1/chat/completions', '/v1/responses', '/v1/messages', '/v1beta/models'];
-        const isAiPath = aiPaths.some(path => requestUrl.pathname.includes(path));
-
-        if (isAiPath && req.method === 'POST') {
-            // 在监控插件中生成请求标识，并存入 config 以供全链路追踪
-            const requestId = Date.now() + Math.random().toString(36).substring(2, 10);
-            config._monitorRequestId = requestId;
-        }
-        
-        return { handled: false };
-    },
-
-    hooks: {
-        /**
-         * 请求转换后的钩子
-         */
-        async onContentGenerated(config) {
-            const { originalRequestBody, processedRequestBody, fromProvider, toProvider, model, _monitorRequestId, isStream } = config;
-            if (!originalRequestBody) return;
-
-            setImmediate(() => {
-                const hasConversion = JSON.stringify(originalRequestBody) !== JSON.stringify(processedRequestBody);
-                logger.info(`[AI Monitor][${_monitorRequestId}] >>> Req Protocol: ${fromProvider}${hasConversion ? ' -> ' + toProvider : ''} | Model: ${model}`);
-                
-                if (hasConversion) {
-                    logger.info(`[AI Monitor][${_monitorRequestId}] [Req Original]: ${JSON.stringify(originalRequestBody)}`);
-                    logger.info(`[AI Monitor][${_monitorRequestId}] [Req Processed]: ${JSON.stringify(processedRequestBody)}`);
-                } else {
-                    logger.info(`[AI Monitor][${_monitorRequestId}] [Req]: ${JSON.stringify(originalRequestBody)}`);
-                }
-            });
-
-            // 处理流式响应的聚合输出
-            if (isStream && _monitorRequestId) {
-                setTimeout(() => {
-                    const cache = aiMonitorPlugin.streamCache.get(_monitorRequestId);
-                    if (cache) {
-                        const hasConversion = JSON.stringify(cache.nativeChunks) !== JSON.stringify(cache.convertedChunks);
-                        logger.info(`[AI Monitor][${_monitorRequestId}] <<< Stream Response Aggregated: ${hasConversion ? cache.toProvider + ' -> ' : ''}${cache.fromProvider}`);
-                        
-                        if (hasConversion) {
-                            logger.info(`[AI Monitor][${_monitorRequestId}] [Res Native Full]: ${JSON.stringify(cache.nativeChunks)}`);
-                            logger.info(`[AI Monitor][${_monitorRequestId}] [Res Converted Full]: ${JSON.stringify(cache.convertedChunks)}`);
-                        } else {
-                            logger.info(`[AI Monitor][${_monitorRequestId}] [Res Full]: ${JSON.stringify(cache.nativeChunks)}`);
-                        }
-                        
-                        aiMonitorPlugin.streamCache.delete(_monitorRequestId);
-                    }
-                }, 2000); // 等待流传输完成
-            }
-        },
-
-        /**
-         * 非流式响应转换监控
-         */
-        async onUnaryResponse({ nativeResponse, clientResponse, fromProvider, toProvider, requestId }) {
-            setImmediate(() => {
-                const reqId = requestId || 'N/A';
-                const hasConversion = JSON.stringify(nativeResponse) !== JSON.stringify(clientResponse);
-                logger.info(`[AI Monitor][${reqId}] <<< Res Protocol: ${hasConversion ? toProvider + ' -> ' : ''}${fromProvider} (Unary)`);
-                
-                if (hasConversion) {
-                    logger.info(`[AI Monitor][${reqId}] [Res Native]: ${JSON.stringify(nativeResponse)}`);
-                    logger.info(`[AI Monitor][${reqId}] [Res Converted]: ${JSON.stringify(clientResponse)}`);
-                } else {
-                    logger.info(`[AI Monitor][${reqId}] [Res]: ${JSON.stringify(nativeResponse)}`);
-                }
-            });
-        },
-
-        /**
-         * 流式响应分块转换监控 - 聚合数据
-         */
-        async onStreamChunk({ nativeChunk, chunkToSend, fromProvider, toProvider, requestId }) {
-            if (!requestId) return;
-
-            if (!aiMonitorPlugin.streamCache.has(requestId)) {
-                aiMonitorPlugin.streamCache.set(requestId, {
-                    nativeChunks: [],
-                    convertedChunks: [],
-                    fromProvider,
-                    toProvider
-                });
-            }
-
-            const cache = aiMonitorPlugin.streamCache.get(requestId);
-            
-            // 过滤 null 值，并判断是否为数组类型
-            if (nativeChunk != null) {
-                if (Array.isArray(nativeChunk)) {
-                    cache.nativeChunks.push(...nativeChunk.filter(item => item != null));
-                } else {
-                    cache.nativeChunks.push(nativeChunk);
-                }
-            }
-            
-            if (chunkToSend != null) {
-                if (Array.isArray(chunkToSend)) {
-                    cache.convertedChunks.push(...chunkToSend.filter(item => item != null));
-                } else {
-                    cache.convertedChunks.push(chunkToSend);
-                }
-            }
-        },
-
-        /**
-         * 内部请求转换监控
-         */
-        async onInternalRequestConverted({ requestId, internalRequest, converterName }) {
-            setImmediate(() => {
-                const reqId = requestId || 'N/A';
-                logger.info(`[AI Monitor][${reqId}] >>> Internal Req Converted [${converterName}]: ${JSON.stringify(internalRequest)}`);
-            });
-        }
-    }
-};
-
-export default aiMonitorPlugin;

src/plugins/api-potluck/api-routes.js

@@ -1,452 +0,0 @@
-/**
- * API 大锅饭 - 管理 API 路由
- * 提供 Key 管理的 RESTful API
- */
-
-import {
-    createKey,
-    listKeys,
-    getKey,
-    deleteKey,
-    updateKeyLimit,
-    resetKeyUsage,
-    toggleKey,
-    updateKeyName,
-    regenerateKey,
-    getStats,
-    validateKey,
-    KEY_PREFIX,
-    applyDailyLimitToAllKeys,
-    getAllKeyIds
-} from './key-manager.js';
-import logger from '../../utils/logger.js';
-
-/**
- * 解析请求体
- * @param {http.IncomingMessage} req
- * @returns {Promise<Object>}
- */
-function parseRequestBody(req) {
-    return new Promise((resolve, reject) => {
-        let body = '';
-        req.on('data', chunk => {
-            body += chunk.toString();
-        });
-        req.on('end', () => {
-            try {
-                resolve(body ? JSON.parse(body) : {});
-            } catch (error) {
-                reject(new Error('JSON 格式无效'));
-            }
-        });
-        req.on('error', reject);
-    });
-}
-
-/**
- * 发送 JSON 响应
- * @param {http.ServerResponse} res
- * @param {number} statusCode
- * @param {Object} data
- */
-function sendJson(res, statusCode, data) {
-    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(data));
-}
-
-/**
- * 验证管理员 Token
- * @param {http.IncomingMessage} req
- * @returns {Promise<boolean>}
- */
-async function checkAdminAuth(req) {
-    const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        return false;
-    }
-    
-    // 动态导入 ui-manager 中的 token 验证逻辑
-    try {
-        const { existsSync, readFileSync } = await import('fs');
-        const { promises: fs } = await import('fs');
-        const path = await import('path');
-        
-        const TOKEN_STORE_FILE = path.join(process.cwd(), 'configs', 'token-store.json');
-        
-        if (!existsSync(TOKEN_STORE_FILE)) {
-            return false;
-        }
-        
-        const content = readFileSync(TOKEN_STORE_FILE, 'utf8');
-        const tokenStore = JSON.parse(content);
-        const token = authHeader.substring(7);
-        const tokenInfo = tokenStore.tokens[token];
-        
-        if (!tokenInfo) {
-            return false;
-        }
-        
-        // 检查是否过期
-        if (Date.now() > tokenInfo.expiryTime) {
-            return false;
-        }
-        
-        return true;
-    } catch (error) {
-        logger.error('[API Potluck] Auth check error:', error.message);
-        return false;
-    }
-}
-
-/**
- * 处理 Potluck 管理 API 请求
- * @param {string} method - HTTP 方法
- * @param {string} path - 请求路径
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @param {http.ServerResponse} res - HTTP 响应对象
- * @returns {Promise<boolean>} - 是否处理了请求
- */
-export async function handlePotluckApiRoutes(method, path, req, res) {
-    // 只处理 /api/potluck 开头的请求
-    if (!path.startsWith('/api/potluck')) {
-        return false;
-    }
-    logger.info('[API Potluck] Handling request:', method, path);
-    
-    // 验证管理员权限
-    const isAuthed = await checkAdminAuth(req);
-    if (!isAuthed) {
-        sendJson(res, 401, { 
-            success: false, 
-            error: { message: '未授权：请先登录', code: 'UNAUTHORIZED' } 
-        });
-        return true;
-    }
-
-    try {
-        // GET /api/potluck/stats - 获取统计信息
-        if (method === 'GET' && path === '/api/potluck/stats') {
-            const stats = await getStats();
-            sendJson(res, 200, { success: true, data: stats });
-            return true;
-        }
-
-        // GET /api/potluck/keys - 获取所有 Key 列表
-        if (method === 'GET' && path === '/api/potluck/keys') {
-            const keys = await listKeys();
-            const stats = await getStats();
-            sendJson(res, 200, { 
-                success: true, 
-                data: { keys, stats } 
-            });
-            return true;
-        }
-
-        // POST /api/potluck/keys/apply-limit - 批量应用每日限额到所有 Key
-        if (method === 'POST' && path === '/api/potluck/keys/apply-limit') {
-            const body = await parseRequestBody(req);
-            const { dailyLimit } = body;
-            
-            if (dailyLimit === undefined || typeof dailyLimit !== 'number' || dailyLimit < 1) {
-                sendJson(res, 400, { success: false, error: { message: 'dailyLimit 必须是一个正数' } });
-                return true;
-            }
-            
-            const result = await applyDailyLimitToAllKeys(dailyLimit);
-            sendJson(res, 200, {
-                success: true,
-                message: `已将每日限额 ${dailyLimit} 应用到 ${result.updated}/${result.total} 个 Key`,
-                data: result
-            });
-            return true;
-        }
-
-        // POST /api/potluck/keys - 创建新 Key
-        if (method === 'POST' && path === '/api/potluck/keys') {
-            const body = await parseRequestBody(req);
-            const { name, dailyLimit } = body;
-            const keyData = await createKey(name, dailyLimit);
-            sendJson(res, 201, {
-                success: true,
-                message: 'API Key 创建成功',
-                data: keyData
-            });
-            return true;
-        }
-
-        // 处理带 keyId 的路由
-        const keyIdMatch = path.match(/^\/api\/potluck\/keys\/([^\/]+)(\/.*)?$/);
-        if (keyIdMatch) {
-            const keyId = decodeURIComponent(keyIdMatch[1]);
-            const subPath = keyIdMatch[2] || '';
-
-            // GET /api/potluck/keys/:keyId - 获取单个 Key 详情
-            if (method === 'GET' && !subPath) {
-                const keyData = await getKey(keyId);
-                if (!keyData) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { success: true, data: keyData });
-                return true;
-            }
-
-            // DELETE /api/potluck/keys/:keyId - 删除 Key
-            if (method === 'DELETE' && !subPath) {
-                const deleted = await deleteKey(keyId);
-                if (!deleted) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { success: true, message: 'Key 删除成功' });
-                return true;
-            }
-
-            // PUT /api/potluck/keys/:keyId/limit - 更新每日限额
-            if (method === 'PUT' && subPath === '/limit') {
-                const body = await parseRequestBody(req);
-                const { dailyLimit } = body;
-                
-                if (typeof dailyLimit !== 'number' || dailyLimit < 0) {
-                    sendJson(res, 400, { 
-                        success: false, 
-                        error: { message: '无效的每日限额值' } 
-                    });
-                    return true;
-                }
-
-                const keyData = await updateKeyLimit(keyId, dailyLimit);
-                if (!keyData) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { 
-                    success: true, 
-                    message: '每日限额更新成功',
-                    data: keyData 
-                });
-                return true;
-            }
-
-            // POST /api/potluck/keys/:keyId/reset - 重置当天调用次数
-            if (method === 'POST' && subPath === '/reset') {
-                const keyData = await resetKeyUsage(keyId);
-                if (!keyData) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { 
-                    success: true, 
-                    message: '使用量重置成功',
-                    data: keyData 
-                });
-                return true;
-            }
-
-            // POST /api/potluck/keys/:keyId/toggle - 切换启用/禁用状态
-            if (method === 'POST' && subPath === '/toggle') {
-                const keyData = await toggleKey(keyId);
-                if (!keyData) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { 
-                    success: true, 
-                    message: `Key 已成功${keyData.enabled ? '启用' : '禁用'}`,
-                    data: keyData 
-                });
-                return true;
-            }
-
-            // PUT /api/potluck/keys/:keyId/name - 更新 Key 名称
-            if (method === 'PUT' && subPath === '/name') {
-                const body = await parseRequestBody(req);
-                const { name } = body;
-                
-                if (!name || typeof name !== 'string') {
-                    sendJson(res, 400, { 
-                        success: false, 
-                        error: { message: '无效的名称值' } 
-                    });
-                    return true;
-                }
-
-                const keyData = await updateKeyName(keyId, name);
-                if (!keyData) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { 
-                    success: true, 
-                    message: '名称更新成功',
-                    data: keyData 
-                });
-                return true;
-            }
-
-            // POST /api/potluck/keys/:keyId/regenerate - 重新生成 Key
-            if (method === 'POST' && subPath === '/regenerate') {
-                const result = await regenerateKey(keyId);
-                if (!result) {
-                    sendJson(res, 404, { success: false, error: { message: '未找到 Key' } });
-                    return true;
-                }
-                sendJson(res, 200, { 
-                    success: true, 
-                    message: 'Key 重新生成成功',
-                    data: {
-                        oldKey: result.oldKey,
-                        newKey: result.newKey,
-                        keyData: result.keyData
-                    }
-                });
-                return true;
-            }
-        }
-
-        // 未匹配的 potluck 路由
-        sendJson(res, 404, { success: false, error: { message: '未找到 Potluck API 端点' } });
-        return true;
-
-    } catch (error) {
-        logger.error('[API Potluck] API error:', error);
-        sendJson(res, 500, {
-            success: false,
-            error: { message: error.message || '内部服务器错误' }
-        });
-        return true;
-    }
-}
-
-/**
- * 从请求中提取 Potluck API Key
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @returns {string|null}
- */
-function extractApiKeyFromRequest(req) {
-    // 1. 检查 Authorization header
-    const authHeader = req.headers['authorization'];
-    if (authHeader && authHeader.startsWith('Bearer ')) {
-        const token = authHeader.substring(7);
-        if (token.startsWith(KEY_PREFIX)) {
-            return token;
-        }
-    }
-
-    // 2. 检查 x-api-key header
-    const xApiKey = req.headers['x-api-key'];
-    if (xApiKey && xApiKey.startsWith(KEY_PREFIX)) {
-        return xApiKey;
-    }
-
-    return null;
-}
-
-/**
- * 处理用户端 API 请求 - 用户通过自己的 API Key 查询使用量
- * @param {string} method - HTTP 方法
- * @param {string} path - 请求路径
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @param {http.ServerResponse} res - HTTP 响应对象
- * @returns {Promise<boolean>} - 是否处理了请求
- */
-export async function handlePotluckUserApiRoutes(method, path, req, res) {
-    // 只处理 /api/potluckuser 开头的请求
-    if (!path.startsWith('/api/potluckuser')) {
-        return false;
-    }
-    logger.info('[API Potluck User] Handling request:', method, path);
-
-    try {
-        // 从请求中提取 API Key
-        const apiKey = extractApiKeyFromRequest(req);
-        
-        if (!apiKey) {
-            sendJson(res, 401, {
-                success: false,
-                error: {
-                    message: '需要 API Key。请在 Authorization 标头 (Bearer maki_xxx) 或 x-api-key 标头中提供您的 API Key。',
-                    code: 'API_KEY_REQUIRED'
-                }
-            });
-            return true;
-        }
-
-        // 验证 API Key
-        const validation = await validateKey(apiKey);
-        
-        if (!validation.valid && validation.reason !== 'quota_exceeded') {
-            const errorMessages = {
-                'invalid_format': 'API Key 格式无效',
-                'not_found': '未找到 API Key',
-                'disabled': 'API Key 已禁用'
-            };
-            
-            sendJson(res, 401, {
-                success: false,
-                error: {
-                    message: errorMessages[validation.reason] || '无效的 API Key',
-                    code: validation.reason
-                }
-            });
-            return true;
-        }
-
-        // GET /api/potluckuser/usage - 获取当前用户的使用量信息
-        if (method === 'GET' && path === '/api/potluckuser/usage') {
-            const keyData = await getKey(apiKey);
-            
-            if (!keyData) {
-                sendJson(res, 404, {
-                    success: false,
-                    error: { message: '未找到 Key', code: 'KEY_NOT_FOUND' }
-                });
-                return true;
-            }
-
-            // 计算使用百分比
-            const usagePercent = keyData.dailyLimit > 0
-                ? Math.round((keyData.todayUsage / keyData.dailyLimit) * 100)
-                : 0;
-
-            // 返回用户友好的使用量信息（隐藏敏感信息）
-            sendJson(res, 200, {
-                success: true,
-                data: {
-                    name: keyData.name,
-                    enabled: keyData.enabled,
-                    usage: {
-                        today: keyData.todayUsage,
-                        limit: keyData.dailyLimit,
-                        remaining: Math.max(0, keyData.dailyLimit - keyData.todayUsage),
-                        percent: usagePercent,
-                        resetDate: keyData.lastResetDate
-                    },
-                    total: keyData.totalUsage,
-                    lastUsedAt: keyData.lastUsedAt,
-                    createdAt: keyData.createdAt,
-                    usageHistory: keyData.usageHistory || {},
-                    // 显示部分遮蔽的 Key ID
-
-                    maskedKey: `${apiKey.substring(0, 12)}...${apiKey.substring(apiKey.length - 4)}`
-                }
-            });
-            return true;
-        }
-
-        // 未匹配的用户端路由
-        sendJson(res, 404, {
-            success: false,
-            error: { message: '未找到用户 API 端点' }
-        });
-        return true;
-
-    } catch (error) {
-        logger.error('[API Potluck] User API error:', error);
-        sendJson(res, 500, {
-            success: false,
-            error: { message: error.message || '内部服务器错误' }
-        });
-        return true;
-    }
-}

src/plugins/api-potluck/index.js

@@ -1,208 +0,0 @@
-/**
- * API 大锅饭插件 - 标准插件格式
- * 
- * 功能：
- * 1. API Key 管理（创建、删除、启用/禁用）
- * 2. 每日配额限制
- * 3. 用量统计
- * 4. 管理 API 接口
- */
-
-import {
-    createKey,
-    listKeys,
-    getKey,
-    deleteKey,
-    updateKeyLimit,
-    resetKeyUsage,
-    toggleKey,
-    updateKeyName,
-    validateKey,
-    incrementUsage,
-    getStats,
-    KEY_PREFIX,
-    setConfigGetter
-} from './key-manager.js';
-
-import {
-    extractPotluckKey,
-    isPotluckRequest,
-    sendPotluckError
-} from './middleware.js';
-
-import logger from '../../utils/logger.js';
-
-import { handlePotluckApiRoutes, handlePotluckUserApiRoutes } from './api-routes.js';
-
-/**
- * 插件定义
- */
-const apiPotluckPlugin = {
-    name: 'api-potluck',
-    version: '1.0.2',
-    description: 'API 大锅饭 - Key 管理和用量统计插件<br>管理端：<a href="potluck.html" target="_blank">potluck.html</a><br>用户端：<a href="potluck-user.html" target="_blank">potluck-user.html</a>',
-    
-    // 插件类型：认证插件
-    type: 'auth',
-    
-    // 优先级：数字越小越先执行，默认认证插件优先级为 9999
-    _priority: 10,
-
-    /**
-     * 初始化钩子
-     * @param {Object} config - 服务器配置
-     */
-    async init(config) {
-        logger.info('[API Potluck Plugin] Initializing...');
-    },
-
-    /**
-     * 销毁钩子
-     */
-    async destroy() {
-        logger.info('[API Potluck Plugin] Destroying...');
-    },
-
-    /**
-     * 静态文件路径
-     */
-    staticPaths: ['potluck.html', 'potluck-user.html'],
-
-    /**
-     * 路由定义
-     */
-    routes: [
-        {
-            method: '*',
-            path: '/api/potluckuser',
-            handler: handlePotluckUserApiRoutes
-        },
-        {
-            method: '*',
-            path: '/api/potluck',
-            handler: handlePotluckApiRoutes
-        }
-    ],
-
-    /**
-     * 认证方法 - 处理 Potluck Key 认证
-     * @param {http.IncomingMessage} req - HTTP 请求
-     * @param {http.ServerResponse} res - HTTP 响应
-     * @param {URL} requestUrl - 解析后的 URL
-     * @param {Object} config - 服务器配置
-     * @returns {Promise<{handled: boolean, authorized: boolean|null, error?: Object, data?: Object}>}
-     */
-    async authenticate(req, res, requestUrl, config) {
-        const apiKey = extractPotluckKey(req, requestUrl);
-        
-        if (!apiKey) {
-            // 不是 potluck 请求，返回 null 让其他认证插件处理
-            return { handled: false, authorized: null };
-        }
-
-        // 验证 Key
-        const validation = await validateKey(apiKey);
-        
-        if (!validation.valid) {
-            const errorMessages = {
-                'invalid_format': 'Invalid API key format',
-                'not_found': 'API key not found',
-                'disabled': 'API key has been disabled',
-                'quota_exceeded': 'Quota exceeded for this API key'
-            };
-
-            const statusCodes = {
-                'invalid_format': 401,
-                'not_found': 401,
-                'disabled': 403,
-                'quota_exceeded': 429
-            };
-
-            const error = {
-                statusCode: statusCodes[validation.reason] || 401,
-                message: errorMessages[validation.reason] || 'Authentication failed',
-                code: validation.reason,
-                keyData: validation.keyData
-            };
-
-            // 发送错误响应
-            sendPotluckError(res, error);
-            return { handled: true, authorized: false, error };
-        }
-
-        // 认证成功，返回数据供后续使用
-        logger.info(`[API Potluck Plugin] Authorized with key: ${apiKey.substring(0, 12)}...`);
-        return {
-            handled: false,
-            authorized: true,
-            data: {
-                potluckApiKey: apiKey,
-                potluckKeyData: validation.keyData
-            }
-        };
-    },
-
-    /**
-     * 钩子函数
-     */
-    hooks: {
-        /**
-         * 内容生成后钩子 - 记录用量
-         * @param {Object} hookContext - 钩子上下文，包含请求和模型信息
-         */
-        async onContentGenerated(hookContext) {
-            if (hookContext.potluckApiKey) {
-                try {
-                    // 传入提供商和模型信息
-                    await incrementUsage(
-                        hookContext.potluckApiKey, 
-                        hookContext.toProvider, 
-                        hookContext.model
-                    );
-                } catch (e) {
-                    // 静默失败，不影响主流程
-                    logger.error('[API Potluck Plugin] Failed to record usage:', e.message);
-                }
-            }
-        }
-
-    },
-
-    // 导出内部函数供外部使用（可选）
-    exports: {
-        createKey,
-        listKeys,
-        getKey,
-        deleteKey,
-        updateKeyLimit,
-        resetKeyUsage,
-        toggleKey,
-        updateKeyName,
-        validateKey,
-        incrementUsage,
-        getStats,
-        KEY_PREFIX,
-        extractPotluckKey,
-        isPotluckRequest
-    }
-};
-
-export default apiPotluckPlugin;
-
-// 也导出命名导出，方便直接引用
-export {
-    createKey,
-    listKeys,
-    getKey,
-    deleteKey,
-    updateKeyLimit,
-    resetKeyUsage,
-    toggleKey,
-    updateKeyName,
-    validateKey,
-    incrementUsage,
-    getStats,
-    KEY_PREFIX,
-    extractPotluckKey,
-    isPotluckRequest
-};

src/plugins/api-potluck/key-manager.js

@@ -1,486 +0,0 @@
-/**
- * API 大锅饭 - Key 管理模块
- * 使用内存缓存 + 写锁 + 定期持久化，解决并发安全问题
- */
-
-import { promises as fs } from 'fs';
-import logger from '../../utils/logger.js';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-
-// 配置文件路径
-const KEYS_STORE_FILE = path.join(process.cwd(), 'configs', 'api-potluck-keys.json');
-const KEY_PREFIX = 'maki_';
-
-// 默认配置
-const DEFAULT_CONFIG = {
-    defaultDailyLimit: 500,
-    persistInterval: 5000
-};
-
-// 配置获取函数（由外部注入）
-let configGetter = null;
-
-/**
- * 设置配置获取函数
- * @param {Function} getter - 返回配置对象的函数
- */
-export function setConfigGetter(getter) {
-    configGetter = getter;
-}
-
-/**
- * 获取当前配置
- */
-function getConfig() {
-    if (configGetter) {
-        return configGetter();
-    }
-    return DEFAULT_CONFIG;
-}
-
-// 内存缓存
-let keyStore = null;
-let isDirty = false;
-let isWriting = false;
-let persistTimer = null;
-let currentPersistInterval = DEFAULT_CONFIG.persistInterval;
-
-/**
- * 初始化：从文件加载数据到内存
- */
-function ensureLoaded() {
-    if (keyStore !== null) return;
-    try {
-        if (existsSync(KEYS_STORE_FILE)) {
-            const content = readFileSync(KEYS_STORE_FILE, 'utf8');
-            keyStore = JSON.parse(content);
-        } else {
-            keyStore = { keys: {} };
-            syncWriteToFile();
-        }
-    } catch (error) {
-        logger.error('[API Potluck] Failed to load key store:', error.message);
-        keyStore = { keys: {} };
-    }
-    
-    // 获取配置的持久化间隔
-    const config = getConfig();
-    currentPersistInterval = config.persistInterval || DEFAULT_CONFIG.persistInterval;
-    
-    // 启动定期持久化
-    if (!persistTimer) {
-        persistTimer = setInterval(persistIfDirty, currentPersistInterval);
-        // 进程退出时保存
-        process.on('beforeExit', () => persistIfDirty());
-        process.on('SIGINT', () => { persistIfDirty(); process.exit(0); });
-        process.on('SIGTERM', () => { persistIfDirty(); process.exit(0); });
-    }
-}
-
-/**
- * 同步写入文件（仅初始化时使用）
- */
-function syncWriteToFile() {
-    try {
-        const dir = path.dirname(KEYS_STORE_FILE);
-        if (!existsSync(dir)) {
-            require('fs').mkdirSync(dir, { recursive: true });
-        }
-        writeFileSync(KEYS_STORE_FILE, JSON.stringify(keyStore, null, 2), 'utf8');
-    } catch (error) {
-        logger.error('[API Potluck] Sync write failed:', error.message);
-    }
-}
-
-/**
- * 异步持久化（带写锁）
- */
-async function persistIfDirty() {
-    if (!isDirty || isWriting || keyStore === null) return;
-    isWriting = true;
-    try {
-        const dir = path.dirname(KEYS_STORE_FILE);
-        if (!existsSync(dir)) {
-            await fs.mkdir(dir, { recursive: true });
-        }
-        // 写入临时文件再重命名，防止写入中断导致文件损坏
-        const tempFile = KEYS_STORE_FILE + '.tmp';
-        await fs.writeFile(tempFile, JSON.stringify(keyStore, null, 2), 'utf8');
-        await fs.rename(tempFile, KEYS_STORE_FILE);
-        isDirty = false;
-    } catch (error) {
-        logger.error('[API Potluck] Persist failed:', error.message);
-    } finally {
-        isWriting = false;
-    }
-}
-
-/**
- * 标记数据已修改
- */
-function markDirty() {
-    isDirty = true;
-}
-
-/**
- * 生成随机 API Key（确保不重复）
- */
-function generateApiKey() {
-    ensureLoaded();
-    let apiKey;
-    let attempts = 0;
-    const maxAttempts = 10;
-    
-    do {
-        apiKey = `${KEY_PREFIX}${crypto.randomBytes(16).toString('hex')}`;
-        attempts++;
-        if (attempts >= maxAttempts) {
-            throw new Error('Failed to generate unique API key after multiple attempts');
-        }
-    } while (keyStore.keys[apiKey]);
-    
-    return apiKey;
-}
-
-/**
- * 获取今天的日期字符串 (YYYY-MM-DD)
- */
-function getTodayDateString() {
-    const now = new Date();
-    return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
-}
-
-/**
- * 检查并重置过期的每日计数
- */
-function checkAndResetDailyCount(keyData) {
-    const today = getTodayDateString();
-    if (keyData.lastResetDate !== today) {
-        keyData.todayUsage = 0;
-        keyData.lastResetDate = today;
-    }
-    return keyData;
-}
-
-/**
- * 创建新的 API Key
-
- * @param {string} name - Key 名称
- * @param {number} [dailyLimit] - 每日限额，不传则使用配置的默认值
- */
-export async function createKey(name = '', dailyLimit = null) {
-    ensureLoaded();
-    const config = getConfig();
-    const actualDailyLimit = dailyLimit ?? config.defaultDailyLimit ?? DEFAULT_CONFIG.defaultDailyLimit;
-    
-    const apiKey = generateApiKey();
-    const now = new Date().toISOString();
-    const today = getTodayDateString();
-
-    const keyData = {
-        id: apiKey,
-        name: name || `Key-${Object.keys(keyStore.keys).length + 1}`,
-        createdAt: now,
-        dailyLimit: actualDailyLimit,
-        todayUsage: 0,
-        totalUsage: 0,
-        lastResetDate: today,
-        lastUsedAt: null,
-        enabled: true
-    };
-
-    keyStore.keys[apiKey] = keyData;
-    markDirty();
-    await persistIfDirty(); // 创建操作立即持久化
-
-    logger.info(`[API Potluck] Created key: ${apiKey.substring(0, 12)}...`);
-    return keyData;
-}
-
-/**
- * 获取所有 Key 列表
- */
-export async function listKeys() {
-    ensureLoaded();
-    const keys = [];
-    for (const [keyId, keyData] of Object.entries(keyStore.keys)) {
-        const updated = checkAndResetDailyCount({ ...keyData });
-        keys.push({
-            ...updated,
-            maskedKey: `${keyId.substring(0, 12)}...${keyId.substring(keyId.length - 4)}`
-        });
-    }
-    return keys;
-}
-
-/**
- * 获取单个 Key 详情
- */
-export async function getKey(keyId) {
-    ensureLoaded();
-    const keyData = keyStore.keys[keyId];
-    if (!keyData) return null;
-    return checkAndResetDailyCount({ ...keyData });
-}
-
-/**
- * 删除 Key
- */
-export async function deleteKey(keyId) {
-    ensureLoaded();
-    if (!keyStore.keys[keyId]) return false;
-    delete keyStore.keys[keyId];
-    markDirty();
-    await persistIfDirty(); // 删除操作立即持久化
-    logger.info(`[API Potluck] Deleted key: ${keyId.substring(0, 12)}...`);
-    return true;
-}
-
-/**
- * 更新 Key 的每日限额
- */
-export async function updateKeyLimit(keyId, newLimit) {
-    ensureLoaded();
-    if (!keyStore.keys[keyId]) return null;
-    keyStore.keys[keyId].dailyLimit = newLimit;
-    markDirty();
-    return keyStore.keys[keyId];
-}
-
-/**
- * 重置 Key 的当天调用次数
- */
-export async function resetKeyUsage(keyId) {
-    ensureLoaded();
-    if (!keyStore.keys[keyId]) return null;
-    keyStore.keys[keyId].todayUsage = 0;
-    keyStore.keys[keyId].lastResetDate = getTodayDateString();
-    markDirty();
-    return keyStore.keys[keyId];
-}
-
-/**
- * 切换 Key 的启用/禁用状态
- */
-export async function toggleKey(keyId) {
-    ensureLoaded();
-    if (!keyStore.keys[keyId]) return null;
-    keyStore.keys[keyId].enabled = !keyStore.keys[keyId].enabled;
-    markDirty();
-    return keyStore.keys[keyId];
-}
-
-/**
- * 更新 Key 名称
- */
-export async function updateKeyName(keyId, newName) {
-    ensureLoaded();
-    if (!keyStore.keys[keyId]) return null;
-    keyStore.keys[keyId].name = newName;
-    markDirty();
-    return keyStore.keys[keyId];
-}
-
-/**
- * 重新生成 API Key（保留原有数据，更换 Key ID）
- * @param {string} oldKeyId - 原 Key ID
- * @returns {Promise<{oldKey: string, newKey: string, keyData: Object}|null>}
- */
-export async function regenerateKey(oldKeyId) {
-    ensureLoaded();
-    const oldKeyData = keyStore.keys[oldKeyId];
-    if (!oldKeyData) return null;
-    
-    // 生成新的唯一 Key
-    const newKeyId = generateApiKey();
-    
-    // 复制数据到新 Key
-    const newKeyData = {
-        ...oldKeyData,
-        id: newKeyId,
-        regeneratedAt: new Date().toISOString(),
-        regeneratedFrom: oldKeyId.substring(0, 12) + '...'
-    };
-    
-    // 删除旧 Key，添加新 Key
-    delete keyStore.keys[oldKeyId];
-    keyStore.keys[newKeyId] = newKeyData;
-    
-    markDirty();
-    await persistIfDirty(); // 立即持久化
-    
-    logger.info(`[API Potluck] Regenerated key: ${oldKeyId.substring(0, 12)}... -> ${newKeyId.substring(0, 12)}...`);
-    
-    return {
-        oldKey: oldKeyId,
-        newKey: newKeyId,
-        keyData: newKeyData
-    };
-}
-
-/**
- * 验证 API Key 是否有效且有配额
- */
-export async function validateKey(apiKey) {
-    ensureLoaded();
-    if (!apiKey || !apiKey.startsWith(KEY_PREFIX)) {
-        return { valid: false, reason: 'invalid_format' };
-    }
-    const keyData = keyStore.keys[apiKey];
-    if (!keyData) return { valid: false, reason: 'not_found' };
-    if (!keyData.enabled) return { valid: false, reason: 'disabled' };
-
-    // 直接在内存中检查和重置
-    checkAndResetDailyCount(keyData);
-    
-    // 检查每日限额
-    if (keyData.todayUsage < keyData.dailyLimit) {
-        return { valid: true, keyData };
-    }
-    
-    return { valid: false, reason: 'quota_exceeded', keyData };
-}
-
-/**
- * 增加 Key 的使用次数（原子操作，直接修改内存）
- * @param {string} apiKey - API Key
- * @param {string} provider - 使用的提供商
- * @param {string} model - 使用的模型
- */
-export async function incrementUsage(apiKey, provider = 'unknown', model = 'unknown') {
-    ensureLoaded();
-    const keyData = keyStore.keys[apiKey];
-    if (!keyData) return null;
-
-    checkAndResetDailyCount(keyData);
-    
-    // 消耗每日限额
-    if (keyData.todayUsage < keyData.dailyLimit) {
-        keyData.todayUsage += 1;
-    } else {
-        // 每日限额用尽
-        return null;
-    }
-    
-    keyData.totalUsage += 1;
-    keyData.lastUsedAt = new Date().toISOString();
-
-    // 记录个人按天统计 (每个 Key 独立)
-    const today = getTodayDateString();
-    if (!keyData.usageHistory) keyData.usageHistory = {};
-    if (!keyData.usageHistory[today]) {
-        keyData.usageHistory[today] = { providers: {}, models: {} };
-    }
-    
-    // 确保 provider 和 model 是字符串
-    const pName = String(provider || 'unknown');
-    const mName = String(model || 'unknown');
-    
-    const userHistory = keyData.usageHistory[today];
-    userHistory.providers[pName] = (userHistory.providers[pName] || 0) + 1;
-    userHistory.models[mName] = (userHistory.models[mName] || 0) + 1;
-
-    // 清理该 Key 的过期历史 (保留 7 天)
-    const userDates = Object.keys(keyData.usageHistory).sort();
-    if (userDates.length > 7) {
-        const dropDates = userDates.slice(0, userDates.length - 7);
-        dropDates.forEach(d => delete keyData.usageHistory[d]);
-    }
-
-    markDirty();
-    
-    return {
-        ...keyData,
-        usedBonus: false
-    };
-}
-
-/**
- * 获取统计信息
- */
-export async function getStats() {
-    ensureLoaded();
-    const keys = Object.values(keyStore.keys);
-    let enabledKeys = 0, todayTotalUsage = 0, totalUsage = 0;
-    const aggregatedHistory = {};
-
-    for (const key of keys) {
-        checkAndResetDailyCount(key);
-        if (key.enabled) enabledKeys++;
-        todayTotalUsage += key.todayUsage;
-        totalUsage += key.totalUsage;
-
-        // 汇总每个 Key 的历史数据
-        if (key.usageHistory) {
-            Object.entries(key.usageHistory).forEach(([date, history]) => {
-                if (!aggregatedHistory[date]) {
-                    aggregatedHistory[date] = { providers: {}, models: {} };
-                }
-                
-                // 汇总提供商
-                if (history.providers) {
-                    Object.entries(history.providers).forEach(([p, count]) => {
-                        aggregatedHistory[date].providers[p] = (aggregatedHistory[date].providers[p] || 0) + count;
-                    });
-                }
-                
-                // 汇总模型
-                if (history.models) {
-                    Object.entries(history.models).forEach(([m, count]) => {
-                        aggregatedHistory[date].models[m] = (aggregatedHistory[date].models[m] || 0) + count;
-                    });
-                }
-            });
-        }
-    }
-
-    return {
-        totalKeys: keys.length,
-        enabledKeys,
-        disabledKeys: keys.length - enabledKeys,
-        todayTotalUsage,
-        totalUsage,
-        usageHistory: aggregatedHistory
-    };
-}
-
-
-/**
- * 批量更新所有 Key 的每日限额
- * @param {number} newLimit - 新的每日限额
- * @returns {Promise<{total: number, updated: number}>}
- */
-export async function applyDailyLimitToAllKeys(newLimit) {
-    ensureLoaded();
-    const keys = Object.values(keyStore.keys);
-    let updated = 0;
-    
-    for (const keyData of keys) {
-        if (keyData.dailyLimit !== newLimit) {
-            keyData.dailyLimit = newLimit;
-            updated++;
-        }
-    }
-    
-    if (updated > 0) {
-        markDirty();
-        await persistIfDirty();
-    }
-    
-    logger.info(`[API Potluck] Applied daily limit ${newLimit} to ${updated}/${keys.length} keys`);
-    return { total: keys.length, updated };
-}
-
-/**
- * 获取所有 Key ID 列表
- * @returns {string[]}
- */
-export function getAllKeyIds() {
-    ensureLoaded();
-    return Object.keys(keyStore.keys);
-}
-
-// 导出常量
-export { KEY_PREFIX };

src/plugins/api-potluck/middleware.js

@@ -1,166 +0,0 @@
-/**
- * API 大锅饭 - 中间件模块
- * 负责请求拦截和配额检查
- */
-
-import { validateKey, incrementUsage, KEY_PREFIX } from './key-manager.js';
-import logger from '../../utils/logger.js';
-
-/**
- * 从请求中提取 Potluck API Key
- * 支持多种认证方式：
- * 1. Authorization: Bearer maki_xxx
- * 2. x-api-key: maki_xxx
- * 3. x-goog-api-key: maki_xxx
- * 4. URL query: ?key=maki_xxx
- * 
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @param {URL} requestUrl - 解析后的 URL 对象
- * @returns {string|null} 提取到的 API Key，如果不是 potluck key 则返回 null
- */
-export function extractPotluckKey(req, requestUrl) {
-    // 1. 检查 Authorization header
-    const authHeader = req.headers['authorization'];
-    if (authHeader && authHeader.startsWith('Bearer ')) {
-        const token = authHeader.substring(7);
-        if (token.startsWith(KEY_PREFIX)) {
-            return token;
-        }
-    }
-
-    // 2. 检查 x-api-key header (Claude style)
-    const xApiKey = req.headers['x-api-key'];
-    if (xApiKey && xApiKey.startsWith(KEY_PREFIX)) {
-        return xApiKey;
-    }
-
-    // 3. 检查 x-goog-api-key header (Gemini style)
-    const googApiKey = req.headers['x-goog-api-key'];
-    if (googApiKey && googApiKey.startsWith(KEY_PREFIX)) {
-        return googApiKey;
-    }
-
-    // 4. 检查 URL query parameter
-    const queryKey = requestUrl.searchParams.get('key');
-    if (queryKey && queryKey.startsWith(KEY_PREFIX)) {
-        return queryKey;
-    }
-
-    return null;
-}
-
-/**
- * 检查请求是否使用 Potluck Key
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @param {URL} requestUrl - 解析后的 URL 对象
- * @returns {boolean}
- */
-export function isPotluckRequest(req, requestUrl) {
-    return extractPotluckKey(req, requestUrl) !== null;
-}
-
-/**
- * Potluck 认证中间件
- * 验证 Potluck API Key 并检查配额
- * 
- * @param {http.IncomingMessage} req - HTTP 请求对象
- * @param {URL} requestUrl - 解析后的 URL 对象
- * @returns {Promise<{authorized: boolean, error?: Object, keyData?: Object, apiKey?: string}>}
- */
-export async function potluckAuthMiddleware(req, requestUrl) {
-    const apiKey = extractPotluckKey(req, requestUrl);
-    
-    if (!apiKey) {
-        // 不是 potluck 请求，返回 null 让原有逻辑处理
-        return { authorized: null };
-    }
-
-    // 验证 Key
-    const validation = await validateKey(apiKey);
-    
-    if (!validation.valid) {
-        const errorMessages = {
-            'invalid_format': 'Invalid API key format',
-            'not_found': 'API key not found',
-            'disabled': 'API key has been disabled',
-            'quota_exceeded': 'Quota exceeded for this API key'
-        };
-
-        const statusCodes = {
-            'invalid_format': 401,
-            'not_found': 401,
-            'disabled': 403,
-            'quota_exceeded': 429
-        };
-
-        return {
-            authorized: false,
-            error: {
-                statusCode: statusCodes[validation.reason] || 401,
-                message: errorMessages[validation.reason] || 'Authentication failed',
-                code: validation.reason,
-                keyData: validation.keyData
-            }
-        };
-    }
-
-    return {
-        authorized: true,
-        keyData: validation.keyData,
-        apiKey: apiKey
-    };
-}
-
-/**
- * 记录 Potluck 请求使用
- * 在请求成功处理后调用
- * 
- * @param {string} apiKey - API Key
- * @returns {Promise<Object|null>}
- */
-export async function recordPotluckUsage(apiKey) {
-    if (!apiKey || !apiKey.startsWith(KEY_PREFIX)) {
-        return null;
-    }
-    return incrementUsage(apiKey);
-}
-
-/**
- * 创建 Potluck 错误响应
- * @param {http.ServerResponse} res - HTTP 响应对象
- * @param {Object} error - 错误信息
- */
-export function sendPotluckError(res, error) {
-    const response = {
-        error: {
-            message: error.message,
-            code: error.code,
-            type: 'potluck_error'
-        }
-    };
-
-    // 如果是配额超限，添加额外信息
-    if (error.code === 'quota_exceeded' && error.keyData) {
-        response.error.quota = {
-            used: error.keyData.todayUsage,
-            limit: error.keyData.dailyLimit,
-            resetDate: error.keyData.lastResetDate
-        };
-    }
-
-    // 检查响应流是否已关闭
-    if (res.writableEnded || res.destroyed) {
-        logger.warn('[API Potluck] Response already ended, skipping error response');
-        return;
-    }
-
-    if (!res.headersSent) {
-        res.writeHead(error.statusCode, { 'Content-Type': 'application/json' });
-    }
-    
-    try {
-        res.end(JSON.stringify(response));
-    } catch (writeError) {
-        logger.error('[API Potluck] Failed to write error response:', writeError.message);
-    }
-}