from web_search_agent.web_search_agent import WebSearchAgent from reading_agent.reading_agent import ReadingAgent import yaml from openai import OpenAI from typing import List from webpage import SearchResultInfo import json from agent_action import * import time from types import SimpleNamespace import concurrent.futures from web_search_agent.search.search_api import web_search import threading import time import os from tqdm import tqdm import requests class Handler: def __init__(self, agent_config, client, handler_config): self.web_search_agent = WebSearchAgent(config=agent_config, client=client) self.reading_agent = ReadingAgent(config=agent_config, client=client) self.id_to_context: dict[int, list[ActionInfo]] = {} self.agent_config = agent_config self.client = client self.handler_config = handler_config self.api_result_dict = {} if os.path.exists(self.agent_config["query_save_path"]): with open(self.agent_config["query_save_path"], 'r', encoding='utf-8') as f: self.api_result_dict = json.load(f) self.query_save_path = self.agent_config["query_save_path"] self.id_to_context_lock = threading.Lock() def search_and_add_to_dict(self, search_query, cur_api_result_dict, cur_api_result_dict_lock): try: organic = web_search(search_query, self.agent_config) with cur_api_result_dict_lock: cur_api_result_dict[search_query] = { 'timestamp': time.time(), 'organic': organic } except Exception as e: print(f"Error in search_and_add_to_dict for query '{search_query}': {str(e)}") def handle_execution_api(self, query_contents: List[dict]): print("开始处理函数调用") cur_api_result_dict = {} cur_api_result_dict_lock = threading.Lock() cache_hit = 0 total_search_call = 0 for query_content in query_contents: if 'tool_call' not in query_content: continue if 'name' not in query_content['tool_call'] or query_content['tool_call']['name'] != 'web_search': continue if 'arguments' not in query_content['tool_call']: continue if 'query' not in query_content['tool_call']['arguments']: continue query_list = query_content['tool_call']['arguments']['query'] if not isinstance(query_list, list): continue total_search_call += len(query_list) for query in query_list: if type(query) != str: continue if query in self.api_result_dict and len(self.api_result_dict[query]['organic']) > 0 and (time.time() - self.api_result_dict[query]['timestamp'] <= 60 * 60 * 24 * 7): cache_hit += 1 continue cur_api_result_dict[query] = { "timestamp": time.time(), "organic": [] } if total_search_call > 0: print(f"本轮总共调用{total_search_call}次，命中{cache_hit}次，命中率为：{cache_hit/total_search_call}", flush=True) start_time = time.time() api_future_list = [] with concurrent.futures.ThreadPoolExecutor(max_workers=1000) as api_executor: for search_query in cur_api_result_dict: api_future = api_executor.submit(self.search_and_add_to_dict, search_query, cur_api_result_dict, cur_api_result_dict_lock) api_future_list.append(api_future) print(f"搜索用时{time.time()-start_time}", flush=True) for api_future in concurrent.futures.as_completed(api_future_list): api_future.result() for key in cur_api_result_dict: self.api_result_dict[key] = cur_api_result_dict[key] with open(self.agent_config["query_save_path"], 'w', encoding='utf-8') as f: json.dump(self.api_result_dict, f, indent=4, ensure_ascii=False) print("缓存已保存", flush=True) start_time = time.time() future_to_content = [] with concurrent.futures.ThreadPoolExecutor(max_workers=1000) as handle_executor: for query_content in query_contents: future = handle_executor.submit(self.handle_single_query, query_content, self.api_result_dict) future_to_content.append(future) # 等待所有任务完成 for i, future in enumerate(future_to_content): query_contents[i]["content"] = future.result() print(f"爬取/阅读网页用时{time.time()-start_time}") print("处理函数调用结束") return query_contents def handle_execution(self): while True: has_query = False while not has_query: with open(self.handler_config.signal_writing_file, 'r', encoding='utf-8') as f: signal_contents = json.load(f) if signal_contents['signal'] == self.handler_config.QUERY_SIGNAL: has_query = True else: time.sleep(10) print("开始处理函数调用") with open(self.handler_config.signal_writing_file, 'r', encoding='utf-8') as f: signal_contents = json.load(f) assert signal_contents['signal'] == self.handler_config.QUERY_SIGNAL with open(self.handler_config.data_writing_file, 'r', encoding="utf-8") as f: query_contents = json.load(f) cur_api_result_dict = {} cur_api_result_dict_lock = threading.Lock() cache_hit = 0 total_search_call = 0 for query_content in query_contents: if 'tool_call' not in query_content: continue if 'name' not in query_content['tool_call'] or query_content['tool_call']['name'] != 'web_search': continue if 'arguments' not in query_content['tool_call']: continue if 'query' not in query_content['tool_call']['arguments']: continue query_list = query_content['tool_call']['arguments']['query'] if not isinstance(query_list, list): continue total_search_call += len(query_list) for query in query_list: if type(query) != str: continue if query in self.api_result_dict and len(self.api_result_dict[query]['organic']) > 0 and (time.time() - self.api_result_dict[query]['timestamp'] <= 60 * 60 * 24 * 7): cache_hit += 1 continue cur_api_result_dict[query] = { "timestamp": time.time(), "organic": [] } if total_search_call > 0: print(f"本轮总共调用{total_search_call}次，命中{cache_hit}次，命中率为：{cache_hit/total_search_call}", flush=True) start_time = time.time() api_future_list = [] with concurrent.futures.ThreadPoolExecutor(max_workers=1000) as api_executor: for search_query in cur_api_result_dict: api_future = api_executor.submit(self.search_and_add_to_dict, search_query, cur_api_result_dict, cur_api_result_dict_lock) api_future_list.append(api_future) print(f"搜索用时{time.time()-start_time}", flush=True) for api_future in concurrent.futures.as_completed(api_future_list): api_future.result() for key in cur_api_result_dict: self.api_result_dict[key] = cur_api_result_dict[key] with open(self.agent_config["query_save_path"], 'w', encoding='utf-8') as f: json.dump(self.api_result_dict, f, indent=4, ensure_ascii=False) print("缓存已保存", flush=True) start_time = time.time() future_to_content = [] with concurrent.futures.ThreadPoolExecutor(max_workers=1000) as handle_executor: for query_content in query_contents: future = handle_executor.submit(self.handle_single_query, query_content, self.api_result_dict) future_to_content.append(future) # 等待所有任务完成 for future in concurrent.futures.as_completed(future_to_content): future.result() print(f"爬取/阅读网页用时{time.time()-start_time}") with open(self.handler_config.data_writing_file, 'w', encoding="utf-8") as f: json.dump(query_contents, f, indent=4, ensure_ascii=False) with open(self.handler_config.data_writing_file, 'r', encoding='utf-8') as f: query_contents_check = json.load(f) assert query_contents == query_contents_check with open(self.handler_config.signal_writing_file, 'w', encoding='utf-8') as f: json.dump({'signal': self.handler_config.RESPONSE_SIGNAL}, f, indent=4, ensure_ascii=False) print("处理函数调用结束") def foward_to_server(self): server_url_list = self.agent_config['server_url_list'] server_cnt = len(server_url_list) while True: has_query = False while not has_query: with open(self.handler_config.signal_writing_file, 'r', encoding='utf-8') as f: signal_contents = json.load(f) if signal_contents['signal'] == self.handler_config.QUERY_SIGNAL: has_query = True else: time.sleep(10) print("开始处理函数调用") with open(self.handler_config.signal_writing_file, 'r', encoding='utf-8') as f: signal_contents = json.load(f) assert signal_contents['signal'] == self.handler_config.QUERY_SIGNAL with open(self.handler_config.data_writing_file, 'r', encoding="utf-8") as f: query_contents = json.load(f) if len(query_contents) == 0: handler_result_list = [] else: batch_cnt_per_server = query_contents[0]["total_number"] // server_cnt + 1 server_query_contents_list = [[] for _ in range(server_cnt)] for query_content in query_contents: server_query_contents_list[query_content['idx'] // batch_cnt_per_server].append(query_content) with concurrent.futures.ThreadPoolExecutor(max_workers=server_cnt) as api_executor: api_future_list = [] for server_idx in range(server_cnt): api_future = api_executor.submit(self.post_request, server_url_list[server_idx], server_query_contents_list[server_idx],server_idx) api_future_list.append(api_future) handler_result_list = [] for i, future in enumerate(api_future_list): handler_result_list += future.result() print(len(handler_result_list), flush=True) with open(self.handler_config.data_writing_file, 'w', encoding="utf-8") as f: json.dump(handler_result_list, f, indent=4, ensure_ascii=False) with open(self.handler_config.data_writing_file, 'r', encoding='utf-8') as f: handler_result_list_check = json.load(f) assert handler_result_list == handler_result_list_check with open(self.handler_config.signal_writing_file, 'w', encoding='utf-8') as f: json.dump({'signal': self.handler_config.RESPONSE_SIGNAL}, f, indent=4, ensure_ascii=False) print("处理函数调用结束") def post_request(self, server_url: str, query_contents: List[dict],server_cnt): if not query_contents: return query_contents while True: try: response = requests.post(f"{server_url}/handle_execution", json={"query_contents": query_contents}, timeout=999) return response.json()['query_contents'] except Exception as e: print(f"{server_cnt} Error occurred: {e}",flush=True) depth += 1 time.sleep(1) def handle_single_query(self, query_content: dict, api_result_dict: dict): try: idx = query_content["idx"] question = query_content["question"] if idx in self.id_to_context: # 如果question不一致，清除缓存 if len(self.id_to_context[idx]) > 0 and question != self.id_to_context[idx][0].user_query: with self.id_to_context_lock: self.id_to_context[idx] = [] search_thinking = query_content["think"] tool_call = query_content["tool_call"] assert "name" in tool_call, "no vliad function name in tool_call" assert "arguments" in tool_call, "no valid arguments in tool_call" assert tool_call["name"] in ["web_search", "browse_webpage"], "invalid tool name" if tool_call["name"] == "web_search": assert "query" in tool_call["arguments"], "no valid query in tool_call" assert isinstance(tool_call["arguments"]["query"], list), "query should be a list" elif tool_call["name"] == "browse_webpage": assert "url_list" in tool_call["arguments"], "no valid url_list in tool_call" assert isinstance(tool_call["arguments"]["url_list"], list), "url_list should be a list" assert len(tool_call["arguments"]["url_list"]) >= 1, "url_list number must be greater than 0" fuc_name = tool_call["name"] arguments = tool_call["arguments"] assert fuc_name in ["web_search", "browse_webpage"], "error tool call" if fuc_name == "web_search": print("web search start!", flush=True) search_query_list = arguments["query"] assert isinstance(search_query_list, list), "error search args(query_list)" search_query_list = search_query_list[0:3] # only perform first 3 search queries web_page_info_list_batch = self.web_search_agent.search_web_batch(user_query=question, search_query_list=search_query_list, api_result_dict=api_result_dict) search_result_info_list = [SearchResultInfo( search_query=search_query_list[j], web_page_info_list=web_page_info_list )for j, web_page_info_list in enumerate(web_page_info_list_batch)] cur_action_info = ActionInfo(user_query=question, search_thinking=search_thinking, search_query_list=search_query_list, search_result_info_list=search_result_info_list) if idx not in self.id_to_context: with self.id_to_context_lock: self.id_to_context[idx] = [] with self.id_to_context_lock: self.id_to_context[idx].append(cur_action_info) content = [] for search_result_info in search_result_info_list: search_query = search_result_info.search_query ret_web_page_info_list = [] for web_page_info in search_result_info.web_page_info_list: ret_web_page_info_list.append({ "title": web_page_info.title, "url": web_page_info.url, "quick_summary": web_page_info.quick_summary }) content.append({ "search_query": search_query, "web_page_info_list": ret_web_page_info_list }) return content elif fuc_name == "browse_webpage": url_list = arguments["url_list"] assert isinstance(url_list, list), "error browse args" assert len(url_list) >= 1, "browse page number must be greater than 0" assert len(self.id_to_context[idx]) >= 1, "no search result" assert question == self.id_to_context[idx][-1].user_query, "question not match" action_info = self.id_to_context[idx][-1] read_webpage_list: List[WebPageInfo] = self.reading_agent.read_batch(user_query=question, search_result_info_list=action_info.search_result_info_list, url_list=url_list, web_search_agent=self.web_search_agent) content = [] for read_webpage in read_webpage_list: information = [] for page_read_info in read_webpage.page_read_info_list: if page_read_info.used: continue information.append({ "page_number": page_read_info.page_number, "page_summary": page_read_info.page_summary }) page_read_info.used = True content.append({ "url": read_webpage.url, "information": information }) return content else: raise ValueError(f"invalid tool call: {fuc_name}") except Exception as e: print(f"error: {e}") return [] if __name__ == "__main__": config = yaml.safe_load(open("./scrl/handler/config.yaml")) handler_config = SimpleNamespace( data_writing_file="./signal/data.json", signal_writing_file="./signal/signal.json", RESPONSE_SIGNAL=0, QUERY_SIGNAL=1, ) client = OpenAI( api_key="sk-xxx", base_url="xxxx" ) handler = Handler(agent_config=config, client=client, handler_config=handler_config) handler.foward_to_server()