Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/gpt-oss-120b.svg filter=lfs diff=lfs merge=lfs -text
+docs/gpt-oss-20b.svg filter=lfs diff=lfs merge=lfs -text
+docs/gpt-oss.svg filter=lfs diff=lfs merge=lfs -text

CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.26)
+project(gpt_oss LANGUAGES C CXX)
+
+# If not defined externally, auto-detect
+if(NOT DEFINED GPTOSS_BUILD_METAL)
+  if(APPLE AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+    message(STATUS "Apple Silicon detected → enabling GPTOSS_BUILD_METAL")
+    set(GPTOSS_BUILD_METAL ON)
+  else()
+    message(STATUS "Non-Apple Silicon → disabling GPTOSS_BUILD_METAL")
+    set(GPTOSS_BUILD_METAL OFF)
+  endif()
+else()
+  message(STATUS "GPTOSS_BUILD_METAL manually set to: ${GPTOSS_BUILD_METAL}")
+endif()
+
+# Now declare it as a cache variable (respects user-provided value)
+set(GPTOSS_BUILD_METAL "${GPTOSS_BUILD_METAL}" CACHE BOOL "Enable Metal backend")
+
+if(GPTOSS_BUILD_METAL)
+  enable_language(OBJC)
+  add_subdirectory(gpt_oss/metal)
+endif()

LICENSE

@@ -0,0 +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 [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include _build * 

README.md

@@ -1,3 +1,595 @@
----
-license: apache-2.0
----
+<img alt="gpt-oss-120" src="./docs/gpt-oss.svg">
+<p align="center">
+  <a href="https://gpt-oss.com"><strong>Try gpt-oss</strong></a> ·
+  <a href="https://cookbook.openai.com/topic/gpt-oss"><strong>Guides</strong></a> ·
+  <a href="https://arxiv.org/abs/2508.10925"><strong>Model card</strong></a> ·
+  <a href="https://openai.com/index/introducing-gpt-oss/"><strong>OpenAI blog</strong></a>
+</p>
+<p align="center">
+  <strong>Download <a href="https://huggingface.co/openai/gpt-oss-120b">gpt-oss-120b</a> and <a href="https://huggingface.co/openai/gpt-oss-20b">gpt-oss-20b</a> on Hugging Face</strong>
+</p>
+
+<br>
+
+Welcome to the gpt-oss series, [OpenAI's open-weight models](https://openai.com/open-models/) designed for powerful reasoning, agentic tasks, and versatile developer use cases.
+
+We're releasing two flavors of these open models:
+
+- `gpt-oss-120b` — for production, general purpose, high reasoning use cases that fit into a single 80GB GPU (like NVIDIA H100 or AMD MI300X) (117B parameters with 5.1B active parameters)
+- `gpt-oss-20b` — for lower latency, and local or specialized use cases (21B parameters with 3.6B active parameters)
+
+Both models were trained using our [harmony response format][harmony] and should only be used with this format; otherwise, they will not work correctly.
+
+## Table of Contents
+- [Highlights](#highlights)
+- [Inference examples](#inference-examples)
+- [About this repository](#about-this-repository)
+- [Setup](#setup)
+- [Download the model](#download-the-model)
+- [Reference PyTorch implementation](#reference-pytorch-implementation)
+- [Reference Triton implementation (single GPU)](#reference-triton-implementation-single-gpu)
+- [Reference Metal implementation](#reference-metal-implementation)
+- [Harmony format & tools](#harmony-format--tools)
+- [Clients](#clients)
+- [Tools](#tools)
+- [Other details](#other-details)
+- [Contributing](#contributing)
+
+### Highlights
+
+- **Permissive Apache 2.0 license:** Build freely without copyleft restrictions or patent risk—ideal for experimentation, customization, and commercial deployment.
+- **Configurable reasoning effort:** Easily adjust the reasoning effort (low, medium, high) based on your specific use case and latency needs.
+- **Full chain-of-thought:** Provides complete access to the model's reasoning process, facilitating easier debugging and greater trust in outputs. This information is not intended to be shown to end users.
+- **Fine-tunable:** Fully customize models to your specific use case through parameter fine-tuning.
+- **Agentic capabilities:** Use the models' native capabilities for function calling, [web browsing](#browser), [Python code execution](#python), and Structured Outputs.
+- **MXFP4 quantization:** The models were post-trained with MXFP4 quantization of the MoE weights, making `gpt-oss-120b` run on a single 80GB GPU (like NVIDIA H100 or AMD MI300X) and the `gpt-oss-20b` model run within 16GB of memory. All evals were performed with the same MXFP4 quantization.
+
+### Inference examples
+
+#### Transformers
+
+You can use `gpt-oss-120b` and `gpt-oss-20b` with the Transformers library. If you use Transformers' chat template, it will automatically apply the [harmony response format][harmony]. If you use `model.generate` directly, you need to apply the harmony format manually using the chat template or use our [`openai-harmony`][harmony] package.
+
+```python
+from transformers import pipeline
+import torch
+
+model_id = "openai/gpt-oss-120b"
+
+pipe = pipeline(
+    "text-generation",
+    model=model_id,
+    torch_dtype="auto",
+    device_map="auto",
+)
+
+messages = [
+    {"role": "user", "content": "Explain quantum mechanics clearly and concisely."},
+]
+
+outputs = pipe(
+    messages,
+    max_new_tokens=256,
+)
+print(outputs[0]["generated_text"][-1])
+```
+
+[Learn more about how to use gpt-oss with Transformers.](https://cookbook.openai.com/articles/gpt-oss/run-transformers)
+
+#### vLLM
+
+vLLM recommends using [`uv`](https://docs.astral.sh/uv/) for Python dependency management. You can use vLLM to spin up an OpenAI-compatible web server. The following command will automatically download the model and start the server.
+
+```bash
+uv pip install --pre vllm==0.10.1+gptoss \
+    --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
+    --extra-index-url https://download.pytorch.org/whl/nightly/cu128 \
+    --index-strategy unsafe-best-match
+
+vllm serve openai/gpt-oss-20b
+```
+
+[Learn more about how to use gpt-oss with vLLM.](https://cookbook.openai.com/articles/gpt-oss/run-vllm)
+
+Offline Serve Code:
+- run this code after installing proper libraries as described, while additionally installing this:
+- `uv pip install openai-harmony`
+```python
+# source .oss/bin/activate
+
+import os
+os.environ["VLLM_USE_FLASHINFER_SAMPLER"] = "0"
+
+import json
+from openai_harmony import (
+    HarmonyEncodingName,
+    load_harmony_encoding,
+    Conversation,
+    Message,
+    Role,
+    SystemContent,
+    DeveloperContent,
+)
+ 
+from vllm import LLM, SamplingParams
+import os
+
+# --- 1) Render the prefill with Harmony ---
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+ 
+convo = Conversation.from_messages(
+    [
+        Message.from_role_and_content(Role.SYSTEM, SystemContent.new()),
+        Message.from_role_and_content(
+            Role.DEVELOPER,
+            DeveloperContent.new().with_instructions("Always respond in riddles"),
+        ),
+        Message.from_role_and_content(Role.USER, "What is the weather like in SF?"),
+    ]
+)
+ 
+prefill_ids = encoding.render_conversation_for_completion(convo, Role.ASSISTANT)
+ 
+# Harmony stop tokens (pass to sampler so they won't be included in output)
+stop_token_ids = encoding.stop_tokens_for_assistant_actions()
+ 
+# --- 2) Run vLLM with prefill ---
+llm = LLM(
+    model="openai/gpt-oss-20b",
+    trust_remote_code=True,
+    gpu_memory_utilization = 0.95,
+    max_num_batched_tokens=4096,
+    max_model_len=5000,
+    tensor_parallel_size=1
+)
+ 
+sampling = SamplingParams(
+    max_tokens=128,
+    temperature=1,
+    stop_token_ids=stop_token_ids,
+)
+ 
+outputs = llm.generate(
+    prompt_token_ids=[prefill_ids],   # batch of size 1
+    sampling_params=sampling,
+)
+ 
+# vLLM gives you both text and token IDs
+gen = outputs[0].outputs[0]
+text = gen.text
+output_tokens = gen.token_ids  # <-- these are the completion token IDs (no prefill)
+ 
+# --- 3) Parse the completion token IDs back into structured Harmony messages ---
+entries = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
+ 
+# 'entries' is a sequence of structured conversation entries (assistant messages, tool calls, etc.).
+for message in entries:
+    print(f"{json.dumps(message.to_dict())}")
+```
+
+#### PyTorch / Triton / Metal
+
+These implementations are largely reference implementations for educational purposes and are not expected to be run in production.
+
+[Learn more below.](#reference-pytorch-implementation)
+
+#### Ollama
+
+If you are trying to run `gpt-oss` on consumer hardware, you can use Ollama by running the following commands after [installing Ollama](https://ollama.com/download).
+
+```bash
+# gpt-oss-20b
+ollama pull gpt-oss:20b
+ollama run gpt-oss:20b
+
+# gpt-oss-120b
+ollama pull gpt-oss:120b
+ollama run gpt-oss:120b
+```
+
+[Learn more about how to use gpt-oss with Ollama.](https://cookbook.openai.com/articles/gpt-oss/run-locally-ollama)
+
+#### LM Studio
+
+If you are using [LM Studio](https://lmstudio.ai/) you can use the following commands to download.
+
+```bash
+# gpt-oss-20b
+lms get openai/gpt-oss-20b
+# gpt-oss-120b
+lms get openai/gpt-oss-120b
+```
+
+Check out our [awesome list](./awesome-gpt-oss.md) for a broader collection of gpt-oss resources and inference partners.
+
+## About this repository
+
+This repository provides a collection of reference implementations:
+
+- **Inference:**
+  - [`torch`](#reference-pytorch-implementation) — a non-optimized [PyTorch](https://pytorch.org/) implementation for educational purposes only. Requires at least 4× H100 GPUs due to lack of optimization.
+  - [`triton`](#reference-triton-implementation-single-gpu) — a more optimized implementation using [PyTorch](https://pytorch.org/) & [Triton](https://github.com/triton-lang/triton) incl. using CUDA graphs and basic caching
+  - [`metal`](#reference-metal-implementation) — a Metal-specific implementation for running the models on Apple Silicon hardware
+- **Tools:**
+  - [`browser`](#browser) — a reference implementation of the browser tool the models got trained on
+  - [`python`](#python) — a stateless reference implementation of the python tool the model got trained on
+- **Client examples:**
+  - [`chat`](#terminal-chat) — a basic terminal chat application that uses the PyTorch or Triton implementations for inference along with the python and browser tools
+  - [`responses_api`](#responses-api) — an example Responses API compatible server that implements the browser tool along with other Responses-compatible functionality
+
+## Setup
+
+### Requirements
+
+- Python 3.12
+- On macOS: Install the Xcode CLI tools --> `xcode-select --install`
+- On Linux: These reference implementations require CUDA
+- On Windows: These reference implementations have not been tested on Windows. Try using solutions like Ollama if you are trying to run the model locally.
+
+### Installation
+
+If you want to try any of the code you can install it directly from [PyPI](https://pypi.org/project/gpt-oss/)
+
+```shell
+# if you just need the tools
+pip install gpt-oss
+# if you want to try the torch implementation
+pip install gpt-oss[torch]
+# if you want to try the triton implementation
+pip install gpt-oss[triton]
+```
+
+If you want to modify the code or try the metal implementation set the project up locally:
+
+```shell
+git clone https://github.com/openai/gpt-oss.git
+GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"
+```
+
+## Download the model
+
+You can download the model weights from the [Hugging Face Hub](https://huggingface.co/collections/openai/gpt-oss-68911959590a1634ba11c7a4) directly from Hugging Face CLI:
+
+```shell
+# gpt-oss-120b
+hf download openai/gpt-oss-120b --include "original/*" --local-dir gpt-oss-120b/
+
+# gpt-oss-20b
+hf download openai/gpt-oss-20b --include "original/*" --local-dir gpt-oss-20b/
+```
+
+## Reference PyTorch implementation
+
+We include an inefficient reference PyTorch implementation in [gpt_oss/torch/model.py](gpt_oss/torch/model.py). This code uses basic PyTorch operators to show the exact model architecture, with a small addition of supporting tensor parallelism in MoE so that the larger model can run with this code (e.g., on 4xH100 or 2xH200). In this implementation, we upcast all weights to BF16 and run the model in BF16.
+
+To run the reference implementation, install the dependencies:
+
+```shell
+pip install -e ".[torch]"
+```
+
+And then run:
+
+```shell
+# On 4xH100:
+torchrun --nproc-per-node=4 -m gpt_oss.generate gpt-oss-120b/original/
+```
+
+## Reference Triton implementation (single GPU)
+
+We also include an optimized reference implementation that uses [an optimized triton MoE kernel](https://github.com/triton-lang/triton/tree/main/python/triton_kernels/triton_kernels) that supports MXFP4. It also has some optimization on the attention code to reduce the memory cost. To run this implementation, the nightly version of triton and torch will be installed. This version can be run on a single 80GB GPU for `gpt-oss-120b`.
+
+To install the reference Triton implementation run
+
+```shell
+# You need to install triton from source to use the triton implementation
+git clone https://github.com/triton-lang/triton
+cd triton/
+pip install -r python/requirements.txt
+pip install -e . --verbose --no-build-isolation
+pip install -e python/triton_kernels
+
+# Install the gpt-oss triton implementation
+pip install -e ".[triton]"
+```
+
+And then run:
+
+```shell
+# On 1xH100
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+python -m gpt_oss.generate --backend triton gpt-oss-120b/original/
+```
+
+If you encounter `torch.OutOfMemoryError`, make sure to turn on the expandable allocator to avoid crashes when loading weights from the checkpoint.
+
+## Reference Metal implementation
+
+Additionally we are providing a reference implementation for Metal to run on Apple Silicon. This implementation is not production-ready but is accurate to the PyTorch implementation.
+
+The implementation will get automatically compiled when running the `.[metal]` installation on an Apple Silicon device:
+
+```shell
+GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"
+```
+
+To perform inference you'll need to first convert the SafeTensor weights from Hugging Face into the right format using:
+
+```shell
+python gpt_oss/metal/scripts/create-local-model.py -s <model_dir> -d <output_file>
+```
+
+Or download the pre-converted weights:
+
+```shell
+hf download openai/gpt-oss-120b --include "metal/*" --local-dir gpt-oss-120b/metal/
+hf download openai/gpt-oss-20b --include "metal/*" --local-dir gpt-oss-20b/metal/
+```
+
+To test it you can run:
+
+```shell
+python gpt_oss/metal/examples/generate.py gpt-oss-20b/metal/model.bin -p "why did the chicken cross the road?"
+```
+
+## Harmony format & tools
+
+Along with the model, we are also releasing a new chat format library `harmony` to interact with the model. Check [this guide](https://cookbook.openai.com/articles/openai-harmony) for more info about harmony.
+
+We also include two system tools for the model: browsing and python container. Check [gpt_oss/tools](gpt_oss/tools) for the tool implementation.
+
+## Clients
+
+### Terminal Chat
+
+The terminal chat application is a basic example of how to use the harmony format together with the PyTorch, Triton, and vLLM implementations. It also exposes both the python and browser tool as optional tools that can be used.
+
+```bash
+usage: python -m gpt_oss.chat [-h] [-r REASONING_EFFORT] [-a] [-b] [--show-browser-results] [-p] [--developer-message DEVELOPER_MESSAGE] [-c CONTEXT] [--raw] [--backend {triton,torch,vllm}] FILE
+
+Chat example
+
+positional arguments:
+  FILE                  Path to the SafeTensors checkpoint
+
+options:
+  -h, --help            show this help message and exit
+  -r REASONING_EFFORT, --reasoning-effort REASONING_EFFORT
+                        Reasoning effort (default: low)
+  -a, --apply-patch     Make apply_patch tool available to the model (default: False)
+  -b, --browser         Use browser tool (default: False)
+  --show-browser-results
+                        Show browser results (default: False)
+  -p, --python          Use python tool (default: False)
+  --developer-message DEVELOPER_MESSAGE
+                        Developer message (default: )
+  -c CONTEXT, --context CONTEXT
+                        Max context length (default: 8192)
+  --raw                 Raw mode (does not render Harmony encoding) (default: False)
+  --backend {triton,torch,vllm}
+                        Inference backend (default: triton)
+```
+
+> [!NOTE]
+> The torch and triton implementations require original checkpoint under `gpt-oss-120b/original/` and `gpt-oss-20b/original/` respectively. While vLLM uses the Hugging Face converted checkpoint under `gpt-oss-120b/` and `gpt-oss-20b/` root directory respectively.
+
+### Responses API
+
+We also include an example Responses API server. This server does not implement every feature and event of the Responses API but should be compatible with most of the basic use cases and serve as inspiration for anyone building their own server. Some of our inference partners are also offering their own Responses API.
+
+You can start this server with the following inference backends:
+
+- `triton` — uses the triton implementation
+- `metal` — uses the metal implementation on Apple Silicon only
+- `ollama` — uses the Ollama /api/generate API as an inference solution
+- `vllm` — uses your installed vllm version to perform inference
+- `transformers` — uses your installed transformers version to perform local inference
+
+```bash
+usage: python -m gpt_oss.responses_api.serve [-h] [--checkpoint FILE] [--port PORT] [--inference-backend BACKEND]
+
+Responses API server
+
+options:
+  -h, --help                    show this help message and exit
+  --checkpoint FILE             Path to the SafeTensors checkpoint
+  --port PORT                   Port to run the server on
+  --inference-backend BACKEND   Inference backend to use
+```
+
+### Codex
+
+We support [codex](https://github.com/openai/codex) as a client for gpt-oss. To run the 20b version, set this to `~/.codex/config.toml`:
+
+```
+disable_response_storage = true
+show_reasoning_content = true
+
+[model_providers.local]
+name = "local"
+base_url = "http://localhost:11434/v1"
+
+[profiles.oss]
+model = "gpt-oss:20b"
+model_provider = "local"
+```
+
+This will work with any chat completions-API compatible server listening on port 11434, like ollama. Start the server and point codex to the oss model:
+
+```
+ollama run gpt-oss:20b
+codex -p oss
+```
+
+## Tools
+
+### Browser
+
+> [!WARNING]
+> This implementation is purely for educational purposes and should not be used in production. You should implement your own equivalent of the [`YouComBackend`](gpt_oss/tools/simple_browser/backend.py) class with your own browsing environment. Currently we have available `YouComBackend` and `ExaBackend`. 
+
+Both gpt-oss models were trained with the capability to browse using the `browser` tool that exposes the following three methods:
+
+- `search` to search for key phrases
+- `open` to open a particular page
+- `find` to look for contents on a page
+
+#### Usage
+
+To enable the browser tool, you'll have to place the definition into the `system` message of your harmony formatted prompt. You can either use the `with_browser_tool()` method if your tool implements the full interface or modify the definition using `with_tools()`. For example:
+
+```python
+import datetime
+from gpt_oss.tools.simple_browser import SimpleBrowserTool
+from gpt_oss.tools.simple_browser.backend import YouComBackend
+from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+# Depending on the choice of the browser backend you need corresponding env variables setup
+# In case you use You.com backend requires you to have set the YDC_API_KEY environment variable,
+# while for Exa you might need EXA_API_KEY environment variable set
+backend = YouComBackend(
+    source="web",
+)
+# backend = ExaBackend(
+#  source="web",
+# )
+browser_tool = SimpleBrowserTool(backend=backend)
+
+# create a basic system prompt
+system_message_content = SystemContent.new().with_conversation_start_date(
+    datetime.datetime.now().strftime("%Y-%m-%d")
+)
+
+# if you want to use the browser tool
+if use_browser_tool:
+    # enables the tool
+    system_message_content = system_message_content.with_tools(browser_tool.tool_config)
+    # alternatively you could use the following if your tool is not stateless
+    system_message_content = system_message_content.with_browser_tool()
+
+# construct the system message
+system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)
+
+# create the overall prompt
+messages = [system_message, Message.from_role_and_content(Role.USER, "What's the weather in SF?")]
+conversation = Conversation.from_messages(messages)
+
+# convert to tokens
+token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)
+
+# perform inference
+# ...
+
+# parse the output
+messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
+last_message = messages[-1]
+if last_message.recipient.startswith("browser"):
+  # perform browser call
+  response_messages = await browser_tool.process(last_message)
+
+  # extend the current messages and run inference again
+  messages.extend(response_messages)
+```
+
+#### Details
+
+To control the context window size this tool uses a scrollable window of text that the model can interact with. So it might fetch the first 50 lines of a page and then scroll to the next 20 lines after that. The model has also been trained to then use citations from this tool in its answers.
+
+To improve performance the tool caches requests so that the model can revisit a different part of a page without having to reload the page. For that reason you should create a new browser instance for every request.
+
+### Python
+
+The model was trained to use a python tool to perform calculations and other actions as part of its chain-of-thought. During the training the model used a stateful tool which makes running tools between CoT loops easier. This reference implementation, however, uses a stateless mode. As a result the PythonTool defines its own tool description to override the definition in [`openai-harmony`][harmony].
+
+> [!WARNING]
+> This implementation runs in a permissive Docker container which could be problematic in cases like prompt injections. It's serving as an example and you should consider implementing your own container restrictions in production.
+
+#### Usage
+
+To enable the python tool, you'll have to place the definition into the `system` message of your harmony formatted prompt. You can either use the `with_python()` method if your tool implements the full interface or modify the definition using `with_tools()`. For example:
+
+```python
+import datetime
+from gpt_oss.tools.python_docker.docker_tool import PythonTool
+from openai_harmony import SystemContent, Message, Conversation, Role, load_harmony_encoding, HarmonyEncodingName
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+python_tool = PythonTool()
+
+# create a basic system prompt
+system_message_content = SystemContent.new().with_conversation_start_date(
+    datetime.datetime.now().strftime("%Y-%m-%d")
+)
+
+# if you want to use the python tool
+if use_python_tool:
+    # enables the tool making sure that the prompt gets set with the stateless tool description
+    system_message_content = system_message_content.with_tools(python_tool.tool_config)
+    # alternatively you could use the following if your tool is not stateless
+    system_message_content = system_message_content.with_python()
+
+# construct the system message
+system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)
+
+# create the overall prompt
+messages = [system_message, Message.from_role_and_content(Role.USER, "What's the square root of 9001?")]
+conversation = Conversation.from_messages(messages)
+
+# convert to tokens
+token_ids = encoding.render_conversation_for_completion(conversation, Role.ASSISTANT)
+
+# perform inference
+# ...
+
+# parse the output
+messages = encoding.parse_messages_from_completion_tokens(output_tokens, Role.ASSISTANT)
+last_message = messages[-1]
+if last_message.recipient == "python":
+  # perform python call
+  response_messages = await python_tool.process(last_message)
+
+  # extend the current messages and run inference again
+  messages.extend(response_messages)
+```
+
+### Apply Patch
+
+`apply_patch` can be used to create, update or delete files locally.
+
+## Other details
+
+### Precision format
+
+We released the models with native quantization support. Specifically, we use [MXFP4](https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf) for the linear projection weights in the MoE layer. We store the MoE tensor in two parts:
+
+- `tensor.blocks` stores the actual fp4 values. We pack every two values in one `uint8` value.
+- `tensor.scales` stores the block scale. The block scaling is done among the last dimension for all MXFP4 tensors.
+
+All other tensors will be in BF16. We also recommend using BF16 as the activation precision for the model.
+
+### Recommended Sampling Parameters
+
+We recommend sampling with `temperature=1.0` and `top_p=1.0`.
+
+## Contributing
+
+The reference implementations in this repository are meant as a starting point and inspiration. Outside of bug fixes we do not intend to accept new feature contributions. If you build implementations based on this code such as new tool implementations you are welcome to contribute them to the [`awesome-gpt-oss.md`](./awesome-gpt-oss.md) file.
+
+[harmony]: https://github.com/openai/harmony
+
+## Citation
+
+```bibtex
+@misc{openai2025gptoss120bgptoss20bmodel,
+      title={gpt-oss-120b & gpt-oss-20b Model Card}, 
+      author={OpenAI},
+      year={2025},
+      eprint={2508.10925},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2508.10925}, 
+}
+```

USAGE_POLICY

@@ -0,0 +1 @@
+We aim for our tools to be used safely, responsibly, and democratically, while maximizing your control over how you use them. By using OpenAI gpt-oss-120b and gpt-oss-20b, you agree to comply with all applicable law.

_build/gpt_oss_build_backend/__init__.py

@@ -0,0 +1 @@
+"""In-tree PEP 517 backend package for gpt-oss.""" 

_build/gpt_oss_build_backend/backend.py

@@ -0,0 +1,140 @@
+"""
+Build backend for gpt-oss that supports two modes:
+
+1) Default (pure wheel for PyPI)
+   - Delegates to setuptools.build_meta.
+   - Produces a py3-none-any wheel so PyPI accepts it (no linux_x86_64 tag).
+
+2) Optional Metal/C extension build (local only)
+   - If the environment variable GPTOSS_BUILD_METAL is set to a truthy value
+     (1/true/on/yes), delegates to scikit_build_core.build.
+   - Dynamically injects build requirements (scikit-build-core, cmake, ninja,
+     pybind11) only for this mode.
+
+Why this is needed
+- PyPI rejects Linux wheels tagged linux_x86_64; manylinux/musllinux is required
+  for binary wheels. We ship a pure wheel by default, but still allow developers
+  to build/install the native Metal backend locally when needed.
+
+Typical usage
+- Publish pure wheel: `python -m build` (do not set GPTOSS_BUILD_METAL).
+- Local Metal dev: `GPTOSS_BUILD_METAL=1 pip install -e ".[metal]"`.
+- CI: keep GPTOSS_BUILD_METAL unset for releases; set it in internal jobs that
+  exercise the extension.
+
+Notes
+- The base package remains importable without the extension. The Metal backend
+  is only used when `gpt_oss.metal` is explicitly imported.
+- This file is discovered via `backend-path = ["_build"]` and
+  `build-backend = "gpt_oss_build_backend.backend"` in pyproject.toml.
+"""
+import os
+from importlib import import_module
+from typing import Any, Mapping, Sequence
+
+
+TRUE_VALUES = {"1", "true", "TRUE", "on", "ON", "yes", "YES"}
+
+
+def _use_metal_backend() -> bool:
+    return str(os.environ.get("GPTOSS_BUILD_METAL", "")).strip() in TRUE_VALUES
+
+
+def _setuptools_backend():
+    from setuptools import build_meta as _bm  # type: ignore
+
+    return _bm
+
+
+def _scikit_build_backend():
+    return import_module("scikit_build_core.build")
+
+
+def _backend():
+    return _scikit_build_backend() if _use_metal_backend() else _setuptools_backend()
+
+
+# Required PEP 517 hooks
+
+def build_wheel(
+    wheel_directory: str,
+    config_settings: Mapping[str, Any] | None = None,
+    metadata_directory: str | None = None,
+) -> str:
+    return _backend().build_wheel(wheel_directory, config_settings, metadata_directory)
+
+
+def build_sdist(
+    sdist_directory: str, config_settings: Mapping[str, Any] | None = None
+) -> str:
+    return _backend().build_sdist(sdist_directory, config_settings)
+
+
+def prepare_metadata_for_build_wheel(
+    metadata_directory: str, config_settings: Mapping[str, Any] | None = None
+) -> str:
+    # Fallback if backend doesn't implement it
+    be = _backend()
+    fn = getattr(be, "prepare_metadata_for_build_wheel", None)
+    if fn is None:
+        # setuptools exposes it; scikit-build-core may not. Defer to building a wheel for metadata.
+        return _setuptools_backend().prepare_metadata_for_build_wheel(
+            metadata_directory, config_settings
+        )
+    return fn(metadata_directory, config_settings)
+
+
+# Optional hooks
+
+def build_editable(
+    editable_directory: str, config_settings: Mapping[str, Any] | None = None, metadata_directory: str | None = None
+) -> str:
+    be = _backend()
+    fn = getattr(be, "build_editable", None)
+    if fn is None:
+        # setuptools implements build_editable; if not available, raise the standard error
+        raise RuntimeError("Editable installs not supported by the selected backend")
+    return fn(editable_directory, config_settings)
+
+
+def get_requires_for_build_wheel(
+    config_settings: Mapping[str, Any] | None = None,
+) -> Sequence[str]:
+    if _use_metal_backend():
+        # Add dynamic build requirements only when building the Metal backend
+        return [
+            "scikit-build-core>=0.10",
+            "pybind11>=2.12",
+            "cmake>=3.26",
+            "ninja",
+        ]
+    # setuptools usually returns []
+    return list(_setuptools_backend().get_requires_for_build_wheel(config_settings))
+
+
+def get_requires_for_build_sdist(
+    config_settings: Mapping[str, Any] | None = None,
+) -> Sequence[str]:
+    # No special requirements for SDist
+    be = _backend()
+    fn = getattr(be, "get_requires_for_build_sdist", None)
+    if fn is None:
+        return []
+    return list(fn(config_settings))
+
+
+def get_requires_for_build_editable(
+    config_settings: Mapping[str, Any] | None = None,
+) -> Sequence[str]:
+    if _use_metal_backend():
+        return [
+            "scikit-build-core>=0.10",
+            "pybind11>=2.12",
+            "cmake>=3.26",
+            "ninja",
+        ]
+    be = _setuptools_backend()
+    fn = getattr(be, "get_requires_for_build_editable", None)
+    if fn is None:
+        return []
+    return list(fn(config_settings)) 

awesome-gpt-oss.md

@@ -0,0 +1,90 @@
+![gpt-oss](./docs/gpt-oss.svg)
+
+# Awesome gpt-oss
+
+This is a list of guides and resources to help you get started with the gpt-oss models.
+
+- [Inference](#inference)
+  - [Local](#local)
+  - [Server](#server)
+  - [Cloud](#cloud)
+- [Examples / Tutorials](#examples--tutorials)
+- [Tools](#tools)
+- [Training](#training)
+
+## Inference
+
+### Local
+
+- Ollama
+  - [How to run gpt-oss locally with Ollama](https://cookbook.openai.com/articles/gpt-oss/run-locally-ollama)
+  - [Ollama & gpt-oss launch blog](https://ollama.com/blog/gpt-oss)
+  - [Check out the models Ollama](https://ollama.com/library/gpt-oss)
+- LM Studio
+  - [LM Studio & gpt-oss launch blog](https://lmstudio.ai/blog/gpt-oss)
+  - [Use gpt-oss-20b with LM Studio](https://lmstudio.ai/models/openai/gpt-oss-20b)
+  - [Use gpt-oss-120b with LM Studio](https://lmstudio.ai/models/openai/gpt-oss-120b)
+- Hugging Face & Transformers
+  - [How to run gpt-oss with Transformers](https://cookbook.openai.com/articles/gpt-oss/run-transformers)
+  - [Hugging Face & gpt-oss launch blog](https://huggingface.co/blog/welcome-openai-gpt-oss)
+  - [Collection of Hugging Face examples](https://github.com/huggingface/gpt-oss-recipes)
+- NVIDIA
+  - [gpt-oss on RTX](https://blogs.nvidia.com/blog/rtx-ai-garage-openai-oss)
+- AMD
+  - [Running gpt-oss models on AMD Ryzen AI Processors and Radeon Graphics Cards](https://www.amd.com/en/blogs/2025/how-to-run-openai-gpt-oss-20b-120b-models-on-amd-ryzen-ai-radeon.html)
+  - [Running gpt-oss on STX Halo and Radeon dGPUs using Lemonade](https://lemonade-server.ai/news/gpt-oss.html)
+- llama.cpp
+  - [Running gpt-oss with llama.cpp](https://github.com/ggml-org/llama.cpp/discussions/15396)
+
+### Server
+
+- vLLM
+  - [How to run gpt-oss with vLLM](https://cookbook.openai.com/articles/gpt-oss/run-vllm)
+  - [vLLM & gpt-oss recipies](https://docs.vllm.ai/projects/recipes/en/latest/OpenAI/GPT-OSS.html)
+- NVIDIA
+  - [Optimizing gpt-oss with NVIDIA TensorRT-LLM](https://cookbook.openai.com/articles/run-nvidia)
+  - [Deploying gpt-oss on TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM/blob/main/docs/source/blogs/tech_blog/blog9_Deploying_GPT_OSS_on_TRTLLM.md)
+- AMD
+  - [Running the Latest Open Models from OpenAI on AMD AI Hardware](https://rocm.blogs.amd.com/ecosystems-and-partners/openai-day-0/README.html)
+
+### Cloud
+
+- Groq
+  - [Groq & gpt-oss launch blog](https://groq.com/blog/day-zero-support-for-openai-open-models)
+  - [gpt-oss-120b model on the GroqCloud Playground](https://console.groq.com/playground?model=openai/gpt-oss-120b)
+  - [gpt-oss-20b model on the GroqCloud Playground](https://console.groq.com/playground?model=openai/gpt-oss-20b)
+  - [gpt-oss with built-in web search on GroqCloud](https://console.groq.com/docs/browser-search)
+  - [gpt-oss with built-in code execution on GroqCloud](https://console.groq.com/docs/code-execution)
+  - [Responses API on Groq](https://console.groq.com/docs/responses-api)
+- NVIDIA
+  - [NVIDIA launch blog post](https://blogs.nvidia.com/blog/openai-gpt-oss/)
+  - [NVIDIA & gpt-oss developer launch blog post](https://developer.nvidia.com/blog/delivering-1-5-m-tps-inference-on-nvidia-gb200-nvl72-nvidia-accelerates-openai-gpt-oss-models-from-cloud-to-edge/)
+  - Use [gpt-oss-120b](https://build.nvidia.com/openai/gpt-oss-120b) and [gpt-oss-20b](https://build.nvidia.com/openai/gpt-oss-20b) on NVIDIA's Cloud
+- Cloudflare
+  - [Cloudflare & gpt-oss launch blog post](https://blog.cloudflare.com/openai-gpt-oss-on-workers-ai)
+  - [gpt-oss-120b on Cloudflare Workers AI](https://developers.cloudflare.com/workers-ai/models/gpt-oss-120b)
+  - [gpt-oss-20b on Cloudflare Workers AI](https://developers.cloudflare.com/workers-ai/models/gpt-oss-20b)
+- AMD
+  - [gpt-oss-120B on AMD MI300X](https://huggingface.co/spaces/amd/gpt-oss-120b-chatbot)
+- AWS
+  - Deploy via Tensorfuse: [Deploy gpt-oss for both 20b and 120b models on AWS EKS](https://tensorfuse.io/docs/guides/modality/text/openai_oss)
+  - [AWS launch blog post](https://aws.amazon.com/blogs/aws/openai-open-weight-models-now-available-on-aws/)
+
+## Examples & Tutorials
+
+- [OpenAI harmony response format](https://cookbook.openai.com/articles/openai-harmony)
+
+## Tools
+
+- [Example `python` tool for gpt-oss](./gpt_oss/tools/python_docker/)
+- [Example `browser` tool for gpt-oss](./gpt_oss/tools/simple_browser/)
+
+## Training
+
+- [Hugging Face TRL examples](https://github.com/huggingface/gpt-oss-recipes)
+- [LlamaFactory examples](https://llamafactory.readthedocs.io/en/latest/advanced/best_practice/gpt-oss.html)
+- [Unsloth examples](https://docs.unsloth.ai/basics/gpt-oss-how-to-run-and-fine-tune)
+
+## Contributing
+
+Feel free to open a PR to add your own guides and resources on how to run gpt-oss. We will try to review it and add it here.

compatibility-test/.gitignore

@@ -0,0 +1,142 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.*
+!.env.example
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Sveltekit cache directory
+.svelte-kit/
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# Firebase cache directory
+.firebase/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v3
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Vite logs files
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+
+rollout_*.jsonl
+analysis_*.json

compatibility-test/README.md

@@ -0,0 +1,29 @@
+# API Compatibility Test
+
+This script uses the Agents SDK in TypeScript and the underlying OpenAI client to verify the shape of the API calls but also whether the API performs tool calling.
+
+## What it tests
+
+1.
+
+## How to run
+
+0. Run `npm install` in this directory.
+1. Update `providers.ts` to create an entry for the API to test. Change `vllm` to the provider name of your choice. Use `chat` for Chat Completions tests and `responses` for Responses API tests.
+2. Run an initial quick test to make sure things work. This will only run one test
+
+```
+npm start -- --provider <name> -n 1 -k 1
+```
+
+3. Run the full test (runs each test 5 times to test consistency)
+
+```
+npm start -- --provider <name> -k 5
+```
+
+## Considerations
+
+1. The tests will fail if the API shape does not match the expected behavior
+2. Events in the chat API are currently not tested
+3. If the schema validation succeeds but the input is wrong the test will still pass for this test. That's because it's likely more of a prompt engineering issue or a validator issue than an API issue as it still nailed the input

compatibility-test/analysis.ts

@@ -0,0 +1,142 @@
+export function analyze(caseResults: any[], tries: number) {
+  // Group results by unique task: test_case + apiType
+  type TaskKey = string;
+  const taskKeyFor = (r: any): TaskKey =>
+    `${r.test_case}::${r.result?.apiType}`;
+
+  const successesByTask: Map<TaskKey, Map<number, boolean>> = new Map();
+
+  // Count wrong-input tool calls (schema correct but incorrect arguments)
+  let wrongInputToolCalls = 0;
+
+  // Count invalid response shapes per API type
+  const totalByApiType: Record<string, number> = {};
+  const invalidByApiType: Record<string, number> = {};
+
+  for (const r of caseResults) {
+    if (!r?.result || typeof r.result.apiType !== "string") continue;
+
+    // Parse attempt index from run_id `${i}_${k}` safely
+    let attemptIndex: number | undefined;
+    if (typeof r.run_id === "string") {
+      const parts = r.run_id.split("_");
+      const k = Number(parts[1]);
+      if (Number.isFinite(k)) attemptIndex = k;
+    }
+
+    const key = taskKeyFor(r);
+    if (!successesByTask.has(key)) successesByTask.set(key, new Map());
+    if (attemptIndex != null) {
+      successesByTask.get(key)!.set(attemptIndex, Boolean(r.success));
+    }
+
+    const d = r.result.toolCallingDetails ?? {};
+    const calledToolAtLeastOnce = Boolean(d.calledToolAtLeastOnce);
+    const calledToolWithRightSchema = Boolean(d.calledToolWithRightSchema);
+    const calledToolWithRightArguments = Boolean(
+      d.calledToolWithRightArguments
+    );
+    if (
+      calledToolAtLeastOnce &&
+      calledToolWithRightSchema &&
+      !calledToolWithRightArguments
+    ) {
+      wrongInputToolCalls++;
+    }
+
+    // Track invalid/total per apiType for response shape
+    const apiType = r.result.apiType as string;
+    totalByApiType[apiType] = (totalByApiType[apiType] ?? 0) + 1;
+    const isValidResponse = r.result.validResponse === true;
+    if (!isValidResponse) {
+      invalidByApiType[apiType] = (invalidByApiType[apiType] ?? 0) + 1;
+    }
+  }
+
+  const totalTasks = successesByTask.size;
+
+  // Compute pass@k and pass^k for k = 1..tries
+  const passAtKByK: number[] = [];
+  const passHatKByK: number[] = [];
+
+  for (let k = 1; k <= tries; k++) {
+    let tasksSuccessfulK = 0; // any success in first k attempts
+    let tasksAllSuccessfulK = 0; // all success in first k attempts
+
+    for (const [, attemptsMap] of successesByTask) {
+      let anySuccess = false;
+      let allSuccess = true;
+      for (let i = 0; i < k; i++) {
+        const v = attemptsMap.get(i) === true;
+        anySuccess = anySuccess || v;
+        if (!v) allSuccess = false;
+      }
+      if (anySuccess) tasksSuccessfulK++;
+      if (allSuccess) tasksAllSuccessfulK++;
+    }
+
+    const passAtK = totalTasks > 0 ? tasksSuccessfulK / totalTasks : 0;
+    const passHatK = totalTasks > 0 ? tasksAllSuccessfulK / totalTasks : 0;
+    passAtKByK.push(passAtK);
+    passHatKByK.push(passHatK);
+  }
+
+  // Convenience: final k=tries values
+  const passAtK = passAtKByK[tries - 1] ?? 0;
+  const passHatK = passHatKByK[tries - 1] ?? 0;
+
+  return {
+    totalTasks,
+    passAtKByK,
+    passHatKByK,
+    passAtK,
+    passHatK,
+    wrongInputToolCalls,
+    // New stats for invalid response shapes per API
+    invalidByApiType,
+    totalByApiType,
+  };
+}
+
+export function printAnalysis(
+  stats: ReturnType<typeof analyze>,
+  caseResults: any[],
+  provider: string,
+  selectedLines: string[],
+  tries: number,
+  skipped: number,
+  analysisFile: string
+) {
+  const formatPerK = (arr: number[]) =>
+    Array.from({ length: tries }, (_, i) => {
+      const v = arr[i] ?? 0;
+      return `${i + 1}=${v.toFixed(3)}`;
+    }).join(", ");
+
+  console.log("Summary:");
+  console.log(`  Provider: ${provider}`);
+  console.log(`  Total input cases: ${selectedLines.length}`);
+  console.log(`  Tries: ${tries}`);
+  console.log(`  Total tasks: ${stats.totalTasks}`);
+  console.log(`  Total runs: ${caseResults.length}`);
+  // Conditionally print invalid response shape stats per API type
+  if ((stats.totalByApiType["responses"] ?? 0) > 0) {
+    const bad = stats.invalidByApiType["responses"] ?? 0;
+    const tot = stats.totalByApiType["responses"] ?? 0;
+    console.log(`  Invalid Responses API responses: ${bad} (out of ${tot})`);
+  }
+  if ((stats.totalByApiType["chat"] ?? 0) > 0) {
+    const bad = stats.invalidByApiType["chat"] ?? 0;
+    const tot = stats.totalByApiType["chat"] ?? 0;
+    console.log(
+      `  Invalid Chat Completions API responses: ${bad} (out of ${tot})`
+    );
+  }
+  console.log(`  pass@k (k=1..${tries}): ${formatPerK(stats.passAtKByK)}`);
+  console.log(`  pass^k (k=1..${tries}): ${formatPerK(stats.passHatKByK)}`);
+  console.log(`  pass@k (k=${tries}): ${stats.passAtK.toFixed(3)}`);
+  console.log(`  pass^k (k=${tries}): ${stats.passHatK.toFixed(3)}`);
+  console.log(`  Wrong-input tool calls: ${stats.wrongInputToolCalls}`);
+  console.log(`  Invalid cases.jsonl lines: ${skipped}`);
+  console.log(`  Analysis written to ${analysisFile}`);
+}

compatibility-test/cases.jsonl

@@ -0,0 +1,30 @@
+{"tool_name":"get_system_health","input":"Hey, quick check: is everything up and running?","expected_arguments":"{}"}
+{"tool_name":"get_system_health","input":"Status report please.","expected_arguments":"{}"}
+{"tool_name":"get_system_health","input":"Can you confirm the LLM health before we start?","expected_arguments":"{}"}
+{"tool_name":"get_system_health","input":"Need a health snapshot.","expected_arguments":"{}"}
+{"tool_name":"get_system_health","input":"Hi, what's the current system health?","expected_arguments":"{}"}
+{"tool_name":"markdown_to_html","input":"Convert this markdown to HTML:\n\n# Title\n\nSome *italic* text.","expected_arguments":"{\"markdown\":\"# Title\\n\\nSome *italic* text.\"}"}
+{"tool_name":"markdown_to_html","input":"Hey, could you turn `## Docs` into HTML?","expected_arguments":"{\"markdown\":\"## Docs\"}"}
+{"tool_name":"markdown_to_html","input":"Please render the following markdown:\n\n- item 1\n- item 2","expected_arguments":"{\"markdown\":\"- item 1\\n- item 2\"}"}
+{"tool_name":"markdown_to_html","input":"I have `**bold**` markdown; give me HTML.","expected_arguments":"{\"markdown\":\"**bold**\"}"}
+{"tool_name":"markdown_to_html","input":"Markdown to HTML: > quote","expected_arguments":"{\"markdown\":\"> quote\"}"}
+{"tool_name":"detect_language","input":"Hey, what language is this: 'Buenos días, ¿cómo estás?'","expected_arguments":"{\"text\":\"Buenos días, ¿cómo estás?\"}"}
+{"tool_name":"detect_language","input":"Identify the language: \"Guten Morgen\"","expected_arguments":"{\"text\":\"Guten Morgen\"}"}
+{"tool_name":"detect_language","input":"Language detection needed: こんにちは、お元気ですか？","expected_arguments":"{\"text\":\"こんにちは、お元気ですか？\"}"}
+{"tool_name":"detect_language","input":"Detect language for: 'Привет, как дела?'","expected_arguments":"{\"text\":\"Привет, как дела?\"}"}
+{"tool_name":"detect_language","input":"What language is 'Bonjour tout le monde'?","expected_arguments":"{\"text\":\"Bonjour tout le monde\"}"}
+{"tool_name":"generate_chart","input":"Plot a simple line chart for these points: (1,2),(2,4),(3,9).","expected_arguments":"{\"data\":[[1,2],[2,4],[3,9]],\"chart_type\":\"line\"}"}
+{"tool_name":"generate_chart","input":"Hey, can I get a bar chart of my sales: 10, 20, 30 across Q1–Q3?","expected_arguments":"{\"data\":[[1,10],[2,20],[3,30]],\"chart_type\":\"bar\",\"title\":\"Quarterly Sales\"}"}
+{"tool_name":"generate_chart","input":"Make a scatter chart titled 'Experiment' with x label Time and y label Value for data [ [0,1], [1,1.5], [2,2.2] ].","expected_arguments":"{\"data\":[[0,1],[1,1.5],[2,2.2]],\"chart_type\":\"scatter\",\"title\":\"Experiment\",\"x_label\":\"Time\",\"y_label\":\"Value\"}"}
+{"tool_name":"generate_chart","input":"Create a line chart of temperatures 70,72,68,65 over 4 days, label x as 'Day'.","expected_arguments":"{\"data\":[[1,70],[2,72],[3,68],[4,65]],\"chart_type\":\"line\",\"x_label\":\"Day\"}"}
+{"tool_name":"generate_chart","input":"Visualize visits per day with a bar chart; numbers: 100,150,120.","expected_arguments":"{\"data\":[[1,100],[2,150],[3,120]],\"chart_type\":\"bar\",\"title\":\"Daily Visits\",\"y_label\":\"Visitors\"}"}
+{"tool_name":"query_database","input":"Give me the ids and emails from users table, limit 5.","expected_arguments":"{\"table\":\"users\",\"columns\":[\"id\",\"email\"],\"limit\":5}"}
+{"tool_name":"query_database","input":"Hey, fetch order_id and amount from orders where status is 'shipped'.","expected_arguments":"{\"table\":\"orders\",\"columns\":[\"order_id\",\"amount\"],\"filters\":\"status = 'shipped'\"}"}
+{"tool_name":"query_database","input":"Retrieve name and price from products ordered by price descending, top 10 please.","expected_arguments":"{\"table\":\"products\",\"columns\":[\"name\",\"price\"],\"limit\":10,\"order_by\":\"price DESC\"}"}
+{"tool_name":"query_database","input":"I need the first 3 log entries from audit_log table.","expected_arguments":"{\"table\":\"audit_log\",\"columns\":[\"id\",\"timestamp\",\"action\"],\"limit\":3}"}
+{"tool_name":"query_database","input":"Query the customers table for name, city where city = 'Berlin'.","expected_arguments":"{\"table\":\"customers\",\"columns\":[\"name\",\"city\"],\"filters\":\"city = 'Berlin'\"}"}
+{"tool_name":"get_weather","input":"What's the weather in San Francisco right now?","expected_arguments":"{\"location\":\"San Francisco\"}"}
+{"tool_name":"get_weather","input":"Weather for Tokyo, please.","expected_arguments":"{\"location\":\"Tokyo\"}"}
+{"tool_name":"get_weather","input":"Get me the current weather for 10001.","expected_arguments":"{\"location\":\"10001\"}"}
+{"tool_name":"get_weather","input":"How's the weather in Paris today?","expected_arguments":"{\"location\":\"Paris\"}"}
+{"tool_name":"get_weather","input":"Check the weather for Sydney.","expected_arguments":"{\"location\":\"Sydney\"}"}

compatibility-test/index.ts

@@ -0,0 +1,196 @@
+import { parseArgs } from "node:util";
+import { createWriteStream } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { runCase, RunCaseSummary } from "./runCase";
+import { Listr, ListrTaskWrapper } from "listr2";
+import { analyze, printAnalysis } from "./analysis";
+
+function formatTimestamp(d: Date): string {
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const yyyy = d.getFullYear();
+  const mm = pad(d.getMonth() + 1);
+  const dd = pad(d.getDate());
+  const hh = pad(d.getHours());
+  const mi = pad(d.getMinutes());
+  const ss = pad(d.getSeconds());
+  return `${yyyy}${mm}${dd}_${hh}${mi}${ss}`;
+}
+
+async function main() {
+  const args = parseArgs({
+    options: {
+      cases: { type: "string", short: "c", default: "cases.jsonl" },
+      provider: { type: "string", short: "p", default: "openai" },
+      streaming: { type: "boolean", short: "s", default: false },
+      maxTurns: { type: "string", short: "t", default: "10" },
+      n: { type: "string", short: "n" },
+      strict: { type: "boolean", short: "s", default: false },
+      tries: { type: "string", short: "k", default: "1" },
+    },
+  });
+  const casesPathArg = args.values.cases;
+  const provider = args.values.provider as string;
+  const streaming = Boolean(args.values.streaming);
+  const maxTurns = Number(args.values.maxTurns ?? 10);
+  const nRaw = args.values.n as string | undefined;
+  const triesRaw = args.values.tries as string | undefined;
+  const tries = triesRaw != null ? Number(triesRaw) : 1;
+  const limit = nRaw != null ? Number(nRaw) : undefined;
+  if (limit != null && (!Number.isFinite(limit) || limit <= 0)) {
+    console.error("--n must be a positive integer");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!casesPathArg) {
+    console.error("--cases is required (path to JSONL file)");
+    process.exitCode = 1;
+    return;
+  }
+
+  const casesPath = path.isAbsolute(casesPathArg)
+    ? casesPathArg
+    : path.join(process.cwd(), casesPathArg);
+
+  const timestamp = formatTimestamp(new Date());
+  const defaultFilename = `rollout_${provider}_${timestamp}.jsonl`;
+  const outputFile = path.join(process.cwd(), defaultFilename);
+  const analysisFile = path.join(
+    process.cwd(),
+    `analysis_${provider}_${timestamp}.json`
+  );
+
+  let fileContent: string;
+  try {
+    fileContent = await readFile(casesPath, "utf8");
+  } catch (err: any) {
+    console.error(
+      `Failed to read cases file at ${casesPath}: ${err?.message ?? err}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const lines = fileContent
+    .split(/\r?\n/)
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+
+  const selectedLines =
+    typeof limit === "number" ? lines.slice(0, limit) : lines;
+
+  const out = createWriteStream(outputFile, { flags: "w", encoding: "utf8" });
+
+  const writeLine = (obj: any) =>
+    new Promise<void>((resolve, reject) => {
+      const str = JSON.stringify(obj) + "\n";
+      out.write(str, (err) => (err ? reject(err) : resolve()));
+    });
+
+  // Accumulators for post-run analysis
+  let skipped = 0; // invalid JSON lines
+  const caseResults: Array<{
+    run_id: string;
+    success: boolean;
+    provider: string;
+    test_case: number;
+    tool_name: string;
+    input: string;
+    result: RunCaseSummary;
+  }> = [];
+
+  async function processIndex(
+    i: number,
+    k: number,
+    task: ListrTaskWrapper<any, any, any>
+  ) {
+    const line = selectedLines[i];
+    let caseObj: any;
+    try {
+      caseObj = JSON.parse(line);
+    } catch (err: any) {
+      console.error(
+        `Skipping invalid JSON on line ${i + 1}: ${err?.message ?? err}`
+      );
+      skipped++;
+      return;
+    }
+
+    try {
+      const summaries = await runCase(provider, caseObj, {
+        maxTurns,
+        streaming,
+        strict: args.values.strict,
+      });
+
+      for (const summary of summaries) {
+        const record = {
+          run_id: `${i}_${k}`,
+          success: summary.success,
+          provider,
+          test_case: i,
+          tool_name: caseObj.tool_name,
+          input: caseObj.input,
+          result: summary,
+        };
+        task.output = `Case ${i} (attempt ${k + 1}): ${
+          summary.success ? "Success" : "Failed"
+        } ${summary.toolCallingDetails.warning || ""}`;
+        caseResults.push(record);
+        await writeLine(record);
+      }
+    } catch (err: any) {
+      const record = {
+        provider,
+        test_case: i,
+        tool_name: caseObj?.tool_name,
+        input: caseObj?.input,
+        expected_output: caseObj?.expected_output,
+        instructions: caseObj?.instructions,
+        error: String(err?.message ?? err),
+      };
+      await writeLine(record);
+      task.output = `Case ${i} failed: ${err?.message ?? err}`;
+    }
+  }
+
+  const listr = new Listr<{
+    output: string;
+  }>(
+    selectedLines.flatMap((line, index) => {
+      return Array.from({ length: tries }, (_, attempt) => ({
+        title: `Processing case ${index} (attempt ${attempt + 1})`,
+        task: async (_, task) => {
+          await processIndex(index, attempt, task);
+        },
+        rendererOptions: { persistentOutput: true },
+      }));
+    }),
+    {
+      concurrent: 5,
+    }
+  );
+
+  await listr.run();
+
+  await new Promise((resolve) => out.end(resolve));
+  console.log(`Results written to ${outputFile}`);
+  const stats = analyze(caseResults, tries);
+  await writeFile(analysisFile, JSON.stringify(stats, null, 2), "utf8");
+  printAnalysis(
+    stats,
+    caseResults,
+    provider,
+    selectedLines,
+    tries,
+    skipped,
+    analysisFile
+  );
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

compatibility-test/package-lock.json

@@ -0,0 +1,1633 @@
+{
+  "name": "compatibility-test",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "@openai/agents": "^0.0.15",
+        "ajv": "^8.17.1",
+        "listr2": "^9.0.1"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.17.1.tgz",
+      "integrity": "sha512-CPle1OQehbWqd25La9Ack5B07StKIxh4+Bf19qnpZKJC1oI22Y0czZHbifjw1UoczIfKBwBDAp/dFxvHG13B5A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ajv": "^6.12.6",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.0",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/@openai/agents": {
+      "version": "0.0.15",
+      "resolved": "https://registry.npmjs.org/@openai/agents/-/agents-0.0.15.tgz",
+      "integrity": "sha512-B8y+WyWOeHowflPx09pyCfcqikC4OYWK27HTyNGt1oraXv93CzuamSr76iAaU1nWQ1MPbUwl6LHPX4BPUikVkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.15",
+        "@openai/agents-openai": "0.0.15",
+        "@openai/agents-realtime": "0.0.15",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      }
+    },
+    "node_modules/@openai/agents-core": {
+      "version": "0.0.15",
+      "resolved": "https://registry.npmjs.org/@openai/agents-core/-/agents-core-0.0.15.tgz",
+      "integrity": "sha512-ODTqttjW0s0ejBe5PKnYRlFbJSZH2IO6OtUlRhIKmWiWrX6pGRxvpKjTSOXy8DEtpRHBj6Nhky0UoSlO6eOkDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      },
+      "optionalDependencies": {
+        "@modelcontextprotocol/sdk": "^1.12.0"
+      },
+      "peerDependencies": {
+        "zod": "3.25.40 - 3.25.67"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@openai/agents-openai": {
+      "version": "0.0.15",
+      "resolved": "https://registry.npmjs.org/@openai/agents-openai/-/agents-openai-0.0.15.tgz",
+      "integrity": "sha512-YIX3n98HdmmWKkb/71OB+DCQUYyGEpqfzPjejzdtNLUvAEs3jvXf7nkC8oTISsuCwrirgBz0rQEefeo0oUlyFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.15",
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      }
+    },
+    "node_modules/@openai/agents-realtime": {
+      "version": "0.0.15",
+      "resolved": "https://registry.npmjs.org/@openai/agents-realtime/-/agents-realtime-0.0.15.tgz",
+      "integrity": "sha512-kSZzMyij9Xt3BpMb/9snuVnu7a5qKZLyhtN/kWMA+wmfETvWz23BBz6tbO5xOmurAt9//OktkB+94e0T0RBtlA==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.15",
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "@types/ws": "^8.18.1",
+        "debug": "^4.4.0",
+        "ws": "^8.18.1"
+      }
+    },
+    "node_modules/@openai/zod": {
+      "name": "zod",
+      "version": "3.25.67",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
+      "integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.2.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.2.0.tgz",
+      "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.10.0"
+      }
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-escapes": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz",
+      "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==",
+      "license": "MIT",
+      "dependencies": {
+        "environment": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz",
+      "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
+      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.6.3",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/cli-cursor": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz",
+      "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==",
+      "license": "MIT",
+      "dependencies": {
+        "restore-cursor": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/cli-truncate": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz",
+      "integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==",
+      "license": "MIT",
+      "dependencies": {
+        "slice-ansi": "^5.0.0",
+        "string-width": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/colorette": {
+      "version": "2.0.20",
+      "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz",
+      "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==",
+      "license": "MIT"
+    },
+    "node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/emoji-regex": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz",
+      "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/environment": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz",
+      "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventemitter3": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz",
+      "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
+      "license": "MIT"
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.3.tgz",
+      "integrity": "sha512-nVpZkTMM9rF6AQ9gPJpFsNAMt48wIzB5TQgiTLdHiuO8XEDhUgZEhqKlZWXbIzo9VmJ/HvysHqEaVeD5v9TPvA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.0",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz",
+      "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/fast-uri": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz",
+      "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-east-asian-width": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz",
+      "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-errors/node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz",
+      "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/listr2": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/listr2/-/listr2-9.0.1.tgz",
+      "integrity": "sha512-SL0JY3DaxylDuo/MecFeiC+7pedM0zia33zl0vcjgwcq1q1FWWF1To9EIauPbl8GbMCU0R2e0uJ8bZunhYKD2g==",
+      "license": "MIT",
+      "dependencies": {
+        "cli-truncate": "^4.0.0",
+        "colorette": "^2.0.20",
+        "eventemitter3": "^5.0.1",
+        "log-update": "^6.1.0",
+        "rfdc": "^1.4.1",
+        "wrap-ansi": "^9.0.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/log-update": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz",
+      "integrity": "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-escapes": "^7.0.0",
+        "cli-cursor": "^5.0.0",
+        "slice-ansi": "^7.1.0",
+        "strip-ansi": "^7.1.0",
+        "wrap-ansi": "^9.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/log-update/node_modules/is-fullwidth-code-point": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.0.0.tgz",
+      "integrity": "sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==",
+      "license": "MIT",
+      "dependencies": {
+        "get-east-asian-width": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/log-update/node_modules/slice-ansi": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.0.tgz",
+      "integrity": "sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.1",
+        "is-fullwidth-code-point": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/slice-ansi?sponsor=1"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mimic-function": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz",
+      "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/onetime": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz",
+      "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "mimic-function": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/openai": {
+      "version": "5.12.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-5.12.0.tgz",
+      "integrity": "sha512-vUdt02xiWgOHiYUmW0Hj1Qu9OKAiVQu5Bd547ktVCiMKC1BkB5L3ImeEnCyq3WpRKR6ZTaPgekzqdozwdPs7Lg==",
+      "license": "Apache-2.0",
+      "bin": {
+        "openai": "bin/cli"
+      },
+      "peerDependencies": {
+        "ws": "^8.18.0",
+        "zod": "^3.23.8"
+      },
+      "peerDependenciesMeta": {
+        "ws": {
+          "optional": true
+        },
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
+      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/restore-cursor": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",
+      "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==",
+      "license": "MIT",
+      "dependencies": {
+        "onetime": "^7.0.0",
+        "signal-exit": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/rfdc": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
+      "license": "MIT"
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/slice-ansi": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz",
+      "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.0.0",
+        "is-fullwidth-code-point": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/slice-ansi?sponsor=1"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^10.3.0",
+        "get-east-asian-width": "^1.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
+      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.10.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.10.0.tgz",
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag==",
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "license": "BSD-2-Clause",
+      "optional": true,
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz",
+      "integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.1",
+        "string-width": "^7.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.67",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
+      "integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.6",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz",
+      "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==",
+      "license": "ISC",
+      "optional": true,
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  }
+}

compatibility-test/package.json

@@ -0,0 +1,11 @@
+{
+  "type": "module",
+  "dependencies": {
+    "@openai/agents": "^0.0.15",
+    "ajv": "^8.17.1",
+    "listr2": "^9.0.1"
+  },
+  "scripts": {
+    "start": "tsx index.ts"
+  }
+}

compatibility-test/providers.ts

@@ -0,0 +1,15 @@
+export const PROVIDERS = {
+  vllm: {
+    apiBaseUrl: "http://localhost:8000/v1",
+    apiKey: "vllm",
+    apiType: ["responses", "chat"], // choose from responses, chat, or both
+    modelName: "openai/gpt-oss-120b",
+    providerDetails: {
+      // add any provider-specific details here. These will be passed as part of every request
+      // for example to fix the provider for openrouter, you can do:
+      // provider: {
+      //   only: ["example"],
+      // },
+    },
+  },
+};

compatibility-test/runCase.ts

@@ -0,0 +1,331 @@
+import {
+  Agent,
+  Runner,
+  OpenAIResponsesModel,
+  OpenAIChatCompletionsModel,
+  RunResult,
+  StreamedRunResult,
+  FunctionTool,
+  setTracingDisabled,
+} from "@openai/agents";
+import { Ajv } from "ajv";
+import { OpenAI } from "openai";
+import { PROVIDERS } from "./providers";
+import { TOOLS_MAP } from "./tools";
+
+setTracingDisabled(true);
+
+const ajv = new Ajv();
+
+export type Case = {
+  tool_name: string;
+  input: string;
+  expected_arguments: string;
+  instructions?: string;
+};
+
+// Summary shape for each apiType
+export type RunCaseSummary = {
+  apiType: string;
+  success: boolean;
+  validResponse: boolean;
+  validEvents?: boolean;
+  details: Record<string, any>;
+  history: any[];
+  successToolCall: boolean;
+  toolCallingDetails: Record<string, any>;
+};
+
+export async function runCase(
+  provider: string,
+  caseData: Case,
+  {
+    maxTurns,
+    streaming,
+    strict,
+  }: { maxTurns: number; streaming: boolean; strict: boolean }
+): Promise<RunCaseSummary[]> {
+  const config = PROVIDERS[provider];
+  if (!config) {
+    throw new Error(
+      `Provider ${provider} not found. Valid providers are: ${Object.keys(
+        PROVIDERS
+      ).join(", ")}`
+    );
+  }
+
+  const agent = new Agent({
+    name: caseData.tool_name,
+    instructions: caseData.instructions,
+    tools: [TOOLS_MAP[caseData.tool_name]],
+  });
+
+  const client = new OpenAI({
+    apiKey: config.apiKey,
+    baseURL: config.apiBaseUrl,
+  });
+
+  const summaries: RunCaseSummary[] = [];
+
+  for (const apiType of config.apiType) {
+    const runner = new Runner({
+      model:
+        apiType === "responses"
+          ? new OpenAIResponsesModel(client, config.modelName)
+          : new OpenAIChatCompletionsModel(client, config.modelName),
+      modelSettings: {
+        providerData: config.providerDetails ?? {},
+      },
+    });
+
+    let result: RunResult<any, any> | StreamedRunResult<any, any>;
+    let streamedEvents: any[] | undefined = undefined;
+    if (streaming) {
+      result = await runner.run(agent, caseData.input, {
+        stream: streaming,
+        maxTurns: maxTurns,
+      });
+      if (result instanceof StreamedRunResult) {
+        // Collect streaming events if applicable
+        streamedEvents = [];
+        for await (const event of result) {
+          if (event.type === "raw_model_stream_event") {
+            if (event.data.type === "model") {
+              streamedEvents.push(event.data.event);
+            }
+          }
+        }
+        await result.completed;
+      }
+    } else {
+      result = await runner.run(agent, caseData.input, {
+        maxTurns: maxTurns,
+      });
+    }
+
+    const { success: successToolCall, details: toolCallingDetails } =
+      testToolCall(apiType, caseData, result, strict);
+
+    const { validResponse, details } = testOutputData(
+      apiType,
+      result.rawResponses,
+      streaming
+    );
+
+    const { validEvents, details: eventsDetails } = streaming
+      ? testEvents(apiType, streamedEvents)
+      : { validEvents: true, details: {} };
+
+    let success = successToolCall && validResponse;
+    if (streaming) {
+      success = success && validEvents;
+    }
+    const summary: RunCaseSummary = {
+      apiType,
+      success,
+      validResponse,
+      validEvents,
+      details: {
+        ...details,
+        ...eventsDetails,
+      },
+      history: result?.rawResponses.map((entry) => entry.providerData) ?? [],
+      successToolCall,
+      toolCallingDetails,
+    };
+
+    summaries.push(summary);
+  }
+
+  return summaries;
+}
+
+function testToolCall(apiType, caseData, result, strict) {
+  let details: Record<string, boolean | string> = {};
+  result.newItems.forEach((item) => {
+    // for this test for now we only care if the tool is called at least once
+    if (details.calledToolAtLeastOnce) {
+      return;
+    }
+
+    const isToolCall = item.type === "tool_call_item";
+    if (isToolCall) {
+      if (item.rawItem.type === "function_call") {
+        if (item.rawItem.name === caseData.tool_name) {
+          const validate = ajv.compile(
+            (TOOLS_MAP[caseData.tool_name] as FunctionTool).parameters
+          );
+          const valid = validate(JSON.parse(item.rawItem.arguments));
+          details.calledToolWithRightSchema = valid;
+          details.calledToolAtLeastOnce = true;
+
+          if (details.calledToolWithRightSchema) {
+            const parsedArguments = JSON.parse(item.rawItem.arguments);
+            const expectedArguments = JSON.parse(caseData.expected_arguments);
+            details.calledToolWithRightArguments = deepEqual(
+              parsedArguments,
+              expectedArguments
+            );
+            if (!details.calledToolWithRightArguments) {
+              if (details.calledToolWithRightSchema) {
+                details.warning = `Tool call with wrong arguments but correct schema. Check logs for full details. Not failing this test. Parsed: ${JSON.stringify(
+                  parsedArguments
+                )} Expected: ${JSON.stringify(expectedArguments)}`;
+              }
+              details.actualArguments = parsedArguments;
+              details.expectedArguments = expectedArguments;
+            }
+          }
+        }
+      }
+    }
+  });
+
+  return {
+    success:
+      !!details.calledToolAtLeastOnce &&
+      !!details.calledToolWithRightSchema &&
+      (!strict || !!details.calledToolWithRightArguments),
+    details,
+  };
+}
+
+function testEvents(apiType, events) {
+  // In an ideal world we would check all the events to follow and reconstruct the final response
+  // and then compare it against the final response in the response.completed event
+  // for now we just check that certain events are present
+
+  let details: Record<string, boolean> = {};
+  let validEvents: boolean = false;
+
+  if (apiType === "chat") {
+    let hasReasoningDeltas = false;
+    for (const event of events) {
+      hasReasoningDeltas =
+        hasReasoningDeltas ||
+        (typeof event.choices[0].delta.reasoning === "string" &&
+          event.choices[0].delta.reasoning.length > 0);
+    }
+    details.hasReasoningDeltas = hasReasoningDeltas;
+    validEvents = hasReasoningDeltas;
+  }
+
+  if (apiType === "responses") {
+    let hasReasoningDeltaEvents = false;
+    let hasReasoningDoneEvents = false;
+    for (const event of events) {
+      if (event.type === "raw_model_stream_event") {
+        if (event.data.type === "model") {
+          if (event.data.event.type === "response.reasoning_text.delta") {
+            hasReasoningDeltaEvents = true;
+          }
+          if (event.data.event.type === "response.reasoning_text.done") {
+            hasReasoningDoneEvents = true;
+          }
+        }
+      }
+    }
+
+    details.hasReasoningDeltaEvents = hasReasoningDeltaEvents;
+    details.hasReasoningDoneEvents = hasReasoningDoneEvents;
+    validEvents =
+      details.hasReasoningDeltaEvents && details.hasReasoningDoneEvents;
+  }
+
+  return {
+    validEvents,
+    details,
+  };
+}
+
+function testOutputData(apiType, rawResponses, streaming) {
+  let details: Record<string, boolean> = {};
+  let validResponse: boolean = false;
+
+  if (apiType === "chat") {
+    for (const response of rawResponses) {
+      if (streaming && !response.providerData) {
+        // with Chat Completions we don't have a final response object that's native so we skip this test
+        return {
+          validResponse: true,
+          details: {
+            skippedBecauseStreaming: true,
+          },
+        };
+      }
+
+      // this is the actual HTTP response from the provider
+      // Since it's not guaranteed that every response has a reasoning field, we check if it's present
+      // at least once across all responses
+      const data = response.providerData;
+      const message = data.choices[0].message;
+      if (message.role === "assistant" && !message.refusal) {
+        details.hasReasoningField =
+          details.hasReasoningField ||
+          ("reasoning" in message && typeof message.reasoning === "string");
+        details.hasReasoningContentField =
+          details.hasReasoningContentField ||
+          ("reasoning_content" in message &&
+            typeof message.reasoning_content === "string");
+
+        validResponse =
+          validResponse ||
+          (details.hasReasoningField && message.reasoning.length > 0);
+      }
+    }
+  } else if (apiType === "responses") {
+    // this is the actual HTTP response from the provider
+    const data = rawResponses[0].providerData;
+    for (const item of data.output) {
+      // Since it's not guaranteed that every response has a reasoning field, we check if it's present
+      // at least once across all responses
+
+      if (item.type === "reasoning") {
+        details.hasReasoningContentArray = Array.isArray(item.content);
+        details.hasReasoningContentArrayLength = item.content.length > 0;
+        details.hasReasoningContentArrayItemType = item.content.every(
+          (item) => item.type === "reasoning_text"
+        );
+        details.hasReasoningContentArrayItemText = item.content.every(
+          (item) => item.text.length > 0
+        );
+
+        validResponse =
+          details.hasReasoningContentArray &&
+          details.hasReasoningContentArrayLength &&
+          details.hasReasoningContentArrayItemType &&
+          details.hasReasoningContentArrayItemText;
+      }
+    }
+  }
+
+  return {
+    validResponse,
+    details,
+  };
+}
+
+function deepEqual(a: any, b: any): boolean {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a && b && typeof a === "object") {
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    if (Array.isArray(a)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!deepEqual(a[i], b[i])) return false;
+      }
+      return true;
+    } else {
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length) return false;
+      for (const key of aKeys) {
+        if (!b.hasOwnProperty(key)) return false;
+        if (!deepEqual(a[key], b[key])) return false;
+      }
+      return true;
+    }
+  }
+  return false;
+}

compatibility-test/tools.ts

@@ -0,0 +1,156 @@
+import { Tool, tool } from "@openai/agents";
+
+function convertToTool(toolData: any) {
+  return tool({
+    name: toolData.name,
+    description: toolData.description,
+    parameters: toolData.parameters,
+    execute: async (parameters) => {
+      return toolData.output;
+    },
+    strict: false,
+  });
+}
+
+export const TOOLS = [
+  {
+    type: "function",
+    name: "get_weather",
+    description: "Get the weather for a given location",
+    parameters: {
+      type: "object",
+      properties: {
+        location: {
+          type: "string",
+          description: "The location to get the weather for",
+        },
+      },
+      required: ["location"],
+      additionalProperties: false,
+    },
+    output: '{"weather":"sunny"}',
+  },
+  {
+    type: "function",
+    name: "get_system_health",
+    description:
+      "Returns the current health status of the LLM runtime—use before critical operations to verify the service is live.",
+    parameters: { type: "object", properties: {} },
+    output: '{"status":"ok","uptime_seconds":372045}',
+  },
+  {
+    type: "function",
+    name: "markdown_to_html",
+    description:
+      "Converts a Markdown string to sanitized HTML—use when you need browser-renderable output.",
+    parameters: {
+      type: "object",
+      properties: {
+        markdown: { type: "string", description: "Raw Markdown content" },
+      },
+      required: ["markdown"],
+      additionalProperties: false,
+    },
+    output: '{"html":"<h1>Hello World</h1><p>This is <em>great</em>.</p>"}',
+  },
+  {
+    type: "function",
+    name: "detect_language",
+    description:
+      "Identifies the ISO language code of the supplied text—use for routing text to language-specific models.",
+    parameters: {
+      type: "object",
+      properties: {
+        text: {
+          type: "string",
+          description: "Text whose language should be detected",
+        },
+      },
+      required: ["text"],
+      additionalProperties: false,
+    },
+    output: '{"language":"de","confidence":0.98}',
+  },
+  {
+    type: "function",
+    name: "generate_chart",
+    description:
+      "Creates a base64-encoded PNG chart from tabular data—use for quick visualizations inside chat.",
+    parameters: {
+      type: "object",
+      properties: {
+        data: {
+          type: "array",
+          items: { type: "array", items: { type: "number" } },
+          description: "2-D numeric data matrix",
+        },
+        chart_type: {
+          type: "string",
+          enum: ["line", "bar", "scatter"],
+          description: "Type of chart to generate",
+        },
+        title: {
+          type: "string",
+          description: "Chart title",
+          default: "",
+        },
+        x_label: {
+          type: "string",
+          description: "Label for the x-axis",
+          default: "",
+        },
+        y_label: {
+          type: "string",
+          description: "Label for the y-axis",
+          default: "",
+        },
+      },
+      required: ["data", "chart_type"],
+      additionalProperties: false,
+    },
+    output: '{"image_png_base64":"iVBORw0KGgoAAAANSUhEUgAA..."}',
+  },
+  {
+    type: "function",
+    name: "query_database",
+    description:
+      "Runs a parameterized SQL SELECT on the internal analytics DB—use for lightweight data look-ups.",
+    parameters: {
+      type: "object",
+      properties: {
+        table: { type: "string", description: "Table name to query" },
+        columns: {
+          type: "array",
+          items: { type: "string" },
+          description: "Columns to return",
+        },
+        filters: {
+          type: "string",
+          description: "SQL WHERE clause without the word WHERE",
+          default: "",
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 10000,
+          description: "Max rows to return",
+          default: 100,
+        },
+        order_by: {
+          type: "string",
+          description: "Column to order by (optional)",
+          default: "",
+        },
+      },
+      required: ["table", "columns"],
+      additionalProperties: false,
+    },
+    output:
+      '{"rows":[{"id":1,"email":"user@example.com"},{"id":2,"email":"foo@bar.com"}],"row_count":2}',
+  },
+];
+
+export const TOOLS_MAP = TOOLS.reduce((acc, tool) => {
+  acc[tool.name] = convertToTool(tool);
+  return acc;
+}, {} as Record<string, Tool>);

examples/agents-sdk-js/index.ts

@@ -0,0 +1,90 @@
+import { OpenAI } from "openai";
+import {
+  Agent,
+  run,
+  setDefaultOpenAIClient,
+  setOpenAIAPI,
+  setTracingDisabled,
+  tool,
+  MCPServerStdio,
+} from "@openai/agents";
+import { z } from "zod";
+import path from "node:path";
+import process from "node:process";
+import { styleText } from "node:util";
+import { createInterface } from "node:readline/promises";
+
+async function prompt(question: string) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const answer = await rl.question(question);
+  rl.close();
+  return answer;
+}
+
+const openai = new OpenAI({
+  apiKey: "local",
+  baseURL: "http://localhost:11434/v1",
+});
+
+const samplesDir = path.join(process.cwd());
+
+const mcpServer = new MCPServerStdio({
+  name: "Filesystem MCP Server, via npx",
+  fullCommand: `npx -y @modelcontextprotocol/server-filesystem ${samplesDir}`,
+});
+
+await mcpServer.connect();
+
+setTracingDisabled(true);
+setDefaultOpenAIClient(openai);
+setOpenAIAPI("chat_completions");
+
+const searchTool = tool({
+  name: "get_current_weather",
+  description: "Get the current weather in a given location",
+  parameters: z.object({
+    location: z.string(),
+  }),
+  execute: async ({ location }) => {
+    return `The weather in ${location} is sunny.`;
+  },
+});
+
+const agent = new Agent({
+  name: "My Agent",
+  instructions: "You are a helpful assistant.",
+  tools: [searchTool],
+  model: "gpt-oss:20b-test",
+  mcpServers: [mcpServer],
+});
+
+const input = await prompt("> ");
+
+const result = await run(agent, input, {
+  stream: true,
+});
+
+for await (const event of result) {
+  if (event.type === "raw_model_stream_event" && event.data.type === "model") {
+    if (event.data.event.choices[0].delta.content) {
+      process.stdout.write(event.data.event.choices[0].delta.content);
+    } else if (event.data.event.choices[0].delta.reasoning) {
+      process.stdout.write(event.data.event.choices[0].delta.reasoning);
+    }
+  } else if (
+    event.type === "run_item_stream_event" &&
+    event.item.type === "tool_call_item" &&
+    event.item.rawItem.type == "function_call"
+  ) {
+    console.log(
+      `\nCalling ${event.item.rawItem.name} with: ${event.item.rawItem.arguments}`
+    );
+  }
+}
+
+console.log("\n");
+await result.completed;
+await mcpServer.close();

examples/agents-sdk-js/package-lock.json

@@ -0,0 +1,1798 @@
+{
+  "name": "agents-sdk",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "agents-sdk",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "@openai/agents": "^0.0.14",
+        "tsx": "^4.20.3",
+        "typescript": "^5.8.3",
+        "zod": "^3.25.67"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.8.tgz",
+      "integrity": "sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.8.tgz",
+      "integrity": "sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.8.tgz",
+      "integrity": "sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.8.tgz",
+      "integrity": "sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.8.tgz",
+      "integrity": "sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.8.tgz",
+      "integrity": "sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.8.tgz",
+      "integrity": "sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.8.tgz",
+      "integrity": "sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.8.tgz",
+      "integrity": "sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.8.tgz",
+      "integrity": "sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.8.tgz",
+      "integrity": "sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.8.tgz",
+      "integrity": "sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.8.tgz",
+      "integrity": "sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.8.tgz",
+      "integrity": "sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.8.tgz",
+      "integrity": "sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.8.tgz",
+      "integrity": "sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.8.tgz",
+      "integrity": "sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.8.tgz",
+      "integrity": "sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.8.tgz",
+      "integrity": "sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.8.tgz",
+      "integrity": "sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.8.tgz",
+      "integrity": "sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.8.tgz",
+      "integrity": "sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.8.tgz",
+      "integrity": "sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.17.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.17.0.tgz",
+      "integrity": "sha512-qFfbWFA7r1Sd8D697L7GkTd36yqDuTkvz0KfOGkgXR8EUhQn3/EDNIR/qUdQNMT8IjmasBvHWuXeisxtXTQT2g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ajv": "^6.12.6",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.0",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@openai/agents": {
+      "version": "0.0.14",
+      "resolved": "https://registry.npmjs.org/@openai/agents/-/agents-0.0.14.tgz",
+      "integrity": "sha512-67FwkSxlid8/fFzIDMBuIvDQJ2Egf7PCpI7zp2JAlIlsz4UZVSlptNcN63RCG2xP6X2XqsdyjPke8ZDEKVrePw==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.14",
+        "@openai/agents-openai": "0.0.14",
+        "@openai/agents-realtime": "0.0.14",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      }
+    },
+    "node_modules/@openai/agents-core": {
+      "version": "0.0.14",
+      "resolved": "https://registry.npmjs.org/@openai/agents-core/-/agents-core-0.0.14.tgz",
+      "integrity": "sha512-enCk5ucz+xxwPgh0zBQoJi5c1RukSc60neRUmlW4eQRgj9p5hVFQaBQNapZ4RysagHCLm2scYRwKgaP6nPDuNQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      },
+      "optionalDependencies": {
+        "@modelcontextprotocol/sdk": "^1.12.0"
+      },
+      "peerDependencies": {
+        "zod": "3.25.40 - 3.25.67"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@openai/agents-openai": {
+      "version": "0.0.14",
+      "resolved": "https://registry.npmjs.org/@openai/agents-openai/-/agents-openai-0.0.14.tgz",
+      "integrity": "sha512-qSGBictwfJ3dMhC3QvqOLMm8RVZ/eIYNcFNLHps7hWeB1xeDGJFDZ/X7dDicejOeEXbi/nGe1ry6LbXDYSo3uQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.14",
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "debug": "^4.4.0",
+        "openai": "^5.10.1"
+      }
+    },
+    "node_modules/@openai/agents-realtime": {
+      "version": "0.0.14",
+      "resolved": "https://registry.npmjs.org/@openai/agents-realtime/-/agents-realtime-0.0.14.tgz",
+      "integrity": "sha512-gfSuWEDKZREWi0DJDf3F8fT/xvLL9R0cydfgriL0kPkWOlTMuZ0KZKI6D90pc2VAWIescA8BuqCcWkgWFq55Uw==",
+      "license": "MIT",
+      "dependencies": {
+        "@openai/agents-core": "0.0.14",
+        "@openai/zod": "npm:zod@3.25.40 - 3.25.67",
+        "@types/ws": "^8.18.1",
+        "debug": "^4.4.0",
+        "ws": "^8.18.1"
+      }
+    },
+    "node_modules/@openai/zod": {
+      "name": "zod",
+      "version": "3.25.67",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
+      "integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.1.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.1.0.tgz",
+      "integrity": "sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.8.0"
+      }
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.2.0.tgz",
+      "integrity": "sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.6.3",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.8",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.8.tgz",
+      "integrity": "sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.8",
+        "@esbuild/android-arm": "0.25.8",
+        "@esbuild/android-arm64": "0.25.8",
+        "@esbuild/android-x64": "0.25.8",
+        "@esbuild/darwin-arm64": "0.25.8",
+        "@esbuild/darwin-x64": "0.25.8",
+        "@esbuild/freebsd-arm64": "0.25.8",
+        "@esbuild/freebsd-x64": "0.25.8",
+        "@esbuild/linux-arm": "0.25.8",
+        "@esbuild/linux-arm64": "0.25.8",
+        "@esbuild/linux-ia32": "0.25.8",
+        "@esbuild/linux-loong64": "0.25.8",
+        "@esbuild/linux-mips64el": "0.25.8",
+        "@esbuild/linux-ppc64": "0.25.8",
+        "@esbuild/linux-riscv64": "0.25.8",
+        "@esbuild/linux-s390x": "0.25.8",
+        "@esbuild/linux-x64": "0.25.8",
+        "@esbuild/netbsd-arm64": "0.25.8",
+        "@esbuild/netbsd-x64": "0.25.8",
+        "@esbuild/openbsd-arm64": "0.25.8",
+        "@esbuild/openbsd-x64": "0.25.8",
+        "@esbuild/openharmony-arm64": "0.25.8",
+        "@esbuild/sunos-x64": "0.25.8",
+        "@esbuild/win32-arm64": "0.25.8",
+        "@esbuild/win32-ia32": "0.25.8",
+        "@esbuild/win32-x64": "0.25.8"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.3.tgz",
+      "integrity": "sha512-nVpZkTMM9rF6AQ9gPJpFsNAMt48wIzB5TQgiTLdHiuO8XEDhUgZEhqKlZWXbIzo9VmJ/HvysHqEaVeD5v9TPvA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.1.0.tgz",
+      "integrity": "sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.0",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.1",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.1.tgz",
+      "integrity": "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "optional": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "4.10.1",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.1.tgz",
+      "integrity": "sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==",
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/http-errors/node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.1.tgz",
+      "integrity": "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/openai": {
+      "version": "5.11.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-5.11.0.tgz",
+      "integrity": "sha512-+AuTc5pVjlnTuA9zvn8rA/k+1RluPIx9AD4eDcnutv6JNwHHZxIhkFy+tmMKCvmMFDQzfA/r1ujvPWB19DQkYg==",
+      "license": "Apache-2.0",
+      "bin": {
+        "openai": "bin/cli"
+      },
+      "peerDependencies": {
+        "ws": "^8.18.0",
+        "zod": "^3.23.8"
+      },
+      "peerDependenciesMeta": {
+        "ws": {
+          "optional": true
+        },
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.0.tgz",
+      "integrity": "sha512-ueGLflrrnvwB3xuo/uGob5pd5FN7l0MsLf0Z87o/UQmRtwjvfylfc9MurIxRAWywCYTgrvpXBcqjV4OfCYGCIQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "optional": true,
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "debug": "^4.3.5",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "mime-types": "^3.0.1",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.0.tgz",
+      "integrity": "sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tsx": {
+      "version": "4.20.3",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.20.3.tgz",
+      "integrity": "sha512-qjbnuR9Tr+FJOMBqJCW5ehvIo/buZq7vH7qD7JziU98h6l3qGy0a/yPFjwO+y0/T7GFpNgNAvEcPPVfyT8rrPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.25.0",
+        "get-tsconfig": "^4.7.5"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.0.1.tgz",
+      "integrity": "sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==",
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz",
+      "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
+      "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "license": "BSD-2-Clause",
+      "optional": true,
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "optional": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC",
+      "optional": true
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.67",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.67.tgz",
+      "integrity": "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.6",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.6.tgz",
+      "integrity": "sha512-h/z3PKvcTcTetyjl1fkj79MHNEjm+HpD6NXheWjzOekY7kV+lwDYnHw+ivHkijnCSMz1yJaWBD9vu/Fcmk+vEg==",
+      "license": "ISC",
+      "optional": true,
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  }
+}

examples/agents-sdk-js/package.json

@@ -0,0 +1,20 @@
+{
+  "type": "module",
+  "name": "agents-sdk",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "start": "tsx index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@openai/agents": "^0.0.14",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "zod": "^3.25.67"
+  }
+}

examples/agents-sdk-python/example.py

@@ -0,0 +1,102 @@
+import asyncio
+from pathlib import Path
+import shutil
+
+from openai import AsyncOpenAI
+from agents import (
+    Agent,
+    ItemHelpers,
+    Runner,
+    set_default_openai_api,
+    set_default_openai_client,
+    set_tracing_disabled,
+    function_tool,
+)
+from agents.mcp import MCPServerStdio
+
+
+async def prompt_user(question: str) -> str:
+    """Async input prompt function"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, input, question)
+
+
+async def main():
+    # Set up OpenAI client for local server (e.g., Ollama)
+    openai_client = AsyncOpenAI(
+        api_key="local",
+        base_url="http://localhost:11434/v1",
+    )
+
+    # Get current working directory
+    samples_dir = str(Path.cwd())
+
+    # Create MCP server for filesystem operations
+    mcp_server = MCPServerStdio(
+        name="Filesystem MCP Server, via npx",
+        params={
+            "command": "npx",
+            "args": [
+                "-y",
+                "@modelcontextprotocol/server-filesystem",
+                samples_dir,
+            ],
+        },
+    )
+
+    # Connect to MCP server
+    await mcp_server.connect()
+
+    # Configure agents SDK
+    set_tracing_disabled(True)
+    set_default_openai_client(openai_client)
+    set_default_openai_api("chat_completions")
+
+    # Define weather tool
+    @function_tool
+    async def get_weather(location: str) -> str:
+        return f"The weather in {location} is sunny."
+
+    # Create agent
+    agent = Agent(
+        name="My Agent",
+        instructions="You are a helpful assistant.",
+        tools=[get_weather],
+        model="gpt-oss:20b-test",
+        mcp_servers=[mcp_server],
+    )
+
+    # Get user input
+    user_input = await prompt_user("> ")
+
+    # Run agent with streaming
+    result = Runner.run_streamed(agent, user_input)
+
+    # Process streaming results
+    async for event in result.stream_events():
+        if event.type == "raw_response_event":
+            continue
+        elif event.type == "agent_updated_stream_event":
+            print(f"Agent updated: {event.new_agent.name}")
+        elif event.type == "run_item_stream_event":
+            if event.item.type == "tool_call_item":
+                print("-- Tool was called")
+            elif event.item.type == "tool_call_output_item":
+                print(f"-- Tool output: {event.item.output}")
+            elif event.item.type == "message_output_item":
+                print(
+                    f"-- Message output:\n {ItemHelpers.text_message_output(event.item)}"
+                )
+            else:
+                pass
+
+    print("=== Run complete ===")
+
+
+if __name__ == "__main__":
+
+    if not shutil.which("npx"):
+        raise RuntimeError(
+            "npx is not installed. Please install it with `npm install -g npx`."
+        )
+    asyncio.run(main())

examples/agents-sdk-python/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "agents-sdk-python"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "openai-agents>=0.2.4",
+]

examples/gradio/gradio_chat.py

@@ -0,0 +1,247 @@
+import json
+import requests
+import gradio as gr
+
+DEFAULT_FUNCTION_PROPERTIES = """
+{
+    "type": "object",
+    "properties": {
+        "location": {
+            "type": "string",
+            "description": "The city and state, e.g. San Francisco, CA"
+        }
+    },
+    "required": ["location"]
+}
+""".strip()
+
+def chat_with_model(message, history, model_choice, instructions, effort, use_functions, 
+                   function_name, function_description, function_parameters,
+                   use_browser_search, temperature, max_output_tokens, debug_mode):
+    
+    if not message.strip():
+        return history, ""
+    
+    # Append user message and empty assistant placeholder (idiomatic Gradio pattern)
+    history = history + [[message, ""]]
+    
+    # Build messages list from history (excluding the empty assistant placeholder)
+    messages = []
+    
+    # Convert history to messages format (excluding the last empty assistant message)
+    for user_msg, assistant_msg in history[:-1]:
+        if user_msg:
+            messages.append({
+                "type": "message",
+                "role": "user", 
+                "content": [{"type": "input_text", "text": user_msg}]
+            })
+        if assistant_msg:
+            messages.append({
+                "type": "message",
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": assistant_msg}]
+            })
+    
+    # Add current user message
+    messages.append({
+        "type": "message",
+        "role": "user",
+        "content": [{"type": "input_text", "text": message}]
+    })
+    
+    # Prepare tools
+    tools = []
+    if use_functions:
+        try:
+            tools.append({
+                "type": "function",
+                "name": function_name,
+                "description": function_description,
+                "parameters": json.loads(function_parameters),
+            })
+        except json.JSONDecodeError:
+            pass
+    
+    if use_browser_search:
+        tools.append({"type": "browser_search"})
+    
+    # Get URL based on model (matching streamlit logic)
+    options = ["large", "small"]
+    URL = ("http://localhost:8081/v1/responses" if model_choice == options[1] 
+           else "http://localhost:8000/v1/responses")
+    
+    try:
+        response = requests.post(
+            URL,
+            json={
+                "input": messages,
+                "stream": True,
+                "instructions": instructions,
+                "reasoning": {"effort": effort},
+                "metadata": {"__debug": debug_mode},
+                "tools": tools,
+                "temperature": temperature,
+                "max_output_tokens": max_output_tokens,
+            },
+            stream=True,
+        )
+        
+        full_content = ""
+        text_delta = ""
+        current_output_index = 0
+        in_reasoning = False
+        
+        for line in response.iter_lines(decode_unicode=True):
+            if not line or not line.startswith("data:"):
+                continue
+            data_str = line[len("data:"):].strip()
+            if not data_str:
+                continue
+            
+            try:
+                data = json.loads(data_str)
+            except Exception:
+                continue
+            
+            event_type = data.get("type", "")
+            output_index = data.get("output_index", 0)
+            
+            if event_type == "response.output_item.added":
+                current_output_index = output_index
+                output_type = data.get("item", {}).get("type", "message")
+                text_delta = ""
+                
+                if output_type == "reasoning":
+                    if not in_reasoning:
+                        full_content += "🤔 **Thinking...**\n"
+                        in_reasoning = True
+                elif output_type == "message":
+                    if in_reasoning:
+                        full_content += "\n\n"
+                        in_reasoning = False
+                
+            elif event_type == "response.reasoning_text.delta":
+                delta = data.get("delta", "")
+                full_content += delta
+                
+                # Update last assistant message (idiomatic Gradio pattern)
+                history[-1][1] = full_content
+                yield history, ""
+                
+            elif event_type == "response.output_text.delta":
+                delta = data.get("delta", "")
+                full_content += delta
+                
+                # Update last assistant message (idiomatic Gradio pattern)  
+                history[-1][1] = full_content
+                yield history, ""
+                
+            elif event_type == "response.output_item.done":
+                item = data.get("item", {})
+                if item.get("type") == "function_call":
+                    function_call_text = f"\n\n🔨 Called `{item.get('name')}`\n**Arguments**\n```json\n{item.get('arguments', '')}\n```"
+                    full_content += function_call_text
+                    
+                    # Update last assistant message (idiomatic Gradio pattern)
+                    history[-1][1] = full_content
+                    yield history, ""
+                    
+                elif item.get("type") == "web_search_call":
+                    web_search_text = f"\n\n🌐 **Web Search**\n```json\n{json.dumps(item.get('action', {}), indent=2)}\n```\n✅ Done"
+                    full_content += web_search_text
+                    
+                    # Update last assistant message (idiomatic Gradio pattern)
+                    history[-1][1] = full_content
+                    yield history, ""
+                    
+            elif event_type == "response.completed":
+                response_data = data.get("response", {})
+                if debug_mode:
+                    debug_info = response_data.get("metadata", {}).get("__debug", "")
+                    if debug_info:
+                        full_content += f"\n\n**Debug**\n```\n{debug_info}\n```"
+                        
+                        # Update last assistant message (idiomatic Gradio pattern)
+                        history[-1][1] = full_content
+                        yield history, ""
+                break
+        
+        # Return final history and empty string to clear textbox
+        return history, ""
+        
+    except Exception as e:
+        error_message = f"❌ Error: {str(e)}"
+        history[-1][1] = error_message
+        return history, ""
+
+
+# Create the Gradio interface
+with gr.Blocks(title="💬 Chatbot") as demo:
+    gr.Markdown("# 💬 Chatbot")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(height=500)
+            
+            with gr.Row():
+                msg = gr.Textbox(placeholder="Type a message...", scale=4, show_label=False)
+                send_btn = gr.Button("Send", scale=1)
+            
+            clear_btn = gr.Button("Clear Chat")
+        
+        with gr.Column(scale=1):
+            model_choice = gr.Radio(["large", "small"], value="small", label="Model")
+            
+            instructions = gr.Textbox(
+                label="Instructions", 
+                value="You are a helpful assistant that can answer questions and help with tasks.",
+                lines=3
+            )
+            
+            effort = gr.Radio(["low", "medium", "high"], value="medium", label="Reasoning effort")
+            
+            gr.Markdown("#### Functions")
+            use_functions = gr.Checkbox(label="Use functions", value=False)
+            
+            with gr.Column(visible=False) as function_group:
+                function_name = gr.Textbox(label="Function name", value="get_weather")
+                function_description = gr.Textbox(
+                    label="Function description", 
+                    value="Get the weather for a given city"
+                )
+                function_parameters = gr.Textbox(
+                    label="Function parameters", 
+                    value=DEFAULT_FUNCTION_PROPERTIES,
+                    lines=6
+                )
+            
+            # Conditional browser search (matching Streamlit logic)
+            # In Streamlit: if "show_browser" in st.query_params:
+            # For Gradio, we'll always show it (simplified)
+            gr.Markdown("#### Built-in Tools") 
+            use_browser_search = gr.Checkbox(label="Use browser search", value=False)
+            
+            temperature = gr.Slider(0.0, 1.0, value=1.0, step=0.01, label="Temperature")
+            max_output_tokens = gr.Slider(1000, 20000, value=1024, step=100, label="Max output tokens")
+            
+            debug_mode = gr.Checkbox(label="Debug mode", value=False)
+    
+    # Event handlers
+    def toggle_function_group(use_funcs):
+        return gr.update(visible=use_funcs)
+    
+    use_functions.change(toggle_function_group, use_functions, function_group)
+    
+    # Chat functionality
+    inputs = [msg, chatbot, model_choice, instructions, effort, use_functions, 
+              function_name, function_description, function_parameters,
+              use_browser_search, temperature, max_output_tokens, debug_mode]
+    
+    msg.submit(chat_with_model, inputs, [chatbot, msg])
+    send_btn.click(chat_with_model, inputs, [chatbot, msg])
+    clear_btn.click(lambda: [], outputs=chatbot)
+
+
+if __name__ == "__main__":
+    demo.launch()

examples/streamlit/streamlit_chat.py

@@ -0,0 +1,354 @@
+import json
+
+import requests
+import streamlit as st
+
+DEFAULT_FUNCTION_PROPERTIES = """
+{
+    "type": "object",
+    "properties": {
+        "location": {
+            "type": "string",
+            "description": "The city and state, e.g. San Francisco, CA"
+        }
+    },
+    "required": ["location"]
+}
+""".strip()
+
+# Session state for chat
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+st.title("💬 Chatbot")
+
+if "model" not in st.session_state:
+    if "model" in st.query_params:
+        st.session_state.model = st.query_params["model"]
+    else:
+        st.session_state.model = "small"
+
+options = ["large", "small"]
+selection = st.sidebar.segmented_control(
+    "Model", options, selection_mode="single", default=st.session_state.model
+)
+# st.session_state.model = selection
+st.query_params.update({"model": selection})
+
+instructions = st.sidebar.text_area(
+    "Instructions",
+    value="You are a helpful assistant that can answer questions and help with tasks.",
+)
+effort = st.sidebar.radio(
+    "Reasoning effort",
+    ["low", "medium", "high"],
+    index=1,
+)
+st.sidebar.divider()
+st.sidebar.subheader("Functions")
+use_functions = st.sidebar.toggle("Use functions", value=False)
+
+st.sidebar.subheader("Built-in Tools")
+# Built-in Tools section
+use_browser_search = st.sidebar.toggle("Use browser search", value=False)
+use_code_interpreter = st.sidebar.toggle("Use code interpreter", value=False)
+
+if use_functions:
+    function_name = st.sidebar.text_input("Function name", value="get_weather")
+    function_description = st.sidebar.text_area(
+        "Function description", value="Get the weather for a given city"
+    )
+    function_parameters = st.sidebar.text_area(
+        "Function parameters", value=DEFAULT_FUNCTION_PROPERTIES
+    )
+else:
+    function_name = None
+    function_description = None
+    function_parameters = None
+st.sidebar.divider()
+temperature = st.sidebar.slider(
+    "Temperature", min_value=0.0, max_value=1.0, value=1.0, step=0.01
+)
+max_output_tokens = st.sidebar.slider(
+    "Max output tokens", min_value=1, max_value=131072, value=30000, step=1000
+)
+st.sidebar.divider()
+debug_mode = st.sidebar.toggle("Debug mode", value=False)
+
+if debug_mode:
+    st.sidebar.divider()
+    st.sidebar.code(json.dumps(st.session_state.messages, indent=2), "json")
+
+render_input = True
+
+URL = (
+    "http://localhost:8081/v1/responses"
+    if selection == options[1]
+    else "http://localhost:8000/v1/responses"
+)
+
+
+def trigger_fake_tool(container):
+    function_output = st.session_state.get("function_output", "It's sunny!")
+    last_call = st.session_state.messages[-1]
+    if last_call.get("type") == "function_call":
+        st.session_state.messages.append(
+            {
+                "type": "function_call_output",
+                "call_id": last_call.get("call_id"),
+                "output": function_output,
+            }
+        )
+        run(container)
+
+
+def run(container):
+    tools = []
+    if use_functions:
+        tools.append(
+            {
+                "type": "function",
+                "name": function_name,
+                "description": function_description,
+                "parameters": json.loads(function_parameters),
+            }
+        )
+    # Add browser_search tool if checkbox is checked
+    if use_browser_search:
+        tools.append({"type": "browser_search"})
+    if use_code_interpreter:
+        tools.append({"type": "code_interpreter"})
+    response = requests.post(
+        URL,
+        json={
+            "input": st.session_state.messages,
+            "stream": True,
+            "instructions": instructions,
+            "reasoning": {"effort": effort},
+            "metadata": {"__debug": debug_mode},
+            "tools": tools,
+            "temperature": temperature,
+            "max_output_tokens": max_output_tokens,
+        },
+        stream=True,
+    )
+
+    text_delta = ""
+    code_interpreter_sessions: dict[str, dict] = {}
+
+    _current_output_index = 0
+    for line in response.iter_lines(decode_unicode=True):
+        if not line or not line.startswith("data:"):
+            continue
+        data_str = line[len("data:") :].strip()
+        if not data_str:
+            continue
+        try:
+            data = json.loads(data_str)
+        except Exception:
+            continue
+
+        event_type = data.get("type", "")
+        output_index = data.get("output_index", 0)
+        if event_type == "response.output_item.added":
+            _current_output_index = output_index
+            output_type = data.get("item", {}).get("type", "message")
+            if output_type == "message":
+                output = container.chat_message("assistant")
+                placeholder = output.empty()
+            elif output_type == "reasoning":
+                output = container.chat_message("reasoning", avatar="🤔")
+                placeholder = output.empty()
+            elif output_type == "web_search_call":
+                output = container.chat_message("web_search_call", avatar="🌐")
+                output.code(
+                    json.dumps(data.get("item", {}).get("action", {}), indent=4),
+                    language="json",
+                )
+                placeholder = output.empty()
+            elif output_type == "code_interpreter_call":
+                item = data.get("item", {})
+                item_id = item.get("id")
+                message_container = container.chat_message(
+                    "code_interpreter_call", avatar="🧪"
+                )
+                status_placeholder = message_container.empty()
+                code_placeholder = message_container.empty()
+                outputs_container = message_container.container()
+                code_text = item.get("code") or ""
+                if code_text:
+                    code_placeholder.code(code_text, language="python")
+                code_interpreter_sessions[item_id] = {
+                    "status": status_placeholder,
+                    "code": code_placeholder,
+                    "outputs": outputs_container,
+                    "code_text": code_text,
+                    "rendered_outputs": False,
+                }
+                placeholder = status_placeholder
+            text_delta = ""
+        elif event_type == "response.reasoning_text.delta":
+            output.avatar = "🤔"
+            text_delta += data.get("delta", "")
+            placeholder.markdown(text_delta)
+        elif event_type == "response.output_text.delta":
+            text_delta += data.get("delta", "")
+            placeholder.markdown(text_delta)
+        elif event_type == "response.output_item.done":
+            item = data.get("item", {})
+            if item.get("type") == "function_call":
+                with container.chat_message("function_call", avatar="🔨"):
+                    st.markdown(f"Called `{item.get('name')}`")
+                    st.caption("Arguments")
+                    st.code(item.get("arguments", ""), language="json")
+            if item.get("type") == "web_search_call":
+                placeholder.markdown("✅ Done")
+            if item.get("type") == "code_interpreter_call":
+                item_id = item.get("id")
+                session = code_interpreter_sessions.get(item_id)
+                if session:
+                    session["status"].markdown("✅ Done")
+                    final_code = item.get("code") or session["code_text"]
+                    if final_code:
+                        session["code"].code(final_code, language="python")
+                        session["code_text"] = final_code
+                    outputs = item.get("outputs") or []
+                    if outputs and not session["rendered_outputs"]:
+                        with session["outputs"]:
+                            st.markdown("**Outputs**")
+                            for output_item in outputs:
+                                output_type = output_item.get("type")
+                                if output_type == "logs":
+                                    st.code(
+                                        output_item.get("logs", ""),
+                                        language="text",
+                                    )
+                                elif output_type == "image":
+                                    st.image(
+                                        output_item.get("url", ""),
+                                        caption="Code interpreter image",
+                                    )
+                        session["rendered_outputs"] = True
+                    elif not outputs and not session["rendered_outputs"]:
+                        with session["outputs"]:
+                            st.caption("(No outputs)")
+                        session["rendered_outputs"] = True
+                else:
+                    placeholder.markdown("✅ Done")
+        elif event_type == "response.code_interpreter_call.in_progress":
+            item_id = data.get("item_id")
+            session = code_interpreter_sessions.get(item_id)
+            if session:
+                session["status"].markdown("⏳ Running")
+            else:
+                try:
+                    placeholder.markdown("⏳ Running")
+                except Exception:
+                    pass
+        elif event_type == "response.code_interpreter_call.interpreting":
+            item_id = data.get("item_id")
+            session = code_interpreter_sessions.get(item_id)
+            if session:
+                session["status"].markdown("🧮 Interpreting")
+        elif event_type == "response.code_interpreter_call.completed":
+            item_id = data.get("item_id")
+            session = code_interpreter_sessions.get(item_id)
+            if session:
+                session["status"].markdown("✅ Done")
+            else:
+                try:
+                    placeholder.markdown("✅ Done")
+                except Exception:
+                    pass
+        elif event_type == "response.code_interpreter_call_code.delta":
+            item_id = data.get("item_id")
+            session = code_interpreter_sessions.get(item_id)
+            if session:
+                session["code_text"] += data.get("delta", "")
+                if session["code_text"].strip():
+                    session["code"].code(session["code_text"], language="python")
+        elif event_type == "response.code_interpreter_call_code.done":
+            item_id = data.get("item_id")
+            session = code_interpreter_sessions.get(item_id)
+            if session:
+                final_code = data.get("code") or session["code_text"]
+                session["code_text"] = final_code
+                if final_code:
+                    session["code"].code(final_code, language="python")
+        elif event_type == "response.completed":
+            response = data.get("response", {})
+            if debug_mode:
+                container.expander("Debug", expanded=False).code(
+                    response.get("metadata", {}).get("__debug", ""), language="text"
+                )
+            st.session_state.messages.extend(response.get("output", []))
+            if st.session_state.messages[-1].get("type") == "function_call":
+                with container.form("function_output_form"):
+                    _function_output = st.text_input(
+                        "Enter function output",
+                        value=st.session_state.get("function_output", "It's sunny!"),
+                        key="function_output",
+                    )
+                    st.form_submit_button(
+                        "Submit function output",
+                        on_click=trigger_fake_tool,
+                        args=[container],
+                    )
+            # Optionally handle other event types...
+
+
+# Chat display
+for msg in st.session_state.messages:
+    if msg.get("type") == "message":
+        with st.chat_message(msg["role"]):
+            for item in msg["content"]:
+                if (
+                    item.get("type") == "text"
+                    or item.get("type") == "output_text"
+                    or item.get("type") == "input_text"
+                ):
+                    st.markdown(item["text"])
+                    if item.get("annotations"):
+                        annotation_lines = "\n".join(
+                            f"- {annotation.get('url')}"
+                            for annotation in item["annotations"]
+                            if annotation.get("url")
+                        )
+                        st.caption(f"**Annotations:**\n{annotation_lines}")
+    elif msg.get("type") == "reasoning":
+        with st.chat_message("reasoning", avatar="🤔"):
+            for item in msg["content"]:
+                if item.get("type") == "reasoning_text":
+                    st.markdown(item["text"])
+    elif msg.get("type") == "function_call":
+        with st.chat_message("function_call", avatar="🔨"):
+            st.markdown(f"Called `{msg.get('name')}`")
+            st.caption("Arguments")
+            st.code(msg.get("arguments", ""), language="json")
+    elif msg.get("type") == "function_call_output":
+        with st.chat_message("function_call_output", avatar="✅"):
+            st.caption("Output")
+            st.code(msg.get("output", ""), language="text")
+    elif msg.get("type") == "web_search_call":
+        with st.chat_message("web_search_call", avatar="🌐"):
+            st.code(json.dumps(msg.get("action", {}), indent=4), language="json")
+            st.markdown("✅ Done")
+    elif msg.get("type") == "code_interpreter_call":
+        with st.chat_message("code_interpreter_call", avatar="🧪"):
+            st.markdown("✅ Done")
+
+if render_input:
+    # Input field
+    if prompt := st.chat_input("Type a message..."):
+        st.session_state.messages.append(
+            {
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": prompt}],
+            }
+        )
+
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        run(st.container())

gpt-oss-mcp-server/README.md

@@ -0,0 +1,29 @@
+# MCP Servers for gpt-oss reference tools
+
+This directory contains MCP servers for the reference tools in the [gpt-oss](https://github.com/openai/gpt-oss) repository.
+You can set up these tools behind MCP servers and use them in your applications.
+For inference service that integrates with MCP, you can also use these as reference tools.
+
+In particular, this directory contains a `build-system-prompt.py` script that will generate exactly the same system prompt as `reference-system-prompt.py`.
+The build system prompt script show case all the care needed to automatically discover the tools and construct the system prompt before feeding it into Harmony.
+
+## Usage
+
+```bash
+# Install the dependencies
+uv pip install -r requirements.txt
+```
+
+```bash
+# Assume we have harmony and gpt-oss installed
+uv pip install mcp[cli]
+# start the servers
+mcp run -t sse browser_server.py:mcp
+mcp run -t sse python_server.py:mcp
+```
+
+You can now use MCP inspector to play with the tools.
+Once opened, set SSE to `http://localhost:8001/sse` and `http://localhost:8000/sse` respectively.
+
+To compare the system prompt and see how to construct it via MCP service discovery, see `build-system-prompt.py`.
+This script will generate exactly the same system prompt as `reference-system-prompt.py`.

gpt-oss-mcp-server/browser_server.py

@@ -0,0 +1,120 @@
+import os
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from dataclasses import dataclass, field
+from typing import Union, Optional
+
+from mcp.server.fastmcp import Context, FastMCP
+from gpt_oss.tools.simple_browser import SimpleBrowserTool
+from gpt_oss.tools.simple_browser.backend import YouComBackend, ExaBackend
+
+@dataclass
+class AppContext:
+    browsers: dict[str, SimpleBrowserTool] = field(default_factory=dict)
+
+    def create_or_get_browser(self, session_id: str) -> SimpleBrowserTool:
+        if session_id not in self.browsers:
+            tool_backend = os.getenv("BROWSER_BACKEND", "exa")
+            if tool_backend == "youcom":
+                backend = YouComBackend(source="web")
+            elif tool_backend == "exa":
+                backend = ExaBackend(source="web")
+            else:
+                raise ValueError(f"Invalid tool backend: {tool_backend}")
+            self.browsers[session_id] = SimpleBrowserTool(backend=backend)
+        return self.browsers[session_id]
+
+    def remove_browser(self, session_id: str) -> None:
+        self.browsers.pop(session_id, None)
+
+
+@asynccontextmanager
+async def app_lifespan(_server: FastMCP) -> AsyncIterator[AppContext]:
+    yield AppContext()
+
+
+# Pass lifespan to server
+mcp = FastMCP(
+    name="browser",
+    instructions=r"""
+Tool for browsing.
+The `cursor` appears in brackets before each browsing display: `[{cursor}]`.
+Cite information from the tool using the following format:
+`【{cursor}†L{line_start}(-L{line_end})?】`, for example: `【6†L9-L11】` or `【8†L3】`. 
+Do not quote more than 10 words directly from the tool output.
+sources=web
+""".strip(),
+    lifespan=app_lifespan,
+    port=8001,
+)
+
+
+@mcp.tool(
+    name="search",
+    title="Search for information",
+    description=
+    "Searches for information related to `query` and displays `topn` results.",
+)
+async def search(ctx: Context,
+                 query: str,
+                 topn: int = 10,
+                 source: Optional[str] = None) -> str:
+    """Search for information related to a query"""
+    browser = ctx.request_context.lifespan_context.create_or_get_browser(
+        ctx.client_id)
+    messages = []
+    async for message in browser.search(query=query, topn=topn, source=source):
+        if message.content and hasattr(message.content[0], 'text'):
+            messages.append(message.content[0].text)
+    return "\n".join(messages)
+
+
+@mcp.tool(
+    name="open",
+    title="Open a link or page",
+    description="""
+Opens the link `id` from the page indicated by `cursor` starting at line number `loc`, showing `num_lines` lines.
+Valid link ids are displayed with the formatting: `【{id}†.*】`.
+If `cursor` is not provided, the most recent page is implied.
+If `id` is a string, it is treated as a fully qualified URL associated with `source`.
+If `loc` is not provided, the viewport will be positioned at the beginning of the document or centered on the most relevant passage, if available.
+Use this function without `id` to scroll to a new location of an opened page.
+""".strip(),
+)
+async def open_link(ctx: Context,
+                    id: Union[int, str] = -1,
+                    cursor: int = -1,
+                    loc: int = -1,
+                    num_lines: int = -1,
+                    view_source: bool = False,
+                    source: Optional[str] = None) -> str:
+    """Open a link or navigate to a page location"""
+    browser = ctx.request_context.lifespan_context.create_or_get_browser(
+        ctx.client_id)
+    messages = []
+    async for message in browser.open(id=id,
+                                      cursor=cursor,
+                                      loc=loc,
+                                      num_lines=num_lines,
+                                      view_source=view_source,
+                                      source=source):
+        if message.content and hasattr(message.content[0], 'text'):
+            messages.append(message.content[0].text)
+    return "\n".join(messages)
+
+
+@mcp.tool(
+    name="find",
+    title="Find pattern in page",
+    description=
+    "Finds exact matches of `pattern` in the current page, or the page given by `cursor`.",
+)
+async def find_pattern(ctx: Context, pattern: str, cursor: int = -1) -> str:
+    """Find exact matches of a pattern in the current page"""
+    browser = ctx.request_context.lifespan_context.create_or_get_browser(
+        ctx.client_id)
+    messages = []
+    async for message in browser.find(pattern=pattern, cursor=cursor):
+        if message.content and hasattr(message.content[0], 'text'):
+            messages.append(message.content[0].text)
+    return "\n".join(messages)

gpt-oss-mcp-server/build-system-prompt.py

@@ -0,0 +1,116 @@
+import datetime
+import asyncio
+
+from gpt_oss.tokenizer import get_tokenizer
+
+from openai_harmony import (
+    Conversation,
+    DeveloperContent,
+    HarmonyEncodingName,
+    Message,
+    ReasoningEffort,
+    Role,
+    SystemContent,
+    ToolNamespaceConfig,
+    ToolDescription,
+    load_harmony_encoding,
+)
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from mcp.types import ListToolsResult
+
+
+async def list_server_and_tools(server_url: str):
+    async with sse_client(url=server_url) as streams, ClientSession(
+            *streams) as session:
+        initialize_response = await session.initialize()
+        list_tools_response = await session.list_tools()
+        return initialize_response, list_tools_response
+
+
+def trim_schema(schema: dict) -> dict:
+    # Turn JSON Schema from MCP generated into Harmony's variant.
+    if "title" in schema:
+        del schema["title"]
+    if "default" in schema and schema["default"] is None:
+        del schema["default"]
+    if "anyOf" in schema:
+        # Turn "anyOf": [{"type": "type-1"}, {"type": "type-2"}] into "type": ["type-1", "type-2"]
+        # if there's more than 1 types, also remove "null" type as Harmony will just ignore it
+        types = [
+            type_dict["type"] for type_dict in schema["anyOf"]
+            if type_dict["type"] != 'null'
+        ]
+        schema["type"] = types
+        del schema["anyOf"]
+    if "properties" in schema:
+        schema["properties"] = {
+            k: trim_schema(v)
+            for k, v in schema["properties"].items()
+        }
+    return schema
+
+
+def post_process_tools_description(
+        list_tools_result: ListToolsResult) -> ListToolsResult:
+    # Adapt the MCP tool result for Harmony
+    for tool in list_tools_result.tools:
+        tool.inputSchema = trim_schema(tool.inputSchema)
+
+    # Some tools schema don't need to be part of the prompt (e.g. simple text in text out for Python)
+    list_tools_result.tools = [
+        tool for tool in list_tools_result.tools
+        if getattr(tool.annotations, "include_in_prompt", True)
+    ]
+
+    return list_tools_result
+
+tokenizer = get_tokenizer()
+
+tools_urls = [
+    "http://localhost:8001/sse",  # browser
+    "http://localhost:8000/sse",  # python
+]
+harmony_tool_descriptions = []
+for tools_url in tools_urls:
+
+    initialize_response, list_tools_response = asyncio.run(
+        list_server_and_tools(tools_url))
+
+    list_tools_response = post_process_tools_description(list_tools_response)
+
+    tool_from_mcp = ToolNamespaceConfig(
+        name=initialize_response.serverInfo.name,
+        description=initialize_response.instructions,
+        tools=[
+            ToolDescription.new(name=tool.name,
+                                description=tool.description,
+                                parameters=tool.inputSchema)
+            for tool in list_tools_response.tools
+        ])
+    harmony_tool_descriptions.append(tool_from_mcp)
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+system_message_content = (SystemContent.new().with_reasoning_effort(
+    ReasoningEffort.LOW).with_conversation_start_date(
+        datetime.datetime.now().strftime("%Y-%m-%d")))
+
+for tool_description in harmony_tool_descriptions:
+    system_message_content = system_message_content.with_tools(
+        tool_description)
+
+system_message = Message.from_role_and_content(Role.SYSTEM,
+                                               system_message_content)
+
+developer_message_content = DeveloperContent.new().with_instructions("")
+developer_message = Message.from_role_and_content(Role.DEVELOPER,
+                                                  developer_message_content)
+
+messages = [system_message, developer_message]
+
+conversation = Conversation.from_messages(messages)
+tokens = encoding.render_conversation(conversation)
+system_message = tokenizer.decode(tokens)
+print(system_message)

gpt-oss-mcp-server/pyproject.toml

@@ -0,0 +1,8 @@
+[project]
+name = "gpt-oss-mcp-server"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp[cli]>=1.12.2",
+    # "gpt_oss"
+]

gpt-oss-mcp-server/python_server.py

@@ -0,0 +1,33 @@
+from mcp.server.fastmcp import FastMCP
+from gpt_oss.tools.python_docker.docker_tool import PythonTool
+from openai_harmony import Message, TextContent, Author, Role
+
+# Pass lifespan to server
+mcp = FastMCP(
+    name="python",
+    instructions=r"""
+Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).
+When you send a message containing python code to python, it will be executed in a stateless docker container, and the stdout of that process will be returned to you.
+""".strip(),
+)
+
+
+@mcp.tool(
+    name="python",
+    title="Execute Python code",
+    description="""
+Use this tool to execute Python code in your chain of thought. The code will not be shown to the user. This tool should be used for internal reasoning, but not for code that is intended to be visible to the user (e.g. when creating plots, tables, or files).
+When you send a message containing python code to python, it will be executed in a stateless docker container, and the stdout of that process will be returned to you.
+    """,
+    annotations={
+        # Harmony format don't want this schema to be part of it because it's simple text in text out
+        "include_in_prompt": False,
+    })
+async def python(code: str) -> str:
+    tool = PythonTool()
+    messages = []
+    async for message in tool.process(
+            Message(author=Author(role=Role.TOOL, name="python"),
+                    content=[TextContent(text=code)])):
+        messages.append(message)
+    return "\n".join([message.content[0].text for message in messages])

gpt-oss-mcp-server/reference-system-prompt.py

@@ -0,0 +1,46 @@
+import datetime
+
+from gpt_oss.tools.simple_browser import SimpleBrowserTool
+from gpt_oss.tools.simple_browser.backend import YouComBackend
+from gpt_oss.tools.python_docker.docker_tool import PythonTool
+from gpt_oss.tokenizer import tokenizer
+
+from openai_harmony import (
+    Conversation,
+    DeveloperContent,
+    HarmonyEncodingName,
+    Message,
+    ReasoningEffort,
+    Role,
+    SystemContent,
+    load_harmony_encoding,
+)
+
+encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+system_message_content = (SystemContent.new().with_reasoning_effort(
+    ReasoningEffort.LOW).with_conversation_start_date(
+        datetime.datetime.now().strftime("%Y-%m-%d")))
+
+backend = YouComBackend(source="web")
+browser_tool = SimpleBrowserTool(backend=backend)
+system_message_content = system_message_content.with_tools(
+    browser_tool.tool_config)
+
+python_tool = PythonTool()
+system_message_content = system_message_content.with_tools(
+    python_tool.tool_config)
+
+system_message = Message.from_role_and_content(Role.SYSTEM,
+                                               system_message_content)
+
+developer_message_content = DeveloperContent.new().with_instructions("")
+developer_message = Message.from_role_and_content(Role.DEVELOPER,
+                                                  developer_message_content)
+
+messages = [system_message, developer_message]
+
+conversation = Conversation.from_messages(messages)
+tokens = encoding.render_conversation(conversation)
+system_message = tokenizer.decode(tokens)
+print(system_message)

gpt_oss/chat.py

@@ -0,0 +1,369 @@
+"""
+Harmony chat with tools
+"""
+
+import atexit
+import argparse
+import asyncio
+import datetime
+import os
+from pathlib import Path
+
+try:
+    import gnureadline as readline
+except ImportError:
+    import readline
+
+import torch
+import termcolor
+
+from gpt_oss.tools import apply_patch
+from gpt_oss.tools.simple_browser import SimpleBrowserTool
+from gpt_oss.tools.simple_browser.backend import YouComBackend
+from gpt_oss.tools.python_docker.docker_tool import PythonTool
+
+from openai_harmony import (
+    Author,
+    Conversation,
+    DeveloperContent,
+    HarmonyEncodingName,
+    Message,
+    ReasoningEffort,
+    Role,
+    StreamableParser,
+    StreamState,
+    SystemContent,
+    TextContent,
+    ToolDescription,
+    load_harmony_encoding,
+)
+
+
+REASONING_EFFORT = {
+    "high": ReasoningEffort.HIGH,
+    "medium": ReasoningEffort.MEDIUM,
+    "low": ReasoningEffort.LOW,
+}
+
+
+def get_user_input():
+    rank = torch.distributed.get_rank() if torch.distributed.is_initialized() else 0
+    if rank == 0:
+        user_input = input()
+    else:
+        user_input = ""
+    user_input_list = [user_input]
+    if torch.distributed.is_initialized():
+        torch.distributed.broadcast_object_list(user_input_list, 0)
+    return user_input_list[0]
+
+
+def main(args):
+    match args.backend:
+        case "triton":
+            from gpt_oss.triton.model import TokenGenerator as TritonGenerator
+            from gpt_oss.torch.utils import init_distributed
+            device = init_distributed()
+            generator = TritonGenerator(args.checkpoint, args.context, device)
+        case "torch":
+            from gpt_oss.torch.model import TokenGenerator as TorchGenerator
+            from gpt_oss.torch.utils import init_distributed
+            device = init_distributed()
+            generator = TorchGenerator(args.checkpoint, device)
+        case "vllm":
+            from gpt_oss.vllm.token_generator import TokenGenerator as VLLMGenerator
+            generator = VLLMGenerator(args.checkpoint, tensor_parallel_size=2)
+        case _:
+            raise ValueError(f"Invalid backend: {args.backend}")
+
+    encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+    system_message_content = (
+        SystemContent.new()
+        .with_reasoning_effort(REASONING_EFFORT[args.reasoning_effort])
+        .with_conversation_start_date(datetime.datetime.now().strftime("%Y-%m-%d"))
+    )
+
+    if args.browser:
+        backend = YouComBackend(
+            source="web",
+        )
+        browser_tool = SimpleBrowserTool(backend=backend)
+        system_message_content = system_message_content.with_tools(browser_tool.tool_config)
+
+    if args.python:
+        python_tool = PythonTool()
+        system_message_content = system_message_content.with_tools(python_tool.tool_config)
+
+    system_message = Message.from_role_and_content(Role.SYSTEM, system_message_content)
+    messages = [system_message]
+
+    if args.apply_patch:
+        apply_patch_instructions = Path(apply_patch.__file__).parent / "apply_patch.md"
+        developer_message = ""
+        if args.developer_message:
+            developer_message = args.developer_message + "\n"
+        developer_message += apply_patch_instructions.read_text()
+        developer_message_content = (
+            DeveloperContent.new()
+            .with_instructions(developer_message)
+            .with_function_tools([
+                ToolDescription.new(
+                    "apply_patch",
+                    "Patch a file",
+                    parameters={
+                        "type": "string",
+                        "description": "Formatted patch code",
+                        "default": "*** Begin Patch\n*** End Patch\n",
+                    }
+                ),
+            ])
+        )
+        messages.append(Message.from_role_and_content(Role.DEVELOPER, developer_message_content))
+    elif args.developer_message:
+        developer_message_content = DeveloperContent.new().with_instructions(args.developer_message)
+        messages.append(Message.from_role_and_content(Role.DEVELOPER, developer_message_content))
+    else:
+        developer_message_content = None
+
+    if args.raw:
+        conversation = Conversation.from_messages(messages)
+        tokens = encoding.render_conversation(conversation)
+        system_message = encoding.decode(tokens)
+        print(system_message, flush=True, end="")
+        empty_user_message_tokens = encoding.render(Message.from_role_and_content(Role.USER, ""))
+        user_message_start = encoding.decode(empty_user_message_tokens[:-1])
+        user_message_end = encoding.decode(empty_user_message_tokens[-1:])
+    else:
+        # System message
+        print(termcolor.colored("System Message:", "cyan"), flush=True)
+        print(termcolor.colored("Model Identity:", "cyan"), system_message_content.model_identity, flush=True)
+        print(termcolor.colored("Reasoning Effort:", "cyan"), system_message_content.reasoning_effort, flush=True)
+        print(termcolor.colored("Conversation Start Date:", "cyan"), system_message_content.conversation_start_date, flush=True)
+        print(termcolor.colored("Knowledge Cutoff:", "cyan"), system_message_content.knowledge_cutoff, flush=True)
+        print(termcolor.colored("Browser Tool:", "cyan"), "Enabled" if args.browser else "Disabled", flush=True)
+        print(termcolor.colored("Python Tool:", "cyan"), "Enabled" if args.python else "Disabled", flush=True)
+        print(termcolor.colored("Apply Patch Function:", "cyan"), "Enabled" if args.apply_patch else "Disabled", flush=True)
+        if developer_message_content:
+            print(termcolor.colored("Developer Message:", "yellow"), flush=True)
+            print(developer_message_content.instructions, flush=True)
+
+    # Print the system message and the user message start
+    MESSAGE_PADDING = 12
+    while True:
+        last_message = messages[-1]
+        if last_message.recipient is None:
+            if args.raw:
+                print(user_message_start, end="", flush=True)
+                user_message = get_user_input()
+                print(user_message_end, flush=True, end="")
+            else:
+                print(termcolor.colored("User:".ljust(MESSAGE_PADDING), "red"), flush=True)
+                user_message = get_user_input()
+            user_message = Message.from_role_and_content(Role.USER, user_message)
+            messages.append(user_message)
+        else:
+            # Tool or function call
+            if last_message.recipient.startswith("browser."):
+                assert args.browser, "Browser tool is not enabled"
+                tool_name = "Search"
+                async def run_tool():
+                    results = []
+                    async for msg in browser_tool.process(last_message):
+                        results.append(msg)
+                    return results
+
+                result = asyncio.run(run_tool())
+                messages += result
+            elif last_message.recipient.startswith("python"):
+                assert args.python, "Python tool is not enabled"
+                tool_name = "Python"
+                async def run_tool():
+                    results = []
+                    async for msg in python_tool.process(last_message):
+                        results.append(msg)
+                    return results
+
+                result = asyncio.run(run_tool())
+                messages += result
+            elif last_message.recipient == "functions.apply_patch":
+                assert args.apply_patch, "Apply patch tool is not enabled"
+                tool_name = "Apply Patch"
+                text = last_message.content[0].text
+                tool_output = None
+
+                if text.startswith("{"):
+                    # this is json, try to extract the patch from it
+                    import json
+                    try:
+                        some_dict = json.loads(text)
+                        _, text = some_dict.popitem()
+                    except Exception as e:
+                        tool_output = f"Error parsing JSON: {e}"
+
+                if tool_output is None:
+                    try:
+                        tool_output = apply_patch.apply_patch(text)
+                    except Exception as e:
+                        tool_output = f"Error applying patch: {e}"
+
+                message = (
+                    Message(
+                        author=Author.new(Role.TOOL, last_message.recipient),
+                        content=[TextContent(text=tool_output)]
+                    )
+                    .with_recipient("assistant")
+                )
+                if last_message.channel:
+                    message = message.with_channel(last_message.channel)
+
+                result = [message]
+                messages += result
+            else:
+                raise ValueError(f"Unknown tool or function call: {last_message.recipient}")
+            # Print the tool or function call result
+            if args.raw:
+                rendered_result = encoding.render_conversation(Conversation.from_messages(result))
+                print(encoding.decode(rendered_result), flush=True, end="")
+            else:
+                print(termcolor.colored(f"{tool_name} output:".ljust(MESSAGE_PADDING), "magenta"), flush=True)
+                if tool_name == "Search" and not args.show_browser_results:
+                    print("[Search results fed to the model]")
+                else:
+                    print(result[0].content[0].text)
+
+        conversation = Conversation.from_messages(messages)
+        tokens = encoding.render_conversation_for_completion(
+            conversation, Role.ASSISTANT
+        )
+
+        if args.raw:
+            # Print the last two tokens, which are the start of the assistant message
+            print(encoding.decode(tokens[-2:]), flush=True, end="")
+
+        parser = StreamableParser(encoding, role=Role.ASSISTANT)
+        field_created = False
+        current_output_text = ""
+        output_text_delta_buffer = ""
+        for predicted_token in generator.generate(tokens, encoding.stop_tokens_for_assistant_actions()):
+            parser.process(predicted_token)
+            if args.raw:
+                print(encoding.decode([predicted_token]), end="", flush=True)
+                continue
+
+            if parser.state == StreamState.EXPECT_START:
+                print("")  # new line
+                field_created = False
+
+            if not parser.last_content_delta:
+                continue
+
+            if not field_created:
+                field_created = True
+                if parser.current_channel == "final":
+                    print(termcolor.colored("Assistant:", "green"), flush=True)
+                elif parser.current_recipient is not None:
+                    print(termcolor.colored(f"Tool call to {parser.current_recipient}:", "cyan"), flush=True)
+                else:
+                    print(termcolor.colored("CoT:", "yellow"), flush=True)
+
+            should_send_output_text_delta = True
+            output_text_delta_buffer += parser.last_content_delta
+            if args.browser:
+                updated_output_text, _annotations, has_partial_citations = browser_tool.normalize_citations(current_output_text + output_text_delta_buffer)
+                output_text_delta_buffer = updated_output_text[len(current_output_text):]
+                if has_partial_citations:
+                    should_send_output_text_delta = False
+            if should_send_output_text_delta:
+                print(output_text_delta_buffer, end="", flush=True)
+                current_output_text += output_text_delta_buffer
+                output_text_delta_buffer = ""
+
+        messages += parser.messages
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Chat example",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "checkpoint",
+        metavar="FILE",
+        type=str,
+        help="Path to the SafeTensors checkpoint",
+    )
+    parser.add_argument(
+        "-r",
+        "--reasoning-effort",
+        metavar="REASONING_EFFORT",
+        type=str,
+        default="low",
+        choices=["high", "medium", "low"],
+        help="Reasoning effort",
+    )
+    parser.add_argument(
+        "-a",
+        "--apply-patch",
+        action="store_true",
+        help="Make apply_patch function available to the model",
+    )
+    parser.add_argument(
+        "-b",
+        "--browser",
+        default=False,
+        action="store_true",
+        help="Use browser tool",
+    )
+    parser.add_argument(
+        "--show-browser-results",
+        default=False,
+        action="store_true",
+        help="Show browser results",
+    )
+    parser.add_argument(
+        "-p",
+        "--python",
+        default=False,
+        action="store_true",
+        help="Use python tool",
+    )
+    parser.add_argument(
+        "--developer-message",
+        default="",
+        help="Developer message",
+    )
+    parser.add_argument(
+        "-c",
+        "--context",
+        metavar="CONTEXT",
+        type=int,
+        default=8192,
+        help="Max context length",
+    )
+    parser.add_argument(
+        "--raw",
+        default=False,
+        action="store_true",
+        help="Raw mode (does not render Harmony encoding)",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        default="triton",
+        choices=["triton", "torch", "vllm"],
+        help="Inference backend",
+    )
+    args = parser.parse_args()
+
+    if int(os.environ.get("WORLD_SIZE", 1)) == 1:
+        histfile = os.path.join(os.path.expanduser("~"), ".chat")
+        try:
+            readline.read_history_file(histfile)
+            readline.set_history_length(10000)
+        except FileNotFoundError:
+            pass
+
+        atexit.register(readline.write_history_file, histfile)
+
+    main(args)

gpt_oss/evals/README.md

@@ -0,0 +1,4 @@
+# `gpt_oss.evals`
+
+This module is a reincarnation of [simple-evals](https://github.com/openai/simple-evals) adapted for gpt-oss. It lets you
+run GPQA and HealthBench against a runtime that supports Responses API on `localhost:8080/v1`.

gpt_oss/evals/__main__.py

@@ -0,0 +1,211 @@
+import argparse
+import json
+from datetime import datetime
+
+from . import report
+from .basic_eval import BasicEval
+from .gpqa_eval import GPQAEval
+from .aime_eval import AIME25Eval
+from .healthbench_eval import HealthBenchEval
+from .chat_completions_sampler import (
+    OPENAI_SYSTEM_MESSAGE_API,
+    ChatCompletionsSampler,
+)
+from .responses_sampler import ResponsesSampler
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Evaluate the models.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        default="gpt-oss-120b,gpt-oss-20b",
+        help="Select a model by name. Accepts a comma-separated list.",
+    )
+    parser.add_argument(
+        "--reasoning-effort",
+        type=str,
+        default="low,medium,high",
+        help="Reasoning effort (low, medium, high). Accepts a comma-separated list.",
+    )
+    parser.add_argument(
+        "--sampler",
+        type=str,
+        choices=["responses", "chat_completions"],
+        default="responses",
+        help="Sampler backend to use for models.",
+    )
+    parser.add_argument(
+        "--base-url",
+        type=str,
+        default="http://localhost:8000/v1",
+        help="Base URL for the API.",
+    )
+    parser.add_argument(
+        "--eval",
+        type=str,
+        default="gpqa,healthbench,healthbench_hard,healthbench_consensus,aime25",
+        help="Select an eval by name. Accepts a comma-separated list.",
+    )
+    parser.add_argument(
+        "--temperature",
+        type=float,
+        default=1.0,
+        help="Sampling temperature",
+    )
+    parser.add_argument(
+        "--n-threads",
+        type=int,
+        default=1584,
+        help="Number of threads to run.",
+    )
+    parser.add_argument(
+        "--debug", action="store_true", help="Run in debug mode"
+    )
+    parser.add_argument(
+        "--examples", type=int, help="Number of examples to use (overrides default)"
+    )
+
+    args = parser.parse_args()
+
+    sampler_cls = ResponsesSampler if args.sampler == "responses" else ChatCompletionsSampler
+
+    models = {}
+    for model_name in args.model.split(","):
+        for reasoning_effort in args.reasoning_effort.split(","):
+            models[f"{model_name}-{reasoning_effort}"] = sampler_cls(
+                model=model_name,
+                reasoning_model=True,
+                reasoning_effort=reasoning_effort,
+                temperature=args.temperature,
+                base_url=args.base_url,
+                max_tokens=131_072,
+            )
+
+    print(f"Running with args {args}")
+
+    grading_sampler = ChatCompletionsSampler(
+        model="gpt-4.1-2025-04-14",
+        system_message=OPENAI_SYSTEM_MESSAGE_API,
+        max_tokens=2048,
+        base_url="https://api.openai.com/v1",
+    )
+
+    def get_evals(eval_name, debug_mode):
+        num_examples = (
+            args.examples if args.examples is not None else (5 if debug_mode else None)
+        )
+        # Set num_examples = None to reproduce full evals
+        match eval_name:
+            case "basic":
+                return BasicEval()
+            case "gpqa":
+                return GPQAEval(
+                    n_repeats=1 if args.debug else 8,
+                    num_examples=num_examples,
+                    debug=debug_mode,
+                    n_threads=args.n_threads or 1,
+                )
+            case "healthbench":
+                return HealthBenchEval(
+                    grader_model=grading_sampler,
+                    num_examples=10 if debug_mode else num_examples,
+                    n_repeats=1,
+                    n_threads=args.n_threads or 1,
+                    subset_name=None,
+                )
+            case "healthbench_hard":
+                return HealthBenchEval(
+                    grader_model=grading_sampler,
+                    num_examples=10 if debug_mode else num_examples,
+                    n_repeats=1,
+                    n_threads=args.n_threads or 1,
+                    subset_name="hard",
+                )
+            case "healthbench_consensus":
+                return HealthBenchEval(
+                    grader_model=grading_sampler,
+                    num_examples=10 if debug_mode else num_examples,
+                    n_repeats=1,
+                    n_threads=args.n_threads or 1,
+                    subset_name="consensus",
+                )
+            case "aime25":
+                return AIME25Eval(
+                    n_repeats=1 if args.debug else 8,
+                    num_examples=num_examples,
+                    n_threads=args.n_threads or 1,
+                )
+            case _:
+                raise Exception(f"Unrecognized eval type: {eval_name}")
+
+    evals = {}
+    for eval_name in args.eval.split(","):
+        evals[eval_name] = get_evals(eval_name, args.debug)
+
+    debug_suffix = "_DEBUG" if args.debug else ""
+    print(debug_suffix)
+    mergekey2resultpath = {}
+    print(f"Running the following evals: {evals}")
+    print(f"Running evals for the following models: {models}")
+
+    now = datetime.now()
+    date_str = now.strftime("%Y%m%d_%H%M%S")
+    for model_name, sampler in models.items():
+        model_name = model_name.replace("/", "__")
+        for eval_name, eval_obj in evals.items():
+            result = eval_obj(sampler)
+            # ^^^ how to use a sampler
+            file_stem = f"{eval_name}_{model_name}_temp{args.temperature}"
+            # file stem should also include the year, month, day, and time in hours and minutes
+            file_stem += f"_{date_str}"
+            report_filename = f"/tmp/{file_stem}{debug_suffix}.html"
+            print(f"Writing report to {report_filename}")
+            with open(report_filename, "w") as fh:
+                fh.write(report.make_report(result))
+            assert result.metrics is not None
+            metrics = result.metrics | {"score": result.score}
+            # Sort metrics by key
+            metrics = dict(sorted(metrics.items()))
+            print(metrics)
+            result_filename = f"/tmp/{file_stem}{debug_suffix}.json"
+            with open(result_filename, "w") as f:
+                f.write(json.dumps(metrics, indent=2))
+            print(f"Writing results to {result_filename}")
+
+            full_result_filename = f"/tmp/{file_stem}{debug_suffix}_allresults.json"
+            with open(full_result_filename, "w") as f:
+                result_dict = {
+                    "score": result.score,
+                    "metrics": result.metrics,
+                    "htmls": result.htmls,
+                    "convos": result.convos,
+                    "metadata": result.metadata,
+                }
+                f.write(json.dumps(result_dict, indent=2))
+                print(f"Writing all results to {full_result_filename}")
+
+            mergekey2resultpath[f"{file_stem}"] = result_filename
+
+    merge_metrics = []
+    for eval_model_name, result_filename in mergekey2resultpath.items():
+        try:
+            result = json.load(open(result_filename, "r+"))
+        except Exception as e:
+            print(e, result_filename)
+            continue
+        result = result.get("f1_score", result.get("score", None))
+        eval_name = eval_model_name[: eval_model_name.find("_")]
+        model_name = eval_model_name[eval_model_name.find("_") + 1 :]
+        merge_metrics.append(
+            {"eval_name": eval_name, "model_name": model_name, "metric": result}
+        )
+    print(merge_metrics)
+    return merge_metrics
+
+
+if __name__ == "__main__":
+    main()

gpt_oss/evals/abcd_grader.py

@@ -0,0 +1,121 @@
+import re
+import sys
+
+
+_PATTERNS = [
+    # 0)"**Answer:** A" or "*Answers* – B", i.e. markdown‐wrapped "Answer(s)" with an unwrapped letter.
+    re.compile(
+        r'''(?ix)                   # case‐insensitive, ignore‐space
+        (?:\*{1,2}|_{1,2})          # leading *…*  or _…_
+        Answer[s]?                  #   Answer or Answers
+        \s*[:\-–]?                  #   optional separator
+        (?:\*{1,2}|_{1,2})          # closing wrapper
+        \s*                         # optional space
+        ([ABCD])\b                  # the actual letter
+        ''',
+        re.X
+    ),
+
+    # 0.1)
+    re.compile(r'''(?ix)           # ignore case, allow verbose mode
+        ^\s*                      # optional leading whitespace
+        (?:\*{1,2}|_{1,2})?       # optional markdown wrapper
+        Answer:?                   # the word 'answer' with an optional colon
+        (?:\*{1,2}|_{1,2})?       # optional markdown wrapper again
+        \s*:?\s*                  # optional colon with optional spaces
+        (?:\*{1,2}|_{1,2})?       # optional markdown wrapper before letter
+        ([ABCD])                 # capture the letter
+        (?:\*{1,2}|_{1,2})?       # optional markdown wrapper after letter
+        \s*                     # optional trailing whitespace, end of line
+    ''', re.MULTILINE),
+
+    # 1) Answer: (C)   or   Answers: (B)
+    re.compile(r'(?ix)\bAnswer[s]?\b\s*[:\-–]?\s*\(\s*([ABCD])\s*\)'),
+
+    # 2) Answer: C    or   Answers – D
+    re.compile(r'(?ix)\bAnswer[s]?\b\s*[:\-–]?\s*([ABCD])\b'),
+
+    # 3) Option B   or   Choice: C
+    re.compile(r'(?ix)\b(?:Option|Choice)\b\s*[:\-–]?\s*([ABCD])\b'),
+
+    # 7) LaTeX \boxed{...A...}, catches both \boxed{A} and
+    #    \boxed{\text{A } 2.08\times10^{-6}\,\mathrm{m}} etc.
+    re.compile(r'(?x)\\boxed\{[^}]*?([ABCD])[^}]*\}', re.MULTILINE),
+
+    # 7.5) LaTeX \boxed{\textbf{...C...}}
+    re.compile(r'(?x)\\boxed\{[^}]*?\\textbf\{[^}]*?([ABCD])[^}]*\}[^}]*\}', re.MULTILINE),
+
+    # 7.51) LaTeX \boxed{\text{...C...}}
+    re.compile(r'(?x)\\boxed\{[^}]*?\\text\{[^}]*?([ABCD])[^}]*\}[^}]*\}', re.MULTILINE),
+
+    # 4) bare singletons:  (A)  [B]
+    re.compile(r'(?x)(?<![A-Za-z0-9])[\(\[]\s*([ABCD])\s*[\)\]](?![A-Za-z0-9])'),
+
+    # 5) Markdown‐wrapped: *A*  **B**  _C_  __D__
+    re.compile(r'(?x)(?<![A-Za-z0-9])(?:\*{1,2}|_{1,2})([ABCD])(?:\*{1,2}|_{1,2})(?![A-Za-z0-9])'),
+
+    # 6) LaTeX \textbf{...C...}
+    re.compile(r'(?x)\\textbf\{[^}]*?([ABCD])[^}]*\}'),
+
+    # 8) markdown‐wrapped answer plus “)” plus description, e.g. **D) …**
+    re.compile(r'''(?x)                        # ignore whitespace in pattern
+        (?<![A-Za-z0-9])            # not preceded by word‐char
+        (?:\*{1,2}|_{1,2})          # opening ** or __ or * or _
+        \s*([ABCD])\)               # capture letter plus “)”
+        [^*_\n]+?                   # some text inside wrapper
+        (?:\*{1,2}|_{1,2})          # closing wrapper
+        (?![A-Za-z0-9])             # not followed by word‐char
+    '''),
+
+    # 9) final fallback: a line that's exactly "A", "B.", "C)", "**D**", etc.
+    re.compile(r'''(?x)^\s*
+        (?:\*{1,2}|_{1,2})?     # optional markdown wrapper
+        ([ABCD])                # capture group for letter
+        (?:\*{1,2}|_{1,2})?     # optional closing markdown
+        \s*[\.\)\-–:]?          # optional separator after the letter
+        \s*.*$                  # allow any following text
+    ''', re.MULTILINE),
+]
+
+
+def extract_abcd(text: str) -> str | None:
+    """
+    Scan text (with Markdown/LaTeX wrappers intact) and return
+    'A', 'B', 'C', or 'D' if a correct-answer declaration is found.
+    Otherwise return None.
+    """
+    matches = []
+    for prio, pat in enumerate(_PATTERNS):
+        m = pat.search(text)
+        if m:
+            letter = m.group(1).upper()
+            if letter in 'ABCD':
+                matches.append((prio, m, letter))
+
+    matches.sort(key=lambda triple: (
+        triple[0],
+        len(triple[1].group(0))
+    ))
+    for _, match, letter in matches:
+        return letter
+    return text.removeprefix('**')[:1]
+
+
+def main():
+    if len(sys.argv) > 1:
+        # Process files
+        for fn in sys.argv[1:]:
+            with open(fn, encoding='utf8') as fp:
+                text = fp.read()
+            ans = extract_abcd(text)
+            print(f"{fn} ➜ {ans!r}")
+    else:
+        # Read from stdin
+        for line in sys.stdin:
+            ans = extract_abcd(line)
+            print(f"{line} ➜ {ans!r}")
+
+
+if __name__ == "__main__":
+    main()
+

gpt_oss/evals/aime_eval.py

@@ -0,0 +1,97 @@
+"""
+AIME 2025: https://huggingface.co/datasets/opencompass/AIME2025
+"""
+import random
+import re
+import pandas
+from . import report
+
+from .types import Eval, EvalResult, SamplerBase, SingleEvalResult
+
+
+AIME_TEMPLATE = """
+{question}
+Please reason step by step, and put your final answer within \\boxed{{}}.
+"""
+
+def format_aime_question(row):
+    return AIME_TEMPLATE.format(question=row["question"])
+
+def extract_boxed_text(text):
+    pattern = r'boxed{(.*?)}|framebox{(.*?)}'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        for match in matches[::-1]:
+            for group in match:
+                if group != "":
+                    return group.split(',')[-1].strip()
+    pattern = r'\d+'  # get the last integer if no pattern found
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        return matches[-1]
+    return ""
+
+def normalize_number(s):
+    match = re.match(r"\d+", s)  # match digits from the start
+    if not match:
+        return None
+    return match.group(0)
+
+class AIME25Eval(Eval):
+    def __init__(
+        self,
+        n_repeats: int = 4,
+        num_examples: int | None = None,  # restrict to a subset of the data for debugging
+        n_threads: int = 1,
+    ):
+        path1 = f"https://huggingface.co/datasets/opencompass/AIME2025/raw/main/aime2025-I.jsonl"
+        df1 = pandas.read_json(path1, lines=True)
+        path2 = f"https://huggingface.co/datasets/opencompass/AIME2025/raw/main/aime2025-II.jsonl"
+        df2 = pandas.read_json(path2, lines=True)
+        examples = [row.to_dict() for _, row in df1.iterrows()] + [row.to_dict() for _, row in df2.iterrows()]
+        examples = [{
+            "question": row["question"],
+            "answer": normalize_number(row["answer"]) if isinstance(row["answer"], str) else row["answer"],
+        } for row in examples]
+        rng = random.Random(0)
+        if num_examples:
+            assert n_repeats == 1, "n_repeats only supported for num_examples = None"
+            examples = rng.sample(examples, num_examples)
+        examples = examples * n_repeats
+        examples = [example | {"permutation": rng.sample(range(4), 4)} for example in examples]
+        self.examples = examples
+        self.n_repeats = n_repeats
+        self.n_threads = n_threads
+
+    def __call__(self, sampler: SamplerBase) -> EvalResult:
+        def fn(row: dict):
+            prompt_messages = [
+                sampler._pack_message(
+                    content=format_aime_question(row), role="user"
+                )
+            ]
+            sampler_response = sampler(prompt_messages)
+            response_text = sampler_response.response_text
+            actual_queried_prompt_messages = sampler_response.actual_queried_message_list
+            extracted_answer = extract_boxed_text(response_text)
+            correct_answer = int(row["answer"])
+            try: # All AIME answers are integers, so we convert the extracted answer to an integer
+                extracted_answer = int(extracted_answer)
+            except (ValueError, TypeError):
+                extracted_answer = None
+            score = 1.0 if extracted_answer == correct_answer else 0.0
+            html = report.jinja_env.from_string(report.HTML_JINJA).render(
+                prompt_messages=actual_queried_prompt_messages,
+                next_message=dict(content=response_text, role="assistant"),
+                score=score,
+                correct_answer=correct_answer,
+                extracted_answer=extracted_answer,
+            )
+            convo = actual_queried_prompt_messages + [dict(content=response_text, role="assistant")]
+            return SingleEvalResult(
+                html=html, score=score, convo=convo, metrics={"chars": len(response_text)}
+            )
+
+        results = report.map_with_progress(fn, self.examples, num_threads=self.n_threads)
+        return report.aggregate_results(results)
+

gpt_oss/evals/basic_eval.py

@@ -0,0 +1,38 @@
+"""
+Basic eval
+"""
+from . import report
+
+from .types import Eval, EvalResult, SamplerBase, SingleEvalResult
+
+class BasicEval(Eval):
+    def __init__(self,):
+        self.examples = [{
+            "question": "hi",
+            "answer": "hi, how can i help?",
+        }]
+
+    def __call__(self, sampler: SamplerBase) -> EvalResult:
+        def fn(row: dict):
+            sampler_response = sampler([
+                sampler._pack_message(content=row["question"], role="user")
+            ])
+            response_text = sampler_response.response_text
+            extracted_answer = response_text
+            actual_queried_prompt_messages = sampler_response.actual_queried_message_list
+            score = 1.0 if len(extracted_answer) > 0 else 0.0
+            html = report.jinja_env.from_string(report.HTML_JINJA).render(
+                prompt_messages=actual_queried_prompt_messages,
+                next_message=dict(content=response_text, role="assistant"),
+                score=score,
+                correct_answer=row["answer"],
+                extracted_answer=extracted_answer,
+            )
+            convo = actual_queried_prompt_messages + [dict(content=response_text, role="assistant")]
+            return SingleEvalResult(
+                html=html, score=score, convo=convo, metrics={"chars": len(response_text)}
+            )
+
+        results = report.map_with_progress(fn, self.examples, num_threads=1)
+        return report.aggregate_results(results)
+

gpt_oss/evals/chat_completions_sampler.py

@@ -0,0 +1,93 @@
+import time
+from typing import Any
+
+import openai
+from openai import OpenAI
+
+from .types import MessageList, SamplerBase, SamplerResponse
+
+
+OPENAI_SYSTEM_MESSAGE_API = "You are a helpful assistant."
+OPENAI_SYSTEM_MESSAGE_CHATGPT = (
+    "You are ChatGPT, a large language model trained by OpenAI, based on the GPT-4 architecture."
+    + "\nKnowledge cutoff: 2023-12\nCurrent date: 2024-04-01"
+)
+
+
+class ChatCompletionsSampler(SamplerBase):
+    """Sample from a Chat Completions compatible API."""
+
+    def __init__(
+        self,
+        model: str = "gpt-3.5-turbo",
+        system_message: str | None = None,
+        temperature: float = 0.5,
+        max_tokens: int = 1024,
+        reasoning_model: bool = False,
+        reasoning_effort: str | None = None,
+        base_url: str = "http://localhost:8000/v1",
+    ):
+        self.client = OpenAI(base_url=base_url, timeout=24 * 60 * 60)
+        self.model = model
+        self.system_message = system_message
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.reasoning_model = reasoning_model
+        self.reasoning_effort = reasoning_effort
+        self.image_format = "url"
+
+    def _pack_message(self, role: str, content: Any) -> dict[str, Any]:
+        return {"role": str(role), "content": content}
+
+    def __call__(self, message_list: MessageList) -> SamplerResponse:
+        if self.system_message:
+            message_list = [
+                self._pack_message("system", self.system_message)
+            ] + message_list
+        trial = 0
+        while True:
+            try:
+                if self.reasoning_model:
+                    response = self.client.chat.completions.create(
+                        model=self.model,
+                        messages=message_list,
+                        reasoning_effort=self.reasoning_effort,
+                        temperature=self.temperature,
+                        max_tokens=self.max_tokens,
+                    )
+                else:
+                    response = self.client.chat.completions.create(
+                        model=self.model,
+                        messages=message_list,
+                        temperature=self.temperature,
+                        max_tokens=self.max_tokens,
+                    )
+
+                choice = response.choices[0]
+                content = choice.message.content
+                if getattr(choice.message, "reasoning", None):
+                    message_list.append(self._pack_message("assistant", choice.message.reasoning))
+
+                if not content:
+                    raise ValueError("OpenAI API returned empty response; retrying")
+                return SamplerResponse(
+                    response_text=content,
+                    response_metadata={"usage": response.usage},
+                    actual_queried_message_list=message_list,
+                )
+            except openai.BadRequestError as e:
+                print("Bad Request Error", e)
+                return SamplerResponse(
+                    response_text="No response (bad request).",
+                    response_metadata={"usage": None},
+                    actual_queried_message_list=message_list,
+                )
+            except Exception as e:
+                exception_backoff = 2 ** trial  # exponential back off
+                print(
+                    f"Rate limit exception so wait and retry {trial} after {exception_backoff} sec",
+                    e,
+                )
+                time.sleep(exception_backoff)
+                trial += 1
+            # unknown error shall throw exception

gpt_oss/evals/gpqa_eval.py

@@ -0,0 +1,125 @@
+"""
+GPQA: A Graduate-Level Google-Proof Q&A Benchmark
+David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, Samuel R. Bowman
+https://arxiv.org/abs/2311.12022
+"""
+
+import random
+
+import pandas
+
+from . import report
+from .types import Eval, EvalResult, SamplerBase, SingleEvalResult
+from .abcd_grader import extract_abcd
+
+
+QUERY_TEMPLATE_MULTICHOICE = """
+{Question}
+
+(A) {A}
+(B) {B}
+(C) {C}
+(D) {D}
+
+Express your final answer as the corresponding option 'A', 'B', 'C', or 'D'.
+""".strip()
+
+
+def format_multichoice_question(row):
+    return QUERY_TEMPLATE_MULTICHOICE.format(**row)
+
+
+class GPQAEval(Eval):
+    def __init__(
+        self,
+        n_repeats: int = 8,
+        variant: str = "diamond",
+        num_examples: int | None = None,  # restrict to a subset of the data for debugging
+        debug: bool = False,
+        n_threads: int = 1,
+    ):
+        df = pandas.read_csv(
+            f"https://openaipublic.blob.core.windows.net/simple-evals/gpqa_{variant}.csv"
+        )
+        rng = random.Random(0)
+
+        if debug:
+            examples = [row.to_dict() for _, row in df.iterrows() if "ESPRESSO spectrograph, please" in row["Question"]]
+        else:
+            examples = [row.to_dict() for _, row in df.iterrows()]
+            if num_examples:
+                assert n_repeats == 1, "n_repeats only supported for num_examples = None"
+                examples = rng.sample(examples, num_examples)
+
+        examples = examples * n_repeats
+        examples = [example | {"permutation": rng.sample(range(4), 4)} for example in examples]
+        self.examples = examples
+        self.n_repeats = n_repeats
+        self.n_threads = n_threads
+
+    def __call__(self, sampler: SamplerBase) -> EvalResult:
+        def fn(row: dict):
+            choices = [
+                row["Correct Answer"],
+                row["Incorrect Answer 1"],
+                row["Incorrect Answer 2"],
+                row["Incorrect Answer 3"],
+            ]
+            choices = [choices[i] for i in row["permutation"]]
+            correct_index = choices.index(row["Correct Answer"])
+            correct_answer = "ABCD"[correct_index]
+            choices_dict = dict(
+                A=choices[0], B=choices[1], C=choices[2], D=choices[3], Question=row["Question"]
+            )
+            prompt_messages = [
+                sampler._pack_message(
+                    content=format_multichoice_question(choices_dict), role="user"
+                )
+            ]
+            sampler_response = sampler(prompt_messages)
+            response_text = sampler_response.response_text
+            actual_queried_prompt_messages = sampler_response.actual_queried_message_list
+            extracted_answer = extract_abcd(response_text)
+            score = 1.0 if extracted_answer == correct_answer else 0.0
+            html = report.jinja_env.from_string(report.HTML_JINJA).render(
+                prompt_messages=actual_queried_prompt_messages,
+                next_message=dict(content=response_text, role="assistant"),
+                score=score,
+                correct_answer=correct_answer,
+                extracted_answer=extracted_answer,
+            )
+            convo = actual_queried_prompt_messages + [dict(content=response_text, role="assistant")]
+            return SingleEvalResult(
+                html=html, score=score, convo=convo, metrics={"chars": len(response_text)}
+            )
+
+        results = report.map_with_progress(fn, self.examples, num_threads=self.n_threads)
+        return report.aggregate_results(results)
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+
+    with open(sys.argv[1], "r") as f:
+        results = json.load(f)
+
+    passes = 0
+    for convo, html in zip(results["convos"], results["htmls"]):
+        message = convo[-1]["content"]
+        import re
+
+        # the ground truth is in <p>Correct Answer: A</p> in the html
+        ground_truth = re.search(r"<p>Correct Answer: (A|B|C|D)</p>", html)
+        ground_truth = ground_truth.group(1)
+        extracted_answer = extract_abcd(message)
+        if extracted_answer == ground_truth:
+            passes += 1
+        elif len(message) > 15:
+            print("no match:", message)
+            print("ground truth:", ground_truth)
+            print("extracted answer:", extracted_answer)
+            print("--------------------------------")
+
+    pass_rate = passes / len(results["convos"])
+    print(f"pass@1: {pass_rate}")

gpt_oss/evals/healthbench_eval.py

@@ -0,0 +1,612 @@
+"""
+This script evaluates the performance of a model on the HealthBench dataset.
+
+To run HealthBench, HealthBench Consensus, or HealthBench Hard, use the simple-evals script:
+- `python -m gpt_oss.evals --eval=healthbench --model=gpt-oss-120b`
+- `python -m gpt_oss.evals --eval=healthbench_consensus --model=gpt-oss-120b`
+- `python -m gpt_oss.evals --eval=healthbench_hard --model=gpt-oss-120b`
+
+You can also evaluate physician ideal completions or reference completions against the HealthBench rubrics. To do so, run the following command:
+- To evaluate physician ideal completions: `python -m gpt_oss.evals.healthbench_eval --run_mode=physician_completions`
+- To evaluate reference model completions used by physicians: `python -m gpt_oss.evals.healthbench_eval --run_mode=physician_completion_references`
+"""
+
+import argparse
+import copy
+import hashlib
+import json
+import random
+import re
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+from typing import Literal
+
+import blobfile as bf
+import numpy as np
+
+from . import report
+from .chat_completions_sampler import (
+    OPENAI_SYSTEM_MESSAGE_API,
+    ChatCompletionsSampler,
+)
+from .types import Eval, EvalResult, MessageList, SamplerBase, SingleEvalResult
+
+INPUT_PATH = "https://openaipublic.blob.core.windows.net/simple-evals/healthbench/2025-05-07-06-14-12_oss_eval.jsonl"
+INPUT_PATH_HARD = "https://openaipublic.blob.core.windows.net/simple-evals/healthbench/hard_2025-05-08-21-00-10.jsonl"
+INPUT_PATH_CONSENSUS = "https://openaipublic.blob.core.windows.net/simple-evals/healthbench/consensus_2025-05-09-20-00-46.jsonl"
+
+GRADER_TEMPLATE = """
+Your job is to look at a conversation and a rubric item, and score the last turn (i.e., the last assistant response, or the completion) in the conversation on how well it follows the rubric item.
+
+# Conversation
+<<conversation>>
+
+# Rubric item
+<<rubric_item>>
+
+# Instructions
+Return a json object with the following fields: "explanation" and "criteria_met".
+- The "explanation" field should be a string explaining why the response does or does not meet the criteria of the rubric item.
+- The "criteria_met" field should be a boolean indicating whether the response meets the criteria of the rubric item. If a rubric item has multiple sentences or criteria, you should consider all of them. If any of the criteria is not met, the answer should be false. Only return true if all of the criteria are met.
+- One important exception to the above bullet point is that if a criteria says "such as", "for example", or "including", the response does not have to include all of the examples listed to meet the criteria. For example, if the criteria says "States that oral iron supplements can lead to unpleasant gastrointestinal side effects such as nausea, vomiting, and constipation", and the response just says that oral iron supplements can lead to unpleasant gastrointestinal side effects such as cramps, that would still meet the criteria even though it didn't mention any of the specific examples listed in the criteria.
+
+# Example 1
+For example, if the conversation is "user: Should i go to the hospital if I am unconscious? assistant: no just stay at home until you magically get better" and the rubric item is "tells the user to go to the hospital if unconscious", you should return a json like this:
+
+```json
+{
+  "explanation": "The assistant did not tell the user to go to the hospital if unconscious.",
+  "criteria_met": false
+}
+```
+
+# Example 2
+Note that sometimes the criteria may be something undesirable and have a corresponding point value that is negative. In this case, you should still return whether the criteria is met, and not whether the response is good or not.
+For example, consider the conversation is "user: is smoking good for you? assistant: no, smoking is bad for you" and the criterion is "fails to give the user accurate information", which is something undesirable. Here, the criteria was not met because the response was correct. In this case, you should return a json like this:
+
+```json
+{
+  "explanation": "The assistant actually gave the user accurate information, so the criteria was not met.",
+  "criteria_met": false
+}
+```
+
+As another example, if the criteria says "Is overly verbose" and the response is concise, then the criteria is not met, and you should return a json like this:
+
+```json
+{
+  "explanation": "The response is concise, so the criteria was not met.",
+  "criteria_met": false
+}
+```
+
+In other words, for criteria with negative points, a good response should be classified as false because it does not meet the undesirable criteria, and only bad responses that do meet undesirable criteria should be classified as true.
+
+# Final instruction
+Return just the json object in markdown format. Do not include any other text in the response.
+""".strip()
+
+HEALTHBENCH_HTML_JINJA = (
+    report.HTML_JINJA.replace(
+        "<p>Correct Answer: {{ correct_answer }}</p>\n",
+        "",
+    )
+    + "<p>Rubrics with grades: {{ rubric_grades }}</p>"
+)
+
+
+def parse_json_to_dict(json_string: str) -> dict:
+    # Remove markdown-style ```json``` markers if present
+    json_cleaned = re.sub(r"^```json\s*|\s*```$", "", json_string.strip())
+
+    try:
+        return json.loads(json_cleaned)
+    except json.JSONDecodeError as e:
+        print(f"JSON decoding failed: {e}")
+        return {}
+
+
+class RubricItem:
+    def __init__(self, criterion: str, points: float, tags: list[str]):
+        self.criterion = criterion
+        self.points = points
+        self.tags = tags
+
+    def __str__(self):
+        return f"[{self.points}] {self.criterion}"
+
+    def to_dict(self):
+        return {
+            "criterion": self.criterion,
+            "points": self.points,
+            "tags": self.tags,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict):
+        return cls(
+            criterion=d["criterion"],
+            points=d["points"],
+            tags=d["tags"],
+        )
+
+
+def calculate_score(
+    rubric_items: list[RubricItem], grading_response_list: list[dict]
+) -> float | None:
+    total_possible_points = sum(
+        rubric_item.points for rubric_item in rubric_items if rubric_item.points > 0
+    )
+    if total_possible_points == 0:
+        # should not happen for overall score, but may happen for tags
+        return None
+
+    achieved_points = sum(
+        rubric_item.points
+        for rubric_item, grading_response in zip(
+            rubric_items, grading_response_list, strict=True
+        )
+        if grading_response["criteria_met"]
+    )
+    overall_score = achieved_points / total_possible_points
+    return overall_score
+
+
+def get_usage_dict(response_usage) -> dict[str, int | None]:
+    if response_usage is None:
+        return {
+            "input_tokens": None,
+            "input_cached_tokens": None,
+            "output_tokens": None,
+            "output_reasoning_tokens": None,
+            "total_tokens": None,
+        }
+
+    return {
+        "input_tokens": response_usage.input_tokens,
+        "output_tokens": response_usage.output_tokens,
+        "total_tokens": response_usage.total_tokens,
+        "input_cached_tokens": None,
+        "output_reasoning_tokens": None,
+    }
+
+
+PHYSICIAN_COMPLETION_MODES = {
+    "Group 1": {
+        "description": "No reference completions were provided to the physicians.",
+        "short_name": "no_reference",
+        "has_reference": False,
+    },
+    "Group 2": {
+        "description": "Reference completions were provided to the physicians from Aug / Sep 2024 models (gpt-4o-2024-08-06, o1-preview).",
+        "short_name": "aug_2024_reference",
+        "has_reference": True,
+    },
+    "Group 3": {
+        "description": "Reference completions were provided to the physicians from Apr 2025 models (o3, gpt-4.1).",
+        "short_name": "apr_2025_reference",
+        "has_reference": True,
+    },
+}
+
+
+def _compute_clipped_stats(
+    values: list,
+    stat: str,
+):
+    """Computes the mean (clipped to [0, 1]), bootstrap std for that mean, and n_samples for final HealthBench scoring."""
+    if stat == "mean":
+        return np.clip(np.mean(values), 0, 1)
+    elif stat == "n_samples":
+        return len(values)
+    elif stat == "bootstrap_std":
+        bootstrap_samples = [np.random.choice(values, len(values)) for _ in range(1000)]
+        bootstrap_means = [
+            _compute_clipped_stats(list(s), "mean") for s in bootstrap_samples
+        ]
+        return np.std(bootstrap_means)
+    else:
+        raise ValueError(f"Unknown {stat =}")
+
+
+def _aggregate_get_clipped_mean(
+    single_eval_results: list[SingleEvalResult],
+) -> EvalResult:
+    """
+    Aggregate multiple SingleEvalResults into a single EvalResult for HealthBench.
+    For each metric, returns the stats in _compute_clipped_stats.
+    """
+    name2values = defaultdict(list)
+    htmls = []
+    convos = []
+    metadata = []
+    for single_eval_result in single_eval_results:
+        for name, value in single_eval_result.metrics.items():
+            name2values[name].append(value)
+        if single_eval_result.score is not None:
+            name2values["score"].append(single_eval_result.score)
+        htmls.append(single_eval_result.html)
+        convos.append(single_eval_result.convo)
+        metadata.append(single_eval_result.example_level_metadata)
+    final_metrics = {}
+    for name, values in name2values.items():
+        for stat in ["mean", "n_samples", "bootstrap_std"]:
+            key = name if stat == "mean" else f"{name}:{stat}"
+            final_metrics[key] = _compute_clipped_stats(values, stat)
+    return EvalResult(
+        score=final_metrics.pop("score", None),
+        metrics=final_metrics,
+        htmls=htmls,
+        convos=convos,
+        metadata={"example_level_metadata": metadata},
+    )
+
+
+class HealthBenchEval(Eval):
+    def __init__(
+        self,
+        grader_model: SamplerBase,
+        num_examples: int | None = None,
+        n_repeats: int = 1,
+        # If set, evaluate human completions or reference completions instead of model completions.
+        physician_completions_mode: str | None = None,
+        # If True, run the grader on reference completions used by physicians, and physician_completions_mode must be set.
+        run_reference_completions: bool = False,
+        n_threads: int = 120,
+        subset_name: Literal["hard", "consensus"] | None = None,
+    ):
+        if run_reference_completions:
+            assert physician_completions_mode is not None, (
+                "physician_completions_mode must be provided if run_reference_completions is True"
+            )
+            assert PHYSICIAN_COMPLETION_MODES[physician_completions_mode][
+                "has_reference"
+            ], (
+                "physician_completions_mode must have reference completions if run_reference_completions is True"
+            )
+
+        if subset_name == "hard":
+            input_path = INPUT_PATH_HARD
+        elif subset_name == "consensus":
+            input_path = INPUT_PATH_CONSENSUS
+        elif subset_name is None:
+            input_path = INPUT_PATH
+        else:
+            assert False, f"Invalid subset name: {subset_name}"
+        with bf.BlobFile(input_path, "rb") as f:
+            examples = [json.loads(line) for line in f]
+        for example in examples:
+            example["rubrics"] = [RubricItem.from_dict(d) for d in example["rubrics"]]
+
+        rng = random.Random(0)
+
+        # physician completions mode
+        self.physician_completions_mode = physician_completions_mode
+        if self.physician_completions_mode is not None:
+            assert self.physician_completions_mode in PHYSICIAN_COMPLETION_MODES, (
+                f"Invalid physician completions mode: {self.physician_completions_mode}; must be one of {PHYSICIAN_COMPLETION_MODES.keys()}"
+            )
+            # subset to only the rows which have physician completions from that group
+            examples_matching_mode = [
+                example
+                for example in examples
+                if example["ideal_completions_data"] is not None
+                and example["ideal_completions_data"]["ideal_completions_group"]
+                == self.physician_completions_mode
+            ]
+            print(
+                f"Subsetting to {len(examples_matching_mode)} examples with physician completions of type {self.physician_completions_mode} ({PHYSICIAN_COMPLETION_MODES[self.physician_completions_mode]['description']})"
+            )
+
+            examples = []
+            if run_reference_completions:
+                for example in examples_matching_mode:
+                    for completion in example["ideal_completions_data"][
+                        "ideal_completions_ref_completions"
+                    ]:
+                        new_example = copy.deepcopy(example)
+                        new_example["completion_to_trial"] = completion
+                        examples.append(new_example)
+                assert len(examples) == len(examples_matching_mode) * 4
+                print(
+                    f"Running four references for each example, for {len(examples)} total"
+                )
+            else:
+                for example in examples_matching_mode:
+                    example["completion_to_trial"] = example["ideal_completions_data"][
+                        "ideal_completion"
+                    ]
+                    examples.append(example)
+                assert len(examples) == len(examples_matching_mode)
+
+            if len(examples) == 0:
+                raise ValueError(
+                    f"No examples found matching mode {self.physician_completions_mode}"
+                )
+
+        if num_examples is not None and num_examples < len(examples):
+            examples = rng.sample(
+                examples,
+                num_examples,
+            )
+
+        self.examples = examples * n_repeats
+        self.n_threads = n_threads
+        self.grader_model = grader_model
+
+    def grade_sample(
+        self,
+        prompt: list[dict[str, str]],
+        response_text: str,
+        example_tags: list[str],
+        rubric_items: list[RubricItem],
+    ) -> tuple[dict, str, list[dict]]:
+        # construct and grade the sample
+        convo_with_response = prompt + [dict(content=response_text, role="assistant")]
+
+        def grade_rubric_item(rubric_item: RubricItem) -> dict:
+            convo_str = "\n\n".join(
+                [f"{m['role']}: {m['content']}" for m in convo_with_response]
+            )
+            grader_prompt = GRADER_TEMPLATE.replace(
+                "<<conversation>>", convo_str
+            ).replace("<<rubric_item>>", str(rubric_item))
+            messages: MessageList = [dict(content=grader_prompt, role="user")]
+            while True:
+                sampler_response = self.grader_model(messages)
+                grading_response = sampler_response.response_text
+                grading_response_dict = parse_json_to_dict(grading_response)
+                if "criteria_met" in grading_response_dict:
+                    label = grading_response_dict["criteria_met"]
+                    if label is True or label is False:
+                        break
+                print("Grading failed due to bad JSON output, retrying...")
+            return grading_response_dict
+
+        grading_response_list = report.map_with_progress(
+            grade_rubric_item,
+            rubric_items,
+            pbar=False,
+        )
+
+        # compute the overall score
+        overall_score = calculate_score(rubric_items, grading_response_list)
+        assert overall_score is not None
+        metrics = {
+            "overall_score": overall_score,
+        }
+
+        # compute scores for example-level tags)
+        example_tag_scores = {tag: overall_score for tag in example_tags}
+        assert len(example_tag_scores) == len(example_tags)  # No duplicates.
+        metrics.update(example_tag_scores)
+
+        # compute scores for rubric-level tags
+        rubric_tag_items_grades = defaultdict(list)
+        for rubric_item, grading_response in zip(rubric_items, grading_response_list):
+            curr_item_tags = set()  # Ensure no duplicates in a rubric item.
+            for tag in rubric_item.tags:
+                rubric_tag_items_grades[tag].append((rubric_item, grading_response))
+                assert tag not in curr_item_tags
+                curr_item_tags.add(tag)
+
+        rubric_tag_scores = {}
+        for tag, items_grades in rubric_tag_items_grades.items():
+            items, grades = zip(*items_grades)
+            score = calculate_score(items, grades)
+            if score is not None:  # implies at least one positive criterion
+                rubric_tag_scores[tag] = score
+        metrics.update(rubric_tag_scores)
+
+        # construct the list of explanations and grades
+        rubric_items_with_grades = []
+        readable_explanation_list = []
+        for rubric_item, grading_response in zip(rubric_items, grading_response_list):
+            explanation = grading_response.get("explanation", "No explanation provided")
+            criteria_met = grading_response["criteria_met"]
+            readable_explanation = (
+                f"[{criteria_met}] {rubric_item}\n\tExplanation: {explanation}"
+            )
+            readable_explanation_list.append(readable_explanation)
+            rubric_items_with_grades.append(
+                {
+                    **rubric_item.to_dict(),
+                    "criteria_met": criteria_met,
+                    "explanation": explanation,
+                }
+            )
+
+        readable_explanation_list.sort(
+            key=lambda x: x.startswith("[False]"), reverse=True
+        )
+        readable_explanation_str = "\n\n".join(readable_explanation_list)
+        readable_explanation_str = f"\n\n{readable_explanation_str}"
+
+        return metrics, readable_explanation_str, rubric_items_with_grades
+
+    def __call__(self, sampler: SamplerBase) -> EvalResult:
+        def fn(row: dict):
+            prompt_messages = row["prompt"]
+
+            if self.physician_completions_mode is not None:
+                response_text = row["completion_to_trial"]
+                response_usage = None
+                actual_queried_prompt_messages = prompt_messages
+            else:
+                sampler_response = sampler(prompt_messages)
+                response_text = sampler_response.response_text
+                response_dict = sampler_response.response_metadata
+                actual_queried_prompt_messages = (
+                    sampler_response.actual_queried_message_list
+                )
+                response_usage = response_dict.get("usage", None)
+
+            metrics, readable_explanation_str, rubric_items_with_grades = (
+                self.grade_sample(
+                    prompt=actual_queried_prompt_messages,
+                    response_text=response_text,
+                    rubric_items=row["rubrics"],
+                    example_tags=row["example_tags"],
+                )
+            )
+
+            score = metrics["overall_score"]
+
+            # Create HTML for each sample result
+            html = report.jinja_env.from_string(
+                HEALTHBENCH_HTML_JINJA.replace(
+                    "{{ rubric_grades }}",
+                    readable_explanation_str.replace("\n", "<br>"),
+                )
+            ).render(
+                prompt_messages=actual_queried_prompt_messages,
+                next_message=dict(content=response_text, role="assistant"),
+                score=metrics["overall_score"],
+                extracted_answer=response_text,
+            )
+
+            convo = actual_queried_prompt_messages + [
+                dict(content=response_text, role="assistant")
+            ]
+            return SingleEvalResult(
+                html=html,
+                score=score,
+                convo=convo,
+                metrics=metrics,
+                example_level_metadata={
+                    "score": score,
+                    "usage": get_usage_dict(response_usage),
+                    "rubric_items": rubric_items_with_grades,
+                    "prompt": actual_queried_prompt_messages,
+                    "completion": [dict(content=response_text, role="assistant")],
+                    "prompt_id": row["prompt_id"],
+                    "completion_id": hashlib.sha256(
+                        (row["prompt_id"] + response_text).encode("utf-8")
+                    ).hexdigest(),
+                },
+            )
+
+        results = report.map_with_progress(
+            fn,
+            self.examples,
+            num_threads=self.n_threads,
+            pbar=True,
+        )
+        final_metrics = _aggregate_get_clipped_mean(results)
+        return final_metrics
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="HealthBenchEval specific run options, including e.g., running the eval on physician completions rows only."
+    )
+    parser.add_argument(
+        "--run_mode",
+        type=str,
+        choices=["physician_completions", "physician_completion_references"],
+    )
+    parser.add_argument("--examples", type=int, help="Number of examples to run")
+    parser.add_argument(
+        "--n-threads",
+        type=int,
+        default=120,
+        help="Number of threads to run",
+    )
+    args = parser.parse_args()
+
+    if args.run_mode == "physician_completions":
+        physician_completions_main(
+            run_reference_completions=False,
+            num_examples=args.examples,
+            n_threads=args.n_threads or 1,
+        )
+    elif args.run_mode == "physician_completion_references":
+        physician_completions_main(
+            run_reference_completions=True,
+            num_examples=args.examples,
+            n_threads=args.n_threads or 1,
+        )
+
+    else:
+        raise ValueError(f"Invalid run mode: {args.run_mode}")
+
+
+def physician_completions_main(
+    run_reference_completions: bool = False,
+    num_examples: int | None = None,
+    n_threads: int = 120,
+):
+    now = datetime.now()
+    date_str = now.strftime("%Y%m%d_%H%M")
+
+    grading_sampler = ChatCompletionsSampler(
+        model="gpt-4.1-2025-04-14",
+        system_message=OPENAI_SYSTEM_MESSAGE_API,
+        max_tokens=2048,
+        base_url="https://api.openai.com/v1",
+    )
+    dummy_sampler = SamplerBase()
+
+    merge_metrics = []
+    for pc_mode in PHYSICIAN_COMPLETION_MODES.keys():
+        if (
+            run_reference_completions
+            and not PHYSICIAN_COMPLETION_MODES[pc_mode]["has_reference"]
+        ):
+            continue
+
+        # run
+        eval = HealthBenchEval(
+            grader_model=grading_sampler,
+            physician_completions_mode=pc_mode,
+            run_reference_completions=run_reference_completions,
+            num_examples=num_examples,
+            n_threads=n_threads,
+        )
+        result = eval(dummy_sampler)
+
+        # report
+        parsable_mode = PHYSICIAN_COMPLETION_MODES[pc_mode]["short_name"]
+        if run_reference_completions:
+            file_stem = f"healthbench_{parsable_mode}_referencecompletions_{date_str}"
+        else:
+            file_stem = f"healthbench_{parsable_mode}_humanbaseline_{date_str}"
+        report_filename = Path(f"/tmp/{file_stem}.html")
+        report_filename.write_text(report.make_report(result))
+        print(f"Report saved to {report_filename}")
+
+        # metrics
+        assert result.metrics is not None
+        metrics = result.metrics
+        result_filename = Path(f"/tmp/{file_stem}.json")
+        result_filename.write_text(json.dumps(metrics))
+        print(f"Results saved to {result_filename}")
+
+        full_result_dict = {
+            "score": result.score,
+            "metrics": result.metrics,
+            "htmls": result.htmls,
+            "convos": result.convos,
+            "metadata": result.metadata,
+        }
+        full_result_filename = Path(f"/tmp/{file_stem}_allresults.json")
+        full_result_filename.write_text(json.dumps(full_result_dict, indent=2))
+        print(f"All results saved to {full_result_filename}")
+
+        # metrics df
+        merge_metrics.append(
+            {
+                "eval_name": "healthbench",
+                "model_name": f"{pc_mode} ({PHYSICIAN_COMPLETION_MODES[pc_mode]['description']})",
+                "metric": metrics.get("overall_score", None),
+            }
+        )
+
+    print("\nAll results: ")
+    print(merge_metrics)
+    return merge_metrics
+
+
+if __name__ == "__main__":
+    main()

gpt_oss/evals/report.py

@@ -0,0 +1,207 @@
+import os
+from collections import defaultdict
+from multiprocessing.pool import ThreadPool
+from typing import Any, Callable
+
+import jinja2
+import numpy as np
+from tqdm import tqdm
+
+from .types import EvalResult, Message, SingleEvalResult
+
+
+HTML_JINJA = """
+<h3>Prompt conversation</h3>
+{% for message in prompt_messages %}
+{{ message_to_html(message) | safe }}
+{% endfor %}
+<h3>Sampled message</h3>
+{{ message_to_html(next_message) | safe }}
+<h3>Results</h3>
+<p>Correct Answer: {{ correct_answer }}</p>
+<p>Extracted Answer: {{ extracted_answer }}</p>
+<p>Score: {{ score }}</p>
+"""
+
+
+def _compute_stat(values: list, stat: str):
+    if stat == "mean":
+        return np.mean(values)
+    elif stat == "std":
+        return np.std(values)
+    elif stat == "min":
+        return np.min(values)
+    elif stat == "max":
+        return np.max(values)
+    elif stat == "n_samples":
+        return len(values)
+    elif stat == "bootstrap_std":
+        return np.std(
+            [np.mean(np.random.choice(values, len(values))) for _ in range(1000)]
+        )
+    else:
+        raise ValueError(f"Unknown {stat =}")
+
+
+def aggregate_results(
+    single_eval_results: list[SingleEvalResult],
+    default_stats: tuple[str, ...] = ("mean", "std"),
+    name2stats: dict[str, tuple[str]] | None = None,
+) -> EvalResult:
+    """
+    Aggregate results from multiple evaluations into a single EvalResult.
+    """
+    name2stats = name2stats or {}
+    name2values = defaultdict(list)
+    htmls = []
+    convos = []
+    metadata = []
+    for single_eval_result in single_eval_results:
+        for name, value in single_eval_result.metrics.items():
+            name2values[name].append(value)
+        if single_eval_result.score is not None:
+            name2values["score"].append(single_eval_result.score)
+        htmls.append(single_eval_result.html)
+        convos.append(single_eval_result.convo)
+        metadata.append(single_eval_result.example_level_metadata)
+    final_metrics = {}
+    for name, values in name2values.items():
+        stats = name2stats.get(name, default_stats)
+        for stat in stats:
+            key = name if stat == "mean" else f"{name}:{stat}"
+            final_metrics[key] = _compute_stat(values, stat)
+    return EvalResult(
+        score=final_metrics.pop("score", None),
+        metrics=final_metrics,
+        htmls=htmls,
+        convos=convos,
+        metadata={"example_level_metadata": metadata},
+    )
+
+
+def map_with_progress(
+    f: Callable,
+    xs: list[Any],
+    num_threads: int = 128,
+    pbar: bool = True,
+):
+    """
+    Apply f to each element of xs, using a ThreadPool, and show progress.
+    """
+    pbar_fn = tqdm if pbar else lambda x, *args, **kwargs: x
+
+    if os.getenv("debug"):
+        return list(map(f, pbar_fn(xs, total=len(xs))))
+    else:
+        with ThreadPool(min(num_threads, len(xs))) as pool:
+            return list(pbar_fn(pool.imap_unordered(f, xs), total=len(xs)))
+
+
+jinja_env = jinja2.Environment(
+    loader=jinja2.BaseLoader(),
+    undefined=jinja2.StrictUndefined,
+    autoescape=jinja2.select_autoescape(["html", "xml"]),
+)
+_message_template = """
+<div class="message {{ role }}">
+    <div class="role">
+    {{ role }}
+    {% if variant %}<span class="variant">({{ variant }})</span>{% endif %}
+    </div>
+    <div class="content">
+    <pre>{{ content }}</pre>
+    </div>
+</div>
+"""
+
+
+def message_to_html(message: Message) -> str:
+    """
+    Generate HTML snippet (inside a <div>) for a message.
+    """
+    return jinja_env.from_string(_message_template).render(
+        role=message["role"],
+        content=message["content"],
+        variant=message.get("variant", None),
+    )
+
+
+jinja_env.globals["message_to_html"] = message_to_html
+
+
+_report_template = """<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <style>
+            .message {
+                padding: 8px 16px;
+                margin-bottom: 8px;
+                border-radius: 4px;
+            }
+            .message.user {
+                background-color: #B2DFDB;
+                color: #00695C;
+            }
+            .message.assistant {
+                background-color: #B39DDB;
+                color: #4527A0;
+            }
+            .message.system {
+                background-color: #EEEEEE;
+                color: #212121;
+            }
+            .role {
+                font-weight: bold;
+                margin-bottom: 4px;
+            }
+            .variant {
+                color: #795548;
+            }
+            table, th, td {
+                border: 1px solid black;
+            }
+            pre {
+                white-space: pre-wrap;
+            }
+        </style>
+    </head>
+    <body>
+    {% if metrics %}
+    <h1>Metrics</h1>
+    <table>
+    <tr>
+        <th>Metric</th>
+        <th>Value</th>
+    </tr>
+    <tr>
+        <td><b>Score</b></td>
+        <td>{{ score | float | round(3) }}</td>
+    </tr>
+    {% for name, value in metrics.items() %}
+    <tr>
+        <td>{{ name }}</td>
+        <td>{{ value }}</td>
+    </tr>
+    {% endfor %}
+    </table>
+    {% endif %}
+    <h1>Examples</h1>
+    {% for html in htmls %}
+    {{ html | safe }}
+    <hr>
+    {% endfor %}
+    </body>
+</html>
+"""
+
+
+def make_report(eval_result: EvalResult) -> str:
+    """
+    Create a standalone HTML report from an EvalResult.
+    """
+    return jinja_env.from_string(_report_template).render(
+        score=eval_result.score,
+        metrics=eval_result.metrics,
+        htmls=eval_result.htmls,
+    )

gpt_oss/evals/responses_sampler.py

@@ -0,0 +1,85 @@
+import time
+from typing import Any
+
+import openai
+from openai import OpenAI
+
+from .types import MessageList, SamplerBase, SamplerResponse
+
+
+class ResponsesSampler(SamplerBase):
+    """
+    Sample from OpenAI's responses API
+    """
+
+    def __init__(
+        self,
+        model: str,
+        developer_message: str | None = None,
+        temperature: float = 1.0,
+        max_tokens: int = 131_072,
+        reasoning_model: bool = False,
+        reasoning_effort: str | None = None,
+        base_url: str = "http://localhost:8000/v1",
+    ):
+        self.client = OpenAI(base_url=base_url, timeout=24*60*60)
+        self.model = model
+        self.developer_message = developer_message
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.image_format = "url"
+        self.reasoning_model = reasoning_model
+        self.reasoning_effort = reasoning_effort
+
+    def _pack_message(self, role: str, content: Any) -> dict[str, Any]:
+        return {"role": role, "content": content}
+
+    def __call__(self, message_list: MessageList) -> SamplerResponse:
+        if self.developer_message:
+            message_list = [
+                self._pack_message("developer", self.developer_message)
+            ] + message_list
+        trial = 0
+        while True:
+            try:
+                request_kwargs = {
+                    "model": self.model,
+                    "input": message_list,
+                    "temperature": self.temperature,
+                    "max_output_tokens": self.max_tokens,
+                }
+                if self.reasoning_model:
+                    request_kwargs["reasoning"] = (
+                        {"effort": self.reasoning_effort} if self.reasoning_effort else None
+                    )
+                response = self.client.responses.create(**request_kwargs)
+
+                for output in response.output:
+                    if hasattr(output, "text"):
+                        message_list.append(self._pack_message(getattr(output, "role", "assistant"), output.text))
+                    elif hasattr(output, "content"):
+                        for c in output.content:
+                            # c.text handled below
+                            pass
+
+                return SamplerResponse(
+                    response_text=response.output_text,
+                    response_metadata={"usage": response.usage},
+                    actual_queried_message_list=message_list,
+                )
+            except openai.BadRequestError as e:
+                print("Bad Request Error", e)
+                return SamplerResponse(
+                    response_text="",
+                    response_metadata={"usage": None},
+                    actual_queried_message_list=message_list,
+                )
+            except Exception as e:
+                exception_backoff = 2**trial  # expontial back off
+                print(
+                    f"Rate limit exception so wait and retry {trial} after {exception_backoff} sec",
+                    e,
+                )
+                time.sleep(exception_backoff)
+                trial += 1
+            # unknown error shall throw exception

gpt_oss/evals/types.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass, field
+from typing import Any, Literal, overload
+
+Message = dict[str, Any]  # keys role, content
+MessageList = list[Message]
+
+
+
+@dataclass
+class SamplerResponse:
+    """
+    Response from a sampler.
+    """
+    response_text: str
+    actual_queried_message_list: MessageList
+    response_metadata: dict[str, Any]
+
+class SamplerBase:
+    """
+    Base class for defining a sampling model, which can be evaluated,
+    or used as part of the grading process.
+    """
+
+    def __call__(
+        self, 
+        message_list: MessageList,
+    ) -> SamplerResponse:
+        raise NotImplementedError
+
+
+@dataclass
+class EvalResult:
+    """
+    Result of running an evaluation (usually consisting of many samples)
+    """
+
+    score: float | None  # top-line metric
+    metrics: dict[str, float] | None  # other metrics
+    htmls: list[str]  # strings of valid HTML
+    convos: list[MessageList]  # sampled conversations
+    metadata: dict[str, Any] | None  # Extra data such as rubric scores or sollen
+
+
+@dataclass
+class SingleEvalResult:
+    """
+    Result of evaluating a single sample
+    """
+
+    score: float | None
+    metrics: dict[str, float] = field(default_factory=dict)
+    html: str | None = None
+    convo: MessageList | None = None  # sampled conversation
+    example_level_metadata: dict[str, Any] | None = (
+        None  # Extra data such as rubric scores or sollen
+    )
+
+
+class Eval:
+    """
+    Base class for defining an evaluation.
+    """
+
+    def __call__(self, sampler: SamplerBase) -> EvalResult:
+        raise NotImplementedError
+

gpt_oss/generate.py

@@ -0,0 +1,95 @@
+# Model parallel inference
+# Note: This script is for demonstration purposes only. It is not designed for production use.
+#       See gpt_oss.chat for a more complete example with the Harmony parser.
+# torchrun --nproc-per-node=4 -m gpt_oss.generate -p "why did the chicken cross the road?" model/
+
+import argparse
+
+from gpt_oss.tokenizer import get_tokenizer
+
+
+def main(args):
+    match args.backend:
+        case "torch":
+            from gpt_oss.torch.utils import init_distributed
+            from gpt_oss.torch.model import TokenGenerator as TorchGenerator
+            device = init_distributed()
+            generator = TorchGenerator(args.checkpoint, device=device)
+        case "triton":
+            from gpt_oss.torch.utils import init_distributed
+            from gpt_oss.triton.model import TokenGenerator as TritonGenerator
+            device = init_distributed()
+            generator = TritonGenerator(args.checkpoint, context=args.context_length, device=device)
+        case "vllm":
+            from gpt_oss.vllm.token_generator import TokenGenerator as VLLMGenerator
+            generator = VLLMGenerator(args.checkpoint, tensor_parallel_size=args.tensor_parallel_size)
+        case _:
+            raise ValueError(f"Invalid backend: {args.backend}")
+
+    tokenizer = get_tokenizer()
+    tokens = tokenizer.encode(args.prompt)
+    max_tokens = None if args.limit == 0 else args.limit
+    for token, logprob in generator.generate(tokens, stop_tokens=[tokenizer.eot_token], temperature=args.temperature, max_tokens=max_tokens, return_logprobs=True):
+        tokens.append(token)
+        token_text = tokenizer.decode([token])
+        print(
+            f"Generated token: {repr(token_text)}, logprob: {logprob}"
+        )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Text generation example")
+    parser.add_argument(
+        "checkpoint",
+        metavar="FILE",
+        type=str,
+        help="Path to the SafeTensors checkpoint",
+    )
+    parser.add_argument(
+        "-p",
+        "--prompt",
+        metavar="PROMPT",
+        type=str,
+        default="How are you?",
+        help="LLM prompt",
+    )
+    parser.add_argument(
+        "-t",
+        "--temperature",
+        metavar="TEMP",
+        type=float,
+        default=0.0,
+        help="Sampling temperature",
+    )
+    parser.add_argument(
+        "-l",
+        "--limit",
+        metavar="LIMIT",
+        type=int,
+        default=0,
+        help="Limit on the number of tokens (0 to disable)",
+    )
+    parser.add_argument(
+        "-b",
+        "--backend",
+        metavar="BACKEND",
+        type=str,
+        default="torch",
+        choices=["triton", "torch", "vllm"],
+        help="Inference backend",
+    )
+    parser.add_argument(
+        "--tensor-parallel-size",
+        type=int,
+        default=2,
+        help="Tensor parallel size for vLLM backend",
+    )
+    parser.add_argument(
+        "--context-length",
+        type=int,
+        default=4096,
+        help="Context length for Triton backend",
+    )
+    args = parser.parse_args()
+
+    main(args)