@sahan-sac/ai-core 0.3.1 → 0.5.0

package/CHANGELOG.md

@@ -1,25 +1,48 @@
-# @sahan-sac/ai-core
-
-## 0.3.1
-
-### Patch Changes
-
-- 5e7f3cb: The build shares modules between subpaths (code splitting) instead of copying them into each one. Before, a class imported from two subpaths was two different classes, so `instanceof` failed (for example `EmailGuardError` from `@sahan-sac/email-kit/guards` against an error thrown through `./layout`), and module-level state such as caches existed once per subpath.
-
-## 0.3.0
-
-### Minor Changes
-
-- b9d2dd6: `createAiService().generate()` takes an optional `signal`. Aborting it stops the chain at once: running attempts are aborted, no further provider starts, and the result is `errorClass: "aborted"`. Aborted attempts are not logged and do not put a provider into cooldown.
-- 4fa21e3: Provider registry and more providers. New `@sahan-sac/ai-core/adapters`: each provider is an adapter with its own env guard and paid flag (`BUILTIN_ADAPTERS`), and `realProviders` builds the chain from it. Added OpenAI, Anthropic (Messages API over REST), DeepSeek, xAI, Perplexity and one custom OpenAI-compatible endpoint (`AI_CUSTOM_*`), all paid and gated by `AI_ALLOW_PAID` (the custom one unless `AI_CUSTOM_FREE`). `AI_PROVIDER_ORDER`, `AI_PROVIDER_ORDER_BLOG` and `AI_PROVIDER_ORDER_CHAT` choose which providers run and in what order; an explicit order is kept as given (`AiProvider.priority`), while cooling providers still drop behind healthy ones. `providerStatuses` explains each adapter's place for health screens, `textAiConfigured(env, purpose?)` checks one purpose's chain, and apps can pass their own adapters to `realProviders`. New factories `openAiCompatibleProvider` and `anthropicProvider`. Existing variables and `realProviders(env, purpose, fetch?)` work as before.
-- f465908: Owner guidance and on-demand checks. `@sahan-sac/ai-core/guard` adds `guidanceSection(text)`, which appends the site owner's standing guidance after a prompt's fixed rules (it steers, never overrides them, and never changes how fenced data is treated), `mergeGuidance(...parts)` to join global and per-feature guidance, and an optional `maxLength` on `wrapUserData`. `@sahan-sac/ai-core/adapters` adds `checkProvider(env, id)` and `checkChain(env, purpose)`: each sends a one-line prompt (a few tokens) through one adapter or a whole chain and reports who answered, how long it took and every fall-through, for a health screen's manual Check button. Neither runs on its own, and neither cools a provider down for real traffic.
-
-## 0.2.0
-
-No changes in this release.
-
-## 0.1.0
-
-### Minor Changes
-
-- b620f44: First release. ai-core: the free-by-default provider chain (Gemini, OpenRouter, NVIDIA, then paid Vertex) with hedging, cooldowns and deadlines, env-driven model resolution, image generation, prompt guards and the shared env schema (ENABLE_BLOG_AI, ENABLE_CHATBOT). blog-kit: full-post, SEO, draft and cover generation, AI images through an ImageSink port, and pure blog utilities. chat-kit: runChat, guarded prompts, output filtering, the knowledge builder, the ChatStore contract and the visitor rate-limit cookie. Licensed Apache-2.0.
+# @sahan-sac/ai-core
+
+## 0.5.0
+
+### Minor Changes
+
+- c0127d5: OmniRoute provider. `omniroute` is a free adapter for a self-hosted OmniRoute gateway: one OpenAI-compatible endpoint that pools many providers' free tiers and fails over between them. It turns on with `OMNIROUTE_BASE_URL` (https, or http on localhost; `/v1` is added when missing; credentials in the URL are refused), sends `OMNIROUTE_API_KEY` when set, and defaults to the gateway's `auto/best-free` model (`OMNIROUTE_MODEL`, `BLOG_OMNIROUTE_MODEL` and `CHAT_OMNIROUTE_MODEL` override it). It is first in the default order, so it leads the chat and blog chains whenever it is configured, and it never needs `AI_ALLOW_PAID`.
+  
+  Free only, even with `AI_ALLOW_PAID`: a model override that is not a free route (`isFreeRoute`: ends `-free` or `:free`) is replaced by `auto/best-free`. `OMNIROUTE_ALLOW_PAID` lets an override name a paid route, but only together with `AI_ALLOW_PAID`; the gateway then counts as paid for that purpose and runs as a last resort. `ProviderAdapter.paid` takes an optional `purpose`, so an adapter can be paid for one purpose and free for the other.
+
+## 0.4.0
+
+### Minor Changes
+
+- 396e692: Three more free-tier adapters:
+  - `groq`: Groq free plan, keyed by `GROQ_API_KEY`. Default models `openai/gpt-oss-120b` for the blog and `openai/gpt-oss-20b` for chat.
+  - `mistral`: Mistral free Experiment plan, keyed by `MISTRAL_API_KEY`. This plan may train on prompts, so the adapter runs in the blog chain only unless `AI_PROVIDER_ORDER_CHAT` lists it.
+  - `cloudflare`: Cloudflare Workers AI, with 10,000 free neurons a day. Needs `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_AI_API_TOKEN`.
+  
+  None of them is paid, so none needs `AI_ALLOW_PAID`. Each model can be overridden per purpose. Adapters gain an optional `defaultPurposes`.
+
+### Patch Changes
+
+- 1570cf6: A provider that answers 402 (no credits, or an empty prepaid wallet) now cools down for 30 minutes instead of being retried on every request, so an unfunded account costs one probe per window rather than a failed round trip each time. `cooldownFor` is exported.
+
+## 0.3.1
+
+### Patch Changes
+
+- 5e7f3cb: The build shares modules between subpaths (code splitting) instead of copying them into each one. Before, a class imported from two subpaths was two different classes, so `instanceof` failed (for example `EmailGuardError` from `@sahan-sac/email-kit/guards` against an error thrown through `./layout`), and module-level state such as caches existed once per subpath.
+
+## 0.3.0
+
+### Minor Changes
+
+- b9d2dd6: `createAiService().generate()` takes an optional `signal`. Aborting it stops the chain at once: running attempts are aborted, no further provider starts, and the result is `errorClass: "aborted"`. Aborted attempts are not logged and do not put a provider into cooldown.
+- 4fa21e3: Provider registry and more providers. New `@sahan-sac/ai-core/adapters`: each provider is an adapter with its own env guard and paid flag (`BUILTIN_ADAPTERS`), and `realProviders` builds the chain from it. Added OpenAI, Anthropic (Messages API over REST), DeepSeek, xAI, Perplexity and one custom OpenAI-compatible endpoint (`AI_CUSTOM_*`), all paid and gated by `AI_ALLOW_PAID` (the custom one unless `AI_CUSTOM_FREE`). `AI_PROVIDER_ORDER`, `AI_PROVIDER_ORDER_BLOG` and `AI_PROVIDER_ORDER_CHAT` choose which providers run and in what order; an explicit order is kept as given (`AiProvider.priority`), while cooling providers still drop behind healthy ones. `providerStatuses` explains each adapter's place for health screens, `textAiConfigured(env, purpose?)` checks one purpose's chain, and apps can pass their own adapters to `realProviders`. New factories `openAiCompatibleProvider` and `anthropicProvider`. Existing variables and `realProviders(env, purpose, fetch?)` work as before.
+- f465908: Owner guidance and on-demand checks. `@sahan-sac/ai-core/guard` adds `guidanceSection(text)`, which appends the site owner's standing guidance after a prompt's fixed rules (it steers, never overrides them, and never changes how fenced data is treated), `mergeGuidance(...parts)` to join global and per-feature guidance, and an optional `maxLength` on `wrapUserData`. `@sahan-sac/ai-core/adapters` adds `checkProvider(env, id)` and `checkChain(env, purpose)`: each sends a one-line prompt (a few tokens) through one adapter or a whole chain and reports who answered, how long it took and every fall-through, for a health screen's manual Check button. Neither runs on its own, and neither cools a provider down for real traffic.
+
+## 0.2.0
+
+No changes in this release.
+
+## 0.1.0
+
+### Minor Changes
+
+- b620f44: First release. ai-core: the free-by-default provider chain (Gemini, OpenRouter, NVIDIA, then paid Vertex) with hedging, cooldowns and deadlines, env-driven model resolution, image generation, prompt guards and the shared env schema (ENABLE_BLOG_AI, ENABLE_CHATBOT). blog-kit: full-post, SEO, draft and cover generation, AI images through an ImageSink port, and pure blog utilities. chat-kit: runChat, guarded prompts, output filtering, the knowledge builder, the ChatStore contract and the visitor rate-limit cookie. Licensed Apache-2.0.

package/LICENSE

@@ -1,202 +1,202 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the
-      purposes of this License, Derivative Works shall not include works
-      that remain separable from, or merely link (or bind by name) to the
-      interfaces of, the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including the
-      original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright
-      owner or by an individual or Legal Entity authorized to submit on
-      behalf of the copyright owner. For the purposes of this definition,
-      "submitted" means any form of electronic, verbal, or written
-      communication sent to the Licensor or its representatives,
-      including but not limited to communication on electronic mailing
-      lists, source code control systems, and issue tracking systems
-      that are managed by, or on behalf of, the Licensor for the purpose
-      of discussing and improving the Work, but excluding communication
-      that is conspicuously marked or otherwise designated in writing
-      by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing
-      the origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Sahan Sachintha
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the
+      purposes of this License, Derivative Works shall not include works
+      that remain separable from, or merely link (or bind by name) to the
+      interfaces of, the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including the
+      original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright
+      owner or by an individual or Legal Entity authorized to submit on
+      behalf of the copyright owner. For the purposes of this definition,
+      "submitted" means any form of electronic, verbal, or written
+      communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing
+      lists, source code control systems, and issue tracking systems
+      that are managed by, or on behalf of, the Licensor for the purpose
+      of discussing and improving the Work, but excluding communication
+      that is conspicuously marked or otherwise designated in writing
+      by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing
+      the origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Sahan Sachintha
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,120 +1,125 @@
-# @sahan-sac/ai-core
-
-The AI layer shared by `@sahan-sac/blog-kit` and `@sahan-sac/chat-kit`: a free-by-default provider chain with automatic fallback, a provider registry you can configure and extend from the environment, model resolution, image generation (NVIDIA FLUX, then paid Gemini/Vertex), and prompt-injection guards.
-
-Headless and framework-agnostic: no Prisma, no Next.js APIs, no React. Everything takes a parsed env or config object; only `aiEnvFromProcess()` reads `process.env`.
-
-## How a request is answered
-
-Two patterns, kept separate:
-
-- **Adapters.** Every provider is wrapped as an `AiProvider` with one `generate(prompt, options)` that returns `{ ok: true, text }` or a classified failure (`http_429`, `timeout`, `truncated`, `invalid_output`, ...). It never throws. Built in: Gemini, OpenRouter (two keys), NVIDIA, OpenAI, Anthropic (Claude), DeepSeek, xAI (Grok), Perplexity, one custom OpenAI-compatible endpoint (vLLM, Ollama, LiteLLM, a gateway), and Vertex AI.
-- **Chain of responsibility.** `createAiService({ providers })` hands the prompt to the first provider. On any retryable failure it passes the prompt to the next one, until one answers, a non-retryable failure stops it, the deadline passes, or the caller aborts. On top of that:
-  - a provider that timed out or was rate limited cools down and moves behind the healthy ones;
-  - optional hedging starts the next provider while a slow one is still running, and the first valid answer wins;
-  - an `accept` check turns a malformed reply into a failure, so the chain moves on.
-
-The registry (`@sahan-sac/ai-core/adapters`) decides which adapters form a chain and in what order:
-
-1. `AI_PROVIDER_ORDER_BLOG` or `AI_PROVIDER_ORDER_CHAT` for that purpose, else `AI_PROVIDER_ORDER`, else the default order: `gemini, openrouter, openrouter-2, nvidia, openai, anthropic, deepseek, xai, perplexity, custom, vertex`.
-2. An adapter runs only when its variables are set. A paid adapter also needs `AI_ALLOW_PAID=true`, even when it is listed.
-3. **Explicit order:** only the listed ids run, in that order. Speed never reorders them; cooling still does.
-4. **Default order:** paid adapters are last resorts, and the free ones are reordered by observed speed.
-
-## Subpaths
-
-| Import | What |
-| --- | --- |
-| `@sahan-sac/ai-core/env` | `aiEnvSchema` (zod), `parseAiEnv(source)`, `aiEnvFromProcess()`, `AiEnv` |
-| `@sahan-sac/ai-core/adapters` | `BUILTIN_ADAPTERS`, `ProviderAdapter`, `realProviders(env, purpose, fetch?, adapters?)`, `chainPlan`, `providerStatuses` (why each adapter is in or out, for health screens), `checkProvider` / `checkChain` (manual checks), `configuredOrder`, `PAID_TEXT_MODELS` |
-| `@sahan-sac/ai-core/providers` | `createAiService` (the chain), `sharedAiHealth`, `realProviders` (re-exported), the provider factories: `geminiProvider`, `openRouterProvider`, `nvidiaProvider`, `openAiCompatibleProvider`, `anthropicProvider`, `vertexProvider` |
-| `@sahan-sac/ai-core/availability` | `textAiConfigured(env, purpose?)`, `blogAiEnabled`, `blogAiImagesEnabled`, `chatbotEnabled` |
-| `@sahan-sac/ai-core/models` | `textModels`, `imageModels`, verified free defaults, `paidAllowed`, `vertexConfigured` |
-| `@sahan-sac/ai-core/image` | `imageConfigFromEnv`, `generateImage` |
-| `@sahan-sac/ai-core/vertex` | `getVertexAccessToken` (service-account JWT exchange, cached) |
-| `@sahan-sac/ai-core/guard` | `wrapUserData(text, maxLength?)`, `guidanceSection`, `mergeGuidance`, `looksLikeLeak`, `ModelPrompt` |
-| `@sahan-sac/ai-core/log` | `AiLogger`, `consoleAiLogger` |
-
-`providers`, `adapters`, `image` and `vertex` reach `server-only` code: use them from server code only.
-
-## Environment
-
-Spread the schema into your own env module so the names never drift:
-
-```ts
-import { aiEnvSchema } from "@sahan-sac/ai-core/env";
-
-const schema = z.object({ ...aiEnvSchema.shape, DATABASE_URL: z.string() });
-```
-
-| Variable | Default | Meaning |
-| --- | --- | --- |
-| `ENABLE_BLOG_AI` | `false` | Blog AI assistant (also needs a blog text provider) |
-| `ENABLE_CHATBOT` | `true` | Chatbot (also needs a chat text provider); `false`/`0`/`no`/`off` turns it off |
-| `AI_ALLOW_PAID` | `false` | Lets paid providers join the chains: OpenAI, Anthropic, DeepSeek, xAI, Perplexity, the custom endpoint (unless `AI_CUSTOM_FREE`), Vertex text and images, Gemini images |
-| `AI_PROVIDER_ORDER`, `AI_PROVIDER_ORDER_BLOG`, `AI_PROVIDER_ORDER_CHAT` | built-in order | Comma-separated adapter ids; only the listed ones run, in that order |
-| `GEMINI_API_KEY`, `OPENROUTER_API_KEY`, `OPENROUTER_API_KEY_2`, `NVIDIA_API_KEY` | unset | Free text providers; `NVIDIA_API_KEY` is also the free image provider |
-| `OPENROUTER_BASE_URL`, `OPENROUTER_ALLOW_PAID_MODELS` | OpenRouter API, `false` | OpenRouter settings |
-| `OPENAI_API_KEY`, `OPENAI_BASE_URL` | unset, OpenAI API | OpenAI (paid); the base URL also points it at any OpenAI-compatible gateway |
-| `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL` | unset, Anthropic API | Anthropic Messages API over REST (paid) |
-| `DEEPSEEK_API_KEY`, `XAI_API_KEY`, `PERPLEXITY_API_KEY` | unset | Paid OpenAI-compatible providers |
-| `AI_CUSTOM_BASE_URL`, `AI_CUSTOM_MODEL`, `AI_CUSTOM_API_KEY`, `AI_CUSTOM_NAME`, `AI_CUSTOM_FREE` | unset, `false` | One custom OpenAI-compatible endpoint. The key is optional for a local server. Paid unless `AI_CUSTOM_FREE=true` |
-| `GOOGLE_CLIENT_EMAIL`, `GOOGLE_PRIVATE_KEY`, `GOOGLE_CLOUD_PROJECT` | unset | Vertex service account (paid). Keep the key on one line with literal `\n` |
-| `GOOGLE_TOKEN_URI` | Google's token endpoint | Override only for testing |
-| `BLOG_<P>_MODEL`, `CHAT_<P>_MODEL`, `<P>_MODEL` | built-in defaults | Model per provider `<P>` (`GEMINI`, `OPENROUTER`, `NVIDIA`, `VERTEX`, `OPENAI`, `ANTHROPIC`, `DEEPSEEK`, `XAI`, `PERPLEXITY`): purpose variable, then provider-wide, then default. Paid-provider names change often, so set them |
-| `IMAGE_*_MODEL`, `IMAGEN_MODEL` | verified free defaults | Image models |
-
-## Example
-
-```ts
-import { chatbotEnabled } from "@sahan-sac/ai-core/availability";
-import { aiEnvFromProcess } from "@sahan-sac/ai-core/env";
-import { createAiService, realProviders, sharedAiHealth } from "@sahan-sac/ai-core/providers";
-
-const env = aiEnvFromProcess();
-if (chatbotEnabled(env)) {
-  const ai = createAiService({ providers: realProviders(env, "chat"), health: sharedAiHealth, timeoutMs: 12_000, deadlineMs: 20_000 });
-  const result = await ai.generate({ system: "You are helpful.", user: "Hello" }, { maxTokens: 200, signal: request.signal });
-  // result.provider: who answered; result.attempts: every provider tried, with its error class.
-}
-```
-
-Pass the request's `signal` so a client that disconnects stops the chain: every running attempt is aborted, no further provider starts, and the result is `{ ok: false, errorClass: "aborted" }`. An aborted attempt is not logged or cooled down.
-
-## Your own adapter
-
-```ts
-import { BUILTIN_ADAPTERS, realProviders, type ProviderAdapter } from "@sahan-sac/ai-core/adapters";
-import { openAiCompatibleProvider } from "@sahan-sac/ai-core/providers";
-
-const groq: ProviderAdapter = {
-  id: "groq",
-  label: "Groq",
-  paid: () => false,
-  missing: () => (process.env.GROQ_API_KEY ? [] : ["GROQ_API_KEY"]),
-  create: ({ fetch }) =>
-    openAiCompatibleProvider({ name: "groq", apiKey: process.env.GROQ_API_KEY!, baseUrl: "https://api.groq.com/openai/v1", model: "llama-3.3-70b-versatile", fetch }),
-};
-
-const providers = realProviders(env, "chat", undefined, [...BUILTIN_ADAPTERS, groq]);
-// Default order: the built-ins, then groq. Or list it: AI_PROVIDER_ORDER=groq,gemini
-```
-
-For a settings screen, `providerStatuses(env, purpose)` reports each adapter's state: `active` (with its position), `not_configured` (with the missing variable names, never values), `needs_paid`, `not_in_order` or `unknown`.
-
-## Manual checks
-
-Reachability for an AI provider means a real prompt, which spends tokens, so run it only when an operator asks:
-
-```ts
-import { checkChain, checkProvider } from "@sahan-sac/ai-core/adapters";
-
-await checkProvider(env, "anthropic"); // { id, ok, provider, ms } or { ok: false, errorClass: "http_401", ... }
-await checkChain(env, "blog"); // the whole chain once: who answered, and `attempts` for every fall-through
-```
-
-`checkProvider` ignores the order and `AI_ALLOW_PAID` (the operator asked for that provider) and answers `not_configured` without a call when a variable is missing. `checkChain` uses a fresh health record, so a failed check never cools a provider down for real traffic.
-
-## Owner guidance
-
-`guidanceSection(text)` appends the site owner's standing guidance (voice, facts, do and don't) after a prompt's fixed rules; it returns `""` for empty text and caps the length. `mergeGuidance(global, perFeature)` joins the layers. Guidance steers the model but never overrides the rules above it or how fenced data is treated.
+# @sahan-sac/ai-core
+
+The AI layer shared by `@sahan-sac/blog-kit` and `@sahan-sac/chat-kit`: a free-by-default provider chain with automatic fallback, a provider registry you can configure and extend from the environment, model resolution, image generation (NVIDIA FLUX, then paid Gemini/Vertex), and prompt-injection guards.
+
+Headless and framework-agnostic: no Prisma, no Next.js APIs, no React. Everything takes a parsed env or config object; only `aiEnvFromProcess()` reads `process.env`.
+
+## How a request is answered
+
+Two patterns, kept separate:
+
+- **Adapters.** Every provider is wrapped as an `AiProvider` with one `generate(prompt, options)` that returns `{ ok: true, text }` or a classified failure (`http_429`, `timeout`, `truncated`, `invalid_output`, ...). It never throws. Built in: Gemini, OpenRouter (two keys), NVIDIA, OpenAI, Anthropic (Claude), DeepSeek, xAI (Grok), Perplexity, one custom OpenAI-compatible endpoint (vLLM, Ollama, LiteLLM, a gateway), and Vertex AI.
+- **Chain of responsibility.** `createAiService({ providers })` hands the prompt to the first provider. On any retryable failure it passes the prompt to the next one, until one answers, a non-retryable failure stops it, the deadline passes, or the caller aborts. On top of that:
+  - a provider that timed out or was rate limited cools down and moves behind the healthy ones;
+  - optional hedging starts the next provider while a slow one is still running, and the first valid answer wins;
+  - an `accept` check turns a malformed reply into a failure, so the chain moves on.
+
+The registry (`@sahan-sac/ai-core/adapters`) decides which adapters form a chain and in what order:
+
+1. `AI_PROVIDER_ORDER_BLOG` or `AI_PROVIDER_ORDER_CHAT` for that purpose, else `AI_PROVIDER_ORDER`, else the default order: `gemini, openrouter, openrouter-2, nvidia, openai, anthropic, deepseek, xai, perplexity, custom, vertex`.
+2. An adapter runs only when its variables are set. A paid adapter also needs `AI_ALLOW_PAID=true`, even when it is listed.
+3. **Explicit order:** only the listed ids run, in that order. Speed never reorders them; cooling still does.
+4. **Default order:** paid adapters are last resorts, and the free ones are reordered by observed speed.
+
+## Subpaths
+
+| Import | What |
+| --- | --- |
+| `@sahan-sac/ai-core/env` | `aiEnvSchema` (zod), `parseAiEnv(source)`, `aiEnvFromProcess()`, `AiEnv` |
+| `@sahan-sac/ai-core/adapters` | `BUILTIN_ADAPTERS`, `ProviderAdapter`, `realProviders(env, purpose, fetch?, adapters?)`, `chainPlan`, `providerStatuses` (why each adapter is in or out, for health screens), `checkProvider` / `checkChain` (manual checks), `configuredOrder`, `PAID_TEXT_MODELS` |
+| `@sahan-sac/ai-core/providers` | `createAiService` (the chain), `sharedAiHealth`, `realProviders` (re-exported), the provider factories: `geminiProvider`, `openRouterProvider`, `nvidiaProvider`, `openAiCompatibleProvider`, `anthropicProvider`, `vertexProvider` |
+| `@sahan-sac/ai-core/availability` | `textAiConfigured(env, purpose?)`, `blogAiEnabled`, `blogAiImagesEnabled`, `chatbotEnabled` |
+| `@sahan-sac/ai-core/models` | `textModels`, `imageModels`, verified free defaults, `paidAllowed`, `vertexConfigured` |
+| `@sahan-sac/ai-core/image` | `imageConfigFromEnv`, `generateImage` |
+| `@sahan-sac/ai-core/vertex` | `getVertexAccessToken` (service-account JWT exchange, cached) |
+| `@sahan-sac/ai-core/guard` | `wrapUserData(text, maxLength?)`, `guidanceSection`, `mergeGuidance`, `looksLikeLeak`, `ModelPrompt` |
+| `@sahan-sac/ai-core/log` | `AiLogger`, `consoleAiLogger` |
+
+`providers`, `adapters`, `image` and `vertex` reach `server-only` code: use them from server code only.
+
+## Environment
+
+Spread the schema into your own env module so the names never drift:
+
+```ts
+import { aiEnvSchema } from "@sahan-sac/ai-core/env";
+
+const schema = z.object({ ...aiEnvSchema.shape, DATABASE_URL: z.string() });
+```
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `ENABLE_BLOG_AI` | `false` | Blog AI assistant (also needs a blog text provider) |
+| `ENABLE_CHATBOT` | `true` | Chatbot (also needs a chat text provider); `false`/`0`/`no`/`off` turns it off |
+| `AI_ALLOW_PAID` | `false` | Lets paid providers join the chains: OpenAI, Anthropic, DeepSeek, xAI, Perplexity, the custom endpoint (unless `AI_CUSTOM_FREE`), Vertex text and images, Gemini images |
+| `AI_PROVIDER_ORDER`, `AI_PROVIDER_ORDER_BLOG`, `AI_PROVIDER_ORDER_CHAT` | built-in order | Comma-separated adapter ids; only the listed ones run, in that order |
+| `GEMINI_API_KEY`, `OPENROUTER_API_KEY`, `OPENROUTER_API_KEY_2`, `NVIDIA_API_KEY` | unset | Free text providers; `NVIDIA_API_KEY` is also the free image provider |
+| `OPENROUTER_BASE_URL`, `OPENROUTER_ALLOW_PAID_MODELS` | OpenRouter API, `false` | OpenRouter settings |
+| `OPENAI_API_KEY`, `OPENAI_BASE_URL` | unset, OpenAI API | OpenAI (paid); the base URL also points it at any OpenAI-compatible gateway |
+| `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL` | unset, Anthropic API | Anthropic Messages API over REST (paid) |
+| `OMNIROUTE_BASE_URL`, `OMNIROUTE_API_KEY` | unset | Your self-hosted [OmniRoute](https://github.com/diegosouzapw/OmniRoute) gateway (https, or http on localhost; `/v1` added when missing) and its gateway key. Free only and first in the default order when set. Model `auto/best-free`; override with `OMNIROUTE_MODEL` or `BLOG_`/`CHAT_` variants. An override must be a free route (ends `-free` or `:free`), or the free default replaces it |
+| `OMNIROUTE_ALLOW_PAID` | `false` | Lets an OmniRoute override name a paid route. `AI_ALLOW_PAID` alone never does; both must be on, and the paid route then runs as a last resort |
+| `GROQ_API_KEY` | unset | Groq free plan (no card). Models `openai/gpt-oss-120b` (blog) and `openai/gpt-oss-20b` (chat); override with `GROQ_MODEL` or `BLOG_`/`CHAT_` variants |
+| `MISTRAL_API_KEY` | unset | Mistral free (Experiment) plan, which may train on prompts. Blog chain only, unless `AI_PROVIDER_ORDER_CHAT` lists `mistral` |
+| `CLOUDFLARE_ACCOUNT_ID`, `CLOUDFLARE_AI_API_TOKEN` | unset | Cloudflare Workers AI, 10,000 free neurons a day. Models `@cf/openai/gpt-oss-120b` / `-20b`; override with `CLOUDFLARE_AI_MODEL` |
+| `DEEPSEEK_API_KEY`, `XAI_API_KEY`, `PERPLEXITY_API_KEY` | unset | Paid OpenAI-compatible providers |
+| `AI_CUSTOM_BASE_URL`, `AI_CUSTOM_MODEL`, `AI_CUSTOM_API_KEY`, `AI_CUSTOM_NAME`, `AI_CUSTOM_FREE` | unset, `false` | One custom OpenAI-compatible endpoint. The key is optional for a local server. Paid unless `AI_CUSTOM_FREE=true` |
+| `GOOGLE_CLIENT_EMAIL`, `GOOGLE_PRIVATE_KEY`, `GOOGLE_CLOUD_PROJECT` | unset | Vertex service account (paid). Keep the key on one line with literal `\n` |
+| `GOOGLE_TOKEN_URI` | Google's token endpoint | Override only for testing |
+| `BLOG_<P>_MODEL`, `CHAT_<P>_MODEL`, `<P>_MODEL` | built-in defaults | Model per provider `<P>` (`GEMINI`, `OPENROUTER`, `NVIDIA`, `VERTEX`, `OPENAI`, `ANTHROPIC`, `DEEPSEEK`, `XAI`, `PERPLEXITY`): purpose variable, then provider-wide, then default. Paid-provider names change often, so set them |
+| `IMAGE_*_MODEL`, `IMAGEN_MODEL` | verified free defaults | Image models |
+
+## Example
+
+```ts
+import { chatbotEnabled } from "@sahan-sac/ai-core/availability";
+import { aiEnvFromProcess } from "@sahan-sac/ai-core/env";
+import { createAiService, realProviders, sharedAiHealth } from "@sahan-sac/ai-core/providers";
+
+const env = aiEnvFromProcess();
+if (chatbotEnabled(env)) {
+  const ai = createAiService({ providers: realProviders(env, "chat"), health: sharedAiHealth, timeoutMs: 12_000, deadlineMs: 20_000 });
+  const result = await ai.generate({ system: "You are helpful.", user: "Hello" }, { maxTokens: 200, signal: request.signal });
+  // result.provider: who answered; result.attempts: every provider tried, with its error class.
+}
+```
+
+Pass the request's `signal` so a client that disconnects stops the chain: every running attempt is aborted, no further provider starts, and the result is `{ ok: false, errorClass: "aborted" }`. An aborted attempt is not logged or cooled down.
+
+## Your own adapter
+
+```ts
+import { BUILTIN_ADAPTERS, realProviders, type ProviderAdapter } from "@sahan-sac/ai-core/adapters";
+import { openAiCompatibleProvider } from "@sahan-sac/ai-core/providers";
+
+const groq: ProviderAdapter = {
+  id: "groq",
+  label: "Groq",
+  paid: () => false,
+  missing: () => (process.env.GROQ_API_KEY ? [] : ["GROQ_API_KEY"]),
+  create: ({ fetch }) =>
+    openAiCompatibleProvider({ name: "groq", apiKey: process.env.GROQ_API_KEY!, baseUrl: "https://api.groq.com/openai/v1", model: "llama-3.3-70b-versatile", fetch }),
+};
+
+const providers = realProviders(env, "chat", undefined, [...BUILTIN_ADAPTERS, groq]);
+// Default order: the built-ins, then groq. Or list it: AI_PROVIDER_ORDER=groq,gemini
+```
+
+For a settings screen, `providerStatuses(env, purpose)` reports each adapter's state: `active` (with its position), `not_configured` (with the missing variable names, never values), `needs_paid`, `not_in_order` or `unknown`.
+
+## Manual checks
+
+Reachability for an AI provider means a real prompt, which spends tokens, so run it only when an operator asks:
+
+```ts
+import { checkChain, checkProvider } from "@sahan-sac/ai-core/adapters";
+
+await checkProvider(env, "anthropic"); // { id, ok, provider, ms } or { ok: false, errorClass: "http_401", ... }
+await checkChain(env, "blog"); // the whole chain once: who answered, and `attempts` for every fall-through
+```
+
+`checkProvider` ignores the order and `AI_ALLOW_PAID` (the operator asked for that provider) and answers `not_configured` without a call when a variable is missing. `checkChain` uses a fresh health record, so a failed check never cools a provider down for real traffic.
+
+## Owner guidance
+
+`guidanceSection(text)` appends the site owner's standing guidance (voice, facts, do and don't) after a prompt's fixed rules; it returns `""` for empty text and caps the length. `mergeGuidance(global, perFeature)` joins the layers. Guidance steers the model but never overrides the rules above it or how fenced data is treated.

package/dist/adapters.d.ts

@@ -1,6 +1,6 @@
 import './env.js';
 import './models.js';
-export { A as AdapterContext, a as AdapterState, b as AdapterStatus, B as BUILTIN_ADAPTERS, C as CHECK_PROMPT, D as DEFAULT_ORDER, P as PAID_TEXT_MODELS, c as ProviderAdapter, d as ProviderCheck, e as chainPlan, f as checkChain, g as checkProvider, h as configuredOrder, p as providerStatuses, realProviders } from './providers.js';
+export { A as AdapterContext, a as AdapterState, b as AdapterStatus, B as BUILTIN_ADAPTERS, C as CHECK_PROMPT, D as DEFAULT_ORDER, F as FREE_TEXT_MODELS, P as PAID_TEXT_MODELS, c as ProviderAdapter, d as ProviderCheck, e as chainPlan, f as checkChain, g as checkProvider, h as configuredOrder, i as isFreeRoute, o as omniRouteBaseUrl, j as omniRouteModel, p as providerStatuses, realProviders } from './providers.js';
 import 'zod';
 import './guard.js';
 import './log.js';

package/dist/adapters.js

@@ -2,14 +2,18 @@ import {
   BUILTIN_ADAPTERS,
   CHECK_PROMPT,
   DEFAULT_ORDER,
+  FREE_TEXT_MODELS,
   PAID_TEXT_MODELS,
   chainPlan,
   checkChain,
   checkProvider,
   configuredOrder,
+  isFreeRoute,
+  omniRouteBaseUrl,
+  omniRouteModel,
   providerStatuses,
   realProviders
-} from "./chunk-R3YY2Y7S.js";
+} from "./chunk-D6KCXFSF.js";
 import "./chunk-BL4J2JNX.js";
 import "./chunk-PMC3UWQ2.js";
 import "./chunk-RBSLNDFW.js";
@@ -17,11 +21,15 @@ export {
   BUILTIN_ADAPTERS,
   CHECK_PROMPT,
   DEFAULT_ORDER,
+  FREE_TEXT_MODELS,
   PAID_TEXT_MODELS,
   chainPlan,
   checkChain,
   checkProvider,
   configuredOrder,
+  isFreeRoute,
+  omniRouteBaseUrl,
+  omniRouteModel,
   providerStatuses,
   realProviders
 };

package/dist/availability.js

@@ -1,6 +1,6 @@
 import {
   chainPlan
-} from "./chunk-R3YY2Y7S.js";
+} from "./chunk-D6KCXFSF.js";
 import {
   imageConfigFromEnv
 } from "./chunk-MRNQPHWI.js";

package/dist/{chunk-R3YY2Y7S.js → chunk-D6KCXFSF.js}

@@ -23,6 +23,13 @@ function modelFor(env, provider, purpose, fallback) {
   return record[`${purpose.toUpperCase()}_${provider}_MODEL`] || record[`${provider}_MODEL`] || fallback[purpose];
 }
 var need = (env, ...names) => names.filter((name) => !env[name]);
+var FREE_TEXT_MODELS = {
+  // OmniRoute's own alias: its "best free" combo, which only routes to free providers.
+  omniroute: { blog: "auto/best-free", chat: "auto/best-free" },
+  groq: { blog: "openai/gpt-oss-120b", chat: "openai/gpt-oss-20b" },
+  mistral: { blog: "mistral-medium-latest", chat: "mistral-small-latest" },
+  cloudflare: { blog: "@cf/openai/gpt-oss-120b", chat: "@cf/openai/gpt-oss-20b" }
+};
 var PAID_TEXT_MODELS = {
   openai: { blog: "gpt-5-mini", chat: "gpt-5-nano" },
   anthropic: { blog: "claude-sonnet-5-5", chat: "claude-haiku-4-5-20251001" },
@@ -45,6 +52,28 @@ function compatibleAdapter(spec) {
     })
   };
 }
+function omniRouteBaseUrl(env) {
+  const raw = env.OMNIROUTE_BASE_URL?.trim();
+  if (!raw) return null;
+  try {
+    const url = new URL(raw);
+    const local = /^(?:localhost|127\.0\.0\.1|\[::1\])$/.test(url.hostname);
+    if (url.username || url.password) return null;
+    if (!(url.protocol === "https:" || url.protocol === "http:" && local)) return null;
+    const base = `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+    return base.endsWith("/v1") ? base : `${base}/v1`;
+  } catch {
+    return null;
+  }
+}
+function isFreeRoute(model) {
+  return /[-:/]free$/i.test(model.trim());
+}
+function omniRouteModel(env, purpose) {
+  const model = modelFor(env, "OMNIROUTE", purpose, FREE_TEXT_MODELS.omniroute);
+  return isFreeRoute(model) || env.OMNIROUTE_ALLOW_PAID && paidAllowed(env) ? model : FREE_TEXT_MODELS.omniroute[purpose];
+}
+var PURPOSES = ["blog", "chat"];
 var openRouterAdapter = (id, keyVar) => ({
   id,
   label: id === "openrouter" ? "OpenRouter" : "OpenRouter (second key)",
@@ -61,6 +90,25 @@ var openRouterAdapter = (id, keyVar) => ({
   })
 });
 var BUILTIN_ADAPTERS = [
+  {
+    // OmniRoute: a self-hosted gateway that pools many providers' free tiers
+    // behind one OpenAI-compatible endpoint and fails over between them. First
+    // in the default order, so it leads whenever its address is set. Free only
+    // unless OMNIROUTE_ALLOW_PAID (see omniRouteModel); a paid route then
+    // counts as paid, so it runs as a last resort like any paid provider.
+    id: "omniroute",
+    label: "OmniRoute (self-hosted gateway)",
+    paid: (env, purpose) => (purpose ? [purpose] : PURPOSES).some((each) => !isFreeRoute(omniRouteModel(env, each))),
+    missing: (env) => omniRouteBaseUrl(env) ? [] : ["OMNIROUTE_BASE_URL"],
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: "omniroute",
+      // A gateway may run without keys; the header must still be well formed.
+      apiKey: env.OMNIROUTE_API_KEY || "none",
+      baseUrl: omniRouteBaseUrl(env),
+      model: omniRouteModel(env, purpose),
+      fetch: fetch2
+    })
+  },
   {
     id: "gemini",
     label: "Gemini",
@@ -68,6 +116,19 @@ var BUILTIN_ADAPTERS = [
     missing: (env) => need(env, "GEMINI_API_KEY"),
     create: ({ env, purpose, fetch: fetch2 }) => geminiProvider({ apiKey: env.GEMINI_API_KEY, model: textModels(env, purpose).gemini, fetchImpl: fetch2 })
   },
+  {
+    id: "groq",
+    label: "Groq",
+    paid: () => false,
+    missing: (env) => need(env, "GROQ_API_KEY"),
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: "groq",
+      apiKey: env.GROQ_API_KEY,
+      baseUrl: "https://api.groq.com/openai/v1",
+      model: modelFor(env, "GROQ", purpose, FREE_TEXT_MODELS.groq),
+      fetch: fetch2
+    })
+  },
   openRouterAdapter("openrouter", "OPENROUTER_API_KEY"),
   openRouterAdapter("openrouter-2", "OPENROUTER_API_KEY_2"),
   {
@@ -83,6 +144,35 @@ var BUILTIN_ADAPTERS = [
       fetch: fetch2
     })
   },
+  {
+    id: "mistral",
+    label: "Mistral",
+    paid: () => false,
+    // The free plan may train on prompts: keep visitors' chat text out unless
+    // the operator lists it in AI_PROVIDER_ORDER_CHAT.
+    defaultPurposes: ["blog"],
+    missing: (env) => need(env, "MISTRAL_API_KEY"),
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: "mistral",
+      apiKey: env.MISTRAL_API_KEY,
+      baseUrl: "https://api.mistral.ai/v1",
+      model: modelFor(env, "MISTRAL", purpose, FREE_TEXT_MODELS.mistral),
+      fetch: fetch2
+    })
+  },
+  {
+    id: "cloudflare",
+    label: "Cloudflare Workers AI",
+    paid: () => false,
+    missing: (env) => need(env, "CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_AI_API_TOKEN"),
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: "cloudflare",
+      apiKey: env.CLOUDFLARE_AI_API_TOKEN,
+      baseUrl: `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(env.CLOUDFLARE_ACCOUNT_ID)}/ai/v1`,
+      model: modelFor(env, "CLOUDFLARE_AI", purpose, FREE_TEXT_MODELS.cloudflare),
+      fetch: fetch2
+    })
+  },
   compatibleAdapter({ id: "openai", label: "OpenAI", envPrefix: "OPENAI", keyVar: "OPENAI_API_KEY", baseUrl: "https://api.openai.com/v1", baseUrlVar: "OPENAI_BASE_URL" }),
   {
     id: "anthropic",
@@ -137,7 +227,7 @@ function configuredOrder(env, purpose) {
 }
 function providerStatuses(env, purpose, adapters = BUILTIN_ADAPTERS) {
   const order = configuredOrder(env, purpose);
-  const ids = order ?? adapters.map((adapter) => adapter.id);
+  const ids = order ?? adapters.filter((adapter) => !adapter.defaultPurposes || adapter.defaultPurposes.includes(purpose)).map((adapter) => adapter.id);
   const byId = new Map(adapters.map((adapter) => [adapter.id, adapter]));
   let position = 0;
   const statuses = [];
@@ -148,13 +238,13 @@ function providerStatuses(env, purpose, adapters = BUILTIN_ADAPTERS) {
       continue;
     }
     const missing = adapter.missing(env);
-    const paid = adapter.paid(env);
+    const paid = adapter.paid(env, purpose);
     const state = missing.length ? "not_configured" : paid && !paidAllowed(env) ? "needs_paid" : "active";
     statuses.push({ id, label: adapter.label, paid, state, missing, ...state === "active" ? { position: position++ } : {} });
   }
   for (const adapter of adapters) {
     if (!ids.includes(adapter.id)) {
-      statuses.push({ id: adapter.id, label: adapter.label, paid: adapter.paid(env), state: "not_in_order", missing: adapter.missing(env) });
+      statuses.push({ id: adapter.id, label: adapter.label, paid: adapter.paid(env, purpose), state: "not_in_order", missing: adapter.missing(env) });
     }
   }
   return statuses;
@@ -203,7 +293,7 @@ function realProviders(env, purpose, fetchImpl, adapters = BUILTIN_ADAPTERS) {
   const explicit = configuredOrder(env, purpose) !== null;
   return chainPlan(env, purpose, adapters).map((adapter, index) => {
     const provider = adapter.create({ env, purpose, fetch: fetchImpl });
-    return explicit ? { name: provider.name, generate: provider.generate, priority: index } : { name: provider.name, generate: provider.generate, lastResort: adapter.paid(env) || provider.lastResort };
+    return explicit ? { name: provider.name, generate: provider.generate, priority: index } : { name: provider.name, generate: provider.generate, lastResort: adapter.paid(env, purpose) || provider.lastResort };
   });
 }
 
@@ -239,6 +329,7 @@ var sharedAiHealth = globalThis.sahanAiHealth ??= createAiHealth();
 function cooldownFor(outcome) {
   if (outcome.ok) return 0;
   if (outcome.errorClass === "timeout" || outcome.status === 429) return AI_COOLDOWN_MS;
+  if (outcome.status === 402) return AI_COOLDOWN_MS * 30;
   if (outcome.status === 401 || outcome.status === 403 || outcome.status === 404) return AI_COOLDOWN_MS * 10;
   return 0;
 }
@@ -548,6 +639,7 @@ export {
   AI_COOLDOWN_MS,
   createAiHealth,
   sharedAiHealth,
+  cooldownFor,
   HEDGE,
   createAiService,
   openRouterProvider,
@@ -558,7 +650,11 @@ export {
   geminiOutcome,
   geminiProvider,
   vertexProvider,
+  FREE_TEXT_MODELS,
   PAID_TEXT_MODELS,
+  omniRouteBaseUrl,
+  isFreeRoute,
+  omniRouteModel,
   BUILTIN_ADAPTERS,
   DEFAULT_ORDER,
   configuredOrder,

package/dist/{chunk-ZIHRZXPE.js → chunk-TEOP42ST.js}

@@ -26,6 +26,33 @@ var aiEnvSchema = z.object({
   OPENROUTER_ALLOW_PAID_MODELS: flag,
   GEMINI_API_KEY: text,
   NVIDIA_API_KEY: text,
+  // OmniRoute (./adapters): a self-hosted gateway pooling free tiers. The
+  // address turns it on; the key is a gateway key from its dashboard.
+  OMNIROUTE_BASE_URL: text,
+  OMNIROUTE_API_KEY: text,
+  OMNIROUTE_MODEL: text,
+  BLOG_OMNIROUTE_MODEL: text,
+  CHAT_OMNIROUTE_MODEL: text,
+  // Lets an OmniRoute model override name a paid route; AI_ALLOW_PAID must be
+  // on as well. Off: only free routes (`-free`, `:free`) are ever sent.
+  OMNIROUTE_ALLOW_PAID: flag,
+  // More free tiers (./adapters). Groq: free plan, no card. Mistral: free
+  // Experiment plan, which may train on prompts, so it joins the chat chain
+  // only when AI_PROVIDER_ORDER_CHAT lists it. Cloudflare Workers AI: 10,000
+  // free neurons a day; needs the account id and a Workers AI token.
+  GROQ_API_KEY: text,
+  GROQ_MODEL: text,
+  BLOG_GROQ_MODEL: text,
+  CHAT_GROQ_MODEL: text,
+  MISTRAL_API_KEY: text,
+  MISTRAL_MODEL: text,
+  BLOG_MISTRAL_MODEL: text,
+  CHAT_MISTRAL_MODEL: text,
+  CLOUDFLARE_ACCOUNT_ID: text,
+  CLOUDFLARE_AI_API_TOKEN: text,
+  CLOUDFLARE_AI_MODEL: text,
+  BLOG_CLOUDFLARE_AI_MODEL: text,
+  CHAT_CLOUDFLARE_AI_MODEL: text,
   // Model overrides, all optional (models.ts): purpose variable, then the
   // provider-wide *_MODEL, then a verified free default.
   OPENROUTER_MODEL: text,

package/dist/env.d.ts

@@ -11,6 +11,25 @@ declare const aiEnvSchema: z.ZodObject<{
     OPENROUTER_ALLOW_PAID_MODELS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
     GEMINI_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     NVIDIA_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OMNIROUTE_BASE_URL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OMNIROUTE_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OMNIROUTE_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_OMNIROUTE_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_OMNIROUTE_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OMNIROUTE_ALLOW_PAID: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
+    GROQ_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    GROQ_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_GROQ_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_GROQ_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    MISTRAL_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    MISTRAL_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_MISTRAL_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_MISTRAL_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CLOUDFLARE_ACCOUNT_ID: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CLOUDFLARE_AI_API_TOKEN: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CLOUDFLARE_AI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_CLOUDFLARE_AI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_CLOUDFLARE_AI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     OPENROUTER_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     GEMINI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     NVIDIA_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;

package/dist/env.js

@@ -3,7 +3,7 @@ import {
   aiEnvFromProcess,
   aiEnvSchema,
   parseAiEnv
-} from "./chunk-ZIHRZXPE.js";
+} from "./chunk-TEOP42ST.js";
 export {
   DEFAULT_GOOGLE_TOKEN_URI,
   aiEnvFromProcess,

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   aiEnvFromProcess,
   aiEnvSchema,
   parseAiEnv
-} from "./chunk-ZIHRZXPE.js";
+} from "./chunk-TEOP42ST.js";
 export {
   aiEnvFromProcess,
   aiEnvSchema,

package/dist/providers.d.ts

@@ -70,6 +70,13 @@ interface AiHealth {
 declare const createAiHealth: () => AiHealth;
 /** One per server instance, for request handlers; tests and scripts get a fresh one by default. */
 declare const sharedAiHealth: AiHealth;
+/**
+ * Quota and slowness pass quickly; a wrong key or a retired model needs an
+ * operator, so it cools longer; an empty prepaid wallet (402) needs someone to
+ * add funds, so it cools longest and costs one probe per half hour instead of
+ * a failed round trip on every request.
+ */
+declare function cooldownFor(outcome: AiOutcome): number;
 interface AiServiceDeps {
     providers: readonly AiProvider[];
     /** Per-provider attempt budget. */
@@ -188,12 +195,42 @@ interface ProviderAdapter {
     /** Lowercase id used in AI_PROVIDER_ORDER. */
     readonly id: string;
     readonly label: string;
-    /** Costs money: runs only with AI_ALLOW_PAID. */
-    paid(env: AiEnv): boolean;
+    /**
+     * Purposes it joins under the default order; unset means all. An explicit
+     * AI_PROVIDER_ORDER(_BLOG|_CHAT) still adds it anywhere it is listed.
+     */
+    readonly defaultPurposes?: readonly TextPurpose[];
+    /**
+     * Costs money: runs only with AI_ALLOW_PAID. `purpose` is set when the
+     * answer can differ per purpose; without it, true when any purpose is paid.
+     */
+    paid(env: AiEnv, purpose?: TextPurpose): boolean;
     /** Env variable names still missing; empty means configured. Never values. */
     missing(env: AiEnv): string[];
     create(context: AdapterContext): AiProvider;
 }
+/**
+ * Defaults for the free-tier adapters that take an id per purpose. The blog
+ * writes long JSON, so it gets the larger model; chat gets the faster one.
+ */
+declare const FREE_TEXT_MODELS: {
+    readonly omniroute: {
+        readonly blog: "auto/best-free";
+        readonly chat: "auto/best-free";
+    };
+    readonly groq: {
+        readonly blog: "openai/gpt-oss-120b";
+        readonly chat: "openai/gpt-oss-20b";
+    };
+    readonly mistral: {
+        readonly blog: "mistral-medium-latest";
+        readonly chat: "mistral-small-latest";
+    };
+    readonly cloudflare: {
+        readonly blog: "@cf/openai/gpt-oss-120b";
+        readonly chat: "@cf/openai/gpt-oss-20b";
+    };
+};
 /**
  * Defaults for the paid adapters. Model names change often: set the
  * provider's *_MODEL variable rather than relying on these.
@@ -220,6 +257,21 @@ declare const PAID_TEXT_MODELS: {
         readonly chat: "sonar";
     };
 };
+/**
+ * OMNIROUTE_BASE_URL as the gateway's `/v1` base, or null when unset or unsafe.
+ * https only, except plain http on localhost for a gateway on the same machine;
+ * never credentials in the URL.
+ */
+declare function omniRouteBaseUrl(env: AiEnv): string | null;
+/** An OmniRoute model id that names a free route: `auto/best-free`, `<provider>/<model>:free`. */
+declare function isFreeRoute(model: string): boolean;
+/**
+ * The OmniRoute model for a purpose. Free only by default: an override that is
+ * not a free route counts only with OMNIROUTE_ALLOW_PAID and AI_ALLOW_PAID both
+ * on; otherwise the free default replaces it, so the gateway keeps answering
+ * for free instead of dropping out of the chain.
+ */
+declare function omniRouteModel(env: AiEnv, purpose: TextPurpose): string;
 declare const BUILTIN_ADAPTERS: readonly ProviderAdapter[];
 /** Free tiers first (fastest, most reliable first), paid last. */
 declare const DEFAULT_ORDER: string[];
@@ -290,4 +342,4 @@ declare function checkChain(env: AiEnv, purpose: TextPurpose, options?: {
  */
 declare function realProviders(env: AiEnv, purpose: TextPurpose, fetchImpl?: typeof fetch, adapters?: readonly ProviderAdapter[]): AiProvider[];
 
-export { type AdapterContext as A, AI_COOLDOWN_MS, AI_TIMEOUT_MS, type AiAttempt, type AiAttemptStatus, type AiGenerateOptions, type AiHealth, type AiOutcome, type AiProvider, type AiResult, type AiServiceDeps, BUILTIN_ADAPTERS as B, CHECK_PROMPT as C, DEFAULT_ORDER as D, HEDGE, type JsonMode, PAID_TEXT_MODELS as P, type AdapterState as a, anthropicOutcome, anthropicProvider, type AdapterStatus as b, type ProviderAdapter as c, createAiHealth, createAiService, type ProviderCheck as d, chainPlan as e, checkChain as f, checkProvider as g, geminiOutcome, geminiProvider, configuredOrder as h, nvidiaProvider, openAiCompatibleProvider, openRouterProvider, providerStatuses as p, realProviders, sharedAiHealth, vertexProvider };
+export { type AdapterContext as A, AI_COOLDOWN_MS, AI_TIMEOUT_MS, type AiAttempt, type AiAttemptStatus, type AiGenerateOptions, type AiHealth, type AiOutcome, type AiProvider, type AiResult, type AiServiceDeps, BUILTIN_ADAPTERS as B, CHECK_PROMPT as C, DEFAULT_ORDER as D, FREE_TEXT_MODELS as F, HEDGE, type JsonMode, PAID_TEXT_MODELS as P, type AdapterState as a, anthropicOutcome, anthropicProvider, type AdapterStatus as b, type ProviderAdapter as c, cooldownFor, createAiHealth, createAiService, type ProviderCheck as d, chainPlan as e, checkChain as f, checkProvider as g, geminiOutcome, geminiProvider, configuredOrder as h, isFreeRoute as i, omniRouteModel as j, nvidiaProvider, omniRouteBaseUrl as o, openAiCompatibleProvider, openRouterProvider, providerStatuses as p, realProviders, sharedAiHealth, vertexProvider };

package/dist/providers.js

@@ -4,6 +4,7 @@ import {
   HEDGE,
   anthropicOutcome,
   anthropicProvider,
+  cooldownFor,
   createAiHealth,
   createAiService,
   geminiOutcome,
@@ -14,7 +15,7 @@ import {
   realProviders,
   sharedAiHealth,
   vertexProvider
-} from "./chunk-R3YY2Y7S.js";
+} from "./chunk-D6KCXFSF.js";
 import "./chunk-BL4J2JNX.js";
 import "./chunk-PMC3UWQ2.js";
 import "./chunk-RBSLNDFW.js";
@@ -24,6 +25,7 @@ export {
   HEDGE,
   anthropicOutcome,
   anthropicProvider,
+  cooldownFor,
   createAiHealth,
   createAiService,
   geminiOutcome,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sahan-sac/ai-core",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Free-by-default AI provider chain with fallback (chain of responsibility over provider adapters: Gemini, OpenRouter, NVIDIA, OpenAI, Anthropic, DeepSeek, xAI, Perplexity, any OpenAI-compatible endpoint, Vertex), env-configurable order, hedging, cooldowns and deadlines, image generation and prompt-injection guards. Shared by @sahan-sac/blog-kit and @sahan-sac/chat-kit.",
   "license": "Apache-2.0",
   "repository": {
@@ -92,6 +92,6 @@
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.build.json",
-    "test": "node --conditions=react-server --import tsx --test \"src/**/*.test.ts\""
+    "test": "node ../../scripts/test-package.mjs --conditions=react-server"
   }
 }