init

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt .
+# RUN apt-get update && apt-get install -y gcc python3-dev
+RUN pip install -r requirements.txt
+# RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+COPY ./sticker.db /tmp/sticker.db
+
+ENV HF_HOME=/tmp/.cache
+
+
+CMD python main.py
+
+EXPOSE 7860

README.md

@@ -1,12 +1,26 @@
 ---
-title: NekoStickers
-emoji: 👀
-colorFrom: green
-colorTo: yellow
+title: NekoAI Lab
+emoji: 📚
+colorFrom: red
+colorTo: blue
 sdk: docker
+sdk_version: 4.19.0
+app_port: 7860
 pinned: false
-license: other
-short_description: agent for matching stickers
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 环境变量配置
+
+- COZE_API_KEY：通过 Space Settings -> Secrets 添加
+
+## 功能特性
+
+✅ 基于语义的表情包搜索
+🖼️ 支持批量上传表情包
+🔍 多语言语义理解（支持中英文）
+⚡ FAISS 实时语义检索
+
+## 参考资料
+
+向量化模型：
+https://huggingface.co/spaces/mteb/leaderboard

app/__init__.py

@@ -0,0 +1 @@
+# 初始化app包

app/api.py

@@ -0,0 +1,52 @@
+from openai import OpenAI
+from app.config import DEEPSEEK_API_KEY
+
+def get_chat_completion(
+    user_prompt: str,
+    system_prompt: str = "You are a helpful AI assistant.",
+    model: str = "deepseek/deepseek-chat-v3-0324:free",
+    api_key: str = DEEPSEEK_API_KEY,
+) -> str:
+    """
+    Get chat completion from DeepSeek model via OpenRouter API.
+    
+    Args:
+        user_prompt: The user's input prompt
+        system_prompt: The system role prompt (default is generic assistant)
+        model: The model to use (default is DeepSeek-V2.5)
+        api_key: API key for OpenRouter (default from config)
+    
+    Returns:
+        The generated response from the model
+    """
+    client = OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=api_key,
+    )
+    
+    headers = {
+        "HTTP-Referer": 'https://huggingface.co/spaces/Nekoko/NekoAI-Lab',
+        "X-Title": "Meme-Search"
+    }
+
+    completion = client.chat.completions.create(
+        extra_headers=headers,
+        model=model,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+    )
+    
+    content =  completion.choices[0].message.content
+    print('>>>> LLM Response', content)
+    return content
+
+
+# Example usage:
+if __name__ == "__main__":
+    response = get_chat_completion(
+        user_prompt="What's the capital of France?",
+        system_prompt="You are a knowledgeable geography assistant."
+    )
+    print(response)

app/config.py

@@ -0,0 +1,38 @@
+import os
+
+# 应用配置
+DATASET_ID = "Nekoko/StickerSet"
+COZE_API_TOKEN = os.getenv('COZE_API_TOKEN')
+HUGGING_FACE_TOKEN = os.getenv('HUGGING_FACE_TOKEN')
+DEEPSEEK_API_KEY = os.getenv('DEEPSEEK_API_KEY')
+MILVUS_DB_FILE = os.getenv('MILVUS_DB_FILE', "./sticker.db")
+MILVUS_DB_URL = os.getenv('MILVUS_DB_URL', "./sticker.db")
+MILVUS_DB_TOKEN = os.getenv('MILVUS_DB_TOKEN', "")
+EMBEDDING_MODEL = 'shibing624/text2vec-base-chinese'
+PUBLIC_URL = os.getenv('PUBLIC_URL')
+
+STICKER_RERANKING_SYSTEM_PROMPT = """
+## 角色
+你是专业的表情包搜索助手，能找到最符合用户关键词的表情包，并为给定表情包列表中各表情包的关键词匹配度打分（0 - 1）并排序。
+## 回复示例:
+[{ "reason": "判断的理由", "sticker_id": "1", "score": 0.8,},
+{ "reason": "判断的理由", "sticker_id": "2", "score": 0.3,}]
+
+## 功能: 分析相关性
+1. 评估表情包列表中表情包描述与关键词的匹配度，给出0到1的评分。
+2. 给出判断的理由（中文）
+
+## 限制
+- 仅处理表情包搜索相关内容，不答无关问题，分清楚关键词和表情包列表。
+- 请只输出纯JSON格式，不要包含任何Markdown标记如```json或```。
+"""
+
+
+# 服务器配置
+HOST = "0.0.0.0"
+PORT = 7860
+
+# 环境配置
+TEMP_DIR = os.getenv('TEMP_DIR', './tmp/')  # Temporary directory for file operations
+
+# 数据库配置

app/database.py

@@ -0,0 +1,155 @@
+from pymilvus import MilvusClient
+from sentence_transformers import SentenceTransformer
+from typing import List, Dict, Any, Optional, Union
+import logging
+
+from app.config import MILVUS_DB_URL, MILVUS_DB_TOKEN, EMBEDDING_MODEL, DATASET_ID
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    """数据库操作类，处理与Milvus的交互"""
+    
+    def __init__(self):
+        self.client = MilvusClient(
+            uri = MILVUS_DB_URL,
+            token= MILVUS_DB_TOKEN)
+        self.model = SentenceTransformer(EMBEDDING_MODEL, trust_remote_code=True)
+        print('初始化模型完成',self.model)
+        self.collection_name = "stickers"
+    
+    def init_collection(self) -> bool:
+        """初始化 Milvus 数据库"""
+        try:
+            print('初始化 Milvus 数据库', self.client.list_collections())
+            if not len(self.client.list_collections()) > 0:
+                self.client.create_collection(
+                    collection_name=self.collection_name,
+                    dimension=768,
+                    primary_field="id",
+                    auto_id=True
+                )
+                self.client.create_index(
+                    collection_name=self.collection_name,
+                    index_type="IVF_SQ8",
+                    metric_type="COSINE",
+                    params={"nlist": 128},
+                    index_params={}
+                )
+                logger.info(f"Collection initialized: {self.collection_name}")
+            print('初始化 Milvus 数据库成功', self.client.list_collections())
+            return True
+        except Exception as e:
+            logger.error(f"Collection initialization failed: {str(e)}")
+            return False
+    
+    def encode_text(self, text: str) -> List[float]:
+        """将文本编码为向量"""
+        return self.model.encode(text).tolist()
+    
+    def store_sticker(self, title: str, description: str, tags: Union[str, List[str]], file_path: str, image_hash: str = None) -> bool:
+        """存储贴纸数据到Milvus"""
+        try:
+            vector = self.encode_text(description)
+            
+            # 处理标签格式
+            if isinstance(tags, str):
+                tags = tags.split(",")
+            
+            logger.info(f"Storing to Milvus - title: {title}, description: {description}, file_path: {file_path}, tags: {tags}, image_hash: {image_hash}")
+            self.client.insert(
+                collection_name=self.collection_name,
+                data=[{
+                    "vector": vector,
+                    "title": title,
+                    "description": description,
+                    "tags": tags,
+                    "file_name": file_path,
+                    "image_hash": image_hash
+                }]
+            )
+            logger.info("Storing to Milvus Success ✅")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to store sticker: {str(e)}")
+            return False
+    
+    def search_stickers(self, description: str, limit: int = 2) -> List[Dict[str, Any]]:
+        """搜索贴纸"""
+        if not description:
+            return []
+        
+        try:
+            text_vector = self.encode_text(description)
+            logger.info(f"Searching Milvus - query: {description}, limit: {limit}")
+            
+            results = self.client.search(
+                collection_name=self.collection_name,
+                data=[text_vector],
+                limit=limit,
+                search_params={
+                    "metric_type": "COSINE",
+                },
+                output_fields=["title", "description", "tags", "file_name"],
+            )
+            
+            logger.info(f"Search Result: {results}")
+            return results[0]
+        except Exception as e:
+            logger.error(f"Search failed: {str(e)}")
+            return []
+    
+    def get_all_stickers(self, limit: int = 1000) -> List[Dict[str, Any]]:
+        """获取所有贴纸"""
+        try:
+            results = self.client.query(
+                collection_name=self.collection_name,
+                filter="",
+                limit=limit,
+                output_fields=["title", "description", "tags", "file_name", "image_hash"]
+            )
+            
+            logger.info(f"Query All Stickers - limit: {limit}, results count: {len(results)}")
+            return results
+        except Exception as e:
+            logger.error(f"Failed to get all stickers: {str(e)}")
+            return []
+    
+    def check_image_exists(self, image_hash: str) -> bool:
+        """检查文件名是否已存在"""
+        try:
+            results = self.client.query(
+                collection_name=self.collection_name,
+                filter=f"image_hash == '{image_hash}'",
+                limit=1,
+                output_fields=["file_name", "image_hash"]
+            )
+            
+            exists = len(results) > 0
+            logger.info(f"Check file exists - hash: {image_hash}, exists: {exists}, results: {results}")
+            return exists
+        except Exception as e:
+            logger.error(f"Failed to check file exists: {str(e)}")
+            return False
+
+    def delete_sticker(self, sticker_id: int) -> str:
+        """删除贴纸"""
+        try:
+            logger.info(f"Deleting sticker - id: {sticker_id}")
+            res = self.client.delete(
+                collection_name=self.collection_name,
+                ids=[sticker_id]
+            )
+            logger.info(f"Deleted sticker - id: {sticker_id}")
+            print(res)
+            return f"Sticker with ID {sticker_id} deleted successfully"
+        except Exception as e:
+            logger.error(f"Failed to delete sticker: {str(e)}")
+            return f"Failed to delete sticker: {str(e)}"
+# 初始化 Milvus 数据库
+
+# 创建数据库实例
+db = Database()

app/gradio_formatter.py

@@ -0,0 +1,81 @@
+from typing import List, Dict, Any
+from app.image_utils import format_image_url
+import logging
+import os
+import gradio as gr
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+logger = logging.getLogger(__name__)
+
+class GradioFormatter:
+    """贴纸格式化类，处理贴纸数据的格式化逻辑"""
+    
+    @staticmethod
+    def _format_image_markdown(image_url: str) -> str:
+        """格式化图片显示，支持本地和远程图片"""
+        if os.path.exists(image_url):
+            # 使用 Gradio 的 Image 组件显示本地图片
+            return f"<img src='{image_url}' style='max-width: 200px; max-height: 200px;'>"
+        return f"![Sticker]({image_url})"
+    
+    @staticmethod
+    def format_all_stickers(results: List[Dict[str, Any]]) -> List[List]:
+        """格式化所有贴纸，用于Gradio UI显示"""
+        formatted_results = []
+        
+        for record in results:
+            logger.info(f"格式化所有贴纸，用于Gradio UI显示: {record}")
+            image_url = format_image_url(record['file_name'])
+            image_markdown = GradioFormatter._format_image_markdown(image_url)
+            
+            formatted_results.append([
+                str(record['id']),
+                image_markdown,
+                record.get('title', ''),
+                record['description'],
+                ", ".join(record['tags']) if isinstance(record['tags'], list) else record['tags'],
+                record['file_name'],
+                record['image_hash'] if 'image_hash' in record else ''
+            ])
+        return formatted_results
+    
+    @staticmethod
+    def format_search_results(results: List[Dict[str, Any]]) -> List[List]:
+        """格式化搜索结果，用于Gradio UI显示"""
+        formatted_results = []
+        logger.info(f"Formatting search results: {len(results)} items")
+        
+        for hit in results:
+            image_url = format_image_url(hit['entity']['file_name'])
+            image_markdown = GradioFormatter._format_image_markdown(image_url)
+            
+            formatted_results.append([
+                image_markdown,
+                round(hit['distance'], 4),
+                hit['entity'].get('description', ''),
+                hit['entity'].get('file_name', '')
+            ])
+        return formatted_results
+
+    @staticmethod
+    def format_ai_search_results(results: List[Dict[str, Any]]) -> List[List]:
+        """格式化 AI 搜索结果，用于Gradio UI显示"""
+        formatted_results = []
+        logger.info(f"Formatting AI search results: {len(results)} items")
+        
+        for hit in results:
+            image_url = format_image_url(hit['entity']['file_name'])
+            image_markdown = GradioFormatter._format_image_markdown(image_url)
+            
+            formatted_results.append([
+                image_markdown,
+                hit['entity'].get('score', ''),
+                hit['entity'].get('reason', ''),
+                hit['entity'].get('description', ''),
+                hit['entity'].get('file_name', '')
+            ])
+        return formatted_results
+
+# 创建格式化器实例
+gradio_formatter = GradioFormatter()

app/image_utils.py

@@ -0,0 +1,107 @@
+import tempfile
+import random
+import requests
+import json
+import logging
+from PIL import Image
+from huggingface_hub import HfApi
+from cozepy import Coze, TokenAuth
+import hashlib
+import os
+
+from app.config import DATASET_ID, COZE_API_TOKEN, HUGGING_FACE_TOKEN
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+logger = logging.getLogger(__name__)
+
+# 初始化API客户端
+api = HfApi()
+# coze = Coze(auth=TokenAuth(token=COZE_API_TOKEN), base_url="https://api.coze.cn")
+
+
+def calculate_image_hash(Image: Image.Image) -> str:
+    """
+    参数:
+        Image
+    返回:
+        str: 图片的MD5哈希字符串
+    """
+    return hashlib.md5(Image.tobytes()).hexdigest()
+
+
+
+def get_image_description(image_url: str) -> str:
+    """获取图片描述"""
+    pass
+    # logger.info(f"Get image description")
+    # workflow = coze.workflows.runs.create(
+    #     workflow_id='7479742935953752091',
+    #     parameters={
+    #         "image_url": image_url
+    #     }
+    # )
+    # logger.info(f"Image description: {workflow.data}")
+    # if (workflow.data):
+    #     description = json.loads(workflow.data)['output']
+    #     return description
+    # else:
+    #     return ""
+
+def save_image_temp(image: Image.Image) -> str:
+    """保存图片到临时文件"""
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_img:
+        image.save(temp_img.name, "PNG")
+        return temp_img.name
+
+
+def upload_to_huggingface(temp_file_path: str) -> tuple:
+    """上传图片到 HuggingFace"""
+    image_filename = f"image_{random.randint(1000, 9999)}.png"
+    file_path = f"images/{image_filename}"
+    
+    logger.info(f"Uploading image to HuggingFace: {file_path}")
+    api.upload_file(
+        path_or_fileobj=temp_file_path,
+        path_in_repo=file_path,
+        repo_id=DATASET_ID,
+        token=HUGGING_FACE_TOKEN,
+        repo_type="dataset"
+    )
+    logger.info(f"Image uploaded successfully: {file_path}")
+    return file_path, image_filename
+
+
+def get_image_cdn_url(file_path: str) -> str:
+    """获取图片CDN URL"""
+    image_url = f"https://huggingface.co/datasets/{DATASET_ID}/resolve/main/{file_path}"
+    logger.info(f"Getting CDN URL for: {image_url}")
+    
+    response = requests.head(
+        image_url, 
+        allow_redirects=True,
+        timeout=10,  
+        headers={
+            'User-Agent': 'NekoAI',
+        }
+    )
+    image_cdn_url = response.url
+    logger.info(f"CDN URL: {image_cdn_url}")
+    return image_cdn_url
+
+
+def format_image_url(file_path: str) -> str:
+    """格式化图片URL，用于显示
+    
+    Args:
+        file_path (str): 图片路径，可以是本地路径或HuggingFace路径
+        
+    Returns:
+        str: 格式化后的URL
+    """
+    # 如果是本地文件，直接返回完整路径
+    if os.path.exists(file_path):
+        return os.path.abspath(file_path)
+    
+    # 如果是HuggingFace路径，返回完整的URL
+    return f"https://huggingface.co/datasets/{DATASET_ID}/resolve/main/{file_path}"

app/services.py

@@ -0,0 +1,284 @@
+import os
+import logging
+import zipfile
+import tempfile
+import shutil
+import json
+from typing import List, Dict, Any, Optional, Union
+from PIL import Image
+from app.api import get_chat_completion
+from app.config import (
+    STICKER_RERANKING_SYSTEM_PROMPT,
+    PUBLIC_URL,
+    TEMP_DIR
+)
+
+from app.database import db
+from app.image_utils import (
+    save_image_temp, 
+    upload_to_huggingface, 
+    get_image_cdn_url, 
+    get_image_description,
+    calculate_image_hash
+)
+from app.gradio_formatter import gradio_formatter
+from multiprocessing import Queue
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+logger = logging.getLogger(__name__)
+
+
+class StickerService:
+    """贴纸服务类，处理贴纸的上传、搜索等业务逻辑"""
+    
+    @staticmethod
+    def upload_sticker(image_file_path: str, title: str, description: str, tags: str) -> str:
+        """上传贴纸"""
+        try:
+            # 打开图片
+            image = Image.open(image_file_path)
+
+            # 检查文件名是否已存在
+            image_hash = calculate_image_hash(image)
+            if db.check_image_exists(image_hash):
+                print(f"文件已存在", image_hash)
+                raise Exception('File_Exists')
+            
+            # 上传到 HuggingFace
+            file_path, image_filename = upload_to_huggingface(image_file_path)
+            # print('>>>> image_file_path', image_file_path)
+            # print('>>>> image_filename', image_filename)
+            # print('>>>> file_path', file_path)
+
+            # 如果没有描述，获取图片描述
+            if not description:
+                image_cdn_url = ''
+                if (PUBLIC_URL):
+                    image_cdn_url = f'{PUBLIC_URL}/gradio_api/file={image_file_path}'
+                else:
+                    image_cdn_url = get_image_cdn_url(file_path)
+                print('image_cdn_url',image_cdn_url)
+                
+                description = get_image_description(image_cdn_url)
+            
+            # 清理临时文件
+            # os.unlink(temp_file_path)
+            
+            # 存储到 Milvus
+            db.store_sticker(title, description, tags, file_path, image_hash)
+            
+            return f"Upload successful! {image_filename}"
+            
+        except Exception as e:
+            logger.error(f"Upload failed: {str(e)}")
+            return f"Upload failed: {str(e)}"
+    
+    @staticmethod
+    def import_stickers(
+        sticker_dataset: str,
+        upload: bool = False,
+        gen_description: bool = False,
+        progress_callback: callable = None,
+        total_files: int = 0
+    ) -> List[str]:
+        """导入表情包数据集
+        
+        Args:
+            sticker_dataset (str): 表情包数据集路径
+            upload (bool, optional): 是否上传到HuggingFace. Defaults to False.
+            gen_description (bool, optional): 是否生成AI描述. Defaults to False.
+            progress_callback (callable, optional): 进度回调函数. Defaults to None.
+            total_files (int, optional): 总文件数. Defaults to 0.
+        """
+        results = []
+        descriptions = {}
+        
+        try:
+            # 创建临时目录
+            temp_dir = TEMP_DIR
+            logger.info(f"Created temporary directory: {temp_dir}")
+            
+            # 解压数据集
+            with zipfile.ZipFile(sticker_dataset, 'r') as zip_ref:
+                zip_ref.extractall(temp_dir)
+            
+            logger.info(f"Extracted dataset to: {temp_dir}")
+            
+            # 尝试读取data.json文件
+            data_json_path = os.path.join(temp_dir, 'data.json')
+            if os.path.exists(data_json_path):
+                with open(data_json_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    descriptions = { x["filename"]: x["content"] for x in data }
+                logger.info(f"Loaded descriptions from data.json")
+            
+            # 遍历解压后的目录
+            for root, dirs, files in os.walk(temp_dir):
+                for file in files:
+                    if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
+                        image_path = os.path.join(root, file)
+                        
+                        try:
+                            # 打开图片
+                            image = Image.open(image_path)
+                            
+                            # 检查文件名是否已存在
+                            image_hash = calculate_image_hash(image)
+                            if db.check_image_exists(image_hash):
+                                results.append(f"跳过已存在的图片: {file}")
+                                if progress_callback:
+                                    progress_callback(file, "Skipped (exists)")
+                                continue
+                            
+                            # 保存到临时文件
+                            temp_file_path = save_image_temp(image)
+                            
+                            # 上传到 HuggingFace
+                            if upload:
+                                file_path, image_filename = upload_to_huggingface(temp_file_path)
+                            else:
+                                file_path = temp_file_path
+                                image_url = file_path
+                            
+                            # 获取图片描述
+                            description = None
+                            if file in descriptions:
+                                description = descriptions[file]
+                            elif gen_description:
+                                image_cdn_url = ''
+                                if (PUBLIC_URL):
+                                    image_cdn_url = f'{PUBLIC_URL}/gradio_api/file={temp_file_path}'
+                                else:
+                                    image_cdn_url = get_image_cdn_url(file_path)
+                                description = get_image_description(image_cdn_url)
+                            
+                            if not description:
+                                logger.warning(f"No description available for {file}")
+                                if progress_callback:
+                                    progress_callback(file, "Skipped (no description)")
+                                continue
+                            
+                            # 清理临时文件
+                            if upload:
+                                os.unlink(temp_file_path)
+                            
+                            db.store_sticker("", description, "", file_path, image_hash)
+                            results.append(f"成功导入: {file}")
+                            
+                            if progress_callback:
+                                progress_callback(file, "Imported")
+                            
+                        except Exception as e:
+                            logger.error(f"Failed to process image {file}: {str(e)}")
+                            results.append(f"处理失败 {file}: {str(e)}")
+                            if progress_callback:
+                                progress_callback(file, f"Failed: {str(e)}")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Import failed: {str(e)}")
+            results.append(f"导入失败: {str(e)}")
+            return results
+            
+        finally:
+            # 清理临时目录
+            if temp_dir and os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+                logger.info(f"Cleaned up temporary directory: {temp_dir}")
+
+    @staticmethod
+    def search_stickers(description: str, limit: int = 2, reranking : bool = False) -> List[Dict[str, Any]]:
+        """搜索贴纸"""
+        if not description:
+            return []
+        
+        try:
+            results = db.search_stickers(description, limit)
+            if (reranking):
+                # 对搜索结果进行重排
+                results = StickerService.rerank_search_results(description, results, limit)
+            return results
+        except Exception as e:
+            logger.error(f"Search failed: {str(e)}")
+            return []
+    
+    @staticmethod
+    def get_all_stickers(limit: int = 1000) -> List[List]:
+        """获取所有贴纸"""
+        try:
+            results = db.get_all_stickers(limit)
+            return gradio_formatter.format_all_stickers(results)
+        except Exception as e:
+            logger.error(f"Failed to get all stickers: {str(e)}")
+            return []
+            
+    @staticmethod
+    def delete_sticker(sticker_id: str) -> str:
+        """删除贴纸"""
+        try:
+            # 首先查询贴纸是否存在
+            result = db.delete_sticker(sticker_id)
+            
+            return f"Sticker with ID {sticker_id} deleted successfully"
+        except Exception as e:
+            logger.error(f"Delete failed: {str(e)}")
+            return f"Delete failed: {str(e)}"
+    
+
+    @staticmethod
+    def rerank_search_results(query: str, sticker_list: List[Dict[str, Any]], limit: int = 5) -> List[Dict[str, Any]]:
+        ## 使用 LLM 模型重新排序搜索结果
+        try:
+            # 构建提示词
+            system_prompt = STICKER_RERANKING_SYSTEM_PROMPT
+            # 构建用户提示词，包含查询和表情包信息
+            _sticker_list = []
+            for hit in sticker_list:
+                _sticker_list.append({
+                    "id": hit["id"],
+                    "description": hit["entity"]["description"]
+                })
+            
+            user_prompt = f"请分析关键词 '{query}' 与以下表情包的相关性:\n{_sticker_list}"
+            
+            print(f">>> 使用 LLM 模型重新排序....", user_prompt, system_prompt)
+            # 调用 LLM 模型获取重排序结果
+            response = get_chat_completion(user_prompt, system_prompt)
+            
+            # 解析 LLM 返回的 JSON 结果
+            reranked_stickers = json.loads(response)
+            
+            # 验证返回结果格式
+            if not isinstance(reranked_stickers, list):
+                raise ValueError("Invalid response format")
+                
+            # 按分数排序
+            reranked_stickers.sort(key=lambda x: float(x.get("score", 0)), reverse=True)
+
+            print(f">>> LLM 排序结果", reranked_stickers)
+
+            
+            # 将重排序结果与原始结果对应
+            rerank_results = []
+            for sticker in reranked_stickers:
+                for hit in sticker_list:
+                    if str(hit["id"]) == str(sticker["sticker_id"]):
+                        hit["entity"]["score"] = sticker["score"]
+                        hit["entity"]["reason"] = sticker["reason"]
+                        rerank_results.append(hit)
+                        break
+            
+            print(f">>> rerank_results", rerank_results)
+            return rerank_results
+
+        except Exception as e:
+            logger.error(f"Reranking failed: {str(e)}")
+            return []
+
+
+
+
+# 创建服务实例
+sticker_service = StickerService()

app/ui.py

@@ -0,0 +1,220 @@
+import gradio as gr
+import logging
+from app.services import sticker_service
+from app.gradio_formatter import gradio_formatter
+import zipfile
+import threading
+from queue import Queue
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class StickerUI:
+    """Main class for the Sticker Search UI application."""
+    
+    def __init__(self):
+        self.demo = None
+        self._initialize_components()
+    
+    def _initialize_components(self):
+        """Initialize all UI components."""
+        # Search Tab
+        self.search_input = gr.Textbox(label="Search keywords")
+        self.limit_input = gr.Slider(1, 10, value=4, step=1, label="Max results")
+        self.search_button = gr.Button("Search")
+        self.deepseek_button = gr.Button("AI Search")
+        self.search_results = gr.Dataframe(
+            headers=["Preview", "Relevance", "Description", "Filename"],
+            datatype=["markdown", "number", "str", "str"],
+            row_count=("dynamic")
+        )
+
+        self.ai_search_results = gr.Dataframe(
+            headers=["Preview", "AI-Score", "AI-Reason", "Description", "Filename"],
+            datatype=["markdown", "number", "str", "str", "str"],
+            row_count=("dynamic")
+        )
+        
+        # Upload Tab
+        self.image_input = gr.Image(type="filepath")
+        self.title_input = gr.Textbox(label="Title")
+        self.tags_input = gr.Textbox(label="Tags (comma separated)")
+        self.desc_input = gr.Textbox(label="Description")
+        self.upload_button = gr.Button("Upload")
+        self.upload_output = gr.Textbox(label="Status")
+        
+        # All Stickers Tab
+        self.refresh_button = gr.Button("Refresh")
+        self.stickers_table = gr.Dataframe(
+            headers=["ID", "Preview", "Title", "Description", "Tags", "Filename", "Hash"],
+            datatype=["str", "markdown", "str", "str", "str", "str", "str"]
+        )
+        
+        # Import Dataset Tab
+        self.dataset_input = gr.File(label="Upload Dataset (ZIP)", file_types=[".zip"])
+        self.import_button = gr.Button("Import Dataset")
+        self.import_progress = gr.Slider(
+            minimum=0,
+            maximum=100,
+            value=0,
+            label="Import Progress",
+            interactive=False
+        )
+        self.import_output = gr.Textbox(label="Import Status", lines=10)
+    
+    def _setup_search_tab(self):
+        """Configure the search tab layout and functionality."""
+        with gr.Tab("Search"):
+            with gr.Row():
+                self.search_input.render()
+                self.limit_input.render()
+            
+            with gr.Row():
+                self.search_button.render()
+                self.deepseek_button.render()
+            
+            self.search_results.render()
+            self.ai_search_results.render()
+            
+            # Event handlers
+            self.search_button.click(
+                fn=lambda q, l: gradio_formatter.format_search_results(
+                    sticker_service.search_stickers(q, l)
+                ),
+                inputs=[self.search_input, self.limit_input],
+                outputs=self.search_results
+            )
+            
+            self.deepseek_button.click(
+                fn=lambda q, l: gradio_formatter.format_ai_search_results(
+                    sticker_service.search_stickers(q, l, reranking=True)
+                ),
+                inputs=[self.search_input, self.limit_input],
+                outputs=self.ai_search_results
+            )
+    
+    def _setup_upload_tab(self):
+        """Configure the upload tab layout and functionality."""
+        with gr.Tab("Upload"):
+            with gr.Row():
+                self.image_input.render()
+            
+            with gr.Row():
+                self.title_input.render()
+                self.tags_input.render()
+            
+            with gr.Row():
+                self.desc_input.render()
+                self.upload_button.render()
+            
+            self.upload_output.render()
+            
+            self.upload_button.click(
+                fn=sticker_service.upload_sticker,
+                inputs=[
+                    self.image_input,
+                    self.title_input,
+                    self.desc_input,
+                    self.tags_input
+                ],
+                outputs=self.upload_output
+            )
+    
+    def _setup_all_stickers_tab(self):
+        """Configure the all stickers tab layout and functionality."""
+        with gr.Tab("All Stickers"):
+            self.refresh_button.render()
+            self.stickers_table.render()
+            
+            self.refresh_button.click(
+                fn=sticker_service.get_all_stickers,
+                outputs=self.stickers_table
+            )
+    
+    def _setup_import_tab(self):
+        """Configure the import dataset tab layout and functionality."""
+        with gr.Tab("Import Dataset"):
+            with gr.Row():
+                self.dataset_input.render()
+            
+            with gr.Row():
+                self.upload_checkbox = gr.Checkbox(label="Upload to HuggingFace", value=False)
+                self.gen_desc_checkbox = gr.Checkbox(label="Generate AI Descriptions", value=False)
+            
+            with gr.Row():
+                self.import_button.render()
+            
+            self.import_output = gr.Textbox(label="Import Status", lines=10)
+            
+            self.import_button.click(
+                fn=self._import_stickers_with_progress,
+                inputs=[
+                    self.dataset_input,
+                    self.upload_checkbox,
+                    self.gen_desc_checkbox
+                ],
+                outputs=self.import_output
+            )
+    
+    def _import_stickers_with_progress(self, dataset_path, upload, gen_description, progress=gr.Progress()):
+        """Import stickers with progress tracking."""
+        try:
+            # Count total files first
+            total_files = 0
+            with zipfile.ZipFile(dataset_path, 'r') as zip_ref:
+                for file in zip_ref.namelist():
+                    if file.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp')):
+                        total_files += 1
+            
+            if total_files == 0:
+                return "No image files found in the dataset"
+            
+            # Track progress
+            processed_files = 0
+            results = []
+            
+            def update_progress(file, status):
+                nonlocal processed_files
+                processed_files += 1
+                progress_value = (processed_files / total_files) 
+                progress(progress_value, desc=f"Processing {file} - {status}")
+                return f"Processing {file} - {status}"
+            
+            # Import stickers
+            results = sticker_service.import_stickers(
+                dataset_path,
+                upload=upload,
+                gen_description=gen_description,
+                progress_callback=update_progress,
+                total_files=total_files
+            )
+            
+            return "\n".join(results)
+            
+        except Exception as e:
+            logger.error(f"Import failed: {str(e)}")
+            return f"Import failed: {str(e)}"
+    
+    def _update_progress(self, progress_queue):
+        """Update progress from queue."""
+        try:
+            while not progress_queue.empty():
+                message, progress = progress_queue.get_nowait()
+                yield message, progress
+        except:
+            pass
+    
+    def create_ui(self):
+        """Create and configure the complete UI."""
+        with gr.Blocks(title="Neko Sticker Search 🔍") as self.demo:
+            self._setup_search_tab()
+            self._setup_upload_tab()
+            self._setup_all_stickers_tab()
+            self._setup_import_tab()
+        
+        return self.demo

embedding_test.py

@@ -0,0 +1,241 @@
+import os
+import logging
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+from sentence_transformers import SentenceTransformer
+from pymilvus import MilvusClient, DataType
+import time
+import gradio as gr
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s %(levelname)s %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+models = [
+    'shibing624/text2vec-base-chinese',
+    'BAAI/bge-small-zh',
+    'BAAI/bge-base-zh',
+    'sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2',
+    'all-MiniLM-L6-v2',
+    'all-MiniLM-L12-v2',
+    'multi-qa-mpnet-base-dot-v1',
+    # 'bge-small-en-v1.5', 不兼容
+    'all-mpnet-base-v2',
+    'jinaai/jina-embeddings-v3',
+]
+
+
+searchers = {}
+
+
+class BaseEmbeddingModel(ABC):
+    @abstractmethod
+    def encode(self, text: str) -> List[float]:
+        pass
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:
+        pass
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        pass
+
+class SentenceTransformerModel(BaseEmbeddingModel):
+    def __init__(self, model_name: str):
+        self.model = SentenceTransformer(model_name, trust_remote_code=True)
+        self._model_name = model_name
+
+    def encode(self, text: str) -> List[float]:
+        result = self.model.encode(text).tolist()
+        return result
+
+    @property
+    def dimension(self) -> int:
+        return self.model.get_sentence_embedding_dimension()
+
+    @property
+    def model_name(self) -> str:
+        return self._model_name
+
+class StickerSearcher:
+    def __init__(self, model: BaseEmbeddingModel):
+        self.model = model
+        self.client = MilvusClient(uri='./sticker.db')
+        self.collection_name = f'test_{model.model_name.replace("/", "_").replace("-", "_")}'
+
+    def init_collection(self) -> bool:
+        try:
+            self.client.drop_collection(collection_name=self.collection_name)
+            self.client.create_collection(
+                collection_name=self.collection_name,
+                dimension=self.model.dimension,
+                primary_field_name='id',
+                auto_id=True
+            )
+            self.client.create_index(
+                collection_name=self.collection_name,
+                index_type='IVF_SQ8',
+                metric_type='COSINE',
+                params={'nlist': 128},
+                index_params={}
+            )
+            self.client.load_collection(self.collection_name)
+            logger.info(f'Collection initialized: {self.collection_name}')
+            return True
+        except Exception as e:
+            logger.error(f'Collection init failed: {str(e)}')
+            return False
+
+    def store_vector(self, title: str, description: str, tags: List[str], file_path: str):
+        vector = self.model.encode(description)
+        data = [{
+            'vector': vector,
+            'title': title,
+            'description': description,
+            'tags': tags,
+            'file_name': file_path
+        }]
+        self.client.insert(self.collection_name, data)
+
+    def search(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        start_time = time.time()
+        query_vector = self.model.encode(query)
+        encode_time = time.time() - start_time
+        start_search_time = time.time()
+        results = self.client.search(
+            collection_name=self.collection_name,
+            data=[query_vector],
+            limit=limit,
+            output_fields=['title', 'description', 'tags', 'file_name']
+        )
+        search_time = time.time() - start_search_time
+        total_time = encode_time + search_time
+        logger.info(f'模型 {self.model.model_name} Encoding耗时: ${encode_time:.4f}，搜索耗时: {search_time:.4f} 秒, 总耗时: {total_time:.4f} 秒')
+        return results[0]
+
+def create_gradio_ui():
+
+    async def search_model(model_name: str, query: str):
+        try:
+            if model_name in searchers:
+                return searchers[model_name].search(query)
+            logger.error(f'Model not loaded: {model_name}')
+            return []
+        except Exception as e:
+            logger.error(f'Search failed: {model_name} | Error: {str(e)}')
+            return []
+
+    async def search_all_models(query):
+        if not query:
+            return []
+
+        print(f'>>>> Searching From Models {query}')
+        results = []
+        for model_name in models:
+            result = await search_model(model_name, query)
+            results.append(result)
+
+        formatted_results = []
+        max_results = max(len(r) for r in results)
+
+        for i in range(max_results):
+            row = [i + 1]
+            for model_results in results:
+                if i < len(model_results):
+                    result = model_results[i]
+                    image_url = f'https://huggingface.co/datasets/Nekoko/StickerSet/resolve/main/{result["entity"]["file_name"]}'
+                    row.append(f'![Sticker]({image_url})\n相似度: {result["distance"]:.4f}')
+                else:
+                    row.append('-')
+            formatted_results.append(row)
+        return formatted_results
+
+    def init_collections():
+        try:
+            client = MilvusClient(uri='./sticker.db')
+            stickers = client.query(
+                collection_name='stickers',
+                filter='',
+                limit=1000,
+                output_fields=['title', 'description', 'tags', 'file_name']
+            )
+            logger.info(f'Stickers loaded: {len(stickers)}')
+
+            def init_model(model_name):
+                try:
+                    searcher = StickerSearcher(SentenceTransformerModel(model_name))
+                    if searcher.init_collection():
+                        searchers[model_name] = searcher
+                        for sticker in stickers:
+                            searcher.store_vector(
+                                sticker.get('title'),
+                                sticker.get('description'),
+                                sticker.get('tags'),
+                                sticker.get('file_name')
+                                )
+                        logger.info(f'Model initialized: {model_name}')
+                except Exception as e:
+                    logger.error(f'Model init failed: {model_name} | Error: {str(e)}')
+
+            for model_name in models:
+                print(f'>>>> 初始化模型 {model_name}')
+                start_time = time.time()
+                init_model(model_name)
+                print(f'>>>> 初始化模型 {model_name} 完成 ✅，耗时 {time.time() - start_time:.4f} 秒')
+            print(f'>>>> 初始化所有模型完成 ✅')
+            return '初始化成功！'
+        except Exception as e:
+            logger.error(f'Data init failed: {str(e)}')
+            return f'初始化失败: {str(e)}'
+
+    with gr.Blocks(title='Neko Sticker Search 🔍', css='.gradio-container img { width: 200px !important; height: 200px !important; object-fit: contain; }') as demo:
+        with gr.Row():
+            search_input = gr.Textbox(label='搜索关键词')
+            search_button = gr.Button('搜索')
+
+
+        headers = ['序号'] + [f'🧊{model.split("/")[-1]}' for i, model in enumerate(models)]
+        results_table = gr.Dataframe(
+            headers=headers,
+            datatype=['number'] + ['markdown'] * len(models),
+            row_count=5,
+            col_count=len(models) + 1
+        )
+
+        status_box = gr.Textbox(label='状态', interactive=False)
+        refresh_button = gr.Button('刷新数据')
+
+        refresh_button.click(fn=init_collections, outputs=status_box)
+        # 由于这里只是简单的搜索操作，可以直接使用同步方式调用
+        search_button.click(
+            fn=search_all_models, 
+            inputs=[search_input], 
+            outputs=results_table
+)
+
+    return demo
+
+if __name__ == '__main__':
+
+    # 提前加载所有模型
+    start_time = time.time()
+    for index, model_name in enumerate(models):
+        try:
+            start_time = time.time()
+            searchers[model_name] = StickerSearcher(SentenceTransformerModel(model_name))
+            print(f'>>>> 预加载模型 {model_name} 完成 ✅, 耗时 {time.time() - start_time:.4f} 秒')
+        except Exception as e:
+            logger.error(f'Model preload failed: {model_name} | Error: {str(e)}')
+
+    logger.info(f'>>>> 预加载模型完成 ✅: {models}, 耗时 {time.time() - start_time:.4f} 秒')
+
+
+
+    demo = create_gradio_ui()
+    demo.launch()

main.py

@@ -0,0 +1,101 @@
+import gradio as gr
+from fastapi import FastAPI, UploadFile, File
+import uvicorn
+import logging
+import os
+import tempfile
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')
+logger = logging.getLogger(__name__)
+
+# 创建FastAPI应用
+app = FastAPI()
+
+# 使用app/database.py中的数据库实例
+from app.database import db
+
+def init_milvus():
+    """初始化 Milvus 数据库"""
+    db.init_collection()
+
+# 图像处理相关功能已经在app/image_utils.py中实现
+
+
+
+# 使用app/services.py中的服务
+from app.services import sticker_service
+
+# 使用app/services.py中的服务，不再需要重复实现这些功能
+
+# 导入UI模块
+from app.ui import StickerUI
+
+# 创建Gradio界面
+
+# FastAPI 路由
+@app.get("/api/list_stickers")
+def api_get_stickers():
+
+    sticker_list = sticker_service.get_all_stickers()
+    print('>>> GET Sticker_list', sticker_list)
+    return sticker_list
+
+
+@app.post("/api/search_stickers")
+async def api_search_stickers(request: dict):
+    description = request.get('description', '')
+    if len(description) > 0:
+        sticker_list = sticker_service.search_stickers(
+            description=description,
+            limit=1,
+        )
+        print('>>> GET Sticker_list', sticker_list)
+        return sticker_list
+    return []  # 当描述为空时返回空列表
+
+
+
+@app.post("/api/delete_sticker")
+async def api_delete_stickers(request: dict):
+    """Delete sticker by ID"""
+    try:
+        sticker_id = request.get('id')
+        if not sticker_id:
+            return {"status": "error", "message": "Missing sticker ID"}
+            
+        result = sticker_service.delete_sticker(sticker_id)
+        return {"status": "success", "message": result}
+    except Exception as e:
+        logger.error(f"Delete failed: {str(e)}")
+        return {"status": "error", "message": f"Delete failed: {str(e)}"}
+
+
+@app.post("/api/import_dataset")
+async def api_import_dataset(file: UploadFile = File(...), upload: bool = False, gen_description: bool = False):
+    """Import sticker dataset from ZIP file"""
+    try:
+        # Create a temporary file to store the uploaded ZIP
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
+            content = await file.read()
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        
+        # Import the dataset
+        results = sticker_service.import_stickers(temp_file_path, upload, gen_description)
+        
+        # Clean up the temporary file
+        os.unlink(temp_file_path)
+        
+        return {"status": "success", "results": results}
+    except Exception as e:
+        logger.error(f"Import failed: {str(e)}")
+        return {"status": "error", "message": f"Import failed: {str(e)}"}
+
+
+# 启动应用
+if __name__ == "__main__":
+    init_milvus()
+    ui = StickerUI()
+    app = gr.mount_gradio_app(app, ui.create_ui(), '/')
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,10 @@
+huggingface_hub>=0.19.4
+requests>=2.31.0
+cozepy>=0.1.0
+gradio==5.22.0
+sentence_transformers>=2.2.2
+fastapi>=0.104.1
+uvicorn>=0.24.0
+Pillow>=10.1.0
+pymilvus>=2.3.3
+openai==1.69.0

sticker-server/README.md

@@ -0,0 +1,45 @@
+# Sticker MCP Server
+
+This is an MCP (Model Context Protocol) server that allows large language models to search and send stickers based on emotion descriptions.
+
+## Features
+
+- Search for stickers based on emotion descriptions
+- Return sticker images in response to queries
+- Integrate with existing sticker search API
+
+## Installation
+
+1. Install dependencies:
+
+   ```
+   cd sticker-server
+   npm install
+   ```
+
+2. Make the server executable:
+
+   ```
+   npm run build
+   ```
+
+3. Configure the MCP settings:
+
+   - For Claude Desktop app: Copy the contents of `mcp_settings.json` to `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - For Claude VSCode extension: Copy the contents of `mcp_settings.json` to `~/Library/Application Support/Trae/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+
+   If the file already exists, merge the "sticker" entry into the existing "mcpServers" object.
+
+## Usage
+
+Once the MCP server is configured, you can ask the language model to express emotions using stickers. For example:
+
+- "Show me a happy sticker"
+- "I'm feeling sad, can you send a sticker?"
+- "Send a cat sticker"
+
+The language model will use the `send_sticker` tool to search for and display an appropriate sticker based on your request.
+
+## How it Works
+
+The server connects to a local sticker search API running at `http://localhost:7860/api/search_stickers` and provides the search results to the language model, which can then display the stickers in its responses.

sticker-server/index.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ErrorCode,
+  ListResourcesRequestSchema,
+  ListResourcesResult,
+  ListResourceTemplatesRequestSchema,
+  McpError,
+  ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+interface Resource {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: Record<
+      string,
+      {
+        type: string;
+        description: string;
+      }
+    >;
+    required?: string[];
+  };
+}
+
+class StickerServer {
+  private server: Server;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "sticker-server",
+        version: "1.0.0",
+      },
+      {
+        capabilities: {
+          resources: {},
+        },
+      }
+    );
+
+    this.setupResourceHandlers();
+
+    this.server.onerror = (error: Error) => console.error("[MCP Error]", error);
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  private setupResourceHandlers(): void {
+    this.server.setRequestHandler(
+      ListResourceTemplatesRequestSchema,
+      async () => ({
+        resourceTemplates: [
+          {
+            uriTemplate:
+              "mcp://sticker-server/send_sticker?description={description}",
+            name: "send sticker",
+            mimeType: "text",
+            description:
+              "请正常回复用户的问题，只有在正常回答用户问题后，根据情境需要，使用此 Resource 读取一个表达特定情绪或描述的贴纸的 URL，并将图片展示到对话内，需要展示图片，而不是 URL",
+          },
+        ],
+      })
+    );
+
+    // Read resource contents
+    this.server.setRequestHandler(
+      ReadResourceRequestSchema,
+      async (request) => {
+        try {
+          const uri = request.params.uri;
+          // mcp://sticker-server/send_sticker?description={description}
+          const description = new URL(uri).searchParams.get("description");
+          const response = await fetch(
+            "http://127.0.0.1:7860/api/search_stickers",
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+              },
+              body: JSON.stringify({ description }),
+            }
+          );
+          const stickerList = await response.json();
+          console.log("uri", uri, "stickerList", stickerList);
+          const imageUrl = stickerList?.[0]?.image_url || "找不到贴纸呢～";
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+          return {
+            contents: [
+              {
+                uri,
+                type: "text",
+                text: imageUrl,
+              },
+            ],
+          };
+        } catch (error) {
+          return {
+            contents: [
+              {
+                uri: "",
+                type: "text",
+                text: JSON.stringify(error),
+              },
+            ],
+          };
+        }
+      }
+    );
+  }
+
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("Sticker MCP server running on stdio");
+  }
+}
+
+const server = new StickerServer();
+server.run().catch(console.error);

sticker-server/mcp_settings.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "sticker": {
+      "command": "node",
+      "args": ["/Users/bytedance/dev/NekoAI-Lab/sticker-server/dist/index.js"],
+      "disabled": false,
+      "autoApprove": []
+    }
+  }
+}

sticker-server/package-lock.json

@@ -0,0 +1,1871 @@
+{
+  "name": "sticker-server",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "sticker-server",
+      "version": "1.0.0",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "*",
+        "axios": "^1.6.0",
+        "node-fetch": "^3.3.2"
+      },
+      "devDependencies": {
+        "@types/node": "^22.13.14",
+        "ts-node": "^10.9.2",
+        "ts-node-dev": "^2.0.0",
+        "typescript": "^5.3.3"
+      }
+    },
+    "node_modules/@cspotcode/source-map-support": {
+      "version": "0.8.1",
+      "resolved": "https://bnpm.byted.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/trace-mapping": "0.3.9"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://bnpm.byted.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.0",
+      "resolved": "https://bnpm.byted.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "dev": true
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.9",
+      "resolved": "https://bnpm.byted.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.8.0.tgz",
+      "integrity": "sha512-e06W7SwrontJDHwCawNO5SGxG+nU9AAx+jpHHZqGl/WrDBdWOpvirC+s58VpJTB5QemI4jTRcjWT4Pt3Q1NPQQ==",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.3",
+        "eventsource": "^3.0.2",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^4.1.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@tsconfig/node10": {
+      "version": "1.0.11",
+      "resolved": "https://bnpm.byted.org/@tsconfig/node10/-/node10-1.0.11.tgz",
+      "integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==",
+      "dev": true
+    },
+    "node_modules/@tsconfig/node12": {
+      "version": "1.0.11",
+      "resolved": "https://bnpm.byted.org/@tsconfig/node12/-/node12-1.0.11.tgz",
+      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
+      "dev": true
+    },
+    "node_modules/@tsconfig/node14": {
+      "version": "1.0.3",
+      "resolved": "https://bnpm.byted.org/@tsconfig/node14/-/node14-1.0.3.tgz",
+      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
+      "dev": true
+    },
+    "node_modules/@tsconfig/node16": {
+      "version": "1.0.4",
+      "resolved": "https://bnpm.byted.org/@tsconfig/node16/-/node16-1.0.4.tgz",
+      "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
+      "dev": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.13.14",
+      "resolved": "https://bnpm.byted.org/@types/node/-/node-22.13.14.tgz",
+      "integrity": "sha512-Zs/Ollc1SJ8nKUAgc7ivOEdIBM8JAKgrqqUYi2J997JuKO7/tpQC+WCetQ1sypiKCQWHdvdg9wBNpUPEWZae7w==",
+      "dev": true,
+      "dependencies": {
+        "undici-types": "~6.20.0"
+      }
+    },
+    "node_modules/@types/strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://bnpm.byted.org/@types/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha512-xevGOReSYGM7g/kUBZzPqCrR/KYAo+F0yiPc85WFTJa0MSLtyFTVTU6cJu/aV4mid7IffDIWqo69THF2o4JiEQ==",
+      "dev": true
+    },
+    "node_modules/@types/strip-json-comments": {
+      "version": "0.0.30",
+      "resolved": "https://bnpm.byted.org/@types/strip-json-comments/-/strip-json-comments-0.0.30.tgz",
+      "integrity": "sha512-7NQmHra/JILCd1QqpSzl8+mJRc8ZHz3uDm8YV1Ks9IhK0epEiTw8aIErbvH9PI+6XbqhyIQy3462nEsn7UVzjQ==",
+      "dev": true
+    },
+    "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==",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.14.1",
+      "resolved": "https://bnpm.byted.org/acorn/-/acorn-8.14.1.tgz",
+      "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
+      "dev": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.4",
+      "resolved": "https://bnpm.byted.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+      "dev": true,
+      "dependencies": {
+        "acorn": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://bnpm.byted.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/arg": {
+      "version": "4.1.3",
+      "resolved": "https://bnpm.byted.org/arg/-/arg-4.1.3.tgz",
+      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
+      "dev": true
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/axios": {
+      "version": "1.8.4",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.8.4.tgz",
+      "integrity": "sha512-eBSYY4Y68NNlHbHBMdeDmKNtDgXWhQsJcGqzO3iLUM0GraQFSS9cVgPX5I9b3lbdFKyYoAEGAZF1DwhTaljNAw==",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://bnpm.byted.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://bnpm.byted.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "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==",
+      "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/body-parser/node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/body-parser/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=="
+    },
+    "node_modules/body-parser/node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://bnpm.byted.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://bnpm.byted.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://bnpm.byted.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "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==",
+      "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==",
+      "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/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://bnpm.byted.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://bnpm.byted.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true
+    },
+    "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==",
+      "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==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "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==",
+      "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==",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/create-require": {
+      "version": "1.1.1",
+      "resolved": "https://bnpm.byted.org/create-require/-/create-require-1.1.1.tgz",
+      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
+      "dev": true
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.6.tgz",
+      "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "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==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/diff": {
+      "version": "4.0.2",
+      "resolved": "https://bnpm.byted.org/diff/-/diff-4.0.2.tgz",
+      "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "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==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/dynamic-dedupe": {
+      "version": "0.3.0",
+      "resolved": "https://bnpm.byted.org/dynamic-dedupe/-/dynamic-dedupe-0.3.0.tgz",
+      "integrity": "sha512-ssuANeD+z97meYOqd50e04Ze5qp4bPqo8cCkI4TRjZkzAUgIDTrXV1R8QCdINpiI+hw14+rYazvTRdQrz0/rFQ==",
+      "dev": true,
+      "dependencies": {
+        "xtend": "^4.0.0"
+      }
+    },
+    "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=="
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "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==",
+      "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==",
+      "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==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "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=="
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.6.tgz",
+      "integrity": "sha512-l19WpE2m9hSuyP06+FbuUUf1G+R0SFLrtQfbRb9PRr+oimOfxQhgGCbVaXg5IvZyyTThJsxh6L/srkMiCeBPDA==",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.0.1.tgz",
+      "integrity": "sha512-VARTJ9CYeuQYb0pZEPbzi740OWFgpHe7AYJ2WFZVnUDUQp5Dk2yJUgF36YsZ81cOyxT0QxmXD2EQpapAouzWVA==",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.0.1.tgz",
+      "integrity": "sha512-ORF7g6qGnD+YtUG9yx4DFoqCShNMmUKiXuT5oWMHiOvt/4WFbHC6yCwQMTSBMno7AqntNCAzzcnnjowRkTL9eQ==",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.0.1",
+        "content-disposition": "^1.0.0",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "4.3.6",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "^2.0.0",
+        "fresh": "2.0.0",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "methods": "~1.1.2",
+        "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.13.0",
+        "range-parser": "~1.2.1",
+        "router": "^2.0.0",
+        "safe-buffer": "5.2.1",
+        "send": "^1.1.0",
+        "serve-static": "^2.1.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "^2.0.0",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-7.5.0.tgz",
+      "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==",
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": "^4.11 || 5 || ^5.0.0-beta.1"
+      }
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://bnpm.byted.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "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/finalhandler/node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/finalhandler/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=="
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
+      "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/form-data/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/form-data/node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "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==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://bnpm.byted.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "dev": true
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://bnpm.byted.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "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==",
+      "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==",
+      "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==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://bnpm.byted.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://bnpm.byted.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "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==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "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==",
+      "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==",
+      "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/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==",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://bnpm.byted.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "dev": true,
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+    },
+    "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==",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://bnpm.byted.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://bnpm.byted.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://bnpm.byted.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://bnpm.byted.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://bnpm.byted.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "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=="
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
+    },
+    "node_modules/make-error": {
+      "version": "1.3.6",
+      "resolved": "https://bnpm.byted.org/make-error/-/make-error-1.3.6.tgz",
+      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+      "dev": 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==",
+      "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==",
+      "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==",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "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==",
+      "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==",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://bnpm.byted.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://bnpm.byted.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "dev": true
+    },
+    "node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://bnpm.byted.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "dev": true,
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+    },
+    "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==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://bnpm.byted.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "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==",
+      "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==",
+      "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==",
+      "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==",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://bnpm.byted.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "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==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://bnpm.byted.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true
+    },
+    "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==",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://bnpm.byted.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-4.1.0.tgz",
+      "integrity": "sha512-ZBmhE1C9LcPoH9XZSdwiPtbPHZROwAnMy+kIFQVrnMCxY4Cudlz3gBOpzilgc0jOgRaiT3sIWfpMomW2ar2orQ==",
+      "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==",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "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==",
+      "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==",
+      "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/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://bnpm.byted.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.10",
+      "resolved": "https://bnpm.byted.org/resolve/-/resolve-1.22.10.tgz",
+      "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==",
+      "dev": true,
+      "dependencies": {
+        "is-core-module": "^2.16.0",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "2.7.1",
+      "resolved": "https://bnpm.byted.org/rimraf/-/rimraf-2.7.1.tgz",
+      "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "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/router/node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/router/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=="
+    },
+    "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"
+        }
+      ]
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+    },
+    "node_modules/send": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.0.tgz",
+      "integrity": "sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==",
+      "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/send/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=="
+    },
+    "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==",
+      "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=="
+    },
+    "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==",
+      "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==",
+      "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==",
+      "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==",
+      "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==",
+      "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==",
+      "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/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://bnpm.byted.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://bnpm.byted.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://bnpm.byted.org/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://bnpm.byted.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://bnpm.byted.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://bnpm.byted.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "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==",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/tree-kill": {
+      "version": "1.2.2",
+      "resolved": "https://bnpm.byted.org/tree-kill/-/tree-kill-1.2.2.tgz",
+      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
+      "dev": true,
+      "bin": {
+        "tree-kill": "cli.js"
+      }
+    },
+    "node_modules/ts-node": {
+      "version": "10.9.2",
+      "resolved": "https://bnpm.byted.org/ts-node/-/ts-node-10.9.2.tgz",
+      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+      "dev": true,
+      "dependencies": {
+        "@cspotcode/source-map-support": "^0.8.0",
+        "@tsconfig/node10": "^1.0.7",
+        "@tsconfig/node12": "^1.0.7",
+        "@tsconfig/node14": "^1.0.0",
+        "@tsconfig/node16": "^1.0.2",
+        "acorn": "^8.4.1",
+        "acorn-walk": "^8.1.1",
+        "arg": "^4.1.0",
+        "create-require": "^1.1.0",
+        "diff": "^4.0.1",
+        "make-error": "^1.1.1",
+        "v8-compile-cache-lib": "^3.0.1",
+        "yn": "3.1.1"
+      },
+      "bin": {
+        "ts-node": "dist/bin.js",
+        "ts-node-cwd": "dist/bin-cwd.js",
+        "ts-node-esm": "dist/bin-esm.js",
+        "ts-node-script": "dist/bin-script.js",
+        "ts-node-transpile-only": "dist/bin-transpile.js",
+        "ts-script": "dist/bin-script-deprecated.js"
+      },
+      "peerDependencies": {
+        "@swc/core": ">=1.2.50",
+        "@swc/wasm": ">=1.2.50",
+        "@types/node": "*",
+        "typescript": ">=2.7"
+      },
+      "peerDependenciesMeta": {
+        "@swc/core": {
+          "optional": true
+        },
+        "@swc/wasm": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ts-node-dev": {
+      "version": "2.0.0",
+      "resolved": "https://bnpm.byted.org/ts-node-dev/-/ts-node-dev-2.0.0.tgz",
+      "integrity": "sha512-ywMrhCfH6M75yftYvrvNarLEY+SUXtUvU8/0Z6llrHQVBx12GiFk5sStF8UdfE/yfzk9IAq7O5EEbTQsxlBI8w==",
+      "dev": true,
+      "dependencies": {
+        "chokidar": "^3.5.1",
+        "dynamic-dedupe": "^0.3.0",
+        "minimist": "^1.2.6",
+        "mkdirp": "^1.0.4",
+        "resolve": "^1.0.0",
+        "rimraf": "^2.6.1",
+        "source-map-support": "^0.5.12",
+        "tree-kill": "^1.2.2",
+        "ts-node": "^10.4.0",
+        "tsconfig": "^7.0.0"
+      },
+      "bin": {
+        "ts-node-dev": "lib/bin.js",
+        "tsnd": "lib/bin.js"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      },
+      "peerDependencies": {
+        "node-notifier": "*",
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "node-notifier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tsconfig": {
+      "version": "7.0.0",
+      "resolved": "https://bnpm.byted.org/tsconfig/-/tsconfig-7.0.0.tgz",
+      "integrity": "sha512-vZXmzPrL+EmC4T/4rVlT2jNVMWCi/O4DIiSj3UHg1OE5kCKbk4mfrXc6dZksLgRM/TZlKnousKH9bbTazUWRRw==",
+      "dev": true,
+      "dependencies": {
+        "@types/strip-bom": "^3.0.0",
+        "@types/strip-json-comments": "0.0.30",
+        "strip-bom": "^3.0.0",
+        "strip-json-comments": "^2.0.0"
+      }
+    },
+    "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==",
+      "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.2",
+      "resolved": "https://bnpm.byted.org/typescript/-/typescript-5.8.2.tgz",
+      "integrity": "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.20.0",
+      "resolved": "https://bnpm.byted.org/undici-types/-/undici-types-6.20.0.tgz",
+      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
+      "dev": true
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/v8-compile-cache-lib": {
+      "version": "3.0.1",
+      "resolved": "https://bnpm.byted.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
+      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
+      "dev": true
+    },
+    "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==",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.3.3.tgz",
+      "integrity": "sha512-d2JWLCivmZYTSIoge9MsgFCZrt571BikcWGYkjC1khllbTeDlGqZ2D8vD8E/lJa8WGWbb7Plm8/XJYV7IJHZZw==",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "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=="
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://bnpm.byted.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/yn": {
+      "version": "3.1.1",
+      "resolved": "https://bnpm.byted.org/yn/-/yn-3.1.1.tgz",
+      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.24.2",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
+      "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.5",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz",
+      "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==",
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  }
+}

sticker-server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "sticker-server",
+  "version": "1.0.0",
+  "description": "MCP Server for searching and sending stickers based on emotions",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "*",
+    "axios": "^1.6.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.14",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3"
+  }
+}

sticker-server/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules"]
+}

upload.py

@@ -0,0 +1,76 @@
+"""
+批量处理贴纸图片的工具模块
+
+功能：
+1. 批量处理指定目录下的图片文件
+2. 使用MD5哈希进行图片去重
+3. 生成图片嵌入向量并存储到数据库
+4. 可选地将处理后的图片移动到输出目录
+"""
+import os
+from typing import List
+from pathlib import Path
+
+from app.services import sticker_service
+
+
+def batch_process_stickers(image_dir: str = 'images.tmp', output_dir: str = 'processed.tmp') -> None:
+    """
+    批量处理目录中的贴纸图片
+    
+    参数:
+        image_dir: 包含贴纸图片的目录路径
+        output_dir: 存储处理后图片的输出目录(默认为'processed')
+    
+    功能:
+        1. 遍历目录中的所有图片文件
+        2. 使用MD5哈希进行去重
+        3. 为每张图片生成嵌入向量并存储到数据库
+        4. 可选地将处理后的图片移动到输出目录
+    """
+    # 创建输出目录(如果不存在)
+    os.makedirs(output_dir, exist_ok=True)
+    # 用于存储已处理图片的哈希集合
+    # 遍历目录中的所有文件
+    # 打印图片数量和列表
+    print('>>> 待处理图片数量', len(os.listdir(image_dir)))
+    for img_path in Path(image_dir).glob('*.*'):
+        # 只处理jpg/jpeg/png格式的图片
+        print('>>>> 正在处理图片', img_path)
+        if img_path.suffix.lower() not in ['.jpg', '.jpeg', '.png']:
+            continue
+        
+        try:
+            # 加载图片并准备元数据
+            from PIL import Image
+            img = Image.open(img_path)
+            title = img_path.stem  # 使用文件名作为标题
+            
+            # 调用上传服务
+            sticker_service.upload_sticker(img, title, "", "")
+            
+            # 可选操作: 将处理后的图片移动到输出目录
+            output_path = os.path.join(output_dir, img_path.name)
+            os.rename(str(img_path), output_path)
+            
+            print(f"已处理: {img_path}")
+        except Exception as e:
+            print(f"处理异常 {img_path}: {str(e)}")
+
+
+if __name__ == '__main__':
+    """
+    命令行入口
+    用法: python batch_upload.py <图片目录> [--output 输出目录]
+    """
+    import argparse
+    
+    # 设置命令行参数解析
+    parser = argparse.ArgumentParser(description='批量处理贴纸图片(带去重功能)')
+    parser.add_argument('image_dir', help='包含贴纸图片的目录')
+    parser.add_argument('--output', '-o', default='processed.tmp', 
+                       help='处理后图片的输出目录(默认为processed)')
+    
+    # 解析参数并执行批量处理
+    args = parser.parse_args()
+    batch_process_stickers(args.image_dir, args.output)