Add files using upload-large-folder tool

.gitattributes

@@ -75,3 +75,13 @@ deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_5_tagged.jso
 deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_1_tagged.json filter=lfs diff=lfs merge=lfs -text
 deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_2_tagged.json filter=lfs diff=lfs merge=lfs -text
 deep_search/data_from_zhiyuan/data_for_rl/musique_tagged/musique_tagged_domain_keypoints_keywords_count.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_for_paper/orignal_871/no_error_data_871.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_8_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_7_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/final_selected_dataset.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_6_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_4_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_for_paper/4-28_4k_question_1/final_selected_dataset.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_3_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_5_tagged.json filter=lfs diff=lfs merge=lfs -text
+deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/final_selected_dataset_1.json filter=lfs diff=lfs merge=lfs -text

deep_search/data_from_zhiyuan/data_for_paper/4-28_4k_question_1/final_selected_dataset.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41d27c626a2eb5a4cd26df4c7a18477850a8493e540377617256230b2258ca3c
+size 77422541

deep_search/data_from_zhiyuan/data_for_paper/orignal_871/no_error_data_871.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:638dac3e6cb9012d1d4498795195da16f89cefa0bbb42f554c606b2d872d659d
+size 79107369

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/split_8_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:025fee5735b799bfac8e988aaf8e0f6f3b7343bc58aa58e12f116e09e4ab9be1
+size 49212976

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/final_selected_dataset.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:975acf28da65eea6d3860afde69293afe7de9696160d9553cfd17984b0350f7e
+size 16227596

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/final_selected_dataset_1.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72f8119923720b9435b918f13228ebc427a2a77cc6ee7e902b4fa0f84de15d07
+size 16227596

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_3_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8b8b62bca48beb7a8f480ba0e6d59ab776b49cb43caeb61fce05e954bbf4e4a
+size 14884742

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_4_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6d045d5527a637d00c1e130268811919faa5cb7e40ee0315ab32cb447b3d76d
+size 16859190

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_5_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8c85b1a5a5bd73d40b173f2d5f10327318cc5b674ee78e9cacd4c93a641f0f7
+size 17154595

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_6_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53b6f27b63c91aec868d2675212200d30cca1e92922140a9bacc4c96ac1e99c2
+size 17098702

deep_search/data_from_zhiyuan/data_syn/data/mixed_data/splits/tagged_domain_keypoints/split_7_tagged.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2bd2a100a7c5e890e98eb1c64aae35c0d1e172a3a717de8b10cd410ef5d8d78b
+size 17795485

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/README.md

@@ -0,0 +1,174 @@
+
+# SimpleDeepSearcher: Deep Information Seeking via Web-Powered Reasoning Trajectory Synthesis
+
+
+## 🚀 Data Synthesis in Real Web Environment
+
+### 1. Launch the Summary Model
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1
+vllm serve "YOUR_SUMMARY_MODEL_PATH" \
+    --tensor-parallel-size=2 \
+    --gpu-memory-utilization 0.95 \
+    --port 8000 > output/vllm_serve.log 2>&1 &
+```
+
+---
+
+### 2. Generate Inference Search Trajectories
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1
+python -u inference/sythesis_data.py \
+    --dataset_name YOUR_DATASET_NAME \
+    --rollout_num YOUR_ROLLOUT_NUM \
+    --cache_dir_base cache \
+    --output_dir_base output \
+    --model_path "/path/to/your/reasoning_model" \
+    --summarization_model_path "/path/to/your/summarization_model" \
+    --summarization_model_url YOUR_SUMMARIZATION_MODEL_URL \
+    --google_subscription_key YOUR_KEY \
+    --google_endpoint "https://google.serper.dev/search" > output/output.log  2>&1
+```
+
+---
+
+## 🎯 Data Construction
+
+### 🔍 Query Sampling
+
+#### 1. Annotate Domains and Keywords of Labeled Data
+
+```bash
+python process_data/query_sampling/data_tag_domain_keypoints.py \
+  --input_file_path "/path/to/your/input.json" \
+  --cuda_visible_devices "0,1" \
+  --model_path "/path/to/your/tag_model"
+```
+
+#### 2. Extract Domains and Keywords
+
+
+```bash
+python process_data/query_sampling/extract_domain_keypoints.py \
+  --input_file_path "/path/to/your/input_tagged.json" \
+  --output_file_path "/path/to/your/output_extracted.json"
+```
+
+#### 3. Count Number of Units
+
+```bash
+python process_data/query_sampling/units_count.py \
+  --input_file "/path/to/your/output_extracted.json"
+```
+
+#### 4. Sample Questions
+
+```bash
+python process_data/query_sampling/query_sampling.py \
+  --input_file "/path/to/your/output_extracted.json" \
+  --total_samples YOUR_TOTAL_SAMPLES_NUMBER
+```
+
+---
+
+### 💬 Response Curation
+
+#### 1. Filter Responses
+
+```bash
+python process_data/repsonse_curation/response_curation.py \
+  --root_path  "/path/to/your/synthesis_data" \
+  --output_path "/path/to/your/curated_data"
+
+#### 2. Format Data
+
+```bash
+python process_data/repsonse_curation/format_data.py \
+  --input_file "/path/to/your/input_file.json"
+```
+
+#### 3. Format Check
+
+```bash
+python process_data/repsonse_curation/format_filter.py \
+  --input_file "/path/to/your/formatted_data.json"
+```
+
+---
+
+## 🧠 SFT Training
+
+> Run the following script after replacing the corresponding variables:
+
+```bash
+export OMP_NUM_THREADS=20
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+
+# Define parameters
+lr=1e-5
+base="BACKBONE"           # path to base model
+tokenizer="TOKENIZER"     # path to tokenizer
+train_data="sft/data/training_data_871.json" # path to train data
+bsz=2                     # batch size
+acc=4                     # gradient accumulation steps
+
+# Create output directory
+JOB_ID=$(( RANDOM % 100000 )) # random JOB-ID
+JOB_NAME=YOUR_JOB_NAME
+output_dir="sft/output/JOB:${JOB_ID}#${JOB_NAME}"
+mkdir -p "$output_dir"
+
+echo "output_dir: ${output_dir}"
+
+# Execute deepspeed command
+deepspeed \
+    --master_port=9944 \
+    sft/sft.py.py \
+    --deepspeed sft/ds_zero3_offload.json \
+    --model_name_or_path $base \
+    --tokenizer_name_or_path $tokenizer \
+    --do_train \
+    --save_safetensors true \
+    --data_path $train_data \
+    --lr_scheduler_type cosine \
+    --output_dir $output_dir \
+    --overwrite_output_dir \
+    --warmup_ratio 0.03 \
+    --gradient_checkpointing true \
+    --per_device_train_batch_size $bsz \
+    --gradient_accumulation_steps $acc \
+    --logging_steps 1 \
+    --learning_rate "$lr" \
+    --num_train_epochs 6 \
+    --save_strategy epoch \
+    --save_only_model true \
+    --model_max_length 30000 \
+    --save_total_limit 5 \
+    --bf16 || exit 1
+```
+
+
+
+### Eval
+
+```bash
+export CUDA_VISIBLE_DEVICES=0,1
+python -u inference/inference.py \
+    --dataset_name YOUR_DATASET_NAME \
+    --cache_dir_base cache \
+    --output_dir_base output \
+    --model_path "/path/to/your/reasoning_model" \
+    --summarization_model_path "/path/to/your/summarization_model" \
+    --summarization_model_url YOUR_SUMMARIZATION_MODEL_URL \
+    --google_subscription_key YOUR_KEY \
+    --google_endpoint "https://google.serper.dev/search" > output/output.log  2>&1
+```
+
+
+LLM as a Judge
+
+```bash
+python eval/gpt_eval.py
+```

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/cache/search_cache.json

@@ -0,0 +1,752 @@
+{
+  "东北大学沈阳 校长": {
+    "searchParameters": {
+      "q": "东北大学沈阳 校长",
+      "type": "search",
+      "num": 11,
+      "mkt": "en-US",
+      "setLang": "en",
+      "engine": "google"
+    },
+    "answerBox": {
+      "snippet": "冯夏庭，工学博士，教授，博士生导师，中国工程院院士。 现任东北大学党委副书记、校长。",
+      "snippetHighlighted": [
+        "冯夏庭"
+      ],
+      "title": "冯夏庭 - 东北大学",
+      "link": "https://www.neu.edu.cn/info/1012/3311.htm"
+    },
+    "organic": [
+      {
+        "title": "现任领导 - 东北大学",
+        "link": "https://www.neu.edu.cn/xygk/xrld.htm",
+        "snippet": "党委书记. 郭海 · 校长. 冯夏庭 · 学术委员会主任. 柴天佑 · 党委副书记. 孙正林 · 党委副书记、纪委书记. 吴豪伟 · 党委副书记. 张皓 · 副校长. 徐峰 · 副校长. 唐立新.",
+        "position": 1
+      },
+      {
+        "title": "东北大学(中国) - 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E4%B8%9C%E5%8C%97%E5%A4%A7%E5%AD%A6_(%E4%B8%AD%E5%9B%BD)",
+        "snippet": "东北大学主校区位于辽宁省沈阳 ... 张学良：奉系军阀领袖张作霖之长子，曾任中华民国陆军一级上将、东北保安军总司令、东北大学校长、东北大学名誉校长、哈尔滨工业大学名誉 ...",
+        "position": 2
+      },
+      {
+        "title": "历任领导 - 东北大学",
+        "link": "https://www.neu.edu.cn/xygk/lrld.htm",
+        "snippet": "历任领导 ; 王永江. ​1923年4月至1927年10月. 兼任东北大学校长 ; 刘尚清. 1927年11月至1928年8月. 兼任东北大学校长 ; 张学良. 1928年8月至1937年1月. 兼任东北大学校长.",
+        "position": 3
+      },
+      {
+        "title": "东北大学_百度百科",
+        "link": "https://baike.baidu.com/item/%E4%B8%9C%E5%8C%97%E5%A4%A7%E5%AD%A6/18014",
+        "snippet": "1928年8月，主政东北的张学良将军兼任东北大学校长。在他的领导下，学校明确了东北大学的办学宗旨、目的：“研究高深学术，培养专门人才，应社会之需要，谋文化之发展”。 ... 同年9 ...",
+        "position": 4
+      },
+      {
+        "title": "现任领导 - 东北大学秦皇岛分校",
+        "link": "https://www.neuq.edu.cn/xxgk1/xrld.htm",
+        "snippet": "赵勇，男，汉族，1973年5月生，辽宁沈阳人，1994年6月加入中国共产党，2001年5月参加工作，工学博士，教授，博士生导师。现任东北大学校长助理，秦皇岛分校党委副书记、校长。",
+        "position": 5
+      },
+      {
+        "title": "东北大学校友总会第七届校友代表大会召开 - 辽宁",
+        "link": "https://liaoning.eol.cn/lngd/202309/t20230918_2488289.shtml",
+        "snippet": "会议宣读并通过东北大学校友总会第七届理事会组成机构名单。校长冯夏庭担任会长，副校长孙雷、王辉担任副会长，理事会由海内外各地校友会代表和学校领导、 ...",
+        "date": "Sep 18, 2023",
+        "position": 6
+      },
+      {
+        "title": "东北大学、沈阳市高新区领导一行来我院调研交流",
+        "link": "https://nbidut.dlut.edu.cn/info/1018/28380.htm",
+        "snippet": "3月21日上午，东北大学校长助理刘延晖、沈阳市高新区科技创新局科技招商部部长敬亚豪等一行人来我院调研交流，我院院长郝海、副院长张博及相关部门负责人陪同调研。",
+        "position": 7
+      },
+      {
+        "title": "冯夏庭任东北大学校长 - 教育部",
+        "link": "http://www.moe.gov.cn/jyb_xwfb/gzdt_gzdt/s5987/202102/t20210202_512233.html",
+        "snippet": "冯夏庭，男，1964年9月生，1985年6月入党，1992年4月参加工作，东北工学院矿山建设工程专业博士研究生毕业，教授，中国工程院院士。2017年8月任东北大学党委常委 ...",
+        "date": "Feb 2, 2021",
+        "attributes": {
+          "Missing": "沈阳 | Show results with:沈阳"
+        },
+        "position": 8
+      },
+      {
+        "title": "党委副书记、校长：赵勇 - 东北大学秦皇岛分校",
+        "link": "https://www.neuq.edu.cn/info/1030/5850.htm",
+        "snippet": "赵勇，男，汉族，1973年5月生，辽宁沈阳人，1994年6月加入中国共产党，2001年5月参加工作，工学博士，教授，博士生导师。 现任东北大学校长助理，秦皇岛分校党委副书记、校长。",
+        "position": 9
+      },
+      {
+        "title": "东北大学校长赵继一行访问和平区政府 - 新闻中心- 中国教育在线",
+        "link": "https://news.eol.cn/dongtai/202004/t20200408_1720520.shtml",
+        "snippet": "近日，校长赵继、副校长唐立新一行访问沈阳市和平区政府，科学技术研究院相关负责人陪同访问。赵继一行与和平区区长马原就��进东北大学-三好街科技成果 ...",
+        "date": "Apr 8, 2020",
+        "position": 10
+      }
+    ],
+    "peopleAlsoAsk": [
+      {
+        "question": "东北大学相当于国内什么大学？",
+        "snippet": "东北大学在国内的排名相当于国内一流大学，如清华大学、北京大学、复旦大学、上海交通大学等。 东北大学的学术研究和教学水平也得到了国内外学者的认可，在国内外学术界享有盛誉。",
+        "title": "东北大学相当于国内哪个大学 - 指南者留学",
+        "link": "https://m.compassedu.hk/wb/153368"
+      },
+      {
+        "question": "大学校长属于什么级别？",
+        "snippet": "行政级别：正厅级（相当于厅长级）。",
+        "title": "举例说明各级别大学校长是什么行政级别？ - 网易",
+        "link": "https://www.163.com/dy/article/JQNUPF2K05364542.html"
+      },
+      {
+        "question": "东北大学在沈阳吗？",
+        "snippet": "学校坐落在东北中心城市辽宁省沈阳市，在沈阳市建有南湖校区、浑南校区和沈河校区，在秦皇岛市设有东北大学秦皇岛分校，在佛山市设有佛山研究生创新学院。 占地总面积264.6万平方米，建筑面积194万平方米。",
+        "title": "学校简介 - 东北大学",
+        "link": "https://www.neu.edu.cn/xygk/xxjj.htm"
+      },
+      {
+        "question": "中国东北大学是985大学吗？",
+        "snippet": "东北大学始建于1923年4月，是一所具有爱国主义光荣传统的大学，是国家首批“211工程”和“985工程”重点建设的教育部直属高校，2017年入选国家首轮世界一流大学建设高校，2022年入选国家第二轮“双一流”建设高校。",
+        "title": "学校简介-东北大学秦皇岛分校",
+        "link": "https://www.neuq.edu.cn/xxgk1/xxjj.htm"
+      }
+    ],
+    "relatedSearches": [
+      {
+        "query": "东北大学在哪"
+      },
+      {
+        "query": "东北大学排名"
+      },
+      {
+        "query": "中国东北大学qs排名"
+      },
+      {
+        "query": "沈阳东北大学"
+      },
+      {
+        "query": "东北大学 副校长"
+      },
+      {
+        "query": "东北大学软件学院"
+      },
+      {
+        "query": "东北大学电话"
+      },
+      {
+        "query": "东北大学邮编"
+      }
+    ],
+    "credits": 2
+  },
+  "北京市市长是谁": {
+    "searchParameters": {
+      "q": "北京市市长是谁",
+      "type": "search",
+      "num": 11,
+      "mkt": "en-US",
+      "setLang": "en",
+      "engine": "google"
+    },
+    "answerBox": {
+      "title": "Mayor of Beijing / Officeholder",
+      "answer": "Yin Yong"
+    },
+    "organic": [
+      {
+        "title": "殷勇_市长_首都之窗 - 北京市人民政府",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/sz/202210/t20221028_2847604.html",
+        "snippet": "殷勇，男，汉族，1969年8月生，研究生，工学博士，中共党员。现任二十届中央委员，十四届全国人大代表，北京市委副书记，市政府党组书记、市长。 工作分工. 领导市政府全面工作， ...",
+        "position": 1
+      },
+      {
+        "title": "殷勇(1969年) - 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E6%AE%B7%E5%8B%87_(1969%E5%B9%B4)",
+        "snippet": "殷勇（1969年8月—），男，湖北武汉人，清华大学自动控制和企业管理双学士，哈佛大学肯尼迪政府学院公共管理硕士、清华大学系统工程博士。中华人民共和国政治人物，长期在国家 ...",
+        "position": 2
+      },
+      {
+        "title": "北京市市长列表- 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E5%8C%97%E4%BA%AC%E5%B8%82%E5%B8%82%E9%95%BF%E5%88%97%E8%A1%A8",
+        "snippet": "彭真，1951年2月26日至1966年5月23日在任。1954年8月前为北京市人民政府市长，1954年8月后称北京市人民委员会市长。 · 吴德，1966年5月23日至1967年4月20日任北京市人民委员会 ...",
+        "position": 3
+      },
+      {
+        "title": "市领导_首都之窗_北京市人民政府门户网站",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/",
+        "snippet": "市委领导. 书记：尹力 ; 市人大常委会领导. 主任：李秀领. 齐静 ; 市政府领导. 市长：殷勇. 夏林茂 ; 市政协领导. 主席：魏小东. 崔述强 ...",
+        "attributes": {
+          "Missing": "是 | Show results with:是"
+        },
+        "sitelinks": [
+          {
+            "title": "殷勇",
+            "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/sz/202210/t20221028_2847604.html"
+          },
+          {
+            "title": "书记：尹力",
+            "link": "https://www.beijing.gov.cn/gongkai/sld/swld/swsj/202211/t20221113_2857628.html"
+          },
+          {
+            "title": "孙军民常委",
+            "link": "https://www.beijing.gov.cn/gongkai/sld/swld/swcw/202207/t20220701_2761151.html"
+          },
+          {
+            "title": "游钧副书记",
+            "link": "https://www.beijing.gov.cn/gongkai/sld/swld/swfsj/202502/t20250227_4020102.html"
+          }
+        ],
+        "position": 4
+      },
+      {
+        "title": "殷勇_百度百科",
+        "link": "https://baike.baidu.com/item/%E6%AE%B7%E5%8B%87/18433971",
+        "snippet": "殷勇，男，汉族，1969年8月生，湖北武汉人，1994年5月加入中国共产党，1997年1月参加工作，研究生毕业（清华大学系统工程专业），工学博士。现任第二十届中央委员，北京市委副书记 ...",
+        "position": 5
+      },
+      {
+        "title": "北京市人民政府_百度百科",
+        "link": "https://baike.baidu.com/item/%E5%8C%97%E4%BA%AC%E5%B8%82%E4%BA%BA%E6%B0%91%E6%94%BF%E5%BA%9C/8249521",
+        "snippet": "现任领导：第二十届中央委员，北京市委副书记，市人民政府市长、党组书记：殷勇。 北京市通州区运河东大街57号是目标地址。",
+        "position": 6
+      },
+      {
+        "title": "中共中央政治局委员、北京市委书记蔡奇调研清华大学并作报告",
+        "link": "https://www.tsinghua.edu.cn/info/1177/22525.htm",
+        "snippet": "清华新闻网11月28日电（记者赵姝婧）11月27日下午，中共中央政治局委员、北京市委书记蔡奇来到清华大学调研，并作主题为“贯彻落实习近平总书记对北京重要讲话精神，更加奋发有为 ...",
+        "position": 7
+      },
+      {
+        "title": "985校长，任北京市副市长！ - 学术桥",
+        "link": "https://www.acabridge.cn/news/202403/t20240329_2590696.shtml",
+        "snippet": "北京日报消息，3月29日上午，北京市十六届人大常委会第九次会议表决，决定任命马骏、穆鹏为北京市副市长。 公开资料显示，马骏，男，汉族，1969年4月出生， ...",
+        "date": "Mar 29, 2024",
+        "position": 8
+      },
+      {
+        "title": "北京历任市长 - 财经- 搜狐",
+        "link": "https://business.sohu.com/20040918/n222116317.shtml",
+        "snippet": "1949年迄今，北京先后有过13任市长，他们是：叶剑英、聂荣臻、彭真、吴德、谢富治、林乎加、焦若愚、陈希同、李其炎、贾庆林、刘淇、孟学农、王岐山。 叶剑英",
+        "date": "Sep 18, 2004",
+        "position": 9
+      },
+      {
+        "title": "北京党政领导人物库 - 地方经济",
+        "link": "http://district.ce.cn/zt/rwk/sf/bj/index.shtml",
+        "snippet": "北京 ; 尹力, 市委书记 ; 殷勇, 市委副书记、市长 ; 游钧, 市委副书记、组织部部长 ; 陈健, 市委常委、市纪委书记，市监委主任 ; 夏林茂, 市委常委、市政府党组副书记、副市长.",
+        "attributes": {
+          "Missing": "是 | Show results with:是"
+        },
+        "position": 10
+      }
+    ],
+    "images": [
+      {
+        "title": "殷勇_市长_首都之窗_北京市人民政府门户网站",
+        "imageUrl": "https://www.beijing.gov.cn/gongkai/sld/szfld/sz/202210/W020230119731299534682.jpg",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/sz/202210/t20221028_2847604.html"
+      },
+      {
+        "title": "市领导_首都之窗_北京市人民政府门户网站",
+        "imageUrl": "https://www.beijing.gov.cn/gongkai/sld/swld/swsj/202211/W020230119725612138202.jpg",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/"
+      },
+      {
+        "title": "蔡奇当选北京市长张硕辅当选北京市监察委主任-中国新闻网",
+        "imageUrl": "http://www.chinanews.com/2017/0120/2017120133457.jpg",
+        "link": "https://www.chinanews.com.cn/m/gn/2017/01-20/8130471.shtml"
+      },
+      {
+        "title": "孙硕_副市长_首都之窗_北京市人民政府门户网站",
+        "imageUrl": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202407/W020240726400551421724.jpg",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202407/t20240726_3760113.html"
+      },
+      {
+        "title": "马骏_副市长_首都之窗_北京市人民政府门户网站",
+        "imageUrl": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202403/W020240329560640219878.jpg",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202403/t20240329_3605299.html"
+      },
+      {
+        "title": "靳伟_副市长_首都之窗_北京市人民政府门户网站",
+        "imageUrl": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202011/W020230119737138365717.jpg",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/fsz/202011/t20201130_2153165.html"
+      },
+      {
+        "title": "殷勇当选北京市市长| 联合早报",
+        "imageUrl": "https://cassette.sphdigital.com.sg/image/zaobao/82cbc4ffc19f2f7229158de5188ce5475b6fcbbdfa63f765ea61c93373c4795d?o=zbimg&oloc=se",
+        "link": "https://www.zaobao.com.sg/realtime/china/story20230119-1354938"
+      },
+      {
+        "title": "殷勇(1969年) - 维基百科，自由的百科全书",
+        "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/e/ee/Ambassador_Burns_speaks_with_Beijing_Mayor_Yin_Yong.png",
+        "link": "https://zh.wikipedia.org/zh-cn/%E6%AE%B7%E5%8B%87_(1969%E5%B9%B4)"
+      },
+      {
+        "title": "薄熙来- 维基百科，自由的百科全书",
+        "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/8/80/Bo-_Ferrero-Waldner_meeting_%282007%29.jpg",
+        "link": "https://zh.wikipedia.org/zh-cn/%E8%96%84%E7%86%99%E6%9D%A5"
+      }
+    ],
+    "peopleAlsoAsk": [
+      {
+        "question": "市委书记和市长谁大？",
+        "snippet": "由于中华人民共和国政府各级行政机构实行党委负责制，市委书记是所在市的实际最高负责人，地位在市人大选出的市长之上。",
+        "title": "市委书记- 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-cn/%E5%B8%82%E5%A7%94%E6%9B%B8%E8%A8%98"
+      },
+      {
+        "question": "北京市区长是什么级别？",
+        "snippet": "区委书记低于市委书记，区长是一个区人民政府的最高领导人，其地位仅次于该区党委最高领导人区委书记，一般区长也兼任该区的区（县）委副书记，区长相当于县长。",
+        "title": "区委书记- 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-cn/%E5%8C%BA%E5%A7%94%E4%B9%A6%E8%AE%B0"
+      },
+      {
+        "question": "殷勇的背景是什么？",
+        "snippet": "殷勇是湖北武汉蔡甸人。 1987年，他考入清华大学自动化系。 1992年，殷勇本科毕业，被推荐到清华大学经济管理学院直接攻读博士学位，师从中国系统工程学科的开创人之一、清华大学工业自动化专业和系统工程专业创办者郑维敏教授，与中国人民银行原行长周小川师出同门。",
+        "title": "殷勇(1969年) - 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E6%AE%B7%E5%8B%87_(1969%E5%B9%B4)"
+      },
+      {
+        "question": "北京市有市长吗？",
+        "snippet": "市政府领导 殷勇，男，汉族，1969年8月生，研究生，工学博士，中共党员。 现任二十届中央委员，十四届全国人大代表，北京市委副书记，市政府党组书记、市长。",
+        "title": "殷勇_市长_首都之窗 - 北京市人民政府",
+        "link": "https://www.beijing.gov.cn/gongkai/sld/szfld/sz/202210/t20221028_2847604.html"
+      }
+    ],
+    "relatedSearches": [
+      {
+        "query": "北京市委书记"
+      },
+      {
+        "query": "北京市长什么级别"
+      },
+      {
+        "query": "北京市副市长被查"
+      },
+      {
+        "query": "北京市书记"
+      },
+      {
+        "query": "上海市长"
+      },
+      {
+        "query": "北京市政府"
+      },
+      {
+        "query": "北京市历任市长"
+      },
+      {
+        "query": "北京市前市长"
+      }
+    ],
+    "credits": 2
+  },
+  "纸牌屋 最终季首播年份": {
+    "searchParameters": {
+      "q": "纸牌屋 最终季首播年份",
+      "type": "search",
+      "num": 11,
+      "mkt": "en-US",
+      "setLang": "en",
+      "engine": "google"
+    },
+    "answerBox": {
+      "snippet": "《纸牌屋第二季》于2014年2月14日播出。 《纸牌屋第三季》于2015年2月27日播出。 《纸牌屋第四季》于2016年3月4日在美国播出，《纸牌屋第五季》于2017年5月30日在美国播出，最终季《纸牌屋第六季》于2018年11月2日在美国Netflix播出。",
+      "snippetHighlighted": [
+        "2018年11月2日"
+      ],
+      "title": "纸牌屋_百度百科",
+      "link": "https://baike.baidu.com/item/%E7%BA%B8%E7%89%8C%E5%B1%8B/75728"
+    },
+    "organic": [
+      {
+        "title": "纸牌屋第六季_百度百科",
+        "link": "https://baike.baidu.com/item/%E7%BA%B8%E7%89%8C%E5%B1%8B%E7%AC%AC%E5%85%AD%E5%AD%A3/22460232",
+        "snippet": "于2018年11月2日在美国Netflix播出。 讲述了美国政治家弗兰克·麦卡锡和他同样野心勃勃的妻子卡罗尔·麦卡锡在华盛顿特区白宫中运作权力的故事。 中文名. 纸牌屋第六季.",
+        "position": 1
+      },
+      {
+        "title": "纸牌屋(美国剧集) - 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E7%B4%99%E7%89%8C%E5%B1%8B_(%E7%BE%8E%E5%9C%8B%E5%8A%87%E9%9B%86)",
+        "snippet": "两部剧集都是基于迈克尔·多布斯同名小说创作的。第一季全部13集于2013年2月1日在流媒体网站奈飞首播。 ... 第二季的13集于2014年2月14日全部释出。 ... 2014年2月4日，即第二季 ...",
+        "position": 2
+      },
+      {
+        "title": "纸牌屋(第六季) - 维基百科",
+        "link": "https://zh.wikipedia.org/zh-hans/%E7%B4%99%E7%89%8C%E5%B1%8B_(%E7%AC%AC%E5%85%AD%E5%AD%A3)",
+        "snippet": "美国政治网络电视剧《纸牌屋》（英语：House of Cards）的第六季于2017年12月4日被Netflix续订，并安排于2018年11月2日播出。不同于之前由十三集组成的季度，第六季只有八集 ...",
+        "position": 3
+      },
+      {
+        "title": "纸牌屋第六季 - 抖音百科",
+        "link": "https://m.baike.com/wikiid/7714418908910672668",
+        "snippet": "《纸牌屋第六季》（House of Cards Season 6）是一部由奈飞公司（Netflix）出品的美国政治题材电视剧，是纸牌屋系列的最终季。该剧于2018年11月2日在美国Netflix播出，",
+        "position": 4
+      },
+      {
+        "title": "《纸牌屋》发布第六季片花女总统独挑最终季大梁",
+        "link": "https://www.huijiwiki.com/wiki/%E6%96%B0%E9%97%BB:2018/03/06/%E3%80%8A%E7%BA%B8%E7%89%8C%E5%B1%8B%E3%80%8B%E5%8F%91%E5%B8%83%E7%AC%AC%E5%85%AD%E5%AD%A3%E7%89%87%E8%8A%B1_%E5%A5%B3%E6%80%BB%E7%BB%9F%E7%8B%AC%E6%8C%91%E6%9C%80%E7%BB%88%E5%AD%A3%E5%A4%A7%E6%A2%81",
+        "snippet": "2013年，美剧《纸牌屋》的首播引起不小轰动，这部讲述美国政坛权力的游戏的剧集以其人性的深度刻画、揭露政坛的另一面和偶尔的黑色幽默桥段获得了无数人的 ...",
+        "date": "Mar 6, 2018",
+        "position": 5
+      },
+      {
+        "title": "纸牌屋第六季House of Cards Season 6 (2018) - 豆瓣电影",
+        "link": "https://movie.douban.com/subject/27185590//",
+        "snippet": "首播: 2018-11-02(美国) 集数: 8 单集片长: 55分钟 又名: 纸牌屋最终季/ 众议院要人/ House of Cards Final season IMDb: tt7538918. 豆瓣评分. 引用. 5.6. 18073人评价. 5 ...",
+        "rating": 5.6,
+        "ratingMax": 10,
+        "ratingCount": 18073,
+        "position": 6
+      },
+      {
+        "title": "捍卫自己的命运！Netflix放出《纸牌屋》最终季正式预告 - 机核",
+        "link": "https://www.gcores.com/articles/102742",
+        "snippet": "导语：今晚，Netflix 放出了《纸牌屋》最终季正式预告。本季剧集将于11月2日在官网全面上线。 《纸牌屋》最终季. 自2013年首播以来，由Netflix 出品的《纸牌屋》一直备受观众 ...",
+        "position": 7
+      },
+      {
+        "title": "纸牌屋_ 百科",
+        "link": "https://baike.weixin.qq.com/v167169186.htm?baike_inner=tv",
+        "snippet": "播出时间2018年11月2日. 集数13集. 剧情简介. 本季将是全剧季 ... 2018年7月4日，《纸牌屋》最终季发布了第二支宣传视频。 2018年8月，《纸牌屋》第六季发布最新剧照。",
+        "position": 8
+      },
+      {
+        "title": "Kevin Spacey 彻底“消失”，《纸牌屋》最终季将于2018 年开拍",
+        "link": "https://nowre.com/lifestyle/283319/kevin-spacey-chedi-xiaoshizhipaiwuzuizhongjijiangyu-2018-niankaipai/",
+        "snippet": "Kevin Spacey 彻底“消失”，《纸牌屋》最终季将于2018 年开拍 ... 第一夫人成为绝对主角。 Kevin Spacey 遭到Netflix 封杀后，《纸牌屋》的最终季何时才会启动 ...",
+        "date": "Dec 5, 2017",
+        "position": 9
+      },
+      {
+        "title": "弗兰克最后的结局- 喜马拉雅手机版",
+        "link": "https://m.ximalaya.com/ask/q11091050",
+        "snippet": "《纸牌屋第三季》于2015年2月27日播出。 《纸牌屋第四季》于2016年3月4日在美国播出《纸牌屋第五季》于2017年5月30日在美国播出，最终季《纸牌屋第六季》于 ...",
+        "date": "Nov 26, 2023",
+        "position": 10
+      }
+    ],
+    "peopleAlsoAsk": [
+      {
+        "question": "纸牌屋第六季弗兰克是怎么死的？",
+        "snippet": "在《纸牌屋》第六季的预告片中，显示安德伍德于2017年去世，他被安葬在位于南卡罗来纳州的父亲的墓旁。 该系列结局也显示，他的得力助手道格·斯坦普（迈克尔·凯利饰演）毒杀了他，以阻止他杀死不肯赦免自己的克莱尔。",
+        "title": "弗兰克·安德伍德 - 维基百科",
+        "link": "https://zh.wikipedia.org/zh-cn/%E5%BC%97%E5%85%B0%E5%85%8B%C2%B7%E5%AE%89%E5%BE%B7%E4%BC%8D%E5%BE%B7"
+      },
+      {
+        "question": "纸牌屋第六季有几集？",
+        "snippet": "美国政治网络电视剧《纸牌屋》（英语：House of Cards）的第六季于2017年12月4日被Netflix续订，并安排于2018年11月2日播出。 不同于之前由十三集组成的季度，第六季只有八集。 本季不会包括由于遭受性侵指控而被解雇的前主角凯文·史派西。",
+        "title": "纸牌屋(第六季) - 维基百科",
+        "link": "https://zh.wikipedia.org/zh-hans/%E7%B4%99%E7%89%8C%E5%B1%8B_(%E7%AC%AC%E5%85%AD%E5%AD%A3)"
+      },
+      {
+        "question": "纸牌屋完结了吗？",
+        "snippet": "《纸牌屋第六季》（House of Cards Season 6）是由奈飞公司（Netflix）出品的政治题材电视剧，是美剧《纸牌屋》系列的第六季，也是该系列最终季。",
+        "title": "纸牌屋第六季_百度百科",
+        "link": "https://baike.baidu.com/item/%E7%BA%B8%E7%89%8C%E5%B1%8B%E7%AC%AC%E5%85%AD%E5%AD%A3/22460232"
+      },
+      {
+        "question": "纸牌屋一共有几季？",
+        "snippet": "纸牌屋(美国剧集)\n纸牌屋 House of Cards\n\n国家／地区\n美国\n语言\n英语\n季数\n6\n集数\n73（每集列表）",
+        "title": "纸牌屋(美国剧集) - 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E7%B4%99%E7%89%8C%E5%B1%8B_(%E7%BE%8E%E5%9C%8B%E5%8A%87%E9%9B%86)"
+      }
+    ],
+    "relatedSearches": [
+      {
+        "query": "纸牌屋第七季"
+      },
+      {
+        "query": "纸牌屋第六季"
+      },
+      {
+        "query": "纸牌屋第一季"
+      },
+      {
+        "query": "纸牌屋第三季"
+      },
+      {
+        "query": "纸牌屋第五季"
+      },
+      {
+        "query": "纸牌屋弗兰克怎么死的"
+      },
+      {
+        "query": "纸牌屋第六季在线"
+      },
+      {
+        "query": "纸牌屋第二季"
+      }
+    ],
+    "credits": 2
+  },
+  "2018平昌冬奥会男子短道速滑500米破世界纪录运动员": {
+    "searchParameters": {
+      "q": "2018平昌冬奥会男子短道速滑500米破世界纪录运动员",
+      "type": "search",
+      "num": 11,
+      "mkt": "en-US",
+      "setLang": "en",
+      "engine": "google"
+    },
+    "answerBox": {
+      "snippet": "2018年2月，平昌冬奥短道速滑男子500米决赛，武大靖打破世界纪录并夺冠，为中国赢得平昌冬奥首枚金牌；2月25日，担任平昌冬奥会闭幕式中国代表团旗手；12月，被新华社体育部评为2018年国际十佳运动员。 2019年1月，任中国奥委会委员；9月，获第七届全国道德模范“全国敬业奉献模范”。",
+      "snippetHighlighted": [
+        "武大靖"
+      ],
+      "title": "武大靖_百度百科",
+      "link": "https://baike.baidu.com/item/%E6%AD%A6%E5%A4%A7%E9%9D%96/5383910"
+    },
+    "organic": [
+      {
+        "title": "武大靖- 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-hans/%E6%AD%A6%E5%A4%A7%E9%9D%96",
+        "snippet": "2018年平昌冬奥会，武大靖在男子500米预赛第一小组出场，并以40.264秒的成绩刷新奥运会纪录，在1/4决赛中又以39秒800打破2012年由杰·亚·塞斯基创下的世界记录，成为历史上第二 ...",
+        "position": 1
+      },
+      {
+        "title": "一天两破世界纪录！武大靖夺中国代表团平昌冬奥首金",
+        "link": "https://www.chinanews.com/m/ty/2018/02-22/8452267.shtml",
+        "snippet": "在平昌冬奥会短道速滑男子500米的决赛中，现世界排名第一的中国选手武大靖以创世界纪录的39秒584获得冠军。",
+        "date": "Feb 22, 2018",
+        "position": 2
+      },
+      {
+        "title": "武大靖击碎世界纪录历史新篇舍我其谁－2018平昌冬季奥运会",
+        "link": "https://www.sport.gov.cn/n4/n14896/n14902/c848367/content.html",
+        "snippet": "滑完半决赛后，我觉得体能已经耗尽了。”半决赛，武大靖的成绩只有40.087秒。 男子500米A组决赛在武大靖、加拿大人吉拉德以及两名韩国选手黄大恒、林孝俊之间 ...",
+        "date": "Feb 23, 2018",
+        "position": 3
+      },
+      {
+        "title": "再破世界纪录！武大靖豪取短道500米赛季三连冠 - 中国新闻网",
+        "link": "https://m.chinanews.com/wap/detail/chs/zw/8674553.shtml",
+        "snippet": "平昌奥运周期中，武大靖的速度不断跃升。2018年初，武大靖在平昌冬奥会短道速滑男子500米半决赛和决赛相继打破世界纪录，并最终夺魁，为中国短道队贡献了当届冬奥会上的唯一 ...",
+        "position": 4
+      },
+      {
+        "title": "平昌冬奥会短道速滑男子500米：武大靖破世界纪录夺冠【5】 - 人民网",
+        "link": "http://world.people.com.cn/n1/2018/0223/c1002-29830304-5.html",
+        "snippet": "2月22日晚，2018平昌冬奥会短道速滑男子500米决赛上演，中国选手武大靖一骑绝尘，没有给韩国队任何机会，以39秒584的成绩再次刷新自己刚创造的世界纪录和 ...",
+        "date": "Feb 23, 2018",
+        "position": 5
+      },
+      {
+        "title": "2018年冬季奥林匹克运动会短道速滑男子500米比赛 - 维基百科",
+        "link": "https://zh.wikipedia.org/zh-hans/2018%E5%B9%B4%E5%86%AC%E5%AD%A3%E5%A5%A5%E6%9E%97%E5%8C%B9%E5%85%8B%E8%BF%90%E5%8A%A8%E4%BC%9A%E7%9F%AD%E9%81%93%E9%80%9F%E6%BB%91%E7%94%B7%E5%AD%90500%E7%B1%B3%E6%AF%94%E8%B5%9B",
+        "snippet": "最终，由中国选手武大靖以破世界纪录的成绩夺冠，这是中国代表团在本届冬奥会上的首枚金牌及唯一一块金牌。 韩��选手黄大宪和林孝俊分获银牌和铜牌。",
+        "position": 6
+      },
+      {
+        "title": "燃爆！武大靖！一年两破世界纪录！ - China Daily",
+        "link": "http://china.chinadaily.com.cn/2018-11/12/content_37246243.htm",
+        "snippet": "2018年2月22日，平昌冬奥短道速滑男子500米决赛，武大靖以39秒584的成绩打破世界纪录强势夺冠，为中国赢得平昌冬奥首枚金牌，也是中国男子短道速滑队 ...",
+        "date": "Nov 12, 2018",
+        "position": 7
+      },
+      {
+        "title": "2018平昌冬奥会短道速滑男子500米：武大靖破世界纪录夺冠",
+        "link": "http://m.cnr.cn/jdt/20180223/t20180223_524141044.html",
+        "snippet": "2月22日晚，2018平昌冬奥会短道速滑男子500米决赛上演，中国选手武大靖一骑绝尘，没有给韩国队任何机会，以39秒584的成绩再次刷新自己刚创造的世界纪录和 ...",
+        "date": "Feb 23, 2018",
+        "position": 8
+      },
+      {
+        "title": "燃爆了！中国短道速滑名将武大靖一年两破世界纪录 - 央视网",
+        "link": "http://news.cctv.com/2018/11/12/ARTIkv6OahnNVbHJ3vk6szOt181112.shtml",
+        "snippet": "2018年2月22日，平昌冬奥短道速滑男子500米决赛，武大靖以39秒584的成绩打破世界纪录强势夺冠，为中国赢得平昌冬奥首枚金牌，也是中国男子短道速滑队在冬季 ...",
+        "date": "Nov 12, 2018",
+        "position": 9
+      },
+      {
+        "title": "武大靖两破500米世界纪录夺冠中国军团获本届冬奥首金 - 人民政协网",
+        "link": "https://www.rmzxw.com.cn/c/2018-02-23/1964457.shtml?n2m=1",
+        "snippet": "39. 584秒，当武大靖滑过终点时，他在今天第二次创造了短道速滑男子500米世界纪录，同时也为中国体育代表团带来了本届冬奥会的首枚金牌。",
+        "date": "Feb 23, 2018",
+        "position": 10
+      }
+    ],
+    "relatedSearches": [
+      {
+        "query": "武大靖老婆"
+      },
+      {
+        "query": "武大靖微博"
+      },
+      {
+        "query": "武大靖演戏"
+      },
+      {
+        "query": "武大靖滑雪"
+      },
+      {
+        "query": "武大靖噓國王在冬眠"
+      },
+      {
+        "query": "王濛"
+      },
+      {
+        "query": "武大靖王鶴棣"
+      },
+      {
+        "query": "许宏志"
+      }
+    ],
+    "credits": 2
+  },
+  "武大靖 2023年 客串电影 角色": {
+    "searchParameters": {
+      "q": "武大靖 2023年 客串电影 角色",
+      "type": "search",
+      "num": 11,
+      "mkt": "en-US",
+      "setLang": "en",
+      "engine": "google"
+    },
+    "organic": [
+      {
+        "title": "武大靖真实演绎自己，冰雪题材剧集《嘘，国王在冬眠》热播 - 大洋新闻",
+        "link": "https://news.dayoo.com/gzrbrmt/202503/18/170636_54800616.htm",
+        "snippet": "《嘘，国王在冬眠》邀请数十位运动员参与拍摄及动作指导，奥运冠军武大靖加盟客串。 除日常围读剧本外，开机前组织主要演员雪场集中训练，以冰雪运动传递年轻 ...",
+        "date": "Mar 18, 2025",
+        "position": 1
+      },
+      {
+        "title": "武大靖- 維基百科，自由的百科全書",
+        "link": "https://zh.wikipedia.org/zh-hant/%E6%AD%A6%E5%A4%A7%E9%9D%96",
+        "snippet": "2020 《我在北京等你》 (客串); 2020 《冰糖燉雪梨》 (客串); 2023 《志願軍：雄兵出擊》 (客串，飾演楊根思); 2025 《噓，國王在冬眠》(客串). 參考資料. 編輯. ^ 奥运冠军 ...",
+        "attributes": {
+          "Missing": "电影 角色"
+        },
+        "position": 2
+      },
+      {
+        "title": "[中国电影报道]武大靖客串出演《嘘，国王在冬眠》 推广冰雪运动",
+        "link": "https://tv.cctv.com/2025/03/24/VIDEVvydehAVIcsMWkgDnZxf250324.shtml",
+        "snippet": "武大靖客串出演《嘘，国王在冬眠》，推广冰雪运动。",
+        "date": "Mar 24, 2025",
+        "attributes": {
+          "Missing": "2023 | Show results with:2023"
+        },
+        "position": 3
+      },
+      {
+        "title": "我校在第六届“我心中的思政课”全国高校大学生 - 马克思主义学院2023",
+        "link": "https://www.bipt.edu.cn/pub/mkszyxy/jxky/zyzs/6880dd503dc746dfa74c27419b9ce8ed.htm",
+        "snippet": "马克思主义学院冷文勇、吴爱萍、李齐、李建华、武靖茗等五位老师指导微电影制作，王佳雨、黄蓝薇、王曦嘉、尹沛郁、肖一弓等17名学生参演了微电影，李齐老师客串了片中角色。",
+        "position": 4
+      },
+      {
+        "title": "虞书欣、林一甜蜜“撒糖”，《嘘，国王在冬眠》能否超越《难哄》？",
+        "link": "https://www.163.com/dy/article/JQD2B2Q7053469KC.html",
+        "snippet": "... 武大靖加盟客串。除日常围读剧本外，开机前组织主要演员雪场集中训练，响应“三亿人上冰雪”号召，以冰雪运动传递年轻人生活新方式。 服化道上，主创 ...",
+        "date": "Mar 11, 2025",
+        "position": 5
+      },
+      {
+        "title": "武大靖- 维基百科，自由的百科全书",
+        "link": "https://zh.wikipedia.org/zh-cn/%E6%AD%A6%E5%A4%A7%E9%9D%96",
+        "snippet": "武大靖（1994年7月24日—）黑龙江省佳木斯市人，中国男子短道速滑队运动员。短 ... 2023 《志愿军：雄兵出击》 (客串，饰演杨根思); 2025 《嘘，国王在冬眠》(客串) ...",
+        "attributes": {
+          "Missing": "电影 角色"
+        },
+        "position": 6
+      },
+      {
+        "title": "武大靖 - 抖音百科",
+        "link": "https://m.baike.com/wikiid/7158714449493901325",
+        "snippet": "武大靖，1994年7月24日出生于黑龙江省佳木斯市，中国男子短道速滑国家队运动员，短道速滑男子500米世界纪录、奥运纪录保持者、吉林省体育局冰上运动管理 ...",
+        "date": "Jan 5, 2025",
+        "position": 7
+      },
+      {
+        "title": "杨紫嫣_百度百科",
+        "link": "https://baike.baidu.hk/item/%E6%A5%8A%E7%B4%AB%E5%AB%A3/16926549",
+        "snippet": "杨紫嫣，1976年4月16日出生于北京，中国大陆演员，毕业于中央戏剧学院表演系。 1994年，因在武侠剧《书剑恩仇录》中饰演香香公主而出道。2011年，在宫廷剧《甄嬛传》中饰演 ...",
+        "position": 8
+      },
+      {
+        "title": "苏有朋_百度百科",
+        "link": "https://baike.baidu.com/item/%E8%8B%8F%E6%9C%89%E6%9C%8B/294596",
+        "snippet": "苏有朋，1973年9月11日出生于台湾省台北市，1991年，考入台湾大学机械工程系。中国台湾影视男演员、歌手、电影导演、制片人。1988年，作为小虎队最小成员“乖乖虎” ...",
+        "position": 9
+      }
+    ],
+    "images": [
+      {
+        "title": "专访丨奥运冠军武大靖：出演电视剧，台词都是真实经历- YouTube",
+        "imageUrl": "https://i.ytimg.com/vi/6fURJC8TrZg/sddefault.jpg",
+        "link": "https://www.youtube.com/watch?v=6fURJC8TrZg"
+      },
+      {
+        "title": "冰上逐梦18年，三战冬奥，两届夺金！专访中国男子短道速滑队运动员武大 ...",
+        "imageUrl": "https://i.ytimg.com/vi/tHmV4cE1QB4/maxresdefault.jpg",
+        "link": "https://www.youtube.com/watch?v=tHmV4cE1QB4"
+      },
+      {
+        "title": "武大靖是真的会飞檐走壁吧#全员加速中2023 #shorts 【咪咕MiGu官方频道 ...",
+        "imageUrl": "https://i.ytimg.com/vi/eoTf4yGkj68/maxres2.jpg?sqp=-oaymwEoCIAKENAF8quKqQMcGADwAQH4AbYIgAKAD4oCDAgAEAEYfyAvKC0wDw==&rs=AOn4CLAxiGqPg0b6eIs4XfxJZpFWANJImQ",
+        "link": "https://www.youtube.com/watch?v=eoTf4yGkj68"
+      },
+      {
+        "title": "中国电影报道]武大靖客串出演《嘘，国王在冬眠》 推广冰雪运动",
+        "imageUrl": "https://p4.img.cctvpic.com/fmspic/2025/03/24/4a9bc7d6a98c49f19af8dc3b01aa3d46-1.jpg",
+        "link": "https://tv.cctv.com/2025/03/24/VIDEVvydehAVIcsMWkgDnZxf250324.shtml"
+      },
+      {
+        "title": "武大靖“本色” 客串《嘘，国王在冬眠》，讲述真实经历(2025) 全集带字幕 ...",
+        "imageUrl": "http://m.iqiyipic.com/u2/image/20250317/7b/0e/pv_1086633913887100_d_601_480_270.jpg",
+        "link": "https://www.iq.com/album/%E6%AD%A6%E5%A4%A7%E9%9D%96-%E2%80%9C%E6%9C%AC%E8%89%B2%E2%80%9D-%E5%AE%A2%E4%B8%B2%E3%80%8A%E5%98%98-%E5%9B%BD%E7%8E%8B%E5%9C%A8%E5%86%AC%E7%9C%A0%E3%80%8B-%E8%AE%B2%E8%BF%B0%E7%9C%9F%E5%AE%9E%E7%BB%8F%E5%8E%86-2025-a5a0t1ao7k?lang=zh_cn"
+      },
+      {
+        "title": "冰糖炖雪梨》将开播武大靖客串盼推广冰雪运动_吉林频道_凤凰网",
+        "imageUrl": "http://x0.ifengimg.com/cmpp/2020_12/e67ed27d0acbf83_size66_w700_h465.jpg",
+        "link": "http://jl.ifeng.com/a/20200320/13953081_0.shtml"
+      },
+      {
+        "title": "榜样7》| 武大靖：冰上竞技当仁不让为国争光初心不改_共产党员网",
+        "imageUrl": "https://p5.img.cctvpic.com/photoworkspace/contentimg/2023/03/25/2023032519580742463.jpg",
+        "link": "https://www.12371.cn/2023/03/25/VIDE1679736123173822.shtml"
+      },
+      {
+        "title": "榜样7》| 武大靖：冰上竞技当仁不让为国争光初心不改_共产党员网",
+        "imageUrl": "https://p1.img.cctvpic.com/photoworkspace/contentimg/2023/03/25/2023032519582757793.jpg",
+        "link": "https://www.12371.cn/2023/03/25/VIDE1679736123173822.shtml"
+      },
+      {
+        "title": "武大靖真实演绎自己，冰雪题材剧集《嘘，国王在冬眠》热播_广州日报大洋网",
+        "imageUrl": "https://dayooimg.dayoo.com/gzrbrmt/img/202503/18/54800616_e6fb6d55-cfef-4af8-816c-041df8bbe3aa.jpg",
+        "link": "https://news.dayoo.com/gzrbrmt/202503/18/170636_54800616.htm"
+      }
+    ],
+    "relatedSearches": [
+      {
+        "query": "Ren Ziwei"
+      },
+      {
+        "query": "武大靖退役"
+      },
+      {
+        "query": "武大靖結婚"
+      },
+      {
+        "query": "武大靖客串"
+      },
+      {
+        "query": "武大靖滑雪"
+      },
+      {
+        "query": "韓天宇"
+      },
+      {
+        "query": "乘風破浪 2023"
+      },
+      {
+        "query": "中國 冬 奧運 動員"
+      },
+      {
+        "query": "王 濛 綜藝"
+      }
+    ],
+    "credits": 2
+  }
+}

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/SimpleDeepSearcher_demo.py

@@ -0,0 +1,899 @@
+# === 标准库导入（Python 内置模块） ===
+import argparse
+import asyncio
+import json
+import logging
+import multiprocessing
+import os
+import re
+import string
+import time
+from functools import partial
+from logging.handlers import RotatingFileHandler
+from typing import Optional, Tuple, List, Dict
+
+# === 第三方库 ===
+import httpx
+import numpy as np
+import streamlit as st
+import torch
+from tqdm import tqdm
+from urllib.parse import urlparse
+# === 第三方 Transformers & vLLM ===
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+from google_search import (
+    google_web_search, 
+    extract_relevant_info, 
+    fetch_page_content, 
+    extract_snippet_with_context
+)
+# from evaluate import (
+#     run_evaluation, 
+#     run_evaluation_for_eval,
+#     extract_answer
+# )
+from prompts import (
+    get_multiqa_instruction,
+    get_math_instruction,
+    get_task_instruction_openqa,
+    get_task_instruction_math,
+    get_webpage_to_reasonchain_instruction
+)
+from openai import OpenAI
+
+from stage_wise_analysis import stage_wise_analysis
+
+# Define special tokens
+BEGIN_SEARCH_QUERY = "<|begin_search_query|>"
+END_SEARCH_QUERY = "<|end_search_query|>"
+BEGIN_SEARCH_RESULT = "<|begin_search_result|>"
+END_SEARCH_RESULT = "<|end_search_result|>"
+
+
+
+# 应用标题
+TITLE = "Chat with LLM"
+
+# 设置 Streamlit 页面配置
+st.set_page_config(page_title=TITLE, layout="wide", initial_sidebar_state="collapsed")
+
+
+
+def tokenize_prompt(history, query, model_path, multi_turn=False):
+    messages = []
+    if multi_turn:
+        for q, r in history:
+            messages.append({"role": "user", "content": q})
+            messages.append({"role": "assistant", "content": r})
+    messages.append({"role": "user", "content": query})
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    return tokenizer.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+# 配置日志
+def setup_logging(log_file):
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            RotatingFileHandler(log_file, maxBytes=1024 * 1024 * 5, backupCount=5),  # 日志文件最大 5MB，保留 5 个备份
+            logging.StreamHandler(),  # 同时输出到控制台
+        ],
+    )
+
+
+def display_chat(chat):
+    with st.chat_message("user", avatar=chat["avatar"]):
+        st.markdown(chat["input"], unsafe_allow_html=True)
+    column_list = st.columns(len(chat["response"]))
+    for i, (column, response) in enumerate(zip(column_list, chat["response"])):
+        with column:
+            st.header(response["model"])
+            with st.chat_message("assistant", avatar=response["avatar"]):
+                st.markdown(response["text"], unsafe_allow_html=True)
+
+def extract_answer(output, mode='gen'):
+    extracted_text = ''
+    if output is None:
+        output = "None"
+    if mode == 'codegen':
+        # Extract the code between ```python and ```
+        pattern = r'```python\s*(.*?)\s*```'
+        matches = re.findall(pattern, output, re.DOTALL | re.IGNORECASE)
+        if matches:
+            extracted_text = matches[-1].strip()  # Take the last match
+    elif mode == 'infogen': # 提取模型基于网页内容生成的推理
+        # Extract content after **Final Information** or **Modified Reasoning Steps**
+        # pattern_info = "\n**Final Information**"
+        # pattern_step = "\n**Modified Reasoning Steps**"
+        pattern_info = "**Final Information**"
+        pattern_step = "**Modified Reasoning Steps**"
+        if pattern_info in output:
+            extracted_text = output.split(pattern_info)[-1].replace("\n","").strip("```").strip()
+        elif pattern_step in output:
+            extracted_text = output.split(pattern_step)[-1].strip("```").strip()
+        else:
+            # extracted_text = "No helpful information found."
+            extracted_text = output
+    else:
+        # Existing extraction logic for 'gen' and 'choose' modes
+        pattern = r'\\boxed\{(.*)\}'
+        matches = re.findall(pattern, output)
+        if matches:
+            extracted_text = matches[-1]  # Take the last match
+            if mode in ['choose', 'qa']:
+                # Handle 'choose' mode
+                inner_pattern = r'\\text\{(.*)\}'
+                inner_matches = re.findall(inner_pattern, extracted_text)
+                if inner_matches:
+                    extracted_text = inner_matches[-1]  # Take the last match
+                extracted_text = extracted_text.strip("()")
+    return extracted_text
+
+# def generate_favicon_html(urls):
+#     favicons = []
+#     for url in urls:
+#         domain = urlparse(url).netloc
+#         favicon_url = f"https://{domain}/favicon.ico"
+#         favicons.append(f'<img src="{favicon_url}" width="16" style="margin-right:4px;">')
+#     return "**🌐 Fetching web pages:** " + "".join(favicons)
+
+def generate_favicon_html(urls):
+    favicons = []
+    for url in urls:
+        domain = urlparse(url).netloc
+        # 使用 Google 的 S2 Favicon 服务
+        # sz=16 表示获取 16x16 大小的图标
+        favicon_service_url = f"https://www.google.com/s2/favicons?domain={domain}&sz=16"
+        favicons.append(f'<img src="{favicon_service_url}" width="16" style="margin-right:4px;" alt=" " onerror="this.style.display=\'none\'">')
+    return "**🌐 Fetching web pages:** " + "".join(favicons)
+
+def webpage_analysis_single(summ_model_url, summ_model_path, prompt) -> str:
+    client_summ_model = OpenAI(
+        base_url=summ_model_url,
+        api_key="EMPTY"
+    )
+    for i in range(10): # max retry 10 times
+        try:
+            completion = client_summ_model.chat.completions.create(
+                model=summ_model_path,
+                max_tokens=8192,
+                temperature=0.6,
+                top_p=0.95,
+                messages=[prompt],
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            logging.info(e)
+            time.sleep(1)
+            continue
+    return "None"
+
+
+
+async def fetch_model_response(widget, history, question, model_config, response_dict, **kwargs):
+    filtered_data = [{"Question": question, "Answer": ""}]
+
+    # temperature = args.temperature
+    # top_p = args.top_p
+    # top_k_sampling = args.top_k_sampling
+    # max_tokens = args.max_tokens
+
+
+    dataset_name = "user_queries"
+    subset_num = -1
+    MAX_SEARCH_LIMIT = 10
+    MAX_TURN = 15
+    top_k = 10
+    max_doc_len = 3000
+    summ_model_path = "/capacity/userdata/models/QwQ-32B"
+    summ_model_url = "http://localhost:8003/v1"
+    google_subscription_key = "cb0d28279a826d7e5cf22d71f683c77ffd4ba27d"
+    google_endpoint = "https://google.serper.dev/search"
+    cache_dir = "../cache"
+    output_dir = "output"
+    is_exclude_urls = False
+    max_tokens = 20480
+
+
+    search_cache_path = os.path.join(cache_dir, 'search_cache.json')
+    url_cache_path = os.path.join(cache_dir, 'url_cache.json')
+    with open(search_cache_path, 'r', encoding='utf-8') as f:
+        search_cache = json.load(f)
+    with open(url_cache_path, 'r', encoding='utf-8') as f:
+        url_cache = json.load(f)
+    
+    widget_output = ""
+
+
+    # Function to save caches
+    def save_caches():
+        with open(search_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(search_cache, f, ensure_ascii=False, indent=2)
+        with open(url_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(url_cache, f, ensure_ascii=False, indent=2)
+    
+    def generate_webpage_to_reasonchain_batch(
+        original_questions: List[str],
+        prev_reasonings: List[str],
+        search_queries: List[str],
+        documents: List[str],
+        summ_model_url: OpenAI,
+        summ_model_path: str,
+        batch_output_records: List[Dict],  # New parameter to collect outputs
+        coherent: bool = False,
+    ) -> List[str]:
+
+        user_prompts = [
+            get_webpage_to_reasonchain_instruction(r, sq, doc)
+            for r, sq, doc in zip(prev_reasonings, search_queries, documents)
+        ]
+
+        logging.info(f"generate_webpage_to_reasonchain_batch, len(user_prompts): {len(user_prompts)}")
+        prompts = [{"role": "user", "content": up} for up in user_prompts]
+        logging.info("webpage ana prompts[0]")
+        logging.info(prompts[0])
+
+        raw_outputs = []
+        
+        for prompt in prompts:
+            raw_output = webpage_analysis_single(summ_model_url, summ_model_path, prompt)
+            raw_outputs.append(raw_output)
+        # webpage_analysis_single_to_map = partial(webpage_analysis_single, summ_model_url, summ_model_path)
+        # with multiprocessing.Pool(processes=10) as pool:
+        #     raw_outputs = list(tqdm(pool.imap(webpage_analysis_single_to_map, prompts), total=len(prompts), desc="generate webpage analyses"))
+
+
+        # Count the number of summarization errors
+        sum_error = 0
+        for output in raw_outputs:
+            if output is None or output == "None" or output == "":
+                sum_error += 1
+        logging.info(f"summarization_error: {sum_error}, ratios: {sum_error / len(raw_outputs)}")
+     
+        extracted_infos = [extract_answer(raw, mode='infogen') for raw in raw_outputs]
+
+        for i, (p, r, e) in enumerate(zip(prompts, raw_outputs, extracted_infos)):
+            batch_output_records.append({
+                'prompt': p,
+                'raw_output': r,
+                'extracted_info': e
+            })
+
+        
+
+        return extracted_infos
+
+    # ---------------------- Preparation of Input Prompts ----------------------
+    input_list = []
+    for item in filtered_data:
+        question = item['Question']
+
+        if dataset_name in ['aime']:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_math(question)
+
+        else:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_openqa(question)
+            
+        
+        # prompt = [{"role": "user", "content": instruction + user_prompt}]
+        prompt = instruction + user_prompt
+        prompt = tokenize_prompt(history, prompt, model_config['model_path'], multi_turn=True)
+        # prompt = tokenizer.apply_chat_template(prompt, tokenize=False, add_generation_prompt=True)
+        input_list.append(prompt)
+        logging.info(f"Input prompt for question '{question}':\n {prompt}")
+
+    # Initialize active sequences
+    active_sequences = [{
+        'item': item,
+        'prompt': prompt,
+        'output': '',
+        'finished': False,
+        'history': [],
+        'search_count': 0,
+        'executed_search_queries': set(),
+        'all_info': [],
+    } for item, prompt in zip(filtered_data, input_list)]
+
+    async def run_generation(sequences: List[Dict], max_tokens: int, turn: int) -> List:
+        prompts = [s['prompt'] for s in sequences]
+        headers = {"User-Agent": "Test Client"}
+        payload = {
+            "prompt": prompts[0],
+            "max_tokens": max_tokens,
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "top_k": 40,
+            "stop":[END_SEARCH_QUERY, "<|im_end|>"],
+            "include_stop_str_in_output": True,
+            "stream": True,
+        }
+        payload.update(kwargs)
+        logging.debug(f"Sending request to model: {model_config['model_name']}")
+        logging.debug(f"Request payload: {payload}")  
+        client = httpx.AsyncClient()
+        async with client.stream(
+            "POST", model_config["api_url"], headers=headers, json=payload
+        ) as response:
+            output_final = ""
+        
+            async for chunk in response.aiter_bytes(): # 1,2,3
+                if chunk:
+                    try:
+                        data = json.loads(chunk.decode("utf-8").rstrip("\x00"))
+                        output = data["text"][0][len(prompts[0]) :]
+                        # logging.info(f"output11111: {output}")
+                        # widget_output += output
+                        if widget_output == "":
+                            widget.markdown(f"**✨ Reasoning {turn}:** " + output, unsafe_allow_html=True)
+                        else:
+                            widget.markdown(widget_output + f"\n**✨ Reasoning {turn}:** " + output, unsafe_allow_html=True)
+                        output_final = output
+                        # output_buffer += output
+                    except json.JSONDecodeError as e:
+                        # logging.error(f"Attention!: JSON decode error: {e}, chunk: {chunk}")
+                        continue
+            
+            return [output_final]
+    
+
+
+    # Function to extract text between two tags
+    def extract_between(text: str, start_tag: str, end_tag: str) -> Optional[str]:
+        pattern = re.escape(start_tag) + r"(.*?)" + re.escape(end_tag)
+        matches = re.findall(pattern, text, flags=re.DOTALL)
+        if matches:
+            return matches[-1].strip()
+        return None
+
+    def replace_recent_steps(origin_str, replace_str):
+        """
+        Replaces specific steps in the original reasoning steps with new steps.
+        If a replacement step contains "DELETE THIS STEP", that step is removed.
+
+        Parameters:
+        - origin_str (str): The original reasoning steps.
+        - replace_str (str): The steps to replace or delete.
+
+        Returns:
+        - str: The updated reasoning steps after applying replacements.
+        """
+
+        def parse_steps(text):
+            """
+            Parses the reasoning steps from a given text.
+
+            Parameters:
+            - text (str): The text containing reasoning steps.
+
+            Returns:
+            - dict: A dictionary mapping step numbers to their content.
+            """
+            step_pattern = re.compile(r"Step\s+(\d+):\s*")
+            steps = {}
+            current_step_num = None
+            current_content = []
+
+            for line in text.splitlines():
+                step_match = step_pattern.match(line)
+                if step_match:
+                    # If there's an ongoing step, save its content
+                    if current_step_num is not None:
+                        steps[current_step_num] = "\n".join(current_content).strip()
+                    current_step_num = int(step_match.group(1))
+                    content = line[step_match.end():].strip()
+                    current_content = [content] if content else []
+                else:
+                    if current_step_num is not None:
+                        current_content.append(line)
+            
+            # Save the last step if any
+            if current_step_num is not None:
+                steps[current_step_num] = "\n".join(current_content).strip()
+            
+            return steps
+
+        # Parse the original and replacement steps
+        origin_steps = parse_steps(origin_str)
+        replace_steps = parse_steps(replace_str)
+
+        # Apply replacements
+        for step_num, content in replace_steps.items():
+            if "DELETE THIS STEP" in content: 
+                # Remove the step if it exists
+                if step_num in origin_steps:
+                    del origin_steps[step_num]
+            else:
+                # Replace or add the step 
+                origin_steps[step_num] = content
+
+        # Sort the steps by step number
+        sorted_steps = sorted(origin_steps.items())
+
+        # Reconstruct the reasoning steps as a single string
+        new_reasoning_steps = "\n\n".join([f"{content}" for num, content in sorted_steps])
+
+        return new_reasoning_steps
+
+
+    # ---------------------- Initialize Collection Structure ----------------------
+    # Initialize a list to collect batch outputs
+    batch_output_records = []
+
+    start_time = time.time()
+    turn = 0
+
+    # Main loop until all sequences are finished or maximum turns reached
+    while True:
+        # Identify sequences that need generation
+        sequences_needing_generation = [seq for seq in active_sequences if not seq['finished']]
+
+        if sequences_needing_generation:
+            turn += 1
+            logging.info(f'\n-------------- Turn {turn} --------------')
+            logging.info(f"We have {len(sequences_needing_generation)} sequences needing generation...")
+            outputs = await run_generation(sequences_needing_generation, max_tokens, turn)
+            if widget_output == "":
+                widget_output += f"**✨ Reasoning {turn}:** " + outputs[0] 
+            else:
+                widget_output += f"\n**✨ Reasoning {turn}:** " + outputs[0]  # Append the first output to widget_output
+            widget.markdown(widget_output, unsafe_allow_html=True)
+            logging.info("Generation completed, processing outputs...")
+
+            # Initialize batch variables
+            batch_relevant_info = []
+            batch_original_questions = []
+            batch_prev_reasonings = []
+            batch_search_queries = []
+            batch_documents = []
+            batch_sequences = []
+
+            # Collect URLs to fetch across all sequences
+            all_urls_to_fetch = set()
+            url_snippets = {}
+            url_sequence_map = {}  # Map URL to list of sequences needing it
+
+            start_search_time = time.time()
+            # Process each sequence and collect URLs
+            for seq, out in zip(sequences_needing_generation, outputs):
+                text = out
+                seq['history'].append(text)
+                # Append generated text to prompt and output
+                seq['prompt'] += text
+                seq['output'] += text
+                seq['all_info'].append({f"turn_{turn}_reason": text})
+                # Extract search query
+                search_query = extract_between(text, BEGIN_SEARCH_QUERY, END_SEARCH_QUERY)
+
+                # If a search query is present and needs to be executed
+                if search_query and seq['output'].rstrip().endswith(END_SEARCH_QUERY):
+                    if seq['search_count'] < MAX_SEARCH_LIMIT and search_query not in seq['executed_search_queries']:
+                        # Execute search, use cache if available
+                        if search_query in search_cache:
+                            results = search_cache[search_query]
+                            logging.info(f"Using cached search results for query: \"{search_query}\"")
+                        else:
+                            try:
+                                if is_exclude_urls and "urls" in seq["item"]["metadata"]: 
+                                    logging.info(f"is_exclude_urls: {is_exclude_urls}")
+                                    exclude_urls = seq["item"]["metadata"]["urls"]
+                                else:
+                                    exclude_urls = []
+
+                                logging.info(f"Execute and cache search for query: \"{search_query}\"")
+
+                                # 更新输出
+                                widget_output += f"\n\n**🔍 Executing search for query:** {search_query}\n"
+                                widget.markdown(widget_output, unsafe_allow_html=True)
+
+                                results = google_web_search(search_query, google_subscription_key, google_endpoint, market='en-US', language='en', exclude_urls=exclude_urls) # 执行搜索
+                                search_cache[search_query] = results
+                                logging.info(f"Executed and cached search for query: \"{search_query}\"")
+                            except Exception as e:
+                                logging.info(f"Error during search query '{search_query}': {e}")
+                                search_cache[search_query] = {}
+                                results = {}
+
+                        # Extract relevant information from Bing search results
+                        relevant_info = extract_relevant_info(results)[:top_k]
+                        seq['relevant_info'] = relevant_info
+
+                        # Extract URLs and snippets
+                        urls_to_fetch = [it['url'] for it in relevant_info]
+
+                        ## 更新网页
+                        widget_output += "\n\n" + generate_favicon_html(urls_to_fetch) + "\n"
+                        widget.markdown(widget_output, unsafe_allow_html=True)
+
+                        snippets = {info['url']: info['snippet'] for info in relevant_info if 'snippet' in info}
+
+                        # Filter URLs that are not cached
+                        urls_to_fetch_filtered = [u for u in urls_to_fetch if u not in url_cache]
+                        cached_urls = [u for u in urls_to_fetch if u in url_cache]
+
+                        # Store info for all_urls_to_fetch and url_snippets
+                        for url in urls_to_fetch_filtered:
+                            all_urls_to_fetch.add(url)
+                            url_snippets[url] = snippets.get(url, "") 
+
+                        all_reasoning_steps = seq['output']
+                        all_reasoning_steps = all_reasoning_steps.replace('\n\n', '\n').split("\n")
+
+                        truncated_prev_reasoning = ""
+                        for i, step in enumerate(all_reasoning_steps):
+                            truncated_prev_reasoning += f"Step {i + 1}: {step}\n\n"
+
+                        prev_steps = truncated_prev_reasoning.split('\n\n')
+                        if len(prev_steps) <= 5:
+                            truncated_prev_reasoning = '\n\n'.join(prev_steps)
+                        else:
+                            truncated_prev_reasoning = ''
+                            for i, step in enumerate(prev_steps):
+                                if i == 0 or i >= len(prev_steps) - 4 or BEGIN_SEARCH_QUERY in step or BEGIN_SEARCH_RESULT in step:
+                                    truncated_prev_reasoning += step + '\n\n'
+                                else:
+                                    if truncated_prev_reasoning[-len('\n\n...\n\n'):] != '\n\n...\n\n':
+                                        truncated_prev_reasoning += '...\n\n'
+                        truncated_prev_reasoning = truncated_prev_reasoning.strip('\n')
+
+                        # Collect parameters for batch processing
+                        batch_relevant_info.append(relevant_info)
+                        batch_original_questions.append(seq['item']['Question'])
+                        batch_prev_reasonings.append(truncated_prev_reasoning)
+                        batch_search_queries.append(search_query)
+                        batch_sequences.append(seq)
+
+                        # Update search count and executed queries
+                        seq['search_count'] += 1
+                        seq['executed_search_queries'].add(search_query)
+
+                    elif seq['search_count'] >= MAX_SEARCH_LIMIT:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nThe maximum search limit is exceeded. You are not allowed to search.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        logging.info(f"Search limit reached for query: \"{search_query}\"")
+
+                    elif search_query in seq['executed_search_queries']:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nYou have searched this query. Please refer to previous results.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        logging.info(f"Repeated search for query: \"{search_query}\"")
+                        
+
+                else:
+                    # If no search query needs to be executed, mark the sequence as finished
+                    seq['finished'] = True
+                    logging.info("Sequence marked as complete.")
+
+            logging.info(f"get search time taken: {time.time() - start_search_time}")
+            logging.info(f"all_urls_to_fetch len: {len(all_urls_to_fetch)}, url_cache len: {len(url_cache)}")
+            logging.info(f"all_urls_to_fetch: {all_urls_to_fetch}")
+            # Batch fetch all URLs at once to optimize speed
+            
+            if all_urls_to_fetch:
+                logging.info(f"Fetching {len(all_urls_to_fetch)} URLs...")
+                try:
+                    fetched_contents = fetch_page_content(
+                        list(all_urls_to_fetch),
+                        use_jina=False,
+                        jina_api_key=None,
+                        # snippets=url_snippets  # Do not pass snippets when updating url_cache directly
+                    )
+                    logging.info(f"Fetched {len(fetched_contents)} URLs successfully.")
+                except Exception as e:
+                    logging.info(f"Error during batch URL fetching: {e}")
+                    fetched_contents = {url: f"Error fetching URL: {e}" for url in all_urls_to_fetch}
+                # Update cache with fetched contents
+                for url, content in fetched_contents.items():
+                    url_cache[url] = content
+
+            # After fetching, prepare formatted documents for batch processing
+            for relevant_info in batch_relevant_info:
+                formatted_documents = ""
+                for i, doc_info in enumerate(relevant_info):
+                    url = doc_info['url']
+                    raw_context = url_cache.get(url, "")
+                    doc_info['snippet'] = doc_info['snippet'].replace('<b>','').replace('</b>','')            
+                    success, filtered_context = extract_snippet_with_context(raw_context, doc_info['snippet'], context_chars=max_doc_len)
+                    if success:
+                        logging.info("extract_snippet_with_context")
+                        context = filtered_context
+                    else: 
+                        logging.info(f"use raw_webpage_context, {len(raw_context)}")
+                        context = raw_context[:max_doc_len*2]
+
+                    doc_info['context'] = context
+                    formatted_documents += f"**Web Page {i + 1}:**\n"
+                    formatted_documents += json.dumps(doc_info, ensure_ascii=False, indent=2) + "\n"
+                logging.info(f'formatted_webpage_documents: {len(formatted_documents)}')
+                batch_documents.append(formatted_documents)
+
+            # After fetching, prepare for batch processing if there are any
+            if batch_sequences:
+                logging.info(f"Batch processing {len(batch_sequences)} sequences with generate_webpage_to_reasonchain_batch...")
+                webpage_analyses = generate_webpage_to_reasonchain_batch(
+                    original_questions=batch_original_questions,
+                    prev_reasonings=batch_prev_reasonings,
+                    search_queries=batch_search_queries,
+                    documents=batch_documents,
+                    summ_model_url=summ_model_url,
+                    summ_model_path=summ_model_path,
+                    batch_output_records=batch_output_records,  # Pass the collection list
+                )
+                logging.info("Batch generation completed, assigning outputs to sequences...")
+
+                for seq, analysis,doc in zip(batch_sequences, webpage_analyses, batch_documents): 
+                    ## 更新输出
+                    widget_output += f"\n**📄Web Pages Summary Results:**\n{analysis}\n"
+                    widget.markdown(widget_output, unsafe_allow_html=True)
+                    if isinstance(analysis, str):
+                        append_text = f"\n\n{BEGIN_SEARCH_RESULT}{analysis}{END_SEARCH_RESULT}\n\n"
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text) 
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+                    else:
+                        append_text = replace_recent_steps(seq['output'], analysis)
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text)
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+
+        # Check if all sequences are finished
+        active_sequences_part = [{
+            'item': ele["item"],
+            'prompt': ele['prompt'],
+            'output': ele["output"],
+            'finished': ele["finished"],
+            'history':ele["history"],
+            'search_count': ele["search_count"],
+            'all_info': ele['all_info']
+        } for ele in active_sequences]
+        # with open(os.path.join(output_dir, f"turn_{turn}.json"), 'w', encoding='utf-8') as f:
+        #     json.dump(active_sequences_part, f, ensure_ascii=False, indent=2)
+        unfinished = [seq for seq in active_sequences if not seq['finished']]
+        if not unfinished:
+            break
+        else:
+            if turn >= MAX_TURN:
+                logging.info(f"Maximum number of turns ({MAX_TURN}) reached, stopping.")
+                break
+
+    total_time = time.time() - start_time
+    logging.info(f"Total time taken: {total_time} seconds")
+
+    # # ---------------------- Save Batch Output Records to JSON File ----------------------
+    # # Define output JSON file path
+    # t = time.localtime()
+    # batch_output_file = os.path.join(output_dir, f'test.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.info_extract.json')
+
+    # # Save batch_output_records to JSON file
+    # with open(batch_output_file, 'w', encoding='utf-8') as f:
+    #     json.dump(batch_output_records, f, ensure_ascii=False, indent=2)
+
+    # logging.info(f"Batch outputs saved to {batch_output_file}")
+
+    # Prepare output list for evaluation
+    output_list = [seq['output'] for seq in active_sequences]
+
+    response_dict["text"] = widget_output# Update the response dictionary with the first output
+
+    # # Run evaluation
+    # if dataset_name in ["eval", "gaia"]:
+    #     run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+    # else:
+    #     run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+
+    # # ---------------------- Stage-wise Analysis ----------------------
+    # turn_files = os.listdir(output_dir)
+    # turn_files = [file for file in turn_files if file.startswith("turn_")]
+    # max_turn_file = max(turn_files, key=lambda x: int(re.search(r'turn_(\d+)', x).group(1)))
+
+    # max_turn_file_path = os.path.join(output_dir, max_turn_file)
+    # logging.info(f"max_turn_file_path: {max_turn_file_path}")
+    # stage_wise_analysis(model_path, max_turn_file_path)
+
+    # ---------------------- Update Search and URL Cache ----------------------
+    logging.info('Updating Search and URL Cache...')
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try:
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache_new = json.load(f)
+        except Exception as e:
+            logging.info(f"Error loading search cache: {e}")
+            search_cache_new = {}
+    else:
+        search_cache_new = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache_new = json.load(f)
+        except Exception as e:
+            logging.info(f"Error loading url cache: {e}")
+            url_cache_new = {}
+    else:
+        url_cache_new = {}
+
+    search_cache.update(search_cache_new)
+    url_cache.update(url_cache_new)
+
+    save_caches()
+
+    logging.info("Process completed.")
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--config",
+        "-c",
+        type=str,
+        default="./demo_client_basic.json",
+        help="path to configs",
+    )
+    parser.add_argument(
+        "--user_avatar",
+        "-a",
+        type=str,
+        default="./user_demo.png",
+        help="path to user avatar",
+    )
+    parser.add_argument(
+        "--log",
+        "-l",
+        type=str,
+        default=f"./chatweb.log",
+        help="path to logs",
+    )
+    return parser.parse_known_args()
+
+
+def load_model_configs(config_path):
+    with open(config_path, "r") as f:
+        return json.load(f)
+
+
+def setup_sidebar(model_config_list):
+    """
+    设置侧边栏，用于配置模型生成参数。
+
+    Args:
+        model_config_list (list): 模型配置列表。
+
+    Returns:
+        tuple: (kwargs_list, visibility_list)，分别存储每个模型的生成参数和可见性设置。
+    """
+    kwargs_list = []
+    visibility_list = []
+    with st.sidebar:
+        st.header("Generate Parameters")
+        for model_config in model_config_list:
+            with st.expander(f'{model_config["model_name"]}'):
+                kwargs = {}
+                for key, key_config in model_config["generate_parameter"].items():
+                    if not isinstance(key_config, dict):
+                        kwargs[key] = key_config
+                        continue
+                    value = getattr(st, key_config["component"])(
+                        key,
+                        key=f'{model_config["model_name"]}-{key}',
+                        **key_config["kwargs"],
+                    )
+                    kwargs[key] = value
+                kwargs_list.append(kwargs)
+                visibility = st.toggle(
+                    "启用",
+                    value=model_config.get("visibility", True),
+                    key=f'{model_config["model_name"]}-visibility',
+                )
+                visibility_list.append(visibility)
+    return kwargs_list, visibility_list
+
+
+def initialize_session_state():
+    if "chat" not in st.session_state:
+        st.session_state["chat"] = []
+
+
+def display_chat_history(chat_container):
+    with chat_container:
+        for chat in st.session_state["chat"]:
+            display_chat(chat)
+
+def handle_user_input(user_input, args, chat_container, model_config_list, kwargs_list, visibility_list):
+    """
+    处理用户输入，调用模型生成响应，并更新聊天记录。
+
+    Args:
+        user_input (str): 用户输入内容。
+        args (argparse.Namespace): 命令行参数。
+        chat_container (streamlit.container): 用于显示聊天记录的容器。
+        model_config_list (list): 模型配置列表。
+        kwargs_list (list): 每个模型的生成参数列表。
+        visibility_list (list): 每个模型的可见性设置列表。
+    """
+    if user_input:
+        logging.info(f"User input received: {user_input}")
+        chat = {"input": user_input, "avatar": args.user_avatar, "response": []}
+        with chat_container:
+            with st.chat_message("user", avatar=args.user_avatar):
+                st.markdown(user_input, unsafe_allow_html=True)
+            column_list = st.columns(sum(visibility_list))
+
+            loop = asyncio.new_event_loop()
+            waiting_list = []
+            model_idx = 0
+            for model_config, kwargs, visibility in zip(
+                model_config_list, kwargs_list, visibility_list
+            ):
+                if not visibility:
+                    continue
+                column = column_list[model_idx]
+                with column:
+                    st.header(model_config["model_name"])
+                    with st.chat_message("assistant", avatar=model_config["avatar"]):
+                        widget = st.empty()
+                history = []
+                for history_chat in st.session_state["chat"]:
+                    history.append(
+                        (
+                            history_chat["input"],
+                            history_chat["response"][model_idx]["text"],
+                        )
+                    )
+                # prompt = tokenize_prompt(
+                #     history, user_input, model_config["model_path"]
+                # )
+                chat["response"].append(
+                    {
+                        "model": model_config["model_name"],
+                        "text": "",
+                        "avatar": model_config["avatar"],
+                    }
+                )
+                waiting_list.append(
+                    fetch_model_response(widget, history, user_input, model_config, chat["response"][-1], **kwargs)
+                )
+                model_idx += 1
+
+            loop.run_until_complete(asyncio.wait(waiting_list))
+            st.session_state["chat"].append(chat)
+            
+            # log chat response
+            for idx, chat_response in enumerate(chat["response"]):
+                logging.info(f"Model: {chat_response['model']}, Response: {chat_response['text']}")
+
+
+
+
+def main():
+    args, _ = parse_arguments()
+    setup_logging(args.log)  # 初始化日志配置
+
+    logging.debug("Starting application")
+    model_config_list = load_model_configs(args.config)
+
+    st.title(TITLE)
+    initialize_session_state()
+
+    kwargs_list, visibility_list = setup_sidebar(model_config_list)
+
+    chat_container = st.container()
+    display_chat_history(chat_container)
+
+    user_input = st.chat_input("")
+    handle_user_input(user_input, args, chat_container, model_config_list, kwargs_list, visibility_list)
+
+
+if __name__ == "__main__":
+    main()

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/SimpleDeepSearcher_demo_1.py

@@ -0,0 +1,1043 @@
+# === 标准库导入（Python 内置模块） ===
+import argparse
+import asyncio
+import json
+import logging
+import multiprocessing
+import os
+import re
+import string
+import time
+from functools import partial
+from logging.handlers import RotatingFileHandler
+from typing import Optional, Tuple, List, Dict
+import hashlib
+
+# === 第三方库 ===
+import httpx
+import numpy as np
+import streamlit as st
+import torch
+from tqdm import tqdm
+from urllib.parse import urlparse
+# === 第三方 Transformers & vLLM ===
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+from google_search import (
+    google_web_search, 
+    extract_relevant_info, 
+    fetch_page_content, 
+    extract_snippet_with_context
+)
+# from evaluate import (
+#     run_evaluation, 
+#     run_evaluation_for_eval,
+#     extract_answer
+# )
+from prompts import (
+    get_multiqa_instruction,
+    get_math_instruction,
+    get_task_instruction_openqa,
+    get_task_instruction_math,
+    get_webpage_to_reasonchain_instruction
+)
+from openai import OpenAI
+
+from stage_wise_analysis import stage_wise_analysis
+
+# Define special tokens
+BEGIN_SEARCH_QUERY = "<|begin_search_query|>"
+END_SEARCH_QUERY = "<|end_search_query|>"
+BEGIN_SEARCH_RESULT = "<|begin_search_result|>"
+END_SEARCH_RESULT = "<|end_search_result|>"
+
+
+
+# 应用标题
+TITLE = "与深度搜索模型对话"
+
+# 设置 Streamlit 页面配置
+st.set_page_config(page_title=TITLE, layout="wide", initial_sidebar_state="collapsed")
+
+
+# --- Authentication Helper Functions ---
+USERS_FILE = "users.json"
+
+def hash_password(password):
+    """Hashes the password using SHA-256."""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+def load_users():
+    """Loads users from the JSON file."""
+    if os.path.exists(USERS_FILE):
+        with open(USERS_FILE, 'r') as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError:
+                return {}
+    return {}
+
+def save_users(users_data):
+    """Saves users to the JSON file."""
+    with open(USERS_FILE, 'w') as f:
+        json.dump(users_data, f, indent=4)
+
+def verify_user(username, password):
+    """Verifies user credentials."""
+    users = load_users()
+    if username in users:
+        hashed_password = hash_password(password)
+        if users[username]['password'] == hashed_password:
+            return True
+    return False
+
+def register_user(username, password):
+    """Registers a new user."""
+    users = load_users()
+    if username in users:
+        return False, "Username already exists."
+    if not username or not password:
+        return False, "Username and password cannot be empty."
+    # Add more password complexity rules if needed
+    users[username] = {'password': hash_password(password)}
+    save_users(users)
+    return True, "Registration successful! Please login."
+
+# --- End Authentication Helper Functions ---
+def tokenize_prompt(history, query, model_path, multi_turn=False):
+    messages = []
+    if multi_turn:
+        for q, r in history:
+            messages.append({"role": "user", "content": q})
+            messages.append({"role": "assistant", "content": r})
+    messages.append({"role": "user", "content": query})
+
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    return tokenizer.apply_chat_template(
+        messages, add_generation_prompt=True, tokenize=False
+    )
+
+# 配置日志
+def setup_logging(log_file):
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        handlers=[
+            RotatingFileHandler(log_file, maxBytes=1024 * 1024 * 5, backupCount=5),  # 日志文件最大 5MB，保留 5 个备份
+            logging.StreamHandler(),  # 同时输出到控制台
+        ],
+    )
+
+
+def display_chat(chat):
+    with st.chat_message("user", avatar=chat["avatar"]):
+        st.markdown(chat["input"], unsafe_allow_html=True)
+    column_list = st.columns(len(chat["response"]))
+    for i, (column, response) in enumerate(zip(column_list, chat["response"])):
+        with column:
+            st.header(response["model"])
+            with st.chat_message("assistant", avatar=response["avatar"]):
+                st.markdown(response["text"], unsafe_allow_html=True)
+
+def extract_answer(output, mode='gen'):
+    extracted_text = ''
+    if output is None:
+        output = "None"
+    if mode == 'codegen':
+        # Extract the code between ```python and ```
+        pattern = r'```python\s*(.*?)\s*```'
+        matches = re.findall(pattern, output, re.DOTALL | re.IGNORECASE)
+        if matches:
+            extracted_text = matches[-1].strip()  # Take the last match
+    elif mode == 'infogen': # 提取模型基于网页内容生成的推理
+        # Extract content after **Final Information** or **Modified Reasoning Steps**
+        # pattern_info = "\n**Final Information**"
+        # pattern_step = "\n**Modified Reasoning Steps**"
+        pattern_info = "**Final Information**"
+        pattern_step = "**Modified Reasoning Steps**"
+        if pattern_info in output:
+            extracted_text = output.split(pattern_info)[-1].replace("\n","").strip("```").strip()
+        elif pattern_step in output:
+            extracted_text = output.split(pattern_step)[-1].strip("```").strip()
+        else:
+            # extracted_text = "No helpful information found."
+            extracted_text = output
+    else:
+        # Existing extraction logic for 'gen' and 'choose' modes
+        pattern = r'\\boxed\{(.*)\}'
+        matches = re.findall(pattern, output)
+        if matches:
+            extracted_text = matches[-1]  # Take the last match
+            if mode in ['choose', 'qa']:
+                # Handle 'choose' mode
+                inner_pattern = r'\\text\{(.*)\}'
+                inner_matches = re.findall(inner_pattern, extracted_text)
+                if inner_matches:
+                    extracted_text = inner_matches[-1]  # Take the last match
+                extracted_text = extracted_text.strip("()")
+    return extracted_text
+
+# def generate_favicon_html(urls):
+#     favicons = []
+#     for url in urls:
+#         domain = urlparse(url).netloc
+#         favicon_url = f"https://{domain}/favicon.ico"
+#         favicons.append(f'<img src="{favicon_url}" width="16" style="margin-right:4px;">')
+#     return "**🌐 Fetching web pages:** " + "".join(favicons)
+
+def generate_favicon_html(urls):
+    favicons = []
+    for url in urls:
+        domain = urlparse(url).netloc
+        # 使用 Google 的 S2 Favicon 服务
+        # sz=16 表示获取 16x16 大小的图标
+        favicon_service_url = f"https://www.google.com/s2/favicons?domain={domain}&sz=16"
+        favicons.append(f'<img src="{favicon_service_url}" width="16" style="margin-right:4px;" alt=" " onerror="this.style.display=\'none\'">')
+    return "**🌐 Fetching web pages:** " + "".join(favicons)
+
+def webpage_analysis_single(summ_model_url, summ_model_path, prompt) -> str:
+    client_summ_model = OpenAI(
+        base_url=summ_model_url,
+        api_key="EMPTY"
+    )
+    for i in range(10): # max retry 10 times
+        try:
+            completion = client_summ_model.chat.completions.create(
+                model=summ_model_path,
+                max_tokens=8192,
+                temperature=0.6,
+                top_p=0.95,
+                messages=[prompt],
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            logging.info(e)
+            time.sleep(1)
+            continue
+    return "None"
+
+
+
+async def fetch_model_response(widget, history, question, model_config, response_dict, **kwargs):
+    filtered_data = [{"Question": question, "Answer": ""}]
+
+    # temperature = args.temperature
+    # top_p = args.top_p
+    # top_k_sampling = args.top_k_sampling
+    # max_tokens = args.max_tokens
+
+
+    dataset_name = "user_queries"
+    subset_num = -1
+    MAX_SEARCH_LIMIT = 10
+    MAX_TURN = 15
+    top_k = 10
+    max_doc_len = 3000
+    summ_model_path = "/capacity/userdata/models/QwQ-32B"
+    summ_model_url = "http://localhost:8003/v1"
+    google_subscription_key = "cb0d28279a826d7e5cf22d71f683c77ffd4ba27d"
+    google_endpoint = "https://google.serper.dev/search"
+    cache_dir = "../cache"
+    output_dir = "output"
+    is_exclude_urls = False
+    max_tokens = 20480
+
+
+    search_cache_path = os.path.join(cache_dir, 'search_cache.json')
+    url_cache_path = os.path.join(cache_dir, 'url_cache.json')
+    with open(search_cache_path, 'r', encoding='utf-8') as f:
+        search_cache = json.load(f)
+    with open(url_cache_path, 'r', encoding='utf-8') as f:
+        url_cache = json.load(f)
+    
+    widget_output = ""
+
+
+    # Function to save caches
+    def save_caches():
+        with open(search_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(search_cache, f, ensure_ascii=False, indent=2)
+        with open(url_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(url_cache, f, ensure_ascii=False, indent=2)
+    
+    def generate_webpage_to_reasonchain_batch(
+        original_questions: List[str],
+        prev_reasonings: List[str],
+        search_queries: List[str],
+        documents: List[str],
+        summ_model_url: OpenAI,
+        summ_model_path: str,
+        batch_output_records: List[Dict],  # New parameter to collect outputs
+        coherent: bool = False,
+    ) -> List[str]:
+
+        user_prompts = [
+            get_webpage_to_reasonchain_instruction(r, sq, doc)
+            for r, sq, doc in zip(prev_reasonings, search_queries, documents)
+        ]
+
+        logging.info(f"generate_webpage_to_reasonchain_batch, len(user_prompts): {len(user_prompts)}")
+        prompts = [{"role": "user", "content": up} for up in user_prompts]
+        logging.info("webpage ana prompts[0]")
+        logging.info(prompts[0])
+
+        raw_outputs = []
+        
+        for prompt in prompts:
+            raw_output = webpage_analysis_single(summ_model_url, summ_model_path, prompt)
+            raw_outputs.append(raw_output)
+        # webpage_analysis_single_to_map = partial(webpage_analysis_single, summ_model_url, summ_model_path)
+        # with multiprocessing.Pool(processes=10) as pool:
+        #     raw_outputs = list(tqdm(pool.imap(webpage_analysis_single_to_map, prompts), total=len(prompts), desc="generate webpage analyses"))
+
+
+        # Count the number of summarization errors
+        sum_error = 0
+        for output in raw_outputs:
+            if output is None or output == "None" or output == "":
+                sum_error += 1
+        logging.info(f"summarization_error: {sum_error}, ratios: {sum_error / len(raw_outputs)}")
+     
+        extracted_infos = [extract_answer(raw, mode='infogen') for raw in raw_outputs]
+
+        for i, (p, r, e) in enumerate(zip(prompts, raw_outputs, extracted_infos)):
+            batch_output_records.append({
+                'prompt': p,
+                'raw_output': r,
+                'extracted_info': e
+            })
+
+        
+
+        return extracted_infos
+
+    # ---------------------- Preparation of Input Prompts ----------------------
+    input_list = []
+    for item in filtered_data:
+        question = item['Question']
+
+        if dataset_name in ['aime']:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_math(question)
+
+        else:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_openqa(question)
+            
+        
+        # prompt = [{"role": "user", "content": instruction + user_prompt}]
+        prompt = instruction + user_prompt
+        prompt = tokenize_prompt(history, prompt, model_config['model_path'], multi_turn=True)
+        # prompt = tokenizer.apply_chat_template(prompt, tokenize=False, add_generation_prompt=True)
+        input_list.append(prompt)
+        logging.info(f"Input prompt for question '{question}':\n {prompt}")
+
+    # Initialize active sequences
+    active_sequences = [{
+        'item': item,
+        'prompt': prompt,
+        'output': '',
+        'finished': False,
+        'history': [],
+        'search_count': 0,
+        'executed_search_queries': set(),
+        'all_info': [],
+    } for item, prompt in zip(filtered_data, input_list)]
+
+    async def run_generation(sequences: List[Dict], max_tokens: int, turn: int) -> List:
+        prompts = [s['prompt'] for s in sequences]
+        headers = {"User-Agent": "Test Client"}
+        payload = {
+            "prompt": prompts[0],
+            "max_tokens": max_tokens,
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "top_k": 40,
+            "stop":[END_SEARCH_QUERY, "<|im_end|>"],
+            "include_stop_str_in_output": True,
+            "stream": True,
+        }
+        payload.update(kwargs)
+        logging.debug(f"Sending request to model: {model_config['model_name']}")
+        logging.debug(f"Request payload: {payload}")  
+        client = httpx.AsyncClient()
+        async with client.stream(
+            "POST", model_config["api_url"], headers=headers, json=payload
+        ) as response:
+            output_final = ""
+        
+            async for chunk in response.aiter_bytes(): # 1,2,3
+                if chunk:
+                    try:
+                        data = json.loads(chunk.decode("utf-8").rstrip("\x00"))
+                        output = data["text"][0][len(prompts[0]) :]
+                        # logging.info(f"output11111: {output}")
+                        # widget_output += output
+                        if widget_output == "":
+                            widget.markdown(f"**✨ Reasoning {turn}:** " + output, unsafe_allow_html=True)
+                        else:
+                            widget.markdown(widget_output + f"\n**✨ Reasoning {turn}:** " + output, unsafe_allow_html=True)
+                        output_final = output
+                        # output_buffer += output
+                    except json.JSONDecodeError as e:
+                        # logging.error(f"Attention!: JSON decode error: {e}, chunk: {chunk}")
+                        continue
+            
+            return [output_final]
+    
+
+
+    # Function to extract text between two tags
+    def extract_between(text: str, start_tag: str, end_tag: str) -> Optional[str]:
+        pattern = re.escape(start_tag) + r"(.*?)" + re.escape(end_tag)
+        matches = re.findall(pattern, text, flags=re.DOTALL)
+        if matches:
+            return matches[-1].strip()
+        return None
+
+    def replace_recent_steps(origin_str, replace_str):
+        """
+        Replaces specific steps in the original reasoning steps with new steps.
+        If a replacement step contains "DELETE THIS STEP", that step is removed.
+
+        Parameters:
+        - origin_str (str): The original reasoning steps.
+        - replace_str (str): The steps to replace or delete.
+
+        Returns:
+        - str: The updated reasoning steps after applying replacements.
+        """
+
+        def parse_steps(text):
+            """
+            Parses the reasoning steps from a given text.
+
+            Parameters:
+            - text (str): The text containing reasoning steps.
+
+            Returns:
+            - dict: A dictionary mapping step numbers to their content.
+            """
+            step_pattern = re.compile(r"Step\s+(\d+):\s*")
+            steps = {}
+            current_step_num = None
+            current_content = []
+
+            for line in text.splitlines():
+                step_match = step_pattern.match(line)
+                if step_match:
+                    # If there's an ongoing step, save its content
+                    if current_step_num is not None:
+                        steps[current_step_num] = "\n".join(current_content).strip()
+                    current_step_num = int(step_match.group(1))
+                    content = line[step_match.end():].strip()
+                    current_content = [content] if content else []
+                else:
+                    if current_step_num is not None:
+                        current_content.append(line)
+            
+            # Save the last step if any
+            if current_step_num is not None:
+                steps[current_step_num] = "\n".join(current_content).strip()
+            
+            return steps
+
+        # Parse the original and replacement steps
+        origin_steps = parse_steps(origin_str)
+        replace_steps = parse_steps(replace_str)
+
+        # Apply replacements
+        for step_num, content in replace_steps.items():
+            if "DELETE THIS STEP" in content: 
+                # Remove the step if it exists
+                if step_num in origin_steps:
+                    del origin_steps[step_num]
+            else:
+                # Replace or add the step 
+                origin_steps[step_num] = content
+
+        # Sort the steps by step number
+        sorted_steps = sorted(origin_steps.items())
+
+        # Reconstruct the reasoning steps as a single string
+        new_reasoning_steps = "\n\n".join([f"{content}" for num, content in sorted_steps])
+
+        return new_reasoning_steps
+
+
+    # ---------------------- Initialize Collection Structure ----------------------
+    # Initialize a list to collect batch outputs
+    batch_output_records = []
+
+    start_time = time.time()
+    turn = 0
+
+    # Main loop until all sequences are finished or maximum turns reached
+    while True:
+        # Identify sequences that need generation
+        sequences_needing_generation = [seq for seq in active_sequences if not seq['finished']]
+
+        if sequences_needing_generation:
+            turn += 1
+            logging.info(f'\n-------------- Turn {turn} --------------')
+            logging.info(f"We have {len(sequences_needing_generation)} sequences needing generation...")
+            outputs = await run_generation(sequences_needing_generation, max_tokens, turn)
+            if widget_output == "":
+                widget_output += f"**✨ Reasoning {turn}:** " + outputs[0] 
+            else:
+                widget_output += f"\n**✨ Reasoning {turn}:** " + outputs[0]  # Append the first output to widget_output
+            widget.markdown(widget_output, unsafe_allow_html=True)
+            logging.info("Generation completed, processing outputs...")
+
+            # Initialize batch variables
+            batch_relevant_info = []
+            batch_original_questions = []
+            batch_prev_reasonings = []
+            batch_search_queries = []
+            batch_documents = []
+            batch_sequences = []
+
+            # Collect URLs to fetch across all sequences
+            all_urls_to_fetch = set()
+            url_snippets = {}
+            url_sequence_map = {}  # Map URL to list of sequences needing it
+
+            start_search_time = time.time()
+            # Process each sequence and collect URLs
+            for seq, out in zip(sequences_needing_generation, outputs):
+                text = out
+                seq['history'].append(text)
+                # Append generated text to prompt and output
+                seq['prompt'] += text
+                seq['output'] += text
+                seq['all_info'].append({f"turn_{turn}_reason": text})
+                # Extract search query
+                search_query = extract_between(text, BEGIN_SEARCH_QUERY, END_SEARCH_QUERY)
+
+                # If a search query is present and needs to be executed
+                if search_query and seq['output'].rstrip().endswith(END_SEARCH_QUERY):
+                    if seq['search_count'] < MAX_SEARCH_LIMIT and search_query not in seq['executed_search_queries']:
+                        # Execute search, use cache if available
+                        if search_query in search_cache:
+                            results = search_cache[search_query]
+                            logging.info(f"Using cached search results for query: \"{search_query}\"")
+                        else:
+                            try:
+                                if is_exclude_urls and "urls" in seq["item"]["metadata"]: 
+                                    logging.info(f"is_exclude_urls: {is_exclude_urls}")
+                                    exclude_urls = seq["item"]["metadata"]["urls"]
+                                else:
+                                    exclude_urls = []
+
+                                logging.info(f"Execute and cache search for query: \"{search_query}\"")
+
+                                # 更新输出
+                                widget_output += f"\n\n**🔍 Executing search for query:** {search_query}\n"
+                                widget.markdown(widget_output, unsafe_allow_html=True)
+
+                                results = google_web_search(search_query, google_subscription_key, google_endpoint, market='en-US', language='en', exclude_urls=exclude_urls) # 执行搜索
+                                search_cache[search_query] = results
+                                logging.info(f"Executed and cached search for query: \"{search_query}\"")
+                            except Exception as e:
+                                logging.info(f"Error during search query '{search_query}': {e}")
+                                search_cache[search_query] = {}
+                                results = {}
+
+                        # Extract relevant information from Bing search results
+                        relevant_info = extract_relevant_info(results)[:top_k]
+                        seq['relevant_info'] = relevant_info
+
+                        # Extract URLs and snippets
+                        urls_to_fetch = [it['url'] for it in relevant_info]
+
+                        ## 更新网页
+                        widget_output += "\n\n" + generate_favicon_html(urls_to_fetch) + "\n"
+                        widget.markdown(widget_output, unsafe_allow_html=True)
+
+                        snippets = {info['url']: info['snippet'] for info in relevant_info if 'snippet' in info}
+
+                        # Filter URLs that are not cached
+                        urls_to_fetch_filtered = [u for u in urls_to_fetch if u not in url_cache]
+                        cached_urls = [u for u in urls_to_fetch if u in url_cache]
+
+                        # Store info for all_urls_to_fetch and url_snippets
+                        for url in urls_to_fetch_filtered:
+                            all_urls_to_fetch.add(url)
+                            url_snippets[url] = snippets.get(url, "") 
+
+                        all_reasoning_steps = seq['output']
+                        all_reasoning_steps = all_reasoning_steps.replace('\n\n', '\n').split("\n")
+
+                        truncated_prev_reasoning = ""
+                        for i, step in enumerate(all_reasoning_steps):
+                            truncated_prev_reasoning += f"Step {i + 1}: {step}\n\n"
+
+                        prev_steps = truncated_prev_reasoning.split('\n\n')
+                        if len(prev_steps) <= 5:
+                            truncated_prev_reasoning = '\n\n'.join(prev_steps)
+                        else:
+                            truncated_prev_reasoning = ''
+                            for i, step in enumerate(prev_steps):
+                                if i == 0 or i >= len(prev_steps) - 4 or BEGIN_SEARCH_QUERY in step or BEGIN_SEARCH_RESULT in step:
+                                    truncated_prev_reasoning += step + '\n\n'
+                                else:
+                                    if truncated_prev_reasoning[-len('\n\n...\n\n'):] != '\n\n...\n\n':
+                                        truncated_prev_reasoning += '...\n\n'
+                        truncated_prev_reasoning = truncated_prev_reasoning.strip('\n')
+
+                        # Collect parameters for batch processing
+                        batch_relevant_info.append(relevant_info)
+                        batch_original_questions.append(seq['item']['Question'])
+                        batch_prev_reasonings.append(truncated_prev_reasoning)
+                        batch_search_queries.append(search_query)
+                        batch_sequences.append(seq)
+
+                        # Update search count and executed queries
+                        seq['search_count'] += 1
+                        seq['executed_search_queries'].add(search_query)
+
+                    elif seq['search_count'] >= MAX_SEARCH_LIMIT:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nThe maximum search limit is exceeded. You are not allowed to search.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        logging.info(f"Search limit reached for query: \"{search_query}\"")
+
+                    elif search_query in seq['executed_search_queries']:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nYou have searched this query. Please refer to previous results.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        logging.info(f"Repeated search for query: \"{search_query}\"")
+                        
+
+                else:
+                    # If no search query needs to be executed, mark the sequence as finished
+                    seq['finished'] = True
+                    logging.info("Sequence marked as complete.")
+
+            logging.info(f"get search time taken: {time.time() - start_search_time}")
+            logging.info(f"all_urls_to_fetch len: {len(all_urls_to_fetch)}, url_cache len: {len(url_cache)}")
+            logging.info(f"all_urls_to_fetch: {all_urls_to_fetch}")
+            # Batch fetch all URLs at once to optimize speed
+            
+            if all_urls_to_fetch:
+                logging.info(f"Fetching {len(all_urls_to_fetch)} URLs...")
+                try:
+                    fetched_contents = fetch_page_content(
+                        list(all_urls_to_fetch),
+                        use_jina=False,
+                        jina_api_key=None,
+                        # snippets=url_snippets  # Do not pass snippets when updating url_cache directly
+                    )
+                    logging.info(f"Fetched {len(fetched_contents)} URLs successfully.")
+                except Exception as e:
+                    logging.info(f"Error during batch URL fetching: {e}")
+                    fetched_contents = {url: f"Error fetching URL: {e}" for url in all_urls_to_fetch}
+                # Update cache with fetched contents
+                for url, content in fetched_contents.items():
+                    url_cache[url] = content
+
+            # After fetching, prepare formatted documents for batch processing
+            for relevant_info in batch_relevant_info:
+                formatted_documents = ""
+                for i, doc_info in enumerate(relevant_info):
+                    url = doc_info['url']
+                    raw_context = url_cache.get(url, "")
+                    doc_info['snippet'] = doc_info['snippet'].replace('<b>','').replace('</b>','')            
+                    success, filtered_context = extract_snippet_with_context(raw_context, doc_info['snippet'], context_chars=max_doc_len)
+                    if success:
+                        logging.info("extract_snippet_with_context")
+                        context = filtered_context
+                    else: 
+                        logging.info(f"use raw_webpage_context, {len(raw_context)}")
+                        context = raw_context[:max_doc_len*2]
+
+                    doc_info['context'] = context
+                    formatted_documents += f"**Web Page {i + 1}:**\n"
+                    formatted_documents += json.dumps(doc_info, ensure_ascii=False, indent=2) + "\n"
+                logging.info(f'formatted_webpage_documents: {len(formatted_documents)}')
+                batch_documents.append(formatted_documents)
+
+            # After fetching, prepare for batch processing if there are any
+            if batch_sequences:
+                logging.info(f"Batch processing {len(batch_sequences)} sequences with generate_webpage_to_reasonchain_batch...")
+                webpage_analyses = generate_webpage_to_reasonchain_batch(
+                    original_questions=batch_original_questions,
+                    prev_reasonings=batch_prev_reasonings,
+                    search_queries=batch_search_queries,
+                    documents=batch_documents,
+                    summ_model_url=summ_model_url,
+                    summ_model_path=summ_model_path,
+                    batch_output_records=batch_output_records,  # Pass the collection list
+                )
+                logging.info("Batch generation completed, assigning outputs to sequences...")
+
+                for seq, analysis,doc in zip(batch_sequences, webpage_analyses, batch_documents): 
+                    ## 更新输出
+                    widget_output += f"\n**📄Web Pages Summary Results:**\n{analysis}\n"
+                    widget.markdown(widget_output, unsafe_allow_html=True)
+                    if isinstance(analysis, str):
+                        append_text = f"\n\n{BEGIN_SEARCH_RESULT}{analysis}{END_SEARCH_RESULT}\n\n"
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text) 
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+                    else:
+                        append_text = replace_recent_steps(seq['output'], analysis)
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text)
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+
+        # Check if all sequences are finished
+        active_sequences_part = [{
+            'item': ele["item"],
+            'prompt': ele['prompt'],
+            'output': ele["output"],
+            'finished': ele["finished"],
+            'history':ele["history"],
+            'search_count': ele["search_count"],
+            'all_info': ele['all_info']
+        } for ele in active_sequences]
+        # with open(os.path.join(output_dir, f"turn_{turn}.json"), 'w', encoding='utf-8') as f:
+        #     json.dump(active_sequences_part, f, ensure_ascii=False, indent=2)
+        unfinished = [seq for seq in active_sequences if not seq['finished']]
+        if not unfinished:
+            break
+        else:
+            if turn >= MAX_TURN:
+                logging.info(f"Maximum number of turns ({MAX_TURN}) reached, stopping.")
+                break
+
+    total_time = time.time() - start_time
+    logging.info(f"Total time taken: {total_time} seconds")
+
+    # # ---------------------- Save Batch Output Records to JSON File ----------------------
+    # # Define output JSON file path
+    # t = time.localtime()
+    # batch_output_file = os.path.join(output_dir, f'test.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.info_extract.json')
+
+    # # Save batch_output_records to JSON file
+    # with open(batch_output_file, 'w', encoding='utf-8') as f:
+    #     json.dump(batch_output_records, f, ensure_ascii=False, indent=2)
+
+    # logging.info(f"Batch outputs saved to {batch_output_file}")
+
+    # Prepare output list for evaluation
+    output_list = [seq['output'] for seq in active_sequences]
+
+    response_dict["text"] = widget_output# Update the response dictionary with the first output
+
+    # # Run evaluation
+    # if dataset_name in ["eval", "gaia"]:
+    #     run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+    # else:
+    #     run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+
+    # # ---------------------- Stage-wise Analysis ----------------------
+    # turn_files = os.listdir(output_dir)
+    # turn_files = [file for file in turn_files if file.startswith("turn_")]
+    # max_turn_file = max(turn_files, key=lambda x: int(re.search(r'turn_(\d+)', x).group(1)))
+
+    # max_turn_file_path = os.path.join(output_dir, max_turn_file)
+    # logging.info(f"max_turn_file_path: {max_turn_file_path}")
+    # stage_wise_analysis(model_path, max_turn_file_path)
+
+    # ---------------------- Update Search and URL Cache ----------------------
+    logging.info('Updating Search and URL Cache...')
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try:
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache_new = json.load(f)
+        except Exception as e:
+            logging.info(f"Error loading search cache: {e}")
+            search_cache_new = {}
+    else:
+        search_cache_new = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache_new = json.load(f)
+        except Exception as e:
+            logging.info(f"Error loading url cache: {e}")
+            url_cache_new = {}
+    else:
+        url_cache_new = {}
+
+    search_cache.update(search_cache_new)
+    url_cache.update(url_cache_new)
+
+    save_caches()
+
+    logging.info("Process completed.")
+
+def parse_arguments():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--config",
+        "-c",
+        type=str,
+        default="./demo_client_basic.json",
+        help="path to configs",
+    )
+    parser.add_argument(
+        "--user_avatar",
+        "-a",
+        type=str,
+        default="./user_demo.png",
+        help="path to user avatar",
+    )
+    parser.add_argument(
+        "--log",
+        "-l",
+        type=str,
+        default=f"./chatweb.log",
+        help="path to logs",
+    )
+    return parser.parse_known_args()
+
+
+def load_model_configs(config_path):
+    with open(config_path, "r") as f:
+        return json.load(f)
+
+
+def setup_sidebar(model_config_list):
+    """
+    设置侧边栏，用于配置模型生成参数。
+
+    Args:
+        model_config_list (list): 模型配置列表。
+
+    Returns:
+        tuple: (kwargs_list, visibility_list)，分别存储每个模型的生成参数和可见性设置。
+    """
+    kwargs_list = []
+    visibility_list = []
+    with st.sidebar:
+        st.header("Generate Parameters")
+        for model_config in model_config_list:
+            with st.expander(f'{model_config["model_name"]}'):
+                kwargs = {}
+                for key, key_config in model_config["generate_parameter"].items():
+                    if not isinstance(key_config, dict):
+                        kwargs[key] = key_config
+                        continue
+                    value = getattr(st, key_config["component"])(
+                        key,
+                        key=f'{model_config["model_name"]}-{key}',
+                        **key_config["kwargs"],
+                    )
+                    kwargs[key] = value
+                kwargs_list.append(kwargs)
+                visibility = st.toggle(
+                    "启用",
+                    value=model_config.get("visibility", True),
+                    key=f'{model_config["model_name"]}-visibility',
+                )
+                visibility_list.append(visibility)
+    return kwargs_list, visibility_list
+
+
+def initialize_session_state():
+    if "chat" not in st.session_state:
+        st.session_state["chat"] = []
+
+
+def initialize_auth_session_state():
+    """Initializes session state variables for authentication."""
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+    if 'current_user' not in st.session_state:
+        st.session_state.current_user = None
+    if 'page' not in st.session_state: # To control navigation: login, register, chat
+        st.session_state.page = 'login'
+
+def display_chat_history(chat_container):
+    with chat_container:
+        for chat in st.session_state["chat"]:
+            display_chat(chat)
+
+
+def handle_user_input(user_input, args, chat_container, model_config_list, kwargs_list, visibility_list):
+    """
+    处理用户输入，调用模型生成响应，并更新聊天记录。
+
+    Args:
+        user_input (str): 用户输入内容。
+        args (argparse.Namespace): 命令行参数。
+        chat_container (streamlit.container): 用于显示聊天记录的容器。
+        model_config_list (list): 模型配置列表。
+        kwargs_list (list): 每个模型的生成参数列表。
+        visibility_list (list): 每个模型的可见性设置列表。
+    """
+    if user_input:
+        logging.info(f"User input received: {user_input}")
+        chat = {"input": user_input, "avatar": args.user_avatar, "response": []}
+        with chat_container:
+            with st.chat_message("user", avatar=args.user_avatar):
+                st.markdown(user_input, unsafe_allow_html=True)
+            column_list = st.columns(sum(visibility_list))
+
+            loop = asyncio.new_event_loop()
+            waiting_list = []
+            model_idx = 0
+            for model_config, kwargs, visibility in zip(
+                model_config_list, kwargs_list, visibility_list
+            ):
+                if not visibility:
+                    continue
+                column = column_list[model_idx]
+                with column:
+                    st.header(model_config["model_name"])
+                    with st.chat_message("assistant", avatar=model_config["avatar"]):
+                        widget = st.empty()
+                history = []
+                for history_chat in st.session_state["chat"]:
+                    history.append(
+                        (
+                            history_chat["input"],
+                            history_chat["response"][model_idx]["text"],
+                        )
+                    )
+                # prompt = tokenize_prompt(
+                #     history, user_input, model_config["model_path"]
+                # )
+                chat["response"].append(
+                    {
+                        "model": model_config["model_name"],
+                        "text": "",
+                        "avatar": model_config["avatar"],
+                    }
+                )
+                waiting_list.append(
+                    fetch_model_response(widget, history, user_input, model_config, chat["response"][-1], **kwargs)
+                )
+                model_idx += 1
+
+            loop.run_until_complete(asyncio.wait(waiting_list))
+            st.session_state["chat"].append(chat)
+            
+            # log chat response
+            for idx, chat_response in enumerate(chat["response"]):
+                logging.info(f"Model: {chat_response['model']}, Response: {chat_response['text']}")
+
+
+# 定义科技感的颜色
+color_shendu = "#00BFFF"  # 例如：深天蓝 (DeepSkyBlue) - 一种科技蓝
+color_sousuo = "#00FFFF" # 例如：青色 (Cyan/Aqua) - 另一种明亮的科技感颜色
+# 或者尝试其他组合:
+# color_shendu = "#7DF9FF"  # 电光蓝 (Electric Blue)
+# color_sousuo = "#00FF7F" # 春绿色 (SpringGreen)
+
+# 构建带有内联CSS的HTML字符串
+# 我们将使用 <h2> 标签，它通常在视觉上与 st.header() 类似
+header_html = f"""
+<h2 style="text-align: center; font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;">
+    <span style="color: {color_sousuo};">深度</span><span style="color: {color_shendu};">搜索系统</span>
+</h2>
+"""
+
+
+
+# --- Authentication Pages ---
+def show_login_page():
+    # 使用 st.markdown 显示自定义标题
+    st.markdown(header_html, unsafe_allow_html=True)
+
+
+    # st.header("深度搜索系统")
+    st.subheader("登录")
+    with st.form("login_form"):
+        username = st.text_input("用户名", key="login_username")
+        password = st.text_input("密码", type="password", key="login_password")
+        submit_button = st.form_submit_button("登录")
+
+        if submit_button:
+            if verify_user(username, password):
+                st.session_state.logged_in = True
+                st.session_state.current_user = username
+                st.session_state.page = 'chat' # Navigate to chat
+                initialize_session_state() # Initialize chat state for the user
+                st.success("登录成功！")
+                st.rerun() # Rerun to reflect login state and show chat page
+            else:
+                st.error("用户名或密码错误！")
+
+    if st.button("新用户注册", key="goto_register"):
+        st.session_state.page = 'register'
+        st.rerun()
+
+def show_registration_page():
+    st.markdown(header_html, unsafe_allow_html=True)
+    st.subheader("新用户注册")
+    with st.form("registration_form"):
+        new_username = st.text_input("用户名", key="reg_username")
+        new_password = st.text_input("密码", type="password", key="reg_password")
+        confirm_password = st.text_input("确认密码", type="password", key="reg_confirm_password")
+        reg_submit_button = st.form_submit_button("注册")
+
+        if reg_submit_button:
+            if not new_username or not new_password:
+                st.warning("密码不能为空！")
+            elif new_password != confirm_password:
+                st.error("密码错误！")
+            else:
+                success, message = register_user(new_username, new_password)
+                if success:
+                    st.success(message)
+                    st.session_state.page = 'login' # Go to login page after registration
+                    st.rerun()
+                else:
+                    st.error(message)
+    
+    if st.button("已经有了账户？请登录", key="goto_login"):
+        st.session_state.page = 'login'
+        st.rerun()
+
+
+def main():
+    args, _ = parse_arguments()
+    setup_logging(args.log)
+    logging.debug("Starting application")
+
+    initialize_auth_session_state() # Initialize auth related session state first
+
+    if not st.session_state.get('logged_in', False):
+        # User is not logged in, show login or registration page
+        page_to_show = st.session_state.get('page', 'login')
+        if page_to_show == 'login':
+            show_login_page()
+        elif page_to_show == 'register':
+            show_registration_page()
+    else:
+        # User is logged in, show the main chat application
+        st.title(TITLE)
+        
+        # Initialize app-specific session state if not already done (e.g., after login)
+        if "chat" not in st.session_state: # Should have been initialized by successful login
+            initialize_session_state()
+
+        model_config_list = load_model_configs(args.config)
+        if not model_config_list: # If config loading failed
+            st.error("Failed to load model configurations. Chat functionality may be limited.")
+            # Potentially stop further execution or provide guidance
+            return
+
+        kwargs_list, visibility_list = setup_sidebar(model_config_list)
+
+        chat_container = st.container()
+        display_chat_history(chat_container)
+
+        user_input = st.chat_input(f"Ask anything, {st.session_state.get('current_user', 'User')}...")
+        if user_input: # Check if user_input is not None (happens on first run)
+            handle_user_input(user_input, args, chat_container, model_config_list, kwargs_list, visibility_list)
+
+
+if __name__ == "__main__":
+    main()

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/demo_client_basic.json

@@ -0,0 +1,51 @@
+[
+    {
+        "model_name": "SimpDS-QwQ-32B",
+        "model_path": "/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41",
+        "api_url": "http://localhost:5126/generate",
+        "avatar": "./simplelog_demo.jpg",
+        "visibility": true,
+        "generate_parameter": {
+            "presence_penalty": {
+                "component": "number_input",
+                "kwargs": {
+                    "min_value": -1.0,
+                    "max_value": 1.0,
+                    "value": 0.0
+                }
+            },
+            "frequency_penalty": {
+                "component": "number_input",
+                "kwargs": {
+                    "min_value": -1.0,
+                    "max_value": 1.0,
+                    "value": 0.0
+                }
+            },
+            "max_tokens": {
+                "component": "number_input",
+                "kwargs": {
+                    "min_value": 512,
+                    "max_value": 32768,
+                    "value": 20480
+                }
+            },
+            "temperature": {
+                "component": "number_input",
+                "kwargs": {
+                    "min_value": 0.0,
+                    "max_value": 1.0,
+                    "value": 0.6
+                }
+            },
+            "top_p": {
+                "component": "number_input",
+                "kwargs": {
+                    "min_value": 0.0,
+                    "max_value": 1.0,
+                    "value": 0.95 
+                }
+            }
+        }
+    }
+]

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/evaluate.py

@@ -0,0 +1,452 @@
+import sys
+sys.path.append("..")
+
+import re
+import json
+import numpy as np
+from collections import Counter
+import string
+import os, time
+from collections import defaultdict
+from lcb_runner.evaluation import codegen_metrics
+from utils.math_equivalence import is_equiv
+
+
+def extract_answer(output, mode='gen'):
+    extracted_text = ''
+    if output is None:
+        output = "None"
+    if mode == 'codegen':
+        # Extract the code between ```python and ```
+        pattern = r'```python\s*(.*?)\s*```'
+        matches = re.findall(pattern, output, re.DOTALL | re.IGNORECASE)
+        if matches:
+            extracted_text = matches[-1].strip()  # Take the last match
+    elif mode == 'infogen': # 提取模型基于网页内容生成的推理
+        # Extract content after **Final Information** or **Modified Reasoning Steps**
+        # pattern_info = "\n**Final Information**"
+        # pattern_step = "\n**Modified Reasoning Steps**"
+        pattern_info = "**Final Information**"
+        pattern_step = "**Modified Reasoning Steps**"
+        if pattern_info in output:
+            extracted_text = output.split(pattern_info)[-1].replace("\n","").strip("```").strip()
+        elif pattern_step in output:
+            extracted_text = output.split(pattern_step)[-1].strip("```").strip()
+        else:
+            # extracted_text = "No helpful information found."
+            extracted_text = output
+    else:
+        # Existing extraction logic for 'gen' and 'choose' modes
+        pattern = r'\\boxed\{(.*)\}'
+        matches = re.findall(pattern, output)
+        if matches:
+            extracted_text = matches[-1]  # Take the last match
+            if mode in ['choose', 'qa']:
+                # Handle 'choose' mode
+                inner_pattern = r'\\text\{(.*)\}'
+                inner_matches = re.findall(inner_pattern, extracted_text)
+                if inner_matches:
+                    extracted_text = inner_matches[-1]  # Take the last match
+                extracted_text = extracted_text.strip("()")
+    return extracted_text
+
+
+def normalize_answer(text):
+    text = text.lower()
+    text = " ".join(text.strip().split())
+    return text
+
+def normalize_answer_qa(s):
+    def remove_articles(text):
+        return re.sub(r"\b(a|an|the)\b", " ", text)
+    def white_space_fix(text):
+        return " ".join(text.strip().split())
+    def remove_punc(text):
+        exclude = set(string.punctuation)
+        return "".join(ch for ch in text if ch not in exclude)
+    def lower(text):
+        return text.lower()
+    return white_space_fix(remove_articles(remove_punc(lower(s))))
+
+
+def evaluate_predictions(output, labeled_answer, mode='gen'):
+    final_metric = {"is_valid_answer": False, "acc": 0, "em": 0, "f1": 0, 'math_equal': 0}
+    # is_valid_answer: 是否存在有效的预测答案。
+    # acc: 精度（accuracy）。指标注答案是否出现在预测答案中
+    # em: 完全匹配（exact match）。指预测答案是否与标注答案完全相同
+    # f1: F1 分数。
+    # math_equal: 数学上的相等性（通常用于判断数值是否相等）
+    pred_answer = extract_answer(output, mode=mode)
+    if pred_answer != '': # 模型给出了有效的预测答案
+        final_metric["is_valid_answer"] = True
+
+    if mode == 'qa':
+        normalized_pred_answer = normalize_answer_qa(pred_answer)
+        # print(f"normalized_pred_answer: {normalized_pred_answer}")
+        for answer in labeled_answer:
+            normalized_ground_truth = normalize_answer_qa(answer)
+            # print(f"normalized_ground_truth: {normalized_ground_truth}--")
+            em = int(normalized_pred_answer == normalized_ground_truth)
+            acc = int(normalized_ground_truth in normalized_pred_answer)
+
+            # 将预测答案和标注答案分割成单词或词汇 tokens，并计算它们的交集（即相同的词汇）。
+            # Counter 是一个字典类型的对象，用于统计词汇的频次，& 操作符求得两个 Counter 对象的交集
+            prediction_tokens = normalized_pred_answer.split()
+            ground_truth_tokens = normalized_ground_truth.split()
+            common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
+            num_same = sum(common.values())
+            if num_same == 0:
+                continue
+            precision = 1.0 * num_same / len(prediction_tokens)
+            recall = 1.0 * num_same / len(ground_truth_tokens)
+            f1 = (2 * precision * recall) / (precision + recall)
+            for k in ["em", "acc", "f1"]:
+                final_metric[k] = max(eval(k), final_metric[k])
+
+    else:
+        normalized_pred_answer = normalize_answer(pred_answer)
+        normalized_ground_truth = normalize_answer(labeled_answer)
+
+        em = int(normalized_pred_answer == normalized_ground_truth)
+        acc = int(normalized_ground_truth in normalized_pred_answer)
+    
+        prediction_tokens = normalized_pred_answer.split()
+        ground_truth_tokens = normalized_ground_truth.split()
+        common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
+        num_same = sum(common.values())
+        if num_same == 0:
+            f1 = 0
+        else:
+            precision = 1.0 * num_same / len(prediction_tokens) if len(prediction_tokens) > 0 else 0
+            recall = 1.0 * num_same / len(ground_truth_tokens) if len(ground_truth_tokens) > 0 else 0
+            if (precision + recall) == 0:
+                f1 = 0
+            else:
+                f1 = (2 * precision * recall) / (precision + recall)
+
+        final_metric["em"] = em
+        final_metric["acc"] = acc
+        final_metric["f1"] = f1
+
+        final_metric["math_equal"] = is_equiv(normalized_pred_answer, normalized_ground_truth)
+
+    # print(em, acc, f1, normalized_pred_answer, '|', normalized_ground_truth)
+    return final_metric, pred_answer
+
+
+
+def run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, split, apply_backoff=False):
+    if dataset_name == 'livecode':
+        # Prepare samples and generations for codegen_metrics
+        samples_list = []
+        generations_list = []
+
+        # Collect difficulty levels for per-domain metrics
+        difficulties = []
+        per_difficulty_count = {}
+        num_valid_answer = 0
+
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            difficulty = item.get("difficulty", "Unknown")
+            difficulties.append(difficulty)
+            # Track metrics per domain
+            if difficulty not in per_difficulty_count.keys():
+                per_difficulty_count[difficulty] = 0
+
+            pred_code = extract_answer(item['Output'], mode='codegen')
+            if pred_code != '':
+                num_valid_answer += 1
+                per_difficulty_count[difficulty] += 1
+            # Assuming each item has 'input_output' with 'inputs' and 'outputs'
+            public_test_cases = json.loads(item.get("public_test_cases", "{}"))
+
+            inputs, outputs = [], []
+            for case in public_test_cases:
+                inputs.append(case["input"])
+                outputs.append(case["output"])
+
+            sample = {
+                "input_output": json.dumps({
+                    "inputs": inputs,
+                    "outputs": outputs
+                }),
+            }
+
+            samples_list.append(sample)
+            generations_list.append([pred_code])
+            item['Pred_Answer'] = pred_code
+            item['Question'] = input_prompt
+
+
+        # Call codegen_metrics with pass@1
+        metrics, results, final_metadata = codegen_metrics(
+            samples_list,
+            generations_list,
+            k_list=[1],  # Evaluate the top 1 generated result
+            num_process_evaluate=2,   # Parallel evaluation
+            timeout=10,  # Set timeout to 10 seconds
+            debug=False,  # Enable debug mode
+        )
+        # print('samples_list', samples_list)
+        # print('generations_list', generations_list)
+        # print('metrics', metrics)
+
+        # Extract pass@1
+        pass_at_1 = metrics.get('pass@1', 0.0)
+        detail_pass_at_1 = metrics['detail']['pass@1']
+
+        for item, pass1, res, meta in zip(filtered_data, detail_pass_at_1.values(), results.values(), final_metadata):
+            item['Metrics'] = {'pass@1': pass1}
+            item['Results'] = res
+            item['Final_metadata'] = meta
+
+        # Initialize per-difficulty metrics
+        difficulty_metrics = defaultdict(list)
+        for idx, difficulty in enumerate(difficulties):
+            pass1 = detail_pass_at_1[idx]
+            difficulty_metrics[difficulty].append(pass1)
+
+        # Compute overall pass@1
+        overall_metrics = {
+            'pass@1': pass_at_1,  # / num_valid_answer * len(input_list),
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # Compute per-difficulty pass@1
+        per_difficulty_metrics = {}
+        for difficulty, passes in difficulty_metrics.items():
+            avg_pass = np.mean(passes) if len(passes) > 0 else 0.0
+            num_valid_answer = per_difficulty_count[difficulty]
+            per_difficulty_metrics[difficulty] = {
+                'pass@1': avg_pass,
+                'num_valid_answer': f'{num_valid_answer} of {len(passes)}'
+            }
+
+        # Save the metrics
+        final_metrics = {
+            'overall': overall_metrics,
+            'per_domain': per_difficulty_metrics
+        }
+
+    else:
+        # Existing evaluation for other datasets
+        avg_em, avg_acc, avg_f1, avg_math = [], [], [], []
+        num_valid_answer = 0
+
+        # If the dataset is GPQA, track metrics per domain
+        domain_metrics = {}
+
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            if dataset_name in ['gpqa', 'medmcqa']:
+                labeled_answer = item["Correct Choice"]
+                # labeled_choice_answer = item["Correct Answer"]
+                mode = 'choose'
+            elif dataset_name in ['math500', 'aime', 'amc']:
+                labeled_answer = item["answer"]
+                mode = 'gen'
+            elif dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','frames', 'realqa', 'realqa_new', 'syn_en', 'syn_zh','musique_syn', 'eval', 'new', 'chinese_simpleqa', 'simpleqa', 'nq', 'triviaqa', 'hotpotqa', 'musique', 'bamboogle', '2wiki']:
+                labeled_answer = item["answer"]
+                mode = 'qa'
+            elif dataset_name in ['pubhealth']:
+                labeled_answer = item["answer"]
+                mode = 'choose'
+            else:
+                # raise ValueError(f"Unknown dataset_name: {dataset_name}")
+                labeled_answer = item["answer"]
+                mode = 'qa'
+
+            metric, pred_answer = evaluate_predictions(output=item['Output'], labeled_answer=labeled_answer, mode=mode)
+            item['Pred_Answer'] = pred_answer
+            item['Metrics'] = metric
+            item['Question'] = input_prompt
+
+            # Determine the validity of the predicted answer
+            my_method_valid = (pred_answer != '' and not (mode == 'choose' and dataset_name == 'gpqa' and len(pred_answer) > 1))
+
+            avg_em.append(metric['em'])
+            avg_acc.append(metric['acc'])
+            avg_f1.append(metric['f1'])
+            avg_math.append(metric['math_equal'])
+
+            if my_method_valid:
+                num_valid_answer += 1
+
+            # If the dataset is GPQA, attempt to track metrics per domain
+            if dataset_name == 'gpqa':
+                domain = item.get("High-level domain", "Unknown")
+                if domain not in domain_metrics:
+                    domain_metrics[domain] = {'em': [], 'acc': [], 'f1': [], 'math_equal': [], 'num_valid_answer': 0, 'total_num': 0}
+                domain_metrics[domain]['total_num'] += 1
+                domain_metrics[domain]['em'].append(metric['em'])
+                domain_metrics[domain]['acc'].append(metric['acc'])
+                domain_metrics[domain]['f1'].append(metric['f1'])
+                domain_metrics[domain]['math_equal'].append(metric['math_equal'])
+                if my_method_valid:
+                    domain_metrics[domain]['num_valid_answer'] += 1
+
+        t = time.localtime()
+        result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+        metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+
+        # Compute overall metrics
+        overall_results = {
+            'em': np.mean(avg_em) if len(avg_em) > 0 else 0.0,
+            'acc': np.mean(avg_acc) if len(avg_acc) > 0 else 0.0,
+            'f1': np.mean(avg_f1) if len(avg_f1) > 0 else 0.0,
+            'math_equal': np.mean(avg_math) if len(avg_em) > 0 else 0.0,
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # If the dataset is GPQA, output average metrics per domain
+        domain_avg_metrics = {}
+        if dataset_name == 'gpqa':
+            for dm, m in domain_metrics.items():
+                domain_avg_metrics[dm] = {
+                    'em': np.mean(m['em']) if len(m['em']) > 0 else 0,
+                    'acc': np.mean(m['acc']) if len(m['acc']) > 0 else 0,
+                    'f1': np.mean(m['f1']) if len(m['f1']) > 0 else 0,
+                    'math_equal': np.mean(m['math_equal']) if len(m['math_equal']) > 0 else 0,
+                    'num_valid_answer': f'{m["num_valid_answer"]} of {m["total_num"]}'
+                }
+
+        # 保存总体和分domain的指标
+        final_metrics = {'overall': overall_results}
+        if dataset_name == 'gpqa':
+            final_metrics['per_domain'] = domain_avg_metrics
+
+    t = time.localtime()
+    result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+    metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+    if apply_backoff:
+        result_json_name = output_dir
+        metrics_json_name = output_dir.replace('.json', '.metrics.backoff.json')
+
+    # Save prediction results and metrics
+    with open(os.path.join(output_dir, result_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(filtered_data, json_file, indent=4, ensure_ascii=False)
+
+    with open(os.path.join(output_dir, metrics_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(final_metrics, json_file, indent=4, ensure_ascii=False)
+
+
+
+def run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, split, apply_backoff=False):
+    if dataset_name not in  ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+        raise ValueError(f"Unsupported dataset: {dataset_name}")
+    else:
+        # Existing evaluation for other datasets
+        avg_em, avg_acc, avg_f1, avg_math = [], [], [], []
+        num_valid_answer = 0
+
+        # If the dataset is eval, track metrics per source
+        source_metrics = {}
+
+
+        
+        for item, input_prompt, result in zip(filtered_data, input_list, output_list):
+            if type(result) == str:
+                item['Output'] = result
+            else:
+                item['Output'] = result.outputs[0].text
+            if dataset_name in ['gpqa', 'medmcqa']:
+                labeled_answer = item["Correct Choice"]
+                # labeled_choice_answer = item["Correct Answer"]
+                mode = 'choose'
+            elif dataset_name in ['math500', 'aime', 'amc']:
+                labeled_answer = item["answer"]
+                mode = 'gen'
+            elif dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','frames', 'realqa', 'realqa_new', 'syn_en', 'syn_zh', 'eval','musique_syn', 'new', 'chinese_simpleqa', 'simpleqa', 'nq', 'triviaqa', 'hotpotqa', 'musique', 'bamboogle', '2wiki']:
+                labeled_answer = item["answer"]
+                mode = 'qa'
+            elif dataset_name in ['pubhealth']:
+                labeled_answer = item["answer"]
+                mode = 'choose'
+            else:
+                raise ValueError(f"Unknown dataset_name: {dataset_name}")
+
+            metric, pred_answer = evaluate_predictions(output=item['Output'], labeled_answer=labeled_answer, mode=mode)
+            item['Pred_Answer'] = pred_answer
+            item['Metrics'] = metric
+            item['Question'] = input_prompt
+
+            # Determine the validity of the predicted answer
+            my_method_valid = (pred_answer != '' and not (mode == 'choose' and dataset_name == 'gpqa' and len(pred_answer) > 1))
+
+            avg_em.append(metric['em'])
+            avg_acc.append(metric['acc'])
+            avg_f1.append(metric['f1'])
+            avg_math.append(metric['math_equal'])
+
+            if my_method_valid:
+                num_valid_answer += 1
+
+            # If the dataset is GPQA, attempt to track metrics per source
+            if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+                source = item.get("source", "Unknown")
+                if source not in source_metrics:
+                    source_metrics[source] = {'em': [], 'acc': [], 'f1': [], 'math_equal': [], 'num_valid_answer': 0, 'total_num': 0}
+                source_metrics[source]['total_num'] += 1
+                source_metrics[source]['em'].append(metric['em'])
+                source_metrics[source]['acc'].append(metric['acc'])
+                source_metrics[source]['f1'].append(metric['f1'])
+                source_metrics[source]['math_equal'].append(metric['math_equal'])
+                if my_method_valid:
+                    source_metrics[source]['num_valid_answer'] += 1
+
+        t = time.localtime()
+        result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+        metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+
+        # Compute overall metrics
+        overall_results = {
+            'em': np.mean(avg_em) if len(avg_em) > 0 else 0.0,
+            'acc': np.mean(avg_acc) if len(avg_acc) > 0 else 0.0,
+            'f1': np.mean(avg_f1) if len(avg_f1) > 0 else 0.0,
+            'math_equal': np.mean(avg_math) if len(avg_em) > 0 else 0.0,
+            'num_valid_answer': f'{num_valid_answer} of {len(input_list)}',
+            'query_latency': f'{(total_time / len(input_list) * 1000):.0f} ms',
+        }
+
+        # If the dataset is eval, output average metrics per source
+        source_avg_metrics = {}
+        if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle','eval', 'musique_syn', 'realqa_new', 'realqa']:
+            for dm, m in source_metrics.items():
+                source_avg_metrics[dm] = {
+                    'em': np.mean(m['em']) if len(m['em']) > 0 else 0,
+                    'acc': np.mean(m['acc']) if len(m['acc']) > 0 else 0,
+                    'f1': np.mean(m['f1']) if len(m['f1']) > 0 else 0,
+                    'math_equal': np.mean(m['math_equal']) if len(m['math_equal']) > 0 else 0,
+                    'num_valid_answer': f'{m["num_valid_answer"]} of {m["total_num"]}'
+                }
+
+        # 保存总体和分source的指标
+        final_metrics = {'overall': overall_results}
+        if dataset_name in ['dpo_484', 'no_error_data_871', 'eval_old_500', 'gaia_level3', 'gaia', 'hle', 'eval', 'musique_syn', 'realqa_new', 'realqa']:
+            final_metrics['per_source'] = source_avg_metrics
+
+    t = time.localtime()
+    result_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.json'
+    metrics_json_name = f'{split}.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.metrics.json'
+    if apply_backoff:
+        result_json_name = output_dir
+        metrics_json_name = output_dir.replace('.json', '.metrics.backoff.json')
+
+    # Save prediction results and metrics
+    with open(os.path.join(output_dir, result_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(filtered_data, json_file, indent=4, ensure_ascii=False)
+
+    with open(os.path.join(output_dir, metrics_json_name), mode='w', encoding='utf-8') as json_file:
+        json.dump(final_metrics, json_file, indent=4, ensure_ascii=False)
+
+
+

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/google_search.py

@@ -0,0 +1,416 @@
+import os
+import json
+import requests
+from requests.exceptions import Timeout
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import time
+import concurrent
+from concurrent.futures import ThreadPoolExecutor
+import pdfplumber
+from io import BytesIO
+import re
+import string
+from typing import Optional, Tuple
+from nltk.tokenize import sent_tokenize
+
+# os.environ['http_proxy'] = 'http://127.0.0.1:7890'
+# os.environ['https_proxy'] = 'http://127.0.0.1:7890'
+
+
+# ----------------------- Custom Headers -----------------------
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
+                  'AppleWebKit/537.36 (KHTML, like Gecko) '
+                  'Chrome/58.0.3029.110 Safari/537.36',
+    'Referer': 'https://www.google.com/',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.5',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1'
+}
+
+# Initialize session
+session = requests.Session()
+session.headers.update(headers)
+
+
+
+def remove_punctuation(text: str) -> str:
+    """Remove punctuation from the text."""
+    return text.translate(str.maketrans("", "", string.punctuation))
+
+def f1_score(true_set: set, pred_set: set) -> float:
+    """Calculate the F1 score between two sets of words."""
+    intersection = len(true_set.intersection(pred_set))
+    if not intersection:
+        return 0.0
+    precision = intersection / float(len(pred_set))
+    recall = intersection / float(len(true_set))
+    return 2 * (precision * recall) / (precision + recall)
+
+def extract_snippet_with_context(full_text: str, snippet: str, context_chars: int = 2500) -> Tuple[bool, str]:
+    """
+    Extract the sentence that best matches the snippet and its context from the full text.
+
+    Args:
+        full_text (str): The full text extracted from the webpage.
+        snippet (str): The snippet to match.
+        context_chars (int): Number of characters to include before and after the snippet.
+
+    Returns:
+        Tuple[bool, str]: The first element indicates whether extraction was successful, the second element is the extracted context.
+    # 这个 extract_snippet_with_context 函数的作用是 从一段长文本中找到最符合给定片段（snippet）的句子，并返回包含该句子的一定上下文范围的文本。它的核心逻辑包括 文本预处理、句子匹配、F1 评分计算、上下文截取 等几个步骤。
+    """
+    try:
+        full_text = full_text[:50000]
+
+        snippet = snippet.lower()
+        snippet = remove_punctuation(snippet)
+        snippet_words = set(snippet.split())
+
+        best_sentence = None
+        best_f1 = 0.2
+
+        # sentences = re.split(r'(?<=[.!?]) +', full_text)  # Split sentences using regex, supporting ., !, ? endings
+        sentences = sent_tokenize(full_text)  # Split sentences using nltk's sent_tokenize
+
+        for sentence in sentences:
+            key_sentence = sentence.lower()
+            key_sentence = remove_punctuation(key_sentence)
+            sentence_words = set(key_sentence.split())
+            f1 = f1_score(snippet_words, sentence_words)
+            if f1 > best_f1:
+                best_f1 = f1
+                best_sentence = sentence
+
+        if best_sentence:
+            para_start = full_text.find(best_sentence)
+            para_end = para_start + len(best_sentence)
+            start_index = max(0, para_start - context_chars)
+            end_index = min(len(full_text), para_end + context_chars)
+            context = full_text[start_index:end_index]
+            return True, context
+        else:
+            # If no matching sentence is found, return the first context_chars*2 characters of the full text
+            return False, full_text[:context_chars * 2]
+    except Exception as e:
+        return False, f"Failed to extract snippet context due to {str(e)}"
+
+def extract_text_from_url(url, use_jina=False, jina_api_key=None, snippet: Optional[str] = None):
+    """
+    Extract text from a URL. If a snippet is provided, extract the context related to it.
+
+    Args:
+        url (str): URL of a webpage or PDF.
+        use_jina (bool): Whether to use Jina for extraction.
+        snippet (Optional[str]): The snippet to search for.
+
+    Returns:
+        str: Extracted text or context.
+    """
+    try:
+        # print(f"extract_text_from_url use_jina: {use_jina}\n")
+        if use_jina:
+            jina_headers = {
+                'Authorization': f'Bearer {jina_api_key}',
+                'X-Return-Format': 'markdown',
+                # 'X-With-Links-Summary': 'true'
+            }
+            response = requests.get(f'https://r.jina.ai/{url}', headers=jina_headers).text
+            # Remove URLs
+            pattern = r"\(https?:.*?\)|\[https?:.*?\]"
+            text = re.sub(pattern, "", response).replace('---','-').replace('===','=').replace('   ',' ').replace('   ',' ')
+            print("use jina to extract text successfully")
+        else:
+            # print(f"don't use jina to extract text")
+            response = session.get(url, timeout=20)  # Set timeout to 20 seconds
+            response.raise_for_status()  # Raise HTTPError if the request failed
+            # Determine the content type
+            content_type = response.headers.get('Content-Type', '')
+            if 'pdf' in content_type:
+                # If it's a PDF file, extract PDF text
+                print("Extracting text from PDF...")
+                return extract_pdf_text(url)
+            # Try using lxml parser, fallback to html.parser if unavailable
+            try:
+                # print("use lxml parser to extract text")
+                soup = BeautifulSoup(response.text, 'lxml')
+            except Exception:
+                print("lxml parser not found or failed, falling back to html.parser")
+                soup = BeautifulSoup(response.text, 'html.parser')
+            text = soup.get_text(separator=' ', strip=True)
+
+        if snippet:
+            success, context = extract_snippet_with_context(text, snippet)
+            if success:
+                print("use extract_snippet_with_context to extract text successfully")
+                return context
+            else:
+                print("use extract_snippet_with_context to extract text failed")
+                return text
+        else:
+            # print("no snippet provided")
+            # If no snippet is provided, return directly
+            return text[:8000]
+            # return text[:10000]
+    except requests.exceptions.HTTPError as http_err:
+        return f"HTTP error occurred: {http_err}"
+    except requests.exceptions.ConnectionError:
+        return "Error: Connection error occurred"
+    except requests.exceptions.Timeout:
+        return "Error: Request timed out after 20 seconds"
+    except Exception as e:
+        return f"Unexpected error: {str(e)}"
+
+def fetch_page_content(urls, max_workers=24, use_jina=False, jina_api_key=None, snippets: Optional[dict] = None):
+    """
+    Concurrently fetch content from multiple URLs.
+
+    Args:
+        urls (list): List of URLs to scrape.
+        max_workers (int): Maximum number of concurrent threads.
+        use_jina (bool): Whether to use Jina for extraction.
+        snippets (Optional[dict]): A dictionary mapping URLs to their respective snippets.
+
+    Returns:
+        dict: A dictionary mapping URLs to the extracted content or context.
+    """
+    results = {}
+    max_workers=20
+    print(f"max_workers: {max_workers}")
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        # Use tqdm to display a progress bar
+        futures = {
+            executor.submit(extract_text_from_url, url, use_jina, jina_api_key,snippets.get(url) if snippets else None): url
+            for url in urls
+        }
+        for future in tqdm(concurrent.futures.as_completed(futures), desc="Fetching URLs", total=len(urls)):
+            url = futures[future]
+            # try:
+            #     data = future.result()
+            #     results[url] = data
+            # except Exception as exc:
+            #     results[url] = f"Error fetching {url}: {exc}"
+            # time.sleep(0.2)  # Simple rate limiting
+
+            for _ in range(5): # max retry 5 times
+                try:
+                    data = future.result()
+                    results[url] = data
+                    break
+                except Exception as exc:
+                    results[url] = f"Error fetching {url}: {exc}"
+                    time.sleep(0.2)
+    return results
+
+
+proxies = {
+    "http": "http://127.0.0.1:7890",
+    "https": "http://127.0.0.1:7890"
+}
+
+
+def google_web_search(query, subscription_key, endpoint, market='en-US', language='en', exclude_urls=[],timeout=2000):
+    """
+    Perform a search using the Bing Web Search API with a set timeout.
+
+    Args:
+        query (str): Search query.
+        subscription_key (str): Subscription key for the Bing Search API.
+        endpoint (str): Endpoint for the Bing Search API.
+        market (str): Market, e.g., "en-US" or "zh-CN".
+        language (str): Language of the results, e.g., "en".
+        timeout (int or float or tuple): Request timeout in seconds.
+                                         Can be a float representing the total timeout,
+                                         or a tuple (connect timeout, read timeout).
+
+    Returns:
+        dict: JSON response of the search results. Returns None or raises an exception if the request times out.
+    函数的目标是使用 Bing Web Search API 执行搜索，并返回 JSON 格式的结果。
+    如果请求超时或出现其他问题，返回空字典（{}）或抛出异常
+    """
+    
+    if exclude_urls:
+        
+        for site in exclude_urls:
+            query += f" -site:{site}"
+        print(f"qeury: {query}, exclude_urls: {exclude_urls}")
+    # query = query + " site:en.wikipedia.org"
+    # print(f"query: {query}")
+    payload = json.dumps({
+        "q": query,  # 设��查询内容
+        "num": 11,
+        "mkt": market,  # 设置市场
+        "setLang": language,  # 设置语言
+        "textDecorations": True,  # 启用文本装饰
+        "textFormat": "HTML"  # 设置文本格式
+    })
+    print(f"query: {query}")
+
+    headers = {
+        'X-API-KEY': subscription_key,
+        'Content-Type': 'application/json'
+    }
+    error_cnt = 0
+    while True:
+        if error_cnt == 20:
+            print(f"qery: {query} has tried {error_cnt} times without success, just skip it.")
+            break
+        try:
+            # 发送POST请求
+            response = requests.request("POST", endpoint, headers=headers, data=payload, proxies=proxies, timeout=timeout)
+            # response = requests.request("POST", endpoint, headers=headers, data=payload, timeout=timeout)
+            response.raise_for_status()  # Raise exception if the request failed 检查响应的状态码。如果返回的状态码是 4xx 或 5xx（表示客户端或服务器错误），它将引发 requests.exceptions.HTTPError 异常
+            search_results = response.json() #
+            return search_results
+        except Timeout:
+            error_cnt += 1
+            print(f"error_cnt: {error_cnt}, Bing Web Search request timed out ({timeout} seconds) for query: {query}")
+            time.sleep(5)
+            # return {}  # Or you can choose to raise an exception
+        except requests.exceptions.RequestException as e:
+            error_cnt += 1
+            print(f"error_cnt: {error_cnt}, Error occurred during Bing Web Search request: {e}, payload: {payload}")
+            time.sleep(5)
+            # return {}
+
+
+def extract_pdf_text(url):
+    """
+    Extract text from a PDF.
+
+    Args:
+        url (str): URL of the PDF file.
+
+    Returns:
+        str: Extracted text content or error message.
+    """
+    try:
+        response = session.get(url, timeout=20)  # Set timeout to 20 seconds
+        if response.status_code != 200:
+            return f"Error: Unable to retrieve the PDF (status code {response.status_code})"
+        
+        # Open the PDF file using pdfplumber
+        with pdfplumber.open(BytesIO(response.content)) as pdf:
+            full_text = ""
+            for page in pdf.pages:
+                text = page.extract_text()
+                if text:
+                    full_text += text
+        
+        # Limit the text length
+        cleaned_text = ' '.join(full_text.split()[:600])
+        return cleaned_text
+    except requests.exceptions.Timeout:
+        return "Error: Request timed out after 20 seconds"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# def extract_relevant_info(search_results):
+#     """
+#     Extract relevant information from Bing search results.
+
+#     Args:
+#         search_results (dict): JSON response from the Bing Web Search API.
+
+#     Returns:
+#         list: A list of dictionaries containing the extracted information.
+#     """
+#     useful_info = []
+    
+#     if 'webPages' in search_results and 'value' in search_results['webPages']: # value 通常是一个列表，包含了搜索结果的每个页面信息
+#         for id, result in enumerate(search_results['webPages']['value']):
+#             info = {
+#                 'id': id + 1,  # Increment id for easier subsequent operations 为每个结果分配一个 id，id + 1 是为了让 ID 从 1 开始，而不是从 0 开始。这对后续操作更直观
+#                 'title': result.get('name', ''), # 每个搜索结果中提取标题
+#                 'url': result.get('url', ''), # 每个搜索结果中提取 URL
+#                 'site_name': result.get('siteName', ''), # 每个搜索结果中提取站点名称
+#                 'date': result.get('datePublished', '').split('T')[0], # 提取搜索结果的发布时间
+#                 'snippet': result.get('snippet', ''),  # Remove HTML tags : 提取搜索结果的简短描述（即摘要或片段），result.get('snippet', '')。这里的 snippet 可能包含 HTML 标签，因此需要在后续的处理中可能会清除这些标签
+#                 # Add context content to the information
+#                 'context': ''  # Reserved field to be filled later
+#             }
+#             useful_info.append(info)
+    
+#     return useful_info
+
+def extract_relevant_info(search_results):
+    """
+    Extract relevant information from Bing search results.
+
+    Args:
+        search_results (dict): JSON response from the Bing Web Search API.
+
+    Returns:
+        list: A list of dictionaries containing the extracted information.
+    """
+    useful_info = []
+
+    if search_results == None:
+        return useful_info
+
+    if 'organic' in search_results : # value 通常是一个列表，包含了搜索结果的每个页面信息
+        for id, result in enumerate(search_results['organic']):
+            info = {
+                'id': id + 1,  # Increment id for easier subsequent operations 为每个结果分配一个 id，id + 1 是为了让 ID 从 1 开始，而不是从 0 开始。这对后续操作更直观
+                'title': result.get('title', ''), # 每个搜索结果中提取标题
+                'url': result.get('link', ''), # 每个搜索结果中提取 URL
+                'site_name': result.get('siteName', ''), # 每个搜索结果中提取站点名称
+                'date': result.get('datePublished', '').split('T')[0], # 提取搜索结果的发布时间
+                'snippet': result.get('snippet', ''),  # Remove HTML tags : 提取搜索结果的简短描述（即摘要或片段），result.get('snippet', '')。这里的 snippet 可能包含 HTML 标签，因此需要在后续的处理中可能会清除这些标签
+                # Add context content to the information
+                'context': ''  # Reserved field to be filled later
+            }
+            useful_info.append(info)
+    else:
+        print("No organic results found.")
+    print(f"len of useful_info: {len(useful_info)}")
+    return useful_info
+
+
+# ------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Example usage
+    # Define the query to search
+    # query = "Structure of dimethyl fumarate"
+    
+    # # Subscription key and endpoint for Bing Search API
+    # BING_SUBSCRIPTION_KEY = "cb0d28279a826d7e5cf22d71f683c77ffd4ba27d"
+    # if not BING_SUBSCRIPTION_KEY:
+    #     raise ValueError("Please set the BING_SEARCH_V7_SUBSCRIPTION_KEY environment variable.")
+    
+    # bing_endpoint = "https://google.serper.dev/search"
+    
+    # # Perform the search
+    # print("Performing Bing Web Search...")
+    # search_results = bing_web_search(query, BING_SUBSCRIPTION_KEY, bing_endpoint)
+    # print(search_results)
+
+
+
+    result = bing_web_search("when does season 14 of grey's anatomy come out", 'cb0d28279a826d7e5cf22d71f683c77ffd4ba27d', 'https://google.serper.dev/search')
+
+    print(result)
+    # print("Extracting relevant information from search results...")
+    # extracted_info = extract_relevant_info(search_results)
+
+    # print("Fetching and extracting context for each snippet...")
+    # for info in tqdm(extracted_info, desc="Processing Snippets"):
+    #     full_text = extract_text_from_url(info['url'], use_jina=False, jina_api_key="jina_04d684ee4cc54d2ebe7c43bb7ad4aff0qlkdZGwm14NFBtm5BDkgK9KNf6vQ", snippet=info["snippet"])  # Get full webpage text
+    #     if full_text and not full_text.startswith("Error"):
+    #         success, context = extract_snippet_with_context(full_text, info['snippet'])
+    #         if success:
+    #             info['context'] = context
+    #             print("-------------------")
+    #             print(f"Snippet: {info['snippet']}\nContext: {context}")
+                
+    #         else:
+    #             info['context'] = f"Could not extract context. Returning first 8000 chars: {full_text[:8000]}"
+    #     else:
+    #         info['context'] = f"Failed to fetch full text: {full_text}"
+
+    # print("Your Search Query:", query)
+    # print("Final extracted information with context:")
+    # print(json.dumps(extracted_info, indent=2, ensure_ascii=False))

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/inference.py

@@ -0,0 +1,774 @@
+import os
+import json
+import time
+import re
+from tqdm import tqdm
+import numpy as np
+import torch
+import string
+from typing import Optional, Tuple, List, Dict
+import argparse
+from functools import partial
+
+import multiprocessing
+from transformers import AutoTokenizer
+from vllm import LLM, SamplingParams
+
+from google_search import (
+    google_web_search, 
+    extract_relevant_info, 
+    fetch_page_content, 
+    extract_snippet_with_context
+)
+from evaluate import (
+    run_evaluation, 
+    run_evaluation_for_eval,
+    extract_answer
+)
+from prompts import (
+    get_multiqa_instruction,
+    get_math_instruction,
+    get_task_instruction_openqa,
+    get_task_instruction_math,
+    get_webpage_to_reasonchain_instruction
+)
+from functools import partial
+from openai import OpenAI
+
+from stage_wise_analysis import stage_wise_analysis
+
+# Define special tokens
+BEGIN_SEARCH_QUERY = "<|begin_search_query|>"
+END_SEARCH_QUERY = "<|end_search_query|>"
+BEGIN_SEARCH_RESULT = "<|begin_search_result|>"
+END_SEARCH_RESULT = "<|end_search_result|>"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run SimpleDeepsearcer for various datasets.")
+
+
+    parser.add_argument(
+        '--dataset_name',
+        type=str,
+        required=True,
+        help="Name of the dataset to use."
+    )
+
+    parser.add_argument(
+        '--subset_num',
+        type=int,
+        default=-1,
+        help="Number of examples to process. Defaults to all if not specified."
+    )
+
+    # Search and document retrieval configuration
+    parser.add_argument(
+        '--max_search_limit',
+        type=int,
+        default=10,
+        help="Maximum number of searches per question."
+    )
+
+    parser.add_argument(
+        '--max_turn',
+        type=int,
+        default=15,
+        help="Maximum number of turns."
+    )
+
+    parser.add_argument(
+        '--top_k',
+        type=int,
+        default=10,
+        help="Maximum number of search documents to return."
+    )
+
+    parser.add_argument(
+        '--max_doc_len',
+        type=int,
+        default=3000,
+        help="Maximum length of each searched document."
+    )
+
+    # Model configuration
+    parser.add_argument(
+        '--model_path',
+        type=str,
+        required=True,
+        help="Path to the reasoning model."
+    )
+
+    # Sampling parameters
+    parser.add_argument(
+        '--temperature',
+        type=float,
+        default=0.6,
+        help="Sampling temperature."
+    )
+
+    parser.add_argument(
+        '--top_p',
+        type=float,
+        default=0.95,
+        help="Top-p sampling parameter."
+    )
+
+    parser.add_argument(
+        '--top_k_sampling',
+        type=int,
+        default=40,
+        help="Top-k sampling parameter."
+    )
+
+    parser.add_argument(
+        '--max_tokens',
+        type=int,
+        default=20480,
+        help="Maximum number of tokens to generate."
+    )
+
+    # Bing API Configuration
+    parser.add_argument(
+        '--google_subscription_key',
+        type=str,
+        required=True,
+        help="Google Search API subscription key."
+    )
+
+    parser.add_argument(
+        '--google_endpoint',
+        type=str,
+        default="https://google.serper.dev/search",
+        help="Google Search API endpoint."
+    )
+
+    parser.add_argument(
+        '--cache_dir_base',
+        type=str,
+        required=True,
+        help="cache path."
+    )
+
+    parser.add_argument(
+        '--output_dir_base',
+        type=str,
+        required=True,
+        help="output_dir"
+    )
+
+    parser.add_argument(
+        '--is_exclude_urls',
+        action="store_true",
+        help="is_exclude_urls"
+    )
+
+
+    parser.add_argument(
+        '--summarization_model_path',
+        type=str,
+        required=True,
+        help="Path to the summary model."
+    )
+
+
+    parser.add_argument(
+        '--summarization_model_url',
+        type=str,
+        required=True,
+        help="Base url of the summarization model."
+    )
+
+    return parser.parse_args()
+
+
+
+def webpage_analysis_single(summ_model_url, summ_model_path, prompt) -> str:
+    client_summ_model = OpenAI(
+        base_url=summ_model_url,
+        api_key="EMPTY"
+    )
+    for i in range(10): # max retry 10 times
+        try:
+            completion = client_summ_model.chat.completions.create(
+                model=summ_model_path,
+                max_tokens=8192,
+                temperature=0.6,
+                top_p=0.95,
+                messages=[prompt],
+            )
+            return completion.choices[0].message.content
+        except Exception as e:
+            print(e)
+            time.sleep(1)
+            continue
+    return "None"
+
+def main():
+    args = parse_args()
+    # Extract arguments
+    dataset_name = args.dataset_name
+    subset_num = args.subset_num
+    MAX_SEARCH_LIMIT = args.max_search_limit
+    MAX_TURN = args.max_turn
+    top_k = args.top_k
+    max_doc_len = args.max_doc_len
+    model_path = args.model_path
+    summ_model_path = args.summarization_model_path
+    summ_model_url = args.summarization_model_url
+    temperature = args.temperature
+    top_p = args.top_p
+    top_k_sampling = args.top_k_sampling
+    max_tokens = args.max_tokens
+    google_subscription_key = args.google_subscription_key
+    google_endpoint = args.google_endpoint
+    cache_dir_base = args.cache_dir_base
+    output_dir_base = args.output_dir_base
+    is_exclude_urls = args.is_exclude_urls
+
+    print(f"CUDA_VISIBLE_DEVICES is set to: {os.environ['CUDA_VISIBLE_DEVICES']}")
+   
+    # Data paths based on dataset
+    data_path = f"./data/{dataset_name}.json"
+
+    print('-----------------------')
+    print(f'Using {dataset_name} set.')
+    print('-----------------------')
+
+    # ---------------------- Caching Mechanism ----------------------
+    # Define cache directories and file paths
+    model_name = model_path.split('/')[-1].replace('-instruct', '')
+    cache_dir = cache_dir_base
+    search_cache_path = os.path.join(cache_dir, 'search_cache.json')
+    url_cache_path = os.path.join(cache_dir, 'url_cache.json')
+
+    # Ensure cache directory exists
+    os.makedirs(cache_dir, exist_ok=True)
+
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try: 
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache = json.load(f)
+        except Exception as e:
+            print(f"load search_cache.json error: {e}")
+            search_cache = {}
+
+    else:
+        search_cache = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache = json.load(f)
+        except Exception as e:
+            print(f"load url_cache.json error: {e}")
+            url_cache = {}
+
+    else:
+        url_cache = {}
+
+    # Function to save caches
+    def save_caches():
+        with open(search_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(search_cache, f, ensure_ascii=False, indent=2)
+        with open(url_cache_path, 'w', encoding='utf-8') as f:
+            json.dump(url_cache, f, ensure_ascii=False, indent=2)
+
+    # ---------------------- Reasoning Model Loading ----------------------
+    print(f"Loading tokenizer from {model_path}...")
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = 'left'
+    print("Tokenizer loaded successfully.")
+
+    # Define output directory based on the dataset
+    output_dir = os.path.join(output_dir_base, dataset_name)
+    os.makedirs(output_dir, exist_ok=True)
+
+    print(f"Loading model from {model_path}...")
+    print(f"device_count: {torch.cuda.device_count()}")
+    
+    # Initialize the LLM
+    llm = LLM(
+        model=model_path,
+        tensor_parallel_size=torch.cuda.device_count(),
+        gpu_memory_utilization=0.95,
+
+    )
+    print("Model loaded successfully.")
+
+    # ---------------------- Data Loading ----------------------
+    print(f"Loading data from {data_path}...")
+    with open(data_path, 'r', encoding='utf-8') as json_file:
+        filtered_data = json.load(json_file)
+    print(f"Data loaded successfully. Total examples: {len(filtered_data)}")
+
+    # ---------------------- Batch Generation Function ----------------------
+    def generate_webpage_to_reasonchain_batch(
+        original_questions: List[str],
+        prev_reasonings: List[str],
+        search_queries: List[str],
+        documents: List[str],
+        dataset_name: str,
+        summ_model_url: OpenAI,
+        summ_model_path: str,
+        batch_output_records: List[Dict],  # New parameter to collect outputs
+        coherent: bool = False,
+    ) -> List[str]:
+
+        user_prompts = [
+            get_webpage_to_reasonchain_instruction(r, sq, doc)
+            for r, sq, doc in zip(prev_reasonings, search_queries, documents)
+        ]
+
+
+        prompts = [{"role": "user", "content": up} for up in user_prompts]
+        print("webpage ana prompts[0]")
+        print(prompts[0])
+
+        webpage_analysis_single_to_map = partial(webpage_analysis_single, summ_model_url, summ_model_path)
+        with multiprocessing.Pool(processes=50) as pool:
+            raw_outputs = list(tqdm(pool.imap(webpage_analysis_single_to_map, prompts), total=len(prompts), desc="generate webpage analyses"))
+
+
+        # Count the number of summarization errors
+        sum_error = 0
+        for output in raw_outputs:
+            if output is None or output == "None" or output == "":
+                sum_error += 1
+        print(f"summarization_error: {sum_error}, ratios: {sum_error / len(raw_outputs)}")
+     
+        extracted_infos = [extract_answer(raw, mode='infogen') for raw in raw_outputs]
+
+        for i, (p, r, e) in enumerate(zip(prompts, raw_outputs, extracted_infos)):
+            batch_output_records.append({
+                'prompt': p,
+                'raw_output': r,
+                'extracted_info': e
+            })
+
+        return extracted_infos
+
+    # ---------------------- Preparation of Input Prompts ----------------------
+    input_list = []
+    for item in filtered_data:
+        question = item['Question']
+
+        if dataset_name in ['aime']:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_math(question)
+
+        else:
+            instruction = get_multiqa_instruction(MAX_SEARCH_LIMIT)
+            user_prompt = get_task_instruction_openqa(question)
+            
+        
+        prompt = [{"role": "user", "content": instruction + user_prompt}]
+        prompt = tokenizer.apply_chat_template(prompt, tokenize=False, add_generation_prompt=True)
+        input_list.append(prompt)
+
+    if subset_num != -1:
+        input_list = input_list[:subset_num]
+        filtered_data = filtered_data[:subset_num]
+
+    # Initialize active sequences
+    active_sequences = [{
+        'item': item,
+        'prompt': prompt,
+        'output': '',
+        'finished': False,
+        'history': [],
+        'search_count': 0,
+        'executed_search_queries': set(),
+        'all_info': [],
+    } for item, prompt in zip(filtered_data, input_list)]
+
+    # ---------------------- Generation Function ----------------------
+    def run_generation(sequences: List[Dict], max_tokens: int) -> List:
+        prompts = [s['prompt'] for s in sequences]
+
+        sampling_params = SamplingParams(
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k_sampling,
+            stop=[END_SEARCH_QUERY, tokenizer.eos_token],
+            include_stop_str_in_output=True,
+        )
+        output_list = llm.generate(prompts, sampling_params=sampling_params) 
+        print(f"run_generation completed {len(output_list)}")
+        return output_list
+
+    # Function to extract text between two tags
+    def extract_between(text: str, start_tag: str, end_tag: str) -> Optional[str]:
+        pattern = re.escape(start_tag) + r"(.*?)" + re.escape(end_tag)
+        matches = re.findall(pattern, text, flags=re.DOTALL)
+        if matches:
+            return matches[-1].strip()
+        return None
+
+    def replace_recent_steps(origin_str, replace_str):
+        """
+        Replaces specific steps in the original reasoning steps with new steps.
+        If a replacement step contains "DELETE THIS STEP", that step is removed.
+
+        Parameters:
+        - origin_str (str): The original reasoning steps.
+        - replace_str (str): The steps to replace or delete.
+
+        Returns:
+        - str: The updated reasoning steps after applying replacements.
+        """
+
+        def parse_steps(text):
+            """
+            Parses the reasoning steps from a given text.
+
+            Parameters:
+            - text (str): The text containing reasoning steps.
+
+            Returns:
+            - dict: A dictionary mapping step numbers to their content.
+            """
+            step_pattern = re.compile(r"Step\s+(\d+):\s*")
+            steps = {}
+            current_step_num = None
+            current_content = []
+
+            for line in text.splitlines():
+                step_match = step_pattern.match(line)
+                if step_match:
+                    # If there's an ongoing step, save its content
+                    if current_step_num is not None:
+                        steps[current_step_num] = "\n".join(current_content).strip()
+                    current_step_num = int(step_match.group(1))
+                    content = line[step_match.end():].strip()
+                    current_content = [content] if content else []
+                else:
+                    if current_step_num is not None:
+                        current_content.append(line)
+            
+            # Save the last step if any
+            if current_step_num is not None:
+                steps[current_step_num] = "\n".join(current_content).strip()
+            
+            return steps
+
+        # Parse the original and replacement steps
+        origin_steps = parse_steps(origin_str)
+        replace_steps = parse_steps(replace_str)
+
+        # Apply replacements
+        for step_num, content in replace_steps.items():
+            if "DELETE THIS STEP" in content: 
+                # Remove the step if it exists
+                if step_num in origin_steps:
+                    del origin_steps[step_num]
+            else:
+                # Replace or add the step 
+                origin_steps[step_num] = content
+
+        # Sort the steps by step number
+        sorted_steps = sorted(origin_steps.items())
+
+        # Reconstruct the reasoning steps as a single string
+        new_reasoning_steps = "\n\n".join([f"{content}" for num, content in sorted_steps])
+
+        return new_reasoning_steps
+
+    # ---------------------- Initialize Collection Structure ----------------------
+    # Initialize a list to collect batch outputs
+    batch_output_records = []
+
+    start_time = time.time()
+    turn = 0
+
+    # Main loop until all sequences are finished or maximum turns reached
+    while True:
+        # Identify sequences that need generation
+        sequences_needing_generation = [seq for seq in active_sequences if not seq['finished']]
+
+        if sequences_needing_generation:
+            turn += 1
+            print(f'\n-------------- Turn {turn} --------------')
+            print(f"We have {len(sequences_needing_generation)} sequences needing generation...")
+            outputs = run_generation(sequences_needing_generation, max_tokens) 
+            print("Generation completed, processing outputs...")
+
+            # Initialize batch variables
+            batch_relevant_info = []
+            batch_original_questions = []
+            batch_prev_reasonings = []
+            batch_search_queries = []
+            batch_documents = []
+            batch_sequences = []
+
+            # Collect URLs to fetch across all sequences
+            all_urls_to_fetch = set()
+            url_snippets = {}
+            url_sequence_map = {}  # Map URL to list of sequences needing it
+
+            start_search_time = time.time()
+            # Process each sequence and collect URLs
+            for seq, out in zip(sequences_needing_generation, outputs):
+                text = out.outputs[0].text
+                seq['history'].append(text)
+                # Append generated text to prompt and output
+                seq['prompt'] += text
+                seq['output'] += text
+                seq['all_info'].append({f"turn_{turn}_reason": text})
+                # Extract search query
+                search_query = extract_between(text, BEGIN_SEARCH_QUERY, END_SEARCH_QUERY)
+
+                # If a search query is present and needs to be executed
+                if search_query and seq['output'].rstrip().endswith(END_SEARCH_QUERY):
+                    if seq['search_count'] < MAX_SEARCH_LIMIT and search_query not in seq['executed_search_queries']:
+                        # Execute search, use cache if available
+                        if search_query in search_cache:
+                            results = search_cache[search_query]
+                            print(f"Using cached search results for query: \"{search_query}\"")
+                        else:
+                            try:
+                                if is_exclude_urls and "urls" in seq["item"]["metadata"]: 
+                                    print(f"is_exclude_urls: {is_exclude_urls}")
+                                    exclude_urls = seq["item"]["metadata"]["urls"]
+                                else:
+                                    exclude_urls = []
+
+                                print(f"Execute and cache search for query: \"{search_query}\"")
+                                results = google_web_search(search_query, google_subscription_key, google_endpoint, market='en-US', language='en', exclude_urls=exclude_urls) # 执行搜索
+                                search_cache[search_query] = results
+                                print(f"Executed and cached search for query: \"{search_query}\"")
+                            except Exception as e:
+                                print(f"Error during search query '{search_query}': {e}")
+                                search_cache[search_query] = {}
+                                results = {}
+
+                        # Extract relevant information from Bing search results
+                        relevant_info = extract_relevant_info(results)[:top_k]
+                        seq['relevant_info'] = relevant_info
+
+                        # Extract URLs and snippets
+                        urls_to_fetch = [it['url'] for it in relevant_info]
+                        snippets = {info['url']: info['snippet'] for info in relevant_info if 'snippet' in info}
+
+                        # Filter URLs that are not cached
+                        urls_to_fetch_filtered = [u for u in urls_to_fetch if u not in url_cache]
+                        cached_urls = [u for u in urls_to_fetch if u in url_cache]
+
+                        # Store info for all_urls_to_fetch and url_snippets
+                        for url in urls_to_fetch_filtered:
+                            all_urls_to_fetch.add(url)
+                            url_snippets[url] = snippets.get(url, "") 
+
+                        all_reasoning_steps = seq['output']
+                        all_reasoning_steps = all_reasoning_steps.replace('\n\n', '\n').split("\n")
+
+                        truncated_prev_reasoning = ""
+                        for i, step in enumerate(all_reasoning_steps):
+                            truncated_prev_reasoning += f"Step {i + 1}: {step}\n\n"
+
+                        prev_steps = truncated_prev_reasoning.split('\n\n')
+                        if len(prev_steps) <= 5:
+                            truncated_prev_reasoning = '\n\n'.join(prev_steps)
+                        else:
+                            truncated_prev_reasoning = ''
+                            for i, step in enumerate(prev_steps):
+                                if i == 0 or i >= len(prev_steps) - 4 or BEGIN_SEARCH_QUERY in step or BEGIN_SEARCH_RESULT in step:
+                                    truncated_prev_reasoning += step + '\n\n'
+                                else:
+                                    if truncated_prev_reasoning[-len('\n\n...\n\n'):] != '\n\n...\n\n':
+                                        truncated_prev_reasoning += '...\n\n'
+                        truncated_prev_reasoning = truncated_prev_reasoning.strip('\n')
+
+                        # Collect parameters for batch processing
+                        batch_relevant_info.append(relevant_info)
+                        batch_original_questions.append(seq['item']['Question'])
+                        batch_prev_reasonings.append(truncated_prev_reasoning)
+                        batch_search_queries.append(search_query)
+                        batch_sequences.append(seq)
+
+                        # Update search count and executed queries
+                        seq['search_count'] += 1
+                        seq['executed_search_queries'].add(search_query)
+
+                    elif seq['search_count'] >= MAX_SEARCH_LIMIT:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nThe maximum search limit is exceeded. You are not allowed to search.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        print(f"Search limit reached for query: \"{search_query}\"")
+
+                    elif search_query in seq['executed_search_queries']:
+                        limit_message = f"\n{BEGIN_SEARCH_RESULT}\nYou have searched this query. Please refer to previous results.\n{END_SEARCH_RESULT}\n"
+                        seq['prompt'] += limit_message
+                        seq['output'] += limit_message
+                        seq['history'].append(limit_message)
+                        seq["all_info"].append({f"turn_{turn}_search_limited": limit_message})
+                        print(f"Repeated search for query: \"{search_query}\"")
+                        
+
+                else:
+                    # If no search query needs to be executed, mark the sequence as finished
+                    seq['finished'] = True
+                    print("Sequence marked as complete.")
+
+            print(f"get search time taken: {time.time() - start_search_time}")
+            print(f"all_urls_to_fetch len: {len(all_urls_to_fetch)}, url_cache len: {len(url_cache)}")
+            print(f"all_urls_to_fetch: {all_urls_to_fetch}")
+            # Batch fetch all URLs at once to optimize speed
+            
+            if all_urls_to_fetch:
+                print(f"Fetching {len(all_urls_to_fetch)} URLs...")
+                try:
+                    fetched_contents = fetch_page_content(
+                        list(all_urls_to_fetch),
+                        use_jina=False,
+                        jina_api_key=None,
+                        # snippets=url_snippets  # Do not pass snippets when updating url_cache directly
+                    )
+                    print(f"Fetched {len(fetched_contents)} URLs successfully.")
+                except Exception as e:
+                    print(f"Error during batch URL fetching: {e}")
+                    fetched_contents = {url: f"Error fetching URL: {e}" for url in all_urls_to_fetch}
+                # Update cache with fetched contents
+                for url, content in fetched_contents.items():
+                    url_cache[url] = content
+
+            # After fetching, prepare formatted documents for batch processing
+            for relevant_info in batch_relevant_info:
+                formatted_documents = ""
+                for i, doc_info in enumerate(relevant_info):
+                    url = doc_info['url']
+                    raw_context = url_cache.get(url, "")
+                    doc_info['snippet'] = doc_info['snippet'].replace('<b>','').replace('</b>','')            
+                    success, filtered_context = extract_snippet_with_context(raw_context, doc_info['snippet'], context_chars=max_doc_len)
+                    if success:
+                        print("extract_snippet_with_context")
+                        context = filtered_context
+                    else: 
+                        print(f"use raw_webpage_context, {len(raw_context)}")
+                        context = raw_context[:max_doc_len*2]
+
+                    doc_info['context'] = context
+                    formatted_documents += f"**Web Page {i + 1}:**\n"
+                    formatted_documents += json.dumps(doc_info, ensure_ascii=False, indent=2) + "\n"
+                print(f'formatted_webpage_documents: {len(formatted_documents)}')
+                batch_documents.append(formatted_documents)
+
+            # After fetching, prepare for batch processing if there are any
+            if batch_sequences:
+                print(f"Batch processing {len(batch_sequences)} sequences with generate_webpage_to_reasonchain_batch...")
+                webpage_analyses = generate_webpage_to_reasonchain_batch(
+                    original_questions=batch_original_questions,
+                    prev_reasonings=batch_prev_reasonings,
+                    search_queries=batch_search_queries,
+                    documents=batch_documents,
+                    dataset_name=dataset_name,
+                    summ_model_url=summ_model_url,
+                    summ_model_path=summ_model_path,
+                    batch_output_records=batch_output_records,  # Pass the collection list
+                )
+                print("Batch generation completed, assigning outputs to sequences...")
+
+                for seq, analysis,doc in zip(batch_sequences, webpage_analyses, batch_documents): 
+                    if isinstance(analysis, str):
+                        append_text = f"\n\n{BEGIN_SEARCH_RESULT}{analysis}{END_SEARCH_RESULT}\n\n"
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text) 
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+                    else:
+                        append_text = replace_recent_steps(seq['output'], analysis)
+                        seq['prompt'] += append_text
+                        seq['output'] += append_text
+                        seq['history'].append(append_text)
+                        seq['all_info'].extend([{f"turn_{turn}_search": doc}, {f"turn_{turn}_webpage_analyses": analysis}])
+
+        # Check if all sequences are finished
+        active_sequences_part = [{
+            'item': ele["item"],
+            'prompt': ele['prompt'],
+            'output': ele["output"],
+            'finished': ele["finished"],
+            'history':ele["history"],
+            'search_count': ele["search_count"],
+            'all_info': ele['all_info']
+        } for ele in active_sequences]
+        with open(os.path.join(output_dir, f"turn_{turn}.json"), 'w', encoding='utf-8') as f:
+            json.dump(active_sequences_part, f, ensure_ascii=False, indent=2)
+        unfinished = [seq for seq in active_sequences if not seq['finished']]
+        if not unfinished:
+            break
+        else:
+            if turn >= MAX_TURN:
+                print(f"Maximum number of turns ({MAX_TURN}) reached, stopping.")
+                break
+
+    total_time = time.time() - start_time
+    print(f"Total time taken: {total_time} seconds")
+
+    # ---------------------- Save Batch Output Records to JSON File ----------------------
+    # Define output JSON file path
+    t = time.localtime()
+    batch_output_file = os.path.join(output_dir, f'test.{t.tm_mon}.{t.tm_mday},{t.tm_hour}:{t.tm_min}.info_extract.json')
+
+    # Save batch_output_records to JSON file
+    with open(batch_output_file, 'w', encoding='utf-8') as f:
+        json.dump(batch_output_records, f, ensure_ascii=False, indent=2)
+
+    print(f"Batch outputs saved to {batch_output_file}")
+
+    # Prepare output list for evaluation
+    output_list = [seq['output'] for seq in active_sequences]
+
+    # Run evaluation
+    if dataset_name in ["eval", "gaia"]:
+        run_evaluation_for_eval(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+    else:
+        run_evaluation(filtered_data, input_list, output_list, dataset_name, output_dir, total_time, 'test')
+
+    # ---------------------- Stage-wise Analysis ----------------------
+    turn_files = os.listdir(output_dir)
+    turn_files = [file for file in turn_files if file.startswith("turn_")]
+    max_turn_file = max(turn_files, key=lambda x: int(re.search(r'turn_(\d+)', x).group(1)))
+
+    max_turn_file_path = os.path.join(output_dir, max_turn_file)
+    print(f"max_turn_file_path: {max_turn_file_path}")
+    stage_wise_analysis(model_path, max_turn_file_path)
+
+    # ---------------------- Update Search and URL Cache ----------------------
+    print('Updating Search and URL Cache...')
+    # Load existing caches or initialize empty dictionaries
+    if os.path.exists(search_cache_path):
+        try:
+            with open(search_cache_path, 'r', encoding='utf-8') as f:
+                search_cache_new = json.load(f)
+        except Exception as e:
+            print(f"Error loading search cache: {e}")
+            search_cache_new = {}
+    else:
+        search_cache_new = {}
+
+    if os.path.exists(url_cache_path):
+        try:
+            with open(url_cache_path, 'r', encoding='utf-8') as f:
+                url_cache_new = json.load(f)
+        except Exception as e:
+            print(f"Error loading url cache: {e}")
+            url_cache_new = {}
+    else:
+        url_cache_new = {}
+
+    search_cache.update(search_cache_new)
+    url_cache.update(url_cache_new)
+
+    save_caches()
+
+    print("Process completed.")
+
+if __name__ == "__main__":
+    main()

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/launch_main.sh

@@ -0,0 +1,3 @@
+streamlit run SimpleDeepSearcher_demo_1.py --server.port 7910
+
+# ssh -L 7910:localhost:7910 sunshuang@183.174.229.142

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/launch_reasoning.log

@@ -0,0 +1,113 @@
+INFO 05-28 08:32:45 api_server.py:116] vLLM API server version 0.6.4
+INFO 05-28 08:32:45 api_server.py:117] args: Namespace(host=None, port=5126, ssl_keyfile=None, ssl_certfile=None, ssl_ca_certs=None, ssl_cert_reqs=0, root_path=None, log_level='debug', model='/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41', task='auto', tokenizer=None, skip_tokenizer_init=False, revision=None, code_revision=None, tokenizer_revision=None, tokenizer_mode='auto', chat_template_text_format='string', trust_remote_code=True, allowed_local_media_path=None, download_dir=None, load_format='auto', config_format=<ConfigFormat.AUTO: 'auto'>, dtype='auto', kv_cache_dtype='auto', quantization_param_path=None, max_model_len=None, guided_decoding_backend='outlines', distributed_executor_backend=None, worker_use_ray=False, pipeline_parallel_size=1, tensor_parallel_size=2, max_parallel_loading_workers=None, ray_workers_use_nsight=False, block_size=16, enable_prefix_caching=False, disable_sliding_window=False, use_v2_block_manager=False, num_lookahead_slots=0, seed=0, swap_space=4, cpu_offload_gb=0, gpu_memory_utilization=0.9, num_gpu_blocks_override=None, max_num_batched_tokens=None, max_num_seqs=256, max_logprobs=20, disable_log_stats=False, quantization=None, rope_scaling=None, rope_theta=None, hf_overrides=None, enforce_eager=False, max_seq_len_to_capture=8192, disable_custom_all_reduce=False, tokenizer_pool_size=0, tokenizer_pool_type='ray', tokenizer_pool_extra_config=None, limit_mm_per_prompt=None, mm_processor_kwargs=None, enable_lora=False, enable_lora_bias=False, max_loras=1, max_lora_rank=16, lora_extra_vocab_size=256, lora_dtype='auto', long_lora_scaling_factors=None, max_cpu_loras=None, fully_sharded_loras=False, enable_prompt_adapter=False, max_prompt_adapters=1, max_prompt_adapter_token=0, device='auto', num_scheduler_steps=1, multi_step_stream_outputs=True, scheduler_delay_factor=0.0, enable_chunked_prefill=None, speculative_model=None, speculative_model_quantization=None, num_speculative_tokens=None, speculative_disable_mqa_scorer=False, speculative_draft_tensor_parallel_size=None, speculative_max_model_len=None, speculative_disable_by_batch_size=None, ngram_prompt_lookup_max=None, ngram_prompt_lookup_min=None, spec_decoding_acceptance_method='rejection_sampler', typical_acceptance_sampler_posterior_threshold=None, typical_acceptance_sampler_posterior_alpha=None, disable_logprobs_during_spec_decoding=None, model_loader_extra_config=None, ignore_patterns=[], preemption_mode=None, served_model_name=None, qlora_adapter_name_or_path=None, otlp_traces_endpoint=None, collect_detailed_traces=None, disable_async_output_proc=False, scheduling_policy='fcfs', override_neuron_config=None, override_pooler_config=None, disable_log_requests=False)
+INFO 05-28 08:32:49 config.py:350] This model supports multiple tasks: {'generate', 'embedding'}. Defaulting to 'generate'.
+INFO 05-28 08:32:49 config.py:1020] Defaulting to use mp for distributed inference
+WARNING 05-28 08:32:49 arg_utils.py:1013] Chunked prefill is enabled by default for models with max_model_len > 32K. Currently, chunked prefill might not work with some features or models. If you encounter any issues, please disable chunked prefill by setting --enable-chunked-prefill=False.
+WARNING 05-28 08:32:49 arg_utils.py:1075] [DEPRECATED] Block manager v1 has been removed, and setting --use-v2-block-manager to True or False has no effect on vLLM behavior. Please remove --use-v2-block-manager in your engine argument. If your use case is not supported by SelfAttnBlockSpaceManager (i.e. block manager v2), please file an issue with detailed information.
+INFO 05-28 08:32:49 config.py:1136] Chunked prefill is enabled with max_num_batched_tokens=512.
+INFO 05-28 08:32:49 llm_engine.py:249] Initializing an LLM engine (v0.6.4) with config: model='/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41', speculative_config=None, tokenizer='/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, override_neuron_config=None, tokenizer_revision=None, trust_remote_code=True, dtype=torch.bfloat16, max_seq_len=131072, download_dir=None, load_format=LoadFormat.AUTO, tensor_parallel_size=2, pipeline_parallel_size=1, disable_custom_all_reduce=False, quantization=None, enforce_eager=False, kv_cache_dtype=auto, quantization_param_path=None, device_config=cuda, decoding_config=DecodingConfig(guided_decoding_backend='outlines'), observability_config=ObservabilityConfig(otlp_traces_endpoint=None, collect_model_forward_time=False, collect_model_execute_time=False), seed=0, served_model_name=/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41, num_scheduler_steps=1, chunked_prefill_enabled=True multi_step_stream_outputs=True, enable_prefix_caching=False, use_async_output_proc=True, use_cached_outputs=False, chat_template_text_format=string, mm_processor_kwargs=None, pooler_config=None)
+INFO 05-28 08:32:50 custom_cache_manager.py:17] Setting Triton cache manager to: vllm.triton_utils.custom_cache_manager:CustomCacheManager
+INFO 05-28 08:32:50 selector.py:135] Using Flash Attention backend.
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:50 selector.py:135] Using Flash Attention backend.
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:50 multiproc_worker_utils.py:215] Worker ready; awaiting tasks
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:51 utils.py:960] Found nccl from library libnccl.so.2
+INFO 05-28 08:32:51 utils.py:960] Found nccl from library libnccl.so.2
+INFO 05-28 08:32:51 pynccl.py:69] vLLM is using nccl==2.21.5
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:51 pynccl.py:69] vLLM is using nccl==2.21.5
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:51 custom_all_reduce_utils.py:242] reading GPU P2P access cache from /root/.cache/vllm/gpu_p2p_access_cache_for_0,1.json
+INFO 05-28 08:32:51 custom_all_reduce_utils.py:242] reading GPU P2P access cache from /root/.cache/vllm/gpu_p2p_access_cache_for_0,1.json
+INFO 05-28 08:32:51 shm_broadcast.py:236] vLLM message queue communication handle: Handle(connect_ip='127.0.0.1', local_reader_ranks=[1], buffer=<vllm.distributed.device_communicators.shm_broadcast.ShmRingBuffer object at 0x7f3d811fb460>, local_subscribe_port=39377, remote_subscribe_port=None)
+INFO 05-28 08:32:51 model_runner.py:1072] Starting to load model /capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41...
+(VllmWorkerProcess pid=7046) INFO 05-28 08:32:51 model_runner.py:1072] Starting to load model /capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+INFO 05-28 08:33:13 model_runner.py:1077] Loading model weights took 30.7292 GB
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:13 model_runner.py:1077] Loading model weights took 30.7292 GB
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:14 worker.py:232] Memory profiling results: total_gpu_memory=79.32GiB initial_memory_usage=32.14GiB peak_torch_memory=30.83GiB memory_usage_post_profile=32.88Gib non_torch_memory=2.11GiB kv_cache_size=38.44GiB gpu_memory_utilization=0.90
+INFO 05-28 08:33:14 worker.py:232] Memory profiling results: total_gpu_memory=79.32GiB initial_memory_usage=32.14GiB peak_torch_memory=32.15GiB memory_usage_post_profile=33.13Gib non_torch_memory=2.36GiB kv_cache_size=36.87GiB gpu_memory_utilization=0.90
+INFO 05-28 08:33:14 distributed_gpu_executor.py:57] # GPU blocks: 18877, # CPU blocks: 2048
+INFO 05-28 08:33:14 distributed_gpu_executor.py:61] Maximum concurrency for 131072 tokens per request: 2.30x
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:16 model_runner.py:1400] Capturing cudagraphs for decoding. This may lead to unexpected consequences if the model is not static. To run the model in eager mode, set 'enforce_eager=True' or use '--enforce-eager' in the CLI.
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:16 model_runner.py:1404] If out-of-memory error occurs during cudagraph capture, consider decreasing `gpu_memory_utilization` or switching to eager mode. You can also reduce the `max_num_seqs` as needed to decrease memory usage.
+INFO 05-28 08:33:16 model_runner.py:1400] Capturing cudagraphs for decoding. This may lead to unexpected consequences if the model is not static. To run the model in eager mode, set 'enforce_eager=True' or use '--enforce-eager' in the CLI.
+INFO 05-28 08:33:16 model_runner.py:1404] If out-of-memory error occurs during cudagraph capture, consider decreasing `gpu_memory_utilization` or switching to eager mode. You can also reduce the `max_num_seqs` as needed to decrease memory usage.
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:27 custom_all_reduce.py:224] Registering 4515 cuda graph addresses
+INFO 05-28 08:33:27 custom_all_reduce.py:224] Registering 4515 cuda graph addresses
+(VllmWorkerProcess pid=7046) INFO 05-28 08:33:27 model_runner.py:1518] Graph capturing finished in 11 secs, took 0.38 GiB
+INFO 05-28 08:33:27 model_runner.py:1518] Graph capturing finished in 11 secs, took 0.39 GiB
+INFO 05-28 08:33:27 launcher.py:19] Available routes are:
+INFO 05-28 08:33:27 launcher.py:27] Route: /openapi.json, Methods: GET, HEAD
+INFO 05-28 08:33:27 launcher.py:27] Route: /docs, Methods: GET, HEAD
+INFO 05-28 08:33:27 launcher.py:27] Route: /docs/oauth2-redirect, Methods: GET, HEAD
+INFO 05-28 08:33:27 launcher.py:27] Route: /redoc, Methods: GET, HEAD
+INFO 05-28 08:33:27 launcher.py:27] Route: /health, Methods: GET
+INFO 05-28 08:33:27 launcher.py:27] Route: /generate, Methods: POST
+INFO:     Started server process [6677]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://0.0.0.0:5126 (Press CTRL+C to quit)
+INFO:     127.0.0.1:47818 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:35:16 async_llm_engine.py:208] Added request 7a9a2ee18fb446afbd060d51c224190e.
+INFO 05-28 08:35:16 metrics.py:449] Avg prompt throughput: 2.4 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.1%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:35:18 async_llm_engine.py:176] Finished request 7a9a2ee18fb446afbd060d51c224190e.
+INFO:     127.0.0.1:32768 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:35:43 async_llm_engine.py:208] Added request 0274d63783a9424895ebf3967037eea6.
+INFO 05-28 08:35:43 metrics.py:449] Avg prompt throughput: 18.7 tokens/s, Avg generation throughput: 4.5 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.2%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:35:45 async_llm_engine.py:176] Finished request 0274d63783a9424895ebf3967037eea6.
+INFO:     127.0.0.1:34688 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:36:18 async_llm_engine.py:208] Added request e91a7ffc50e64c208a8562539904b167.
+INFO 05-28 08:36:18 metrics.py:449] Avg prompt throughput: 11.5 tokens/s, Avg generation throughput: 3.2 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.1%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:36:23 async_llm_engine.py:176] Finished request e91a7ffc50e64c208a8562539904b167.
+INFO:     127.0.0.1:46322 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:36:46 async_llm_engine.py:208] Added request 2079f99c40994405b88a84c49074e96a.
+INFO 05-28 08:36:46 metrics.py:449] Avg prompt throughput: 11.0 tokens/s, Avg generation throughput: 9.2 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.1%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:36:51 async_llm_engine.py:176] Finished request 2079f99c40994405b88a84c49074e96a.
+INFO:     127.0.0.1:37476 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:36:59 async_llm_engine.py:208] Added request c35e0822295247489b4b19365703d8be.
+INFO 05-28 08:36:59 metrics.py:449] Avg prompt throughput: 25.1 tokens/s, Avg generation throughput: 18.9 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.1%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:37:01 async_llm_engine.py:176] Finished request c35e0822295247489b4b19365703d8be.
+INFO:     127.0.0.1:43218 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 08:37:18 async_llm_engine.py:208] Added request 007a4fe3f4bc41eeaebe4edfbb4d698a.
+INFO 05-28 08:37:18 metrics.py:449] Avg prompt throughput: 27.0 tokens/s, Avg generation throughput: 5.3 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.2%, CPU KV cache usage: 0.0%.
+INFO 05-28 08:37:20 async_llm_engine.py:176] Finished request 007a4fe3f4bc41eeaebe4edfbb4d698a.
+INFO:     127.0.0.1:33394 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 09:11:47 async_llm_engine.py:208] Added request 6e201846b67c4419933e05e2f670de1c.
+INFO 05-28 09:11:47 metrics.py:449] Avg prompt throughput: 0.2 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.1%, CPU KV cache usage: 0.0%.
+INFO 05-28 09:11:52 metrics.py:449] Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 58.1 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.2%, CPU KV cache usage: 0.0%.
+INFO 05-28 09:11:52 async_llm_engine.py:176] Finished request 6e201846b67c4419933e05e2f670de1c.
+INFO:     127.0.0.1:38640 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 09:12:08 async_llm_engine.py:208] Added request 920b955f49c74fe48b8f2442bbd29176.
+INFO 05-28 09:12:08 metrics.py:449] Avg prompt throughput: 32.5 tokens/s, Avg generation throughput: 1.1 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.2%, CPU KV cache usage: 0.0%.
+INFO 05-28 09:12:10 async_llm_engine.py:176] Finished request 920b955f49c74fe48b8f2442bbd29176.
+INFO:     127.0.0.1:57750 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 09:12:36 async_llm_engine.py:208] Added request f1a574e3675e4d659f7264c0930c9f28.
+INFO 05-28 09:12:36 metrics.py:449] Avg prompt throughput: 26.3 tokens/s, Avg generation throughput: 5.3 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.4%, CPU KV cache usage: 0.0%.
+INFO 05-28 09:12:38 async_llm_engine.py:176] Finished request f1a574e3675e4d659f7264c0930c9f28.
+INFO:     127.0.0.1:33516 - "POST /generate HTTP/1.1" 200 OK
+INFO 05-28 09:13:06 async_llm_engine.py:208] Added request dbbd72486eef4c78b2a1955745e5754d.
+INFO 05-28 09:13:06 metrics.py:449] Avg prompt throughput: 40.4 tokens/s, Avg generation throughput: 4.5 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.5%, CPU KV cache usage: 0.0%.
+INFO 05-28 09:13:08 async_llm_engine.py:176] Finished request dbbd72486eef4c78b2a1955745e5754d.
+INFO 05-28 10:08:05 launcher.py:57] Shutting down FastAPI HTTP server.
+INFO:     Shutting down
+INFO:     Waiting for application shutdown.
+INFO:     Application shutdown complete.
+INFO 05-28 10:08:05 async_llm_engine.py:62] Engine is gracefully shutting down.
+INFO 05-28 10:08:06 multiproc_worker_utils.py:120] Killing local vLLM worker processes
+[rank0]:[W528 10:08:06.073770299 ProcessGroupNCCL.cpp:1250] Warning: WARNING: process group has NOT been destroyed before we destruct ProcessGroupNCCL. On normal program exit, the application should call destroy_process_group to ensure that any pending NCCL operations have finished in this process. In rare cases this process can exit before this point and block the progress of another member of the process group. This constraint has always been present,  but this warning has only been added since PyTorch 2.4 (function operator())
+/opt/aps/python/lib/python3.10/multiprocessing/resource_tracker.py:224: UserWarning: resource_tracker: There appear to be 1 leaked shared_memory objects to clean up at shutdown
+  warnings.warn('resource_tracker: There appear to be %d '

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/launch_reasoning.sh

@@ -0,0 +1,8 @@
+export CUDA_VISIBLE_DEVICES=0,1
+export MODEL_PATH=/capacity/userdata/ss/sft_search/JOB:2284#LR:1e-5#BASE:QwQ-32B#TOKEN:QwQ-32B#BSZ:2#ACC:4_no_error_data_871/checkpoint-41
+python -m vllm.entrypoints.api_server \
+    --port 5126 \
+    --model $MODEL_PATH \
+    --tensor-parallel-size 2 \
+    --trust-remote-code 
+# ssh -R 5129:localhost:5129 -NT -o ServerAliveInterval=60 aibox-142

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/launch_summ.sh

@@ -0,0 +1,11 @@
+
+# export CUDA_VISIBLE_DEVICES=0,1
+# nohup vllm serve /capacity/userdata/models/QwQ-32B \
+#     --tensor-parallel-size=2 \
+#     --gpu-memory-utilization 0.95 \
+#     --port 8003 > /opt/aps/workdir/sunshuang/deep_search/search_o1/sft_logs/vllm_serve_qwq_1.log 2>&1 &
+export CUDA_VISIBLE_DEVICES=2,3
+vllm serve /capacity/userdata/models/QwQ-32B \
+    --tensor-parallel-size=2 \
+    --gpu-memory-utilization 0.95 \
+    --port 8003

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/lcb_runner/benchmarks/__init__.py

@@ -0,0 +1,13 @@
+from lcb_runner.benchmarks.code_generation import (
+    CodeGenerationProblem,
+    load_code_generation_dataset,
+    load_code_generation_dataset_not_fast,
+)
+from lcb_runner.benchmarks.test_output_prediction import (
+    TestOutputPredictionProblem,
+    load_test_prediction_dataset,
+)
+from lcb_runner.benchmarks.code_execution import (
+    CodeExecutionProblem,
+    load_code_execution_dataset,
+)

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/lcb_runner/benchmarks/code_execution.py

@@ -0,0 +1,67 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class CodeExecutionProblem:
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    function_name: str
+    code: str
+    input: str
+    output: str
+    id: str
+    problem_id: str
+    numsteps: int
+
+    def __post_init__(self):
+        pass
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "function_name": self.function_name,
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+            "id": self.id,
+            "problem_id": self.problem_id,
+            "numsteps": self.numsteps,
+            "output_list": output_list,
+            "pred_list": pred_list,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "code": self.code,
+            "input": self.input,
+            "output": self.output,
+        }
+
+
+def load_code_execution_dataset(release_version="release_v1") -> list[CodeExecutionProblem]:
+    dataset = load_dataset("livecodebench/execution-v2", split="test")
+    dataset = [CodeExecutionProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_execution_dataset()

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/lcb_runner/benchmarks/code_generation.py

@@ -0,0 +1,139 @@
+import json
+import zlib
+import pickle
+import base64
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+class Platform(Enum):
+    LEETCODE = "leetcode"
+    CODEFORCES = "codeforces"
+    ATCODER = "atcoder"
+
+
+class Difficulty(Enum):
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+
+
+class TestType(Enum):
+    STDIN = "stdin"
+    FUNCTIONAL = "functional"
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: TestType
+
+    def __post_init__(self):
+        self.testtype = TestType(self.testtype)
+        # if self.testtype == TestType.FUNCTIONAL:
+        #     self.input = json.loads(self.input)
+        #     self.output = json.loads(self.output)
+
+
+@dataclass
+class CodeGenerationProblem:
+    question_title: str
+    question_content: str
+    platform: Platform
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    starter_code: str
+    difficulty: Difficulty
+    public_test_cases: list[Test]
+    private_test_cases: list[Test]
+    metadata: dict
+
+    def __post_init__(self):
+        self.platform = Platform(self.platform)
+        self.difficulty = Difficulty(self.difficulty)
+        self.contest_date = datetime.fromisoformat(self.contest_date)
+
+        self.public_test_cases = json.loads(self.public_test_cases)  # type: ignore
+        self.public_test_cases = [Test(**t) for t in self.public_test_cases]
+
+        try:
+            self.private_test_cases = json.loads(self.private_test_cases)  # type: ignore
+        except:
+            self.private_test_cases = json.loads(
+                pickle.loads(
+                    zlib.decompress(
+                        base64.b64decode(self.private_test_cases.encode("utf-8"))  # type: ignore
+                    )
+                )
+            )  # type: ignore
+        self.private_test_cases = [Test(**t) for t in self.private_test_cases]
+
+        self.metadata = json.loads(self.metadata)  # type: ignore
+
+    def insert_output(self, output_list: list[str], code_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "platform": self.platform.value,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "starter_code": self.starter_code,
+            "difficulty": self.difficulty.value,
+            "output_list": output_list,
+            "code_list": code_list,
+        }
+
+    def insert_output_evaluation(
+        self,
+        output_list: list[str],
+        code_list: list[str],
+        graded_list: list[bool],
+        **kwargs,
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        for k, v in kwargs.items():
+            output[k] = v
+        return output
+
+    def get_evaluation_sample(self):
+        return {
+            "input_output": json.dumps(
+                {
+                    "inputs": [
+                        t.input
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "outputs": [
+                        t.output
+                        for t in self.public_test_cases + self.private_test_cases
+                    ],
+                    "fn_name": self.metadata.get("func_name", None),
+                }
+            ),
+        }
+
+
+def load_code_generation_dataset(release_version="release_v1") -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation_lite", split="test", version_tag=release_version, trust_remote_code=True)
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+def load_code_generation_dataset_not_fast(release_version="release_v1") -> list[CodeGenerationProblem]:
+    dataset = load_dataset("livecodebench/code_generation", split="test")
+    dataset = [CodeGenerationProblem(**p) for p in dataset]  # type: ignore
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_code_generation_dataset()

deep_search/search_o1/scripts/infer_github/SimpleDeepSearcher_new/inference/lcb_runner/benchmarks/test_output_prediction.py

@@ -0,0 +1,70 @@
+import json
+from enum import Enum
+from datetime import datetime
+from dataclasses import dataclass
+
+from datasets import load_dataset
+
+
+@dataclass
+class Test:
+    input: str
+    output: str
+    testtype: str
+
+
+@dataclass
+class TestOutputPredictionProblem:
+    question_title: str
+    question_content: str
+    question_id: str
+    contest_id: str
+    contest_date: datetime
+    difficulty: str
+    test: list[Test]
+    starter_code: str
+    function_name: str
+    test_id: int
+
+    def __post_init__(self):
+        self.test = [Test(**t) for t in json.loads(self.test)]  # type: ignore
+
+    def insert_output(self, output_list: list[str], pred_list: list[str]) -> dict:
+        return {
+            "question_title": self.question_title,
+            "question_content": self.question_content,
+            "question_id": self.question_id,
+            "contest_id": self.contest_id,
+            "contest_date": self.contest_date.isoformat(),
+            "difficulty": self.difficulty,
+            "output_list": output_list,
+            "pred_list": pred_list,
+            "test_id": self.test_id,
+            "function_name": self.function_name,
+            "starter_code": self.starter_code,
+        }
+
+    def insert_output_evaluation(
+        self, output_list: list[str], code_list: list[str], graded_list: list[bool]
+    ) -> dict:
+        output = self.insert_output(output_list, code_list)
+        output["graded_list"] = graded_list
+        output["pass@1"] = graded_list.count(True) / len(graded_list)
+        return output
+
+    def get_evaluation_sample(self) -> dict:
+        return {
+            "input": self.question_content,
+            "output": self.test[0].output,
+        }
+
+
+def load_test_prediction_dataset(release_version="release_v1") -> list[TestOutputPredictionProblem]:
+    dataset = load_dataset("livecodebench/test_generation", split="test")  # type: ignore
+    dataset = [TestOutputPredictionProblem(**d) for d in dataset]
+    print(f"Loaded {len(dataset)} prediction problems")
+    return dataset
+
+
+if __name__ == "__main__":
+    dataset = load_test_prediction_dataset()