From 404a62dfa23ae680c90ec8bb40a7d68fc5e4e0df Mon Sep 17 00:00:00 2001 From: agi Date: Thu, 20 Apr 2023 00:43:55 +0200 Subject: [PATCH 01/16] Basic implementation of an plugin system for OA --- .../oasst_inference_server/chat_repository.py | 3 +- .../oasst_inference_server/routes/chats.py | 1 + .../oasst_inference_server/routes/configs.py | 67 +++ .../oasst_inference_server/routes/workers.py | 3 + .../oasst_inference_server/schemas/chat.py | 2 + inference/worker/PLUGINS.md | 37 ++ inference/worker/chat_chain.py | 420 ++++++++++++++++++ inference/worker/chat_chain_prompts.py | 55 +++ inference/worker/chat_chain_utils.py | 216 +++++++++ inference/worker/hf_langchain_inference.py | 46 ++ inference/worker/interface.py | 2 + inference/worker/opeanapi_parser.py | 81 ++++ .../worker/plugins/calculator/ai-plugin.json | 18 + inference/worker/plugins/calculator/icon.png | Bin 0 -> 172927 bytes inference/worker/plugins/calculator/main.py | 88 ++++ inference/worker/requirements.txt | 3 + inference/worker/work.py | 19 +- .../oasst_shared/schemas/inference.py | 81 +++- package-lock.json | 6 + website/package-lock.json | 46 +- website/package.json | 1 + website/public/locales/en/common.json | 12 +- .../src/components/Chat/ChatConfigDrawer.tsx | 4 +- .../src/components/Chat/ChatConfigSummary.tsx | 2 +- website/src/components/Chat/ChatContext.tsx | 5 +- .../src/components/Chat/ChatConversation.tsx | 9 +- website/src/components/Chat/ChatForm.tsx | 15 +- .../src/components/Chat/ChatMessageEntry.tsx | 12 +- website/src/components/Chat/ChatSection.tsx | 3 +- .../src/components/Chat/PluginsChooser.tsx | 220 +++++++++ .../components/Messages/BaseMessageEntry.tsx | 7 +- .../Messages/PluginUsageDetails.tsx | 147 ++++++ website/src/lib/oasst_inference_client.ts | 19 + website/src/lib/routes.ts | 4 + website/src/pages/api/chat/plugin_config.ts | 20 + website/src/pages/chat/[id].tsx | 13 +- website/src/types/Chat.ts | 11 + 37 files changed, 1658 insertions(+), 40 deletions(-) create mode 100644 inference/worker/PLUGINS.md create mode 100644 inference/worker/chat_chain.py create mode 100644 inference/worker/chat_chain_prompts.py create mode 100644 inference/worker/chat_chain_utils.py create mode 100644 inference/worker/hf_langchain_inference.py create mode 100644 inference/worker/opeanapi_parser.py create mode 100644 inference/worker/plugins/calculator/ai-plugin.json create mode 100644 inference/worker/plugins/calculator/icon.png create mode 100644 inference/worker/plugins/calculator/main.py create mode 100644 package-lock.json create mode 100644 website/src/components/Chat/PluginsChooser.tsx create mode 100644 website/src/components/Messages/PluginUsageDetails.tsx create mode 100644 website/src/pages/api/chat/plugin_config.ts diff --git a/inference/server/oasst_inference_server/chat_repository.py b/inference/server/oasst_inference_server/chat_repository.py index d37bc981cb..ee4b396bd0 100644 --- a/inference/server/oasst_inference_server/chat_repository.py +++ b/inference/server/oasst_inference_server/chat_repository.py @@ -79,12 +79,13 @@ async def abort_work(self, message_id: str, reason: str) -> models.DbMessage: await self.session.refresh(message) return message - async def complete_work(self, message_id: str, content: str) -> models.DbMessage: + async def complete_work(self, message_id: str, content: str, work_parameters: inference.WorkParameters) -> models.DbMessage: logger.debug(f"Completing work on message {message_id}") message = await self.get_assistant_message_by_id(message_id) message.state = inference.MessageState.complete message.work_end_at = datetime.datetime.utcnow() message.content = content + message.work_parameters = work_parameters await self.session.commit() logger.debug(f"Completed work on message {message_id}") await self.session.refresh(message) diff --git a/inference/server/oasst_inference_server/routes/chats.py b/inference/server/oasst_inference_server/routes/chats.py index be06227596..a3211a3859 100644 --- a/inference/server/oasst_inference_server/routes/chats.py +++ b/inference/server/oasst_inference_server/routes/chats.py @@ -102,6 +102,7 @@ async def create_assistant_message( work_parameters = inference.WorkParameters( model_config=model_config, sampling_parameters=request.sampling_parameters, + plugins=request.plugins, ) assistant_message = await ucr.initiate_assistant_message( parent_id=request.parent_id, diff --git a/inference/server/oasst_inference_server/routes/configs.py b/inference/server/oasst_inference_server/routes/configs.py index e2b8b58f5c..04de1adb9e 100644 --- a/inference/server/oasst_inference_server/routes/configs.py +++ b/inference/server/oasst_inference_server/routes/configs.py @@ -1,9 +1,23 @@ import fastapi import pydantic +import requests +import json +import yaml +from loguru import logger from oasst_inference_server.settings import settings from oasst_shared import model_configs from oasst_shared.schemas import inference + +# NOTE: Replace this with plugins that we will provide out of the box +DUMMY_PLUGINS = [ + inference.PluginEntry( + url="http://192.168.0.35:8085/ai-plugin.json", + enabled=False, + trusted=True, + ), +] + router = fastapi.APIRouter( prefix="/configs", tags=["configs"], @@ -73,3 +87,56 @@ async def get_model_configs() -> list[ModelConfigInfo]: for model_config_name in model_configs.MODEL_CONFIGS if (settings.allowed_model_config_names == "*" or model_config_name in settings.allowed_model_config_names_list) ] + +@router.post("/plugin_config") +async def get_plugin_config(plugin: inference.PluginEntry) -> inference.PluginEntry | fastapi.HTTPException: + plugin_config = None + try: + response = requests.get(plugin.url) + response.raise_for_status() + except requests.exceptions.RequestException: + return fastapi.HTTPException(status_code=404, detail="Plugin not found") + + config = {} + try: + content_type = response.headers.get('Content-Type') + if 'application/json' in content_type or plugin.url.endswith('.json'): + config = json.loads(response.text) + elif 'application/yaml' in content_type or 'application/x-yaml' in content_type or plugin.url.endswith('.yaml') or plugin.url.endswith('.yml'): + config = yaml.safe_load(response.text) + else: + raise Exception(f"Unsupported content type: {content_type}. Only JSON and YAML are supported.") + + plugin_config = inference.PluginConfig(**config) + except Exception as e: + return fastapi.HTTPException(status_code=404, detail="Failed to parse plugin config, error: " + str(e)) + + return inference.PluginEntry(url=plugin.url, enabled=plugin.enabled, plugin_config=plugin_config) + +@router.get("/builtin_plugins") +async def get_builtin_plugins() -> list[inference.PluginEntry] | fastapi.HTTPException: + plugins = [] + + for plugin in DUMMY_PLUGINS: + try: + response = requests.get(plugin.url) + response.raise_for_status() + except requests.exceptions.RequestException: + logger.warning(f"Failed to fetch plugin config from {plugin.url}") + continue + + try: + plugin_config = inference.PluginConfig(**response.json()) + except ValueError: + logger.warning(f"Failed to parse plugin config from {plugin.url}") + continue + + final_plugin: inference.PluginEntry = inference.PluginEntry( + url=plugin.url, + enabled=plugin.enabled, + trusted=plugin.trusted, + plugin_config=plugin_config, + ) + plugins.append(final_plugin) + + return plugins diff --git a/inference/server/oasst_inference_server/routes/workers.py b/inference/server/oasst_inference_server/routes/workers.py index aea450d9e4..d0a53c55eb 100644 --- a/inference/server/oasst_inference_server/routes/workers.py +++ b/inference/server/oasst_inference_server/routes/workers.py @@ -340,9 +340,12 @@ async def handle_generated_text_response( message_id = work_response_container.message_id async with deps.manual_create_session() as session: cr = chat_repository.ChatRepository(session=session) + work_parameters = work_response_container.work_request.parameters + work_parameters = work_parameters.copy(update={"used_plugin": response.used_plugin}) message = await cr.complete_work( message_id=message_id, content=response.text, + work_parameters=work_parameters, ) logger.info(f"Completed work for {message_id=}") message_packet = inference.InternalFinishedMessageResponse( diff --git a/inference/server/oasst_inference_server/schemas/chat.py b/inference/server/oasst_inference_server/schemas/chat.py index dc0147ab54..6c30576de7 100644 --- a/inference/server/oasst_inference_server/schemas/chat.py +++ b/inference/server/oasst_inference_server/schemas/chat.py @@ -14,6 +14,8 @@ class CreateAssistantMessageRequest(pydantic.BaseModel): parent_id: str model_config_name: str sampling_parameters: inference.SamplingParameters = pydantic.Field(default_factory=inference.SamplingParameters) + plugins: list[inference.PluginEntry] = pydantic.Field(default_factory=list[inference.PluginEntry]) + used_plugin: inference.PluginUsed | None = None class PendingResponseEvent(pydantic.BaseModel): diff --git a/inference/worker/PLUGINS.md b/inference/worker/PLUGINS.md new file mode 100644 index 0000000000..5e0fa9edbb --- /dev/null +++ b/inference/worker/PLUGINS.md @@ -0,0 +1,37 @@ +# Plugin system for OA +This is a basic implementation of support for external augmentation and OpenAI/ChatGPT plugins into the Open-Assistant. +In the current state, this is more of a proof-of-concept and should be considered to be used behind some experimental flag. + + ## Architecture + There is now some kind of middleware between work.py(worker) and the final prompt that is passed to the inference server for generation and streaming. +That middleware is responsible for checking if there is an enabled plugin in the userland/UI and if so, it will take over the job of creating curated pre-prompts for plugin usage, as well as generating subsequent calls to LLM(inner monologues) in order to generate the final externally **augmented** prompt, that will be passed back to the worker and next to the inference, for final LLM generation/streaming tokens to the frontend. +## Plugins +Plugins are in essence just pretty wrappers around some kind of API-s and serve a purpose to help LLM utilize it more precisely and reliably, so they can be quite useful and powerful augmentation tools for Open-Assistant. +Two main parts of a plugin are the ai-plugin.json file, which is just the main descriptor of a plugin, and the second part is OpenAPI specification of the plugin API-s. + +Here is OpenAI plugins [specification](https://platform.openai.com/docs/plugins/getting-started) that is currently partially supported with this system. + +For now, only non-authentication-based plugins are supported. +Some of them are: + - https://www.klarna.com/.well-known/ai-plugin.json + - https://www.joinmilo.com/.well-known/ai-plugin.json + +And quite a few of them can be found on this website [plugin "store" wellknown.ai](https://www.wellknown.ai/) + +One of the ideas of the plugin system is that we can have some internal OA plugins, which will be like out-of-the-box plugins, and there could be endless third-party community-developed plugins as well. + +There is one python based plugin called **calculator**, included in this system for now, as a proof of concept and as a learning material of how one could create own plugins. + +### Notes regarding the reliability and performance and the limitations of the plugin system +Performance can vary a lot depending on the models and plugins used. Some of them work better some worse, but that aspect should improve as we get better and better models. +One of the biggest limitations at the moment is context size and instruction following capabilities. +And that is combated with some prompt tricks, truncations of the plugin OpenAPI descriptions and dynamically including/excluding parts of the prompts in the internal processing of the subsequent generations of intermediate texts (inner monologues). +More of the limitations and possible alternatives are explained in code comments. + +The current approach is somewhat hybrid I would say, and relies on the zero-shot capabilities of a model. +There will be one more branch with the plugin system that will be a bit different approach than this one as it will be utilizing other smaller embedding transformer models and vector stores, so we can do A/B testing of the system alongside new OA model releases. + +## Relevant files for the inference side of the plugin system +- chat_chain.py +- chat_chain_utils.py *(tweaking tools/plugin description string generation can help for some models)* +- chat_chain_prompts.py *(tweaking prompts can help also)* diff --git a/inference/worker/chat_chain.py b/inference/worker/chat_chain.py new file mode 100644 index 0000000000..a0e614076a --- /dev/null +++ b/inference/worker/chat_chain.py @@ -0,0 +1,420 @@ +import datetime +import interface +import transformers +from typing import Tuple +from langchain.agents import Tool +from oasst_shared.model_configs import ModelConfig +from oasst_shared.schemas import inference +from langchain.prompts import PromptTemplate +from langchain.memory import ConversationBufferMemory +from hf_langchain_inference import HFInference +from settings import settings +from chat_chain_utils import (extract_tool_and_input, use_tool, + prepare_prompt, compose_tools_from_plugin) +from chat_chain_prompts import ( + PREFIX, SUFFIX, V2_PROMPTER_PREFIX, + V2_ASST_PREFIX, HUMAN_PREFIX, ASSISTANT_PREFIX, OBSERVATION_SEQ +) +from loguru import logger + + +# NOTE: Max depth of retries for tool usage +MAX_DEPTH = 4 +MAX_TOOL_RESPONSE_TOKENS = 256 + +# NOTE: If we want to exclude tools description from final prompt, +# to save ctx token space, but it can hurt output quality, especially if +# truncation kicks in! +REMOVE_TOOLS_FROM_FINAL_PROMPT = True + +current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + +llm = HFInference( + inference_server_url=settings.inference_server_url, + max_new_tokens=512, + stop_sequences=[], + top_k=50, + temperature=0.2, + repetition_penalty=(1 / 0.83), + seed=42, +) + + +def populate_memory(memory: ConversationBufferMemory, + work_request: inference.WorkRequest) -> None: + for message in work_request.thread.messages[:-1]: + if (message.role == "prompter" and + message.state == inference.MessageState.manual and message.content): + memory.chat_memory.add_user_message(message.content) + elif (message.role == "assistant" and + message.state == inference.MessageState.complete and + message.content): + memory.chat_memory.add_ai_message(message.content) + + +def handle_plugin_usage(input_prompt: str, + prompt_template: PromptTemplate, + language: str, + tools: list[Tool], + memory: ConversationBufferMemory, + plugin: inference.PluginEntry | None, + parameters: interface.GenerateStreamParameters, + worker_config: inference.WorkerConfig, + tokenizer: transformers.PreTrainedTokenizer, + ) -> Tuple[str, inference.PluginUsed]: + execution_details = inference.PluginExecutionDetails( + inner_monologue=[], + final_tool_output="", + final_prompt="", + final_generation_assisted=False, + error_message="", + status="failure", + ) + plugin_used = inference.PluginUsed( + name=None, + url=None, + execution_details=execution_details, + ) + + if plugin is None: + return input_prompt, plugin_used + + chain_finished = False + achieved_depth = 0 + assisted = False + inner_prompt = "" + inner_monologue = [] + + eos_token = "" + if hasattr(tokenizer, "eos_token"): + eos_token = tokenizer.eos_token + + tools_names = [tool.name for tool in tools] + + init_prompt = f"{input_prompt}{eos_token}{V2_ASST_PREFIX}" + memory, init_prompt = prepare_prompt(init_prompt, + prompt_template, + memory, + tools_names, + current_time, + language, + tokenizer, + worker_config) + + # NOTE: Do not strip() any of the outputs ever, as it will degrade the + # instruction following performance, at least with + # `OpenAssistant/oasst-sft-6-llama-30b-epoch-1 model` + logger.info(f"#################### init_prompt: {init_prompt}") + chain_response = llm.generate(prompts=[init_prompt], + stop=[ASSISTANT_PREFIX, + OBSERVATION_SEQ, + f"\n{OBSERVATION_SEQ}"]).generations[0][0].text + chain_response = chain_response.replace("\n\n", "\n") + + inner_monologue.append("In: " + str(init_prompt)) + inner_monologue.append("Out: " + str(chain_response)) + + # out_1 -> tool name/assistant prefix + # out_2 -> tool input/assistant response + out_1, out_2 = extract_tool_and_input(llm_output=chain_response, + ai_prefix=ASSISTANT_PREFIX) + + # whether model decided to use Plugin or not + assisted = False if ASSISTANT_PREFIX in out_1 else True + chain_finished = not assisted + + # Check if there is need to go deeper + while not chain_finished and assisted and achieved_depth < MAX_DEPTH: + tool_response = use_tool(out_1, out_2, tools) + + # Save previous chain response, that we will use for the final prompt + prev_chain_response = chain_response + + new_prompt = f"{input_prompt}{eos_token}{V2_ASST_PREFIX}{chain_response}{OBSERVATION_SEQ} {tool_response}" + memory, new_prompt = prepare_prompt(new_prompt, + prompt_template, + memory, + tools_names, + current_time, + language, + tokenizer, + worker_config) + + # NOTE: Do not strip() any of the outputs ever, as it will degrade the + # instruction following performance, at least with + # `OpenAssistant/oasst-sft-6-llama-30b-epoch-1 model` + logger.info(f"#################### new_prompt: {new_prompt}") + chain_response = llm.generate(prompts=[new_prompt], + stop=[ASSISTANT_PREFIX, + OBSERVATION_SEQ, + f"\n{OBSERVATION_SEQ}"]).generations[0][0].text + chain_response = chain_response.replace("\n\n", "\n") + + inner_monologue.append("In: " + str(new_prompt)) + inner_monologue.append("Out: " + str(chain_response)) + + out_1, out_2 = extract_tool_and_input(llm_output=chain_response, ai_prefix=ASSISTANT_PREFIX) + # Did model decided to use Plugin again or not? + assisted = False if ASSISTANT_PREFIX in out_1 else True + + # NOTE: Check if tool response contains ERROR string, this is something + # that we would like to avoid, but until models are better, we will + # help them with this... + # for now models, sometime decides to retry, when tool usage reports + # error, but sometime it just ignore error... + if (tool_response.find("ERROR") != -1 and assisted is False): + chain_response = prev_chain_response + assisted = True + + # Now LLM is done with using the plugin, + # so we need to generate the final prompt + if not assisted: + chain_finished = True + + if REMOVE_TOOLS_FROM_FINAL_PROMPT: + TEMPLATE = f"""{V2_PROMPTER_PREFIX}{PREFIX}{SUFFIX}""" + input_variables = [ + "input", + "chat_history", + "language", + "current_time" + ] + + prompt_template = PromptTemplate( + input_variables=input_variables, template=TEMPLATE + ) + tools_names = None + + final_input = f"{input_prompt}{eos_token}{V2_ASST_PREFIX}{prev_chain_response}{OBSERVATION_SEQ} {tool_response}" + memory, inner_prompt = prepare_prompt(final_input, + prompt_template, + memory, + tools_names, + current_time, + language, + tokenizer, + worker_config) + + inner_prompt = f"{inner_prompt}\nThought: Should I use a tool? No\n{ASSISTANT_PREFIX}: " + + plugin_used.execution_details.inner_monologue = inner_monologue + plugin_used.execution_details.final_tool_output = tool_response + plugin_used.execution_details.final_prompt = inner_prompt + plugin_used.execution_details.final_generation_assisted = True + plugin_used.execution_details.achieved_depth = achieved_depth + 1 + plugin_used.execution_details.status = "success" + plugin_used.name = getattr(plugin.plugin_config, 'name_for_human', None) + plugin_used.trusted = getattr(plugin, 'trusted', None) + plugin_used.url = getattr(plugin, 'url', None) + + return inner_prompt, plugin_used + achieved_depth += 1 + + plugin_used.name = getattr(plugin.plugin_config, 'name_for_human', None) + plugin_used.trusted = getattr(plugin, 'trusted', None) + plugin_used.url = getattr(plugin, 'url', None) + plugin_used.execution_details.inner_monologue = inner_monologue + + # bring back ASSISTANT_PREFIX to chain_response, + # that was omitted with stop=[ASSISTANT_PREFIX] + chain_response = f"{chain_response}{ASSISTANT_PREFIX}: " + + # Return non-assisted response + if chain_finished: + # Malformed non-assisted LLM output + if not out_2 or out_2 == "": + plugin_used.execution_details.status = "failure" + plugin_used.execution_details.error_message = "Malformed LLM output" + return init_prompt, plugin_used + + plugin_used.execution_details.status = "success" + return init_prompt + chain_response + ASSISTANT_PREFIX + ": ", plugin_used + else: + # Max depth reached, just try to answer without using a tool + plugin_used.execution_details.final_prompt = init_prompt + plugin_used.execution_details.achieved_depth = achieved_depth + plugin_used.execution_details.status = "failure" + plugin_used.execution_details.error_message = f"Max depth reached: {MAX_DEPTH}" + init_prompt = f"{init_prompt}Thought: Should I use a tool? No\n{ASSISTANT_PREFIX}: " + return init_prompt , plugin_used + + +def handle_conversation(work_request: inference.WorkRequest, + worker_config: inference.WorkerConfig, + parameters: interface.GenerateStreamParameters, + tokenizer: transformers.PreTrainedTokenizer) -> Tuple[str, inference.PluginUsed | None]: + try: + original_prompt = work_request.thread.messages[-1].content + if not original_prompt: + raise ValueError("Prompt is empty") + + language = "English" + + # Get one and only one enabled plugin + # TODO: Add support for multiple plugins at once + # maybe... should be explored + plugin = next((p for p in parameters.plugins if p.enabled), None) + + # Compose tools from plugin, where every endpoint of plugin will become + # one tool, and return prepared prompt with instructions + tools_instructions_template, tools = compose_tools_from_plugin(plugin) + plugin_enabled = len(tools) + + eos_token = "" + if hasattr(tokenizer, "eos_token"): + eos_token = tokenizer.eos_token + + memory = ConversationBufferMemory(memory_key="chat_history", + input_key="input", + output_key='output', + ai_prefix=ASSISTANT_PREFIX, + human_prefix=HUMAN_PREFIX) + + populate_memory(memory, work_request) + + TEMPLATE = f"""{V2_PROMPTER_PREFIX}{PREFIX}{tools_instructions_template}{SUFFIX}""" + input_variables = [ + "input", + "chat_history", + "language", + "current_time", + ] + (["tools_names"] if plugin_enabled else []) + + # NOTE: Should we pass language from the UI here? + prompt_template = PromptTemplate( + input_variables=input_variables, template=TEMPLATE + ) + + # Run trough plugin chain. Returns PluginUsed and final prompt + # that will be passed to worker for final completion with LLM + # using sampling settings derived from frontend UI + if plugin_enabled: + return handle_plugin_usage(original_prompt, + prompt_template, + language, + tools, + memory, + plugin, + parameters, + worker_config, + tokenizer) + + # Just regular prompt template without plugin chain. + # Here is prompt in format of a template, that includes some + # external/ "realtime" data, such as current date&time and language + # that can be passed from frontend here. + input = f"{original_prompt}{eos_token}{V2_ASST_PREFIX}" + memory, init_prompt = prepare_prompt(input, + prompt_template, + memory, + None, + current_time, + language, + tokenizer, + worker_config) + return init_prompt, None + + except Exception as e: + logger.error(f"Error while handling conversation: {e}") + return "", None + + +# NOTE: Only for local DEV and prompt "engineering" +# some of the plugins that can be used for testing: +# - https://www.klarna.com/.well-known/ai-plugin.json +# - https://nla.zapier.com/.well-known/ai-plugin.json (this one is behind auth) +# - https://chat-calculator-plugin.supportmirage.repl.co/.well-known/ai-plugin.json (error responses seems to be html) +# - https://www.joinmilo.com/.well-known/ai-plugin.json (works quite well, but +# is very simple, so it's not very useful for testing) +if __name__ == "__main__": + plugin = inference.PluginEntry( + enabled=True, + url="https://www.joinmilo.com/.well-known/ai-plugin.json", + plugin_config=inference.PluginConfig( + name_for_human="Local dev plugin", + name_for_model="Local dev plugin", + description_for_model="Local dev plugin", + description_for_human="Local dev plugin", + schema_version="0.0.1", + api={"type": "openapi", + "url": "http://localhost:8082/openapi.json", + "has_user_authentication": False}, + auth={"type": "none"}, + ) + ) + + model_config = ModelConfig( + model_id="decapoda-research/llama-30b-hf", + max_input_length=1024, + max_total_length=2048, + ) + + work_parameters = inference.WorkParameters( + model_config=model_config, + do_sample=True, + seed=42, + plugins=[plugin] + ) + parameters = interface.GenerateStreamParameters.from_work_parameters(work_parameters) + + worker_config = inference.WorkerConfig( + model_config=model_config, + model_id=model_config.model_id, + max_input_length=model_config.max_input_length, + max_total_length=model_config.max_total_length, + do_sample=True, + seed=42, + ) + + while True: + input_ = input("Enter your input: ") + if input == "exit": + break + work_request = inference.WorkRequest( + request_type="work", + parameters=work_parameters, + thread=inference.Thread( + messages=[ + inference.MessageRead( + id="1", + chat_id="1", + parent_id=None, + content="Hi, what is your name?", + created_at=datetime.datetime.now(), + role="prompter", + state=inference.MessageState.complete, + score=0, + work_parameters=work_parameters, + reports=[], + ), + inference.MessageRead( + id="1", + chat_id="1", + parent_id=None, + content="Hello, my name is Open Assisstant, how i can help you today?", + created_at=datetime.datetime.now(), + role="assistant", + state=inference.MessageState.complete, + score=0, + work_parameters=work_parameters, + reports=[], + ), + inference.MessageRead( + id="1", + chat_id="1", + parent_id=None, + content=input_, + created_at=datetime.datetime.now(), + role="prompter", + state=inference.MessageState.in_progress, + score=0, + work_parameters=work_parameters, + reports=[], + ), + ] + ), + ) + tokenizer = transformers.LlamaTokenizer.from_pretrained(model_config.model_id) + final_out, used_plugin = handle_conversation(work_request, worker_config, parameters, tokenizer) + print(f"Used_plugin: {used_plugin}") + print(final_out) diff --git a/inference/worker/chat_chain_prompts.py b/inference/worker/chat_chain_prompts.py new file mode 100644 index 0000000000..8ce868fbec --- /dev/null +++ b/inference/worker/chat_chain_prompts.py @@ -0,0 +1,55 @@ +V2_ASST_PREFIX = "<|assistant|>" +V2_PROMPTER_PREFIX = "<|prompter|>" + +ASSISTANT_PREFIX = "Open Assistant" +HUMAN_PREFIX = "Human" +OBSERVATION_SEQ = "Observation:" + +# Adjust according to the training dates and datasets used +# Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. +# Assistant is constantly learning and improving, and its capabilities are constantly evolving. +KNOWLEDGE_DATE_CUTOFF = "2021-09-01" + +TALKING_STYLE="" + +PREFIX = """Open Assistant is a large language model trained by LAION. +Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. +""" + +TOOLS_PREFIX = """ +TOOLS: +----- + +Assistant has access to the following tools: +""" + +INSTRUCTIONS = f""" +To use a tool, please use the following format: + +``` +Thought: Should I use a tool? Yes +Action: the action to take, should be one of {{tools_names}} +Action Input: the input to the action, should be in json format. +Observation: the result of the action you use this to answer the question! +``` + +When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format: + +``` +Thought: Should I use a tool? No +{ASSISTANT_PREFIX}: [your response here] +``` +""" + +SUFFIX = f""" +Begin! +CHAT HISTORY: +{{chat_history}} + +Current system date/time: {{current_time}} +Knowledge date cutoff: {KNOWLEDGE_DATE_CUTOFF} + +When answering a question, you MUST use the following language: {{language}}{TALKING_STYLE} +Question: {{input}} +""" + diff --git a/inference/worker/chat_chain_utils.py b/inference/worker/chat_chain_utils.py new file mode 100644 index 0000000000..e7268b3b0f --- /dev/null +++ b/inference/worker/chat_chain_utils.py @@ -0,0 +1,216 @@ +import re +import json +import requests +import threading +import transformers +from typing import Tuple +from langchain.prompts import PromptTemplate +from langchain.agents import Tool +from opeanapi_parser import prepare_plugin_for_llm +from chat_chain_prompts import OBSERVATION_SEQ +from chat_chain_prompts import TOOLS_PREFIX, INSTRUCTIONS +from langchain.memory import ConversationBufferMemory +from oasst_shared.schemas import inference +from loguru import logger + +tokenizer_lock = threading.Lock() + + +# NOTE: https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance +# We are using plugin API-s endpoint/paths as tool names, +# e.g.: /get_weather, /get_news etc... so this algo should be fine +# possible improvement: try levenshtein or vector distances +# but best way is to just use better models. +def similarity(ts1: str, ts2: str) -> float: + if ts1 == ts2: + return 1 + + match = 0 + len1, len2 = len(ts1), len(ts2) + max_dist = (max(len1, len2) // 2) - 1 + + hash_ts1 = [0] * len1 + hash_ts2 = [0] * len2 + + for i in range(len1): + for j in range(max(0, i - max_dist), min(len2, i + max_dist + 1)): + if ts1[i] == ts2[j] and hash_ts2[j] == 0: + hash_ts1[i] = 1 + hash_ts2[j] = 1 + match += 1 + break + + if match == 0: + return 0 + + t = 0 + point = 0 + + for i in range(len1): + if hash_ts1[i] == 1: + while hash_ts2[point] == 0: + point += 1 + if ts1[i] != ts2[point]: + t += 1 + point += 1 + + t /= 2 + return (match / len1 + match / len2 + (match - t) / match) / 3.0 + + +# TODO: Can be improved, like... try to use another pass trough LLM +# with custom tuned prompt for fixing the formatting. +# e.g. "This is malformed text, please fix it: {malformed text} -> FIX magic :)" +def extract_tool_and_input(llm_output: str, ai_prefix: str) -> Tuple[str, str]: + if f"{ai_prefix}:" in llm_output: + return ai_prefix, llm_output.split(f"{ai_prefix}:")[-1].strip() + regex = r"Action: (.*?)[\n]*Action Input: (.*)" + match = re.search(regex, llm_output, re.MULTILINE | re.DOTALL) + if not match: + if OBSERVATION_SEQ in llm_output: + return ai_prefix, llm_output.split(OBSERVATION_SEQ)[-1].strip() + return ai_prefix, llm_output + action = match.group(1) + action_input = match.group(2) + return action.strip().replace("'", ""), action_input.strip().strip(" ") + + +# Truncate string, but append matching bracket if string starts with [ or { or ( +# it helps in a way, that LLM will not try to just continue generating output +# continuation +def truncate_str(output: str, max_length: int = 1024) -> str: + if len(output) > max_length: + if output[0] == "(": + return output[:max_length] + ")" + if output[0] == "[": + return output[:max_length] + "]" + if output[0] == "{": + return output[:max_length] + "}" + return output + + +def use_tool(tool_name: str, tool_input: str, tools: list) -> str: + for tool in tools: + if similarity(tool.name, tool_name) > 0.9: + return tool.func(tool_input) + return f"ERROR! {tool_name} is not a valid tool. Try again with different tool!" + + +# Needs more work for errors, error-prompt tweaks are currently based on +# `OpenAssistant/oasst-sft-6-llama-30b-epoch-1 model` +# TODO: Add POST, PUT etc... methods +class RequestsForLLM: + def run(self, params: str, url: str, param_location: str, type: str) -> str: + try: + print(f"Running {type} request on {url} with params: {params}, param_location: {param_location}") + + query_params = json.loads(params) + if param_location == "path": + for _, value in query_params.items(): + url += f"/{value}" + query_params = {} + + res = requests.get(url, params=query_params) + if res.status_code != 200: + return f"ERROR! That didn't work, try modifying Action Input.\n{res.text}. Try again!" + + # NOTE: We don't want to truncate this, but we also don't have + # infinite context space for some of the plugin responses, + # this truncation also degrades LLM continuation... but... + return truncate_str(res.text) + except Exception as e: + return f"ERROR! That didn't work, try modifying Action Input.\n{e}. Try again!" + + +def compose_tools_from_plugin(plugin: inference.PluginEntry | None) -> Tuple[str, list[Tool]]: + if not plugin: + return "", [] + + llm_plugin = prepare_plugin_for_llm(plugin.url) + if not llm_plugin: + return "", [] + + tools = [] + request_tool = RequestsForLLM() + + # Generate tool for each endpoint of the plugin + # NOTE: This approach is a bit weird, but it is a good way to help LLM + # to use tools, so LLM does not need to choose api server url + # and paramter locations: query, path, body, etc. on its own. + # LLM will only, choose what endpoint, what parameters and what values + # to use. Modifying this part of the prompt, we can degrade or improve + # performance of tool usage. + for endpoint in llm_plugin["endpoints"]: + params = ", ".join( + [ # NOTE: "name":-> excluded on purpose, because llama most of the + # times chooses to use that instead of the actual parameter name + f""" "{param.name}", "in":"{param.in_}", "description": "{param.description}, "schema":"{param.schema_}\"""" + for param in endpoint.params + ]) + + # NOTE: LangChain is using internaly {input_name} for templating + # and some OA/ChatGPT plugins of course, can have {some_word} in theirs + # descriptions + params = params.replace("{", "{{").replace("}", "}}") + + param_location = endpoint.params[0].in_ if len(endpoint.params) > 0 else 'query' + tool = Tool( + name=endpoint.operation_id, # Could be path, e.g /api/v1/endpoint + # but it can lead LLM to makeup some URLs + # and problem with EP description is that + # it can be too long for some plugins + func=lambda req_params: request_tool.run(url=endpoint.url, + params=req_params, + param_location=param_location, + type=endpoint.type), + description=f"\nOpenAPI specification params:\n{params}") + tools.append(tool) + + tools_string = "\n".join([f"> {tool.name}{tool.description}" for tool in tools]) + # NOTE: This can be super long for some plugins, that I tested so far. + # and because we don't have 32k CTX size, we need to truncate it. + plugin_description_for_model = truncate_str(llm_plugin["description_for_model"]) + return f"{TOOLS_PREFIX}{tools_string}\n\n{llm_plugin['name_for_model']} plugin description:\n{plugin_description_for_model}\n\n{INSTRUCTIONS}", tools + + +# TODO: +# here we will not be not truncating per token, but will be deleting messages +# from the history, and we will leave hard truncation to work.py which if +# occurs it will degrade quality of the output. +def prepare_prompt(input_prompt: str, + prompt_template: PromptTemplate, + memory: ConversationBufferMemory, + tools_names: list[str] | None, + current_time: str, + language: str, + tokenizer: transformers.PreTrainedTokenizer, + worker_config: inference.WorkerConfig) -> Tuple[ConversationBufferMemory, str]: + + max_input_length = worker_config.model_config.max_input_length + + args = { + "input": input_prompt, + "language": language, + "current_time": current_time, + "chat_history": memory.buffer + } + + if tools_names: + args["tools_names"] = tools_names + + out_prompt = prompt_template.format(**args) + + with tokenizer_lock: + ids = tokenizer.encode(out_prompt) + print(len(ids)) + + # soft truncation + while len(ids) > max_input_length and len(memory.chat_memory.messages) > 0: + memory.chat_memory.messages.pop(0) + out_prompt = prompt_template.format(**args) + + with tokenizer_lock: + ids = tokenizer.encode(out_prompt) + logger.warning(f"Prompt too long, deleting chat history. New length: {len(ids)}") + + return memory, out_prompt diff --git a/inference/worker/hf_langchain_inference.py b/inference/worker/hf_langchain_inference.py new file mode 100644 index 0000000000..1c57ec487c --- /dev/null +++ b/inference/worker/hf_langchain_inference.py @@ -0,0 +1,46 @@ +from typing import List, Optional +from langchain.llms.base import LLM +from text_generation import Client + +class HFInference(LLM): + max_new_tokens: int = 512 + top_k: int | None = None + top_p: float | None = None + typical_p: float | None = None + temperature: float = 0.8 + repetition_penalty: float | None = None + stop_sequences: List[str] = [] + seed: int = 42 + inference_server_url: str = "" + + @property + def _llm_type(self) -> str: + return "hf-inference" + + def _call(self, prompt: str, stop: Optional[List[str]] = []) -> str: + if stop is None: + stop = self.stop_sequences + else: + stop += self.stop_sequences + + print(stop) + client = Client(self.inference_server_url, timeout=1000) + res = client.generate( + prompt, + stop_sequences=stop, + max_new_tokens=self.max_new_tokens, + top_k=self.top_k, + top_p=self.top_p, + typical_p=self.typical_p, + temperature=self.temperature, + repetition_penalty=self.repetition_penalty, + seed=self.seed, + ) + # remove stop sequences from the end of the generated text + for stop_seq in stop: + if stop_seq in res.generated_text: + res.generated_text = res.generated_text[ + : res.generated_text.index(stop_seq) + ] + + return res.generated_text diff --git a/inference/worker/interface.py b/inference/worker/interface.py index df424d4e89..55df803341 100644 --- a/inference/worker/interface.py +++ b/inference/worker/interface.py @@ -15,6 +15,7 @@ class GenerateStreamParameters(pydantic.BaseModel): seed: int | None = None stop: list[str] = [] details: bool = True + plugins: list[inference.PluginEntry] = pydantic.Field(default_factory=list[inference.PluginEntry]) @staticmethod def from_work_parameters(params: inference.WorkParameters) -> "GenerateStreamParameters": @@ -27,6 +28,7 @@ def from_work_parameters(params: inference.WorkParameters) -> "GenerateStreamPar temperature=params.sampling_parameters.temperature, repetition_penalty=params.sampling_parameters.repetition_penalty, seed=params.seed, + plugins=params.plugins, ) diff --git a/inference/worker/opeanapi_parser.py b/inference/worker/opeanapi_parser.py new file mode 100644 index 0000000000..9dcca3e8e8 --- /dev/null +++ b/inference/worker/opeanapi_parser.py @@ -0,0 +1,81 @@ +import yaml +import json +import requests +from oasst_shared.schemas import inference + + +def fetch_openapi_spec(url): + response = requests.get(url) + if response.status_code != 200: + raise Exception(f"Failed to fetch data from URL: {url}. Status code: {response.status_code}") + + content_type = response.headers.get('Content-Type') + + if 'application/json' in content_type or url.endswith('.json'): + return json.loads(response.text) + elif 'application/yaml' in content_type or 'application/x-yaml' in content_type or url.endswith('.yaml') or url.endswith('.yml'): + return yaml.safe_load(response.text) + else: + raise Exception(f"Unsupported content type: {content_type}. Only JSON and YAML are supported.") + + +def get_plugin_config(url: str) -> inference.PluginConfig | None: + try: + response = requests.get(url) + response.raise_for_status() + plugin_dict = response.json() + return plugin_dict + except (requests.RequestException, ValueError) as e: + print(f"Error downloading or parsing Plugin config: {e}") + return None + + +# TODO: Extract endpoints from this function to separate one! +# also get rid of endpoints from PluginConfig class +def prepare_plugin_for_llm(plugin_url: str) -> inference.PluginConfig | None: + + plugin_config = get_plugin_config(plugin_url) + if not plugin_config: + return None + + openapi_dict = fetch_openapi_spec(plugin_config["api"]["url"]) + if not openapi_dict: + return None + + endpoints = [] + + base_url = '' + if 'servers' in openapi_dict: + base_url = openapi_dict['servers'][0]['url'] + + paths = openapi_dict['paths'] + + for path, methods in paths.items(): + for method, details in methods.items(): + endpoint_data = { + "type": method, + "summary": details.get("summary", ""), + "operation_id": details.get("operationId", ""), + "url": f"{base_url}{path}" if base_url else plugin_config["api"]["url"].replace("/openapi.json", "") + path, + "path": path, + "params": [ + inference.PluginOpenAPIParameter( + name=param["name"], + in_=param["in"], + description=param.get("description", ""), + required=param["required"], + schema_=param["schema"], + ) + for param in details.get("parameters", []) + ], + } + + if 'tags' in details: + tag_name = details['tags'][0] + endpoint_data["tag"] = tag_name + + endpoint = inference.PluginOpenAPIEndpoint(**endpoint_data) + endpoints.append(endpoint) + + plugin_config["endpoints"] = endpoints + return plugin_config diff --git a/inference/worker/plugins/calculator/ai-plugin.json b/inference/worker/plugins/calculator/ai-plugin.json new file mode 100644 index 0000000000..4cade80d6d --- /dev/null +++ b/inference/worker/plugins/calculator/ai-plugin.json @@ -0,0 +1,18 @@ +{ + "schema_version": "v1", + "name_for_model": "Simple calculator", + "name_for_human": "Calculator", + "description_for_human": "Simple calculator based on numexpr python library", + "description_for_model": "Useful for when you need to answer questions about math, calculations, and other things that require numbers.\nWhen you providing final answer to the user, please describe operations used in the process", + "api": { + "type": "openapi", + "url": "http://192.168.0.35:8085/openapi.json", + "has_user_authentication": false + }, + "auth": { + "type": "none" + }, + "logo_url": "http://192.168.0.35:8085/icon.png", + "contact_email": "ai-plugins@open-assistant.io", + "legal_info_url": "https://open-assistant.io/legal" +} diff --git a/inference/worker/plugins/calculator/icon.png b/inference/worker/plugins/calculator/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..0d784341e44e2c1920663996999250f1705f5e57 GIT binary patch literal 172927 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

|DESYtxWe#WN`F$+=4o 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%0D3@$zaF(U=hr=Sj~;n4vCuj2A#33>mD%C#*s37N z>7fMt*rN}&*F0#iwB&lZGGw-Kt<^fU2O&1B%9xQecHEZfG2WlI37N$ll`hD}6?9-N z|KWQsx5r-fkUIzXRRvITj?x7N0S+rQ#UH_Yg}pWIU2lH1IlCLGo!i4ZCDgj-xB0=!P-zT4D>Rtonex0tr!Hsdi>ELZC#;_3LK=JzkG!wU`q**h zu*Ls(=*p+kQO7nzn6wu|=!rkwlhm1}KE(-^1n9b!l++6$&h+Q(9eQCTjc>Ab!n9&^ z2gXl~ah%e`m9?SFIFp{u2s=}Z&AOdwtF@@DxXH`6L6h1PhL9PQy^-7AsP^D}=i7a@ zu1VqVR)GeRhV^#lSt8t`aT;NtfJcq&22u_gSNJ^n;#PO#O=s{vA`8vwYYBo>#u|J`2ulNdjR2_ZaAu_dNeT*I-w{ zUM-~vT3N`?lncM%!{|?7ELYB;#{TDya~jy=cE7!*_TdLE>5)Eb&fOg0aNI7FWbSY< z9~VzhO|lK+k6gqzte0z@RPsp*3fLg^^snyr``$k7zmGD0k1C0WXF)RZ#+@W9LRumq zzc3Doq$PxV?QyybRz<+$aI6||V?Y2?KDwg|lNjNK992h;Un-D3RKHYimZrkpX~jxH z1*1#U#NTT4sSXqVDnErV1&{0&>2lJ1b#6Skik#zgL$1J2btW#0F5&F|47O`CY*{vw+b#d)PL8EY0ae074s}g+wBm&8^zn{ zHLBxX;B&~_Z4b4|C{M7Vy_0e6*1!(DuxFL_?A_Qqd|fE)W2Z-Cn1f?m8LqFO-b#Fy zZ`7-V#I;)+?htTnS-CtmOTn1y@J~5S!Jr7;BXd`34Rd0T;n}m^bOdlPW_o$-Y|K+< zcdU!i3w0hPX35gIA;6R&pJ6DR`n1n^4X`6i*M>E40*?!7-CrX}+?{`}TcJw<5B3dQ zI=|b_8;;mKhK*a;?R$dvqcbfJfTr*T?=}~{@C%(sBmdKwI-;a81F&s#Zd>h=Wv!$q zGAhy{9H(c|o@V97F}uHOzxP?=3!nq>i^uO!@@Dv=zX(KwI27u_M1Ef(tHb50kkKKz znQms31tcM;904}pXJHM_TWhP6co2>1Pj@hBFU#EJ?&ve8V28X1uA$z2fT72LHf^viK&HG0X9W&2-{}y8$Aa$%0j0pTTYmwFC8s4NZfme z-lQ;B?exsgS^m5X8Tur38ExXS@~jASLR}wFT zinc?DFU5rs#Sx>s*vR7>vt;~ee(5IpX;}9jO~6X5HN=Xa`Hk^P76da9Q4*%z(CL?$ z3jvi#>*{naO|H!NrqjLnLD=yg3~Uc^;!`b`4{NH4)-rO_tNDE}o|9HiEBai2UU|oZ z*_@mFA~Vv^1>CBvXooXOyyB2vf`VU_S$vH-(UPLw&J$J^u+08ze2<)r&9?H_r>5Rb<}-Z&-e3`3rmPY-yoM%gCsrK2l<$~_Jpd`cQD^mM!0Hww<3`AU_Y zs8(IPn9WoM8RcInw| zp%+fX8*eg`Sdzv;QN`6{8kNKuPP?^asHcN&%JMbJ@o)Pr>cLvG>ljScq#zbXGu6pW zGmk?1SAW&hjbi*o z#$?XzhHcjsFiEqsi(X+F!`v#>Q4>`>x+As5?8u@I|NjbNDX}4u7FfEG7$6VV6 zKEA6w9P!kUN1BC9+&&-LFh@AW4x7mAF*d9%LyrKL3jKji&{q&IVN+GL-`A&VfI~J0 zO+;xqaSO$kk!Ekk7hR^}LB%d-f;8q4UF`T&yxSci0T15seI5t`7}RuccA8aKDW)Mn zb>bz#O??V#=&!1a$kg@JhA8Dy!DI0hNDA{RSyf1uW$QGYk}*DO%hu zc}h4l(31K$I^uk#twXSG{85HPlWF@YYeL_Bdnu_(N%H_IDa|U5+lI>1oM4=(=bau5 z4?JHIio1X9WysKjOTNNTlyo!`6V7B}?}j;PiP9sa9j9V>pK2Myu`J8{GDTNv@1_jc zOvK00DuA~E>}@pFe7D^}eO${S{Bq_nx-v0Y<{U&Z{9Y{QL-%o6lan)V{rtS08fwxy>3SkUghBN4y@??d9=HvuG zob)45aXjb&%F})=orG^v43@JuyJ~#=%je9wd*2^Rv{4WssLbo@ii3`J2?__gq!n^Y z@zZ65Vl$D#$Y|8waq}ewlt+#Y!6W;{hQ{vJ5V(le!lk-%l+ukJMxR4-ibs5$4-?aS z6eF#^@o#14^mAY`Yty~$${2Qqn7I6jAWE`**Lyt5DE|bBb$;{>1HnN`{fY`^%BM3z zjuP{9&U6)=)DLC^h~Ua8;jm44xg-meqjID7(IkVkyA$2qG>Crd+mBTo#bEfy^%?M` zY!yIVR&~Xp9tzAO_M^PB&*o?>6YjRJp7|O&(m9KcGmu~zv!I=Zz==6f#BUA)AS=c! zk=td`-i;=uQ>Gil8MQcB>9=Z#+a`1Eu!_fVeGPmsYTl*J10}nrhI+(pf)-hgBH4Oy z2o2J-gjFpdKTq&}QKH@%GgNn=qi(e2c=4>Y7g=3S;PjQg)En+aVwC zO6Qd&=p_VnZ7c&X@!sc7!5?7>C$(s$d|IJL!0ZVFbLb}eszUhE01a-;BZm?D1o~y| zzeE=d=YFAnEHLra~Svn-JA>U=>kc zy6b1}&`Bc~x3m*oJJ-iFE?K13U04N9H$Q_@A823OtYHe3 zZ^O2;VM2oH-%|wOj;E`}sn9AkphQ~SOvZy{kkR2-R6SypEToC4be`A+nV<<>ssdMf zZJ^iz+n{}#Q@7yE1#@51p0Bd?S@kJM$ze^d4o=LW16Lg7NtS5+xl^lW7|M+O&W!!5 z8Z#I zqmEB07`_JC`LrzUBhHo9E44#JCLQq!hu<98seJqP%MFPHqu&oa(xliecj3%x_wBel zR4;TAkna!Z7N}z60gxaY;Tyk6M&=jd!a90>2kqhFcVwf>CB@PUswO-^i%egZ_sc42)eT=`$*vc?JCJ9lFbLaHp$JNJ=OFM9h+*D)Wlk zC_C~qN;Q*`&&OvLnUWx%^<$u z)Sh#9OqJ=&7QOJifLAOpSMSMNETt){KC+jXfCqWLwkv;T#)V{*RV<0vUmPW5C(>Kl z9S+i|OXsNaz4jYapEXu)(gElAorj~=P5=m}Mf!OFSe9WN{4RtJFL&;PmxNG#i6dc! z3{JIbntDWlFhZAJiX!1ony{7eQpUXRQW<}td7WvL+_?nK!X(-b2z1wy)#FWY%CBRs zr)yv#ue2urmD!O#;4dE{q-}H0g3n&vJ|^PrV54;7FF1*nb?fw00wjcMropWzxZF_yEkc=k+ z#QV|cVy)NpvdBjG^}I9TufFyIH7UZOO3~VbJjfL*|MuUZIrO7rogXmGp#Z7mvM&L| zcnDGsO&*Snhs}<(FpO22cJ)W@@HVR zJLtJ3C~_Tom!y~)pUDI(zMf`6NQIczNfNpSI%4k#WfH2(rQ6^=f+#0)&~xfrs#*+& zfyhlFrp@qqv8~SBp^ugzC_QE7s_PR88th)O$%R=e(SMeVq!T{0V<{@l0hapTp_HxU zTG6OeVSll#kNz7d5`-NNJq$ZG@7O7Ehc|7#6>sG7bJgSh<{BBab#)7^ zz^YnYz~kdqsqQ41&>!s+AP=G@QXCEiv^=);Wi6#6%XTXg^E1HkS!v9i7P!nF<}57` zIJ6hq+&a8rEH%f+Gv%Y|0+KkSVWflRRlD5q&7I1Ws^Mmevq4r$gQ{Re&t+RXozZI_ zZ0Ef>I93dTX#5*n>9Sr&{9N+7fo8B{yu-_8>?mIxZHp>EY@cNB;?OG}b73PdR?jes zOqCpRltNeKM7*Hm2q^tCpC<4C^27qFV}p}SRZP`m7?)6D&Oti9OOn|;M_bK5$m-PO z1iOpO-PXqyRfOpnksaUG*b9v}uwK0vaqs#-DK~r}5yz=3U9eSmEXFHGD)QS&>+-7p z-r}~vd$F`Y|1)>!QRpD>u*E5s6Lh9_e}S&-i|f7%#`WAevP8?tY}Eoy=erx!U5(v} z(L+$~Kn_+CvW|6UNNR(yZzT&ug=0W%eHrgaKjsFiFjF$TLpiV5q%?M(i49tC3eCd^ z_lzexDBG69f_cOtD{->FN8hfPVfa!dvlQAb8$QXFT83wt`H{Wg70}{TH!o`d@pS9#k_O#(dPo z`DV&0vg+@HV_1$Gm7s7A{@ptQWZ{m+_ODrF$&Q>&mxAtGDx9Q1H+&kk3ttRCeGFU{ zO@#-t86#=0{*RgiZ%>T~5r(M^K%ls|>4CXTl7rZ8B~X zWUC0h=+9^F(1AbRof>p-opjG$iC5NTCuk0RL!xOD>1{S7N;lxW!#d_|IP6Q-Y!z&$ zO*o_0Jc?Q(*>Fvcf+i7$2KyH5KALb1)z3dyS-u-a4dD%CqefD9>*Lqg^Df78qo2G^ z$6AdR1wwFgGnK>T4_I{W3#h?_aB~>?SQd+6P=)X}nIUVZlyP`B@H4QZVz5daJDgrp z(11=Z{SD_4gTqmw?Cf;pWsS3AesGr#08Sd`>Ibc39yx=^NHn5gMA&m=jyw<1aXL|I z*l@B3!PnL~w;Qj)pM;oJns~d&TZRP(7f%H$a<0r|v-F9R-JPCJBXYoSo$osc9K}Cw zdvTPMItIL(+blnk#*S%84T8nZCV~ksS9W7)uh<`7fl$X@>Q!^ z+M?Y1&8c%A%%6`N4t{7mg?piL7O;*~TJdcmGmn-LO!WD?O_;%-O3>*)Z4-C84tLd= z-W#CJfr2?oFBzo5Mqs7GNqd?l3jJWv#=RJW1<`(^<@Mi<$a$xYUIvE_W_nsgzPfoy zdPuF(E+mKi3fBomcx6dy8&3~QW2v>>w+AD=G)Q78HHv`>{YJH(nEE@Q^K`sThNvQ( zz;DuVMVnFBQfHQ0hY^T-&MG}cgmG|EoIP42iB)z$M;>3gDhP7t#cZx6l^IocS#g!Q zbaCn9vx?wy5eBbk(h-Fdh5plRqol#c&@v}*LT0KXIFaR{T$@Nc{t`YA2W5U2C$ypi z>GF-6x-GfvxcT=57U`0llX@sqmJz`q_->!=87CTj+@oWZbM$Ih*(}=8R>>3Y+_2=a zsIe8RybPpdx?}wpEXO7--^4pqx{~Xzr^raB@+>&C=KFm_@;537PC0!Y=^^7ksPw5h74{#B0 z$d%I~bw!*Ok12?QxVpJ?dC;6`E2~N^UUa#es$P-3;no@_J)k}rFI2F@+C#Zf_PdF$ zk~t-HqOyVq)xrvtxiay3ntRC)q#s8evj+oN^(IAwciC||u9Uc=E-3oHXm1-L&iLod z9Xio8>XjU2k^D>BH&ls~@vKZ!LC%d!FfHgGwxoLiyECD4l?Z3)-Q~kVZ{YTVt0 zCP%AwwoVb#4`9HN>QEMBgbRUm$bxESMwNuVv?Wji`o$GnJ+7FLIDm^cS$Q%|Kt7 zXU;8f%UW=n;^OFw6Nqwc%6bkh?GTADo@KE+*zBd5g=IfvXOx}^)A`mm(NNS3V^&MU zqc$c_>f-{#B$~V1M48X7v)veqB+kd$$zdX8*jzm1VLF~|=T?E>o%PwW#|sG`pGuHi zoWPNi_~A%P>D&kDAwp0AqXe(I6b606XpL*E3-)`EhsqPtxyufc6PwX|0AC#o&T1XO zInzt-!K3c=2E(jy@T}C>`ahACg%wr?(Uk9I#5#L4V+1pzu6e%A#dtpo??il(S)khHn1Mfzq55sqzT%cqB}EF*s3oQO?;_QoE>a zY7FD8K~p9KQS{NHCbdP}lF^U>hjH9Cc*CV2t5ha0V~S>;liD}6Q#NP!&==nU3(P7P zJB6&wten3tM5eUDywq%MPW3r~l)^bmZf$znra2?4Fc|PQIX=b~jv3AYFnJ(x!m}Ej z+sHl{9qSqoTM7LVa$ql3q?Qm`WDKCB_Yo5)Qw?3Wpphx5RJ&yxk5C zPO$LpV>kwcY^$<^k}2{b1y&p~%!WU^&f|o{CWZbXR*p>H)ewlNLHwJu)qc*$+HxQR zZ%hKKq(M0UaO!lfZv}qm^j?vQ@r&K!iU#B198=U3b!lS3X&a$ zNl4=Q>W0wAs?ppMrSASUPiyb~z^g}Olsx1i)TuNm>M0&kS|uTAXZmN}3JQDaU5P+i z91T__AqYPOaHa@%nNJ4Y%;vn?LuR@02L061&2uL8TmndaXJ@oh%pwIDW*ib+#0DrC|=%@;-fT2VK)bWH>Wa-3fq{LK}JW%uTICN4M@dV z*2u!F)!L}86Y{WmQ7BnS8A)cKVfE;=eJz^k5Gk5}{0ycKh7`@+VWm+gY83!q0^lXb zy_cJ2az3I~zF{sse4QEQoK9|x7_hiQz3%mvW_94=?FEyEvVf^Y`@c=A& zbeb(7+4|B^g|2oD(;u!RrJ@AR@%U?(kSZw^p#|i!X;_ghWB_OS^Ri^{ zss=ixHkvvuGcv_>hFOt%tq`^-Ax@0(oZ``6%6~^ctK~h#zAMG5#;Ya|f$^c%!Z;aw zBYeD3Fafp$J8;eDJ|o_Yuf8_T;Khsu9A1W@0h0ue5OJ(nbG6Sw=gHrR2oK27WK-nO zztXSJvCx!bxyWx@l*O!@dez&D`^ss7W6#^+AoV(2R40@nqF>019N}C6`Vv_H-z6+6 z3JYt=1=B8qQ~3zqMqMJH52*Y;D=UtW2$ny}*-K{YP1zt1rm0;PaGYK$ZOoZk<>pI3G?EqOPK~@ ztFRFZf&IjK%_YP2a!L9sbv2Lv>5`)F%aU6Wb^imq#!8Qa>~r_k@m0*9ULW}^wyhPM zwN$^;n`iIPxfRzQtRcd4yO$UJ{t{v}2GAMq%4&`?3&X%+oKA_V?v!#H_j@r+JvA!W z0E!nge+;i2Ldl~_waP@1wa=A&4pf2Rj=-r#(}jl9_q7|9t$lDdM+2?DdgRDVFQ!kU z6NZm(S@X7b4fk>M>(=&;d_~Bz|%;degWH)5!$ki@D*<*#CRen@l`b@*sxoCF* z8D}W+9EcNs9WktpaKasbC6_V6X*OZWT?Xw(0qgrw7LoIdnopyav0Z-Rrf?VCXKMg+ z!X!5qXD%o%VH?BsC6?fAO29gVWV0BY>py-?nG?^bM{W>C@Iy$aQv}|EWm=$L3(#G> z`7$~5$U=HPAc9WK-2%~EN$FbB3Yg$i(PMLuv!GkcaiA*mD}?RE)3_?ns!8JdY4ouzS(L8;&so@cXY34dgFdo_0Wu!!?>`_H$n6Kzd z>>2U4SOy7)o{>ppq$%&Q#;%N<0Ski`cjDHL>)jQ%8Tn!D{C7f)WzJ8LiSIGSoQB$r z7mi)Vwx3=XhSOKb!8=Ebk)}s*@oX_)3+tz&GYG=8!K`9GMx6>KRsAe*uV7H;>nI!J zHy?8#i)4+Cg~Wr z8U6pzs)IC@4+!C@P_Y5&G5FW1A@qU5j5#GWy5@~j0x`}ANzfiwd%&x{)q%u!A2LCo z_Sp=l7u)L0*U(LBWljA5tm-*0_=kMxt6m++;501{hX|+6=g>3Tni98?$sJ;pvdElZ z-isw?^k0%l3C0|kb#pFi?Q(~8O{e!9<&@1CxDG4(1!Gi_jc13os~ZZ1-NSH%Wp{GW zv~(ZKjsZaZn~Zn-Dv*AOV2!3AwLin`2o|NRfS*n)f)dxo8kY9;weBPFp-9#@r8}JrP@Ygfc5&q5($+?-GlN4xMUZHnb@| z#}chZ7Z>)yTUOX)qBro*a?Eb_*HSs~mUxf)G|mM6FLOF&%$Hzg)9@>qnQL~}w~o;| zI?9-F#UsT^82 zi1LPtwAL_G^_T!Xc$YN@)mt-=DlceVoSt&nB&l7)j&~aW!Z&5_qWMs0Sp;Qzaj8+c zwh|r8*$F0t7=a+NX+4mJ9pEg|y49ou4DrZ~MUG>LhwJvP6@8HX#)}$A=CEP>A^>7m zacEsIDv=Kn(O*YmC41)ts5XcJ3%9Jp890Dk5)s1Uhx0O?`3@I?k~<1pPLBX3#Hou_ zzz{;SfznKx%r#&-M$Kw)FBUn%OjIMS-TP{TH?g5Ta17$cI=mcunuLx}%J!ggGl9At z^`GD~$Yv>@2lLZD;8cC_D3%+rS(B9thlir!1l)k~tG(zZW+>ZC8;kw{XO#qg_Nv#a zDHfzSiMzaPvx4?Hj~0s->5+UKp%Llr8lNc9Hgv{#zR@yNa2bbwwTjU+07%{D>-^64 z=gb{CcDX||!^W&eSES8$k{B2J_$(u(a<3iq$f08ouLN%%ZN-eIiCx?e7T-DQ`2}hF(u+n_XO6PVC4((O08KVh)$tyW`y&*nyXv>a`?U~HdY$M5i!cecZ zYSGQ!Y1*b?#4Tphn1;ksWeD=7tlM$MbM?eroW=4%Ec-a8?T;cA?VZp#HEmMxQxKRs z^R>9e%~NzTqqikycbtTG&_Mfvh#9Mn!eI=e>v)BMd3gd?so1PV%kAt8tC_)$K+#v$ zSB>ui&tPO>P-&mtnDAow>T(bnw-Spb0d!_M4$)#@v4g>la1^C+2TAoYbD4Fh9FMB; zU7vhbRh9nTcjz76u6A9(AS7efwJdxgB{b181vFf=y5jbtfVtp=WMl@qBy1Cf(JZH{ zxR=N_YJ2){ft1yhFNzV>>H-5|b&>`SIh=G^XxxVb5Wz+>Rag!+WQ;aQnlB48-CUydu0s;rv z9pvB;e1x*nIm0ep`o{c;rgHco^&MeYdg& zUOamM=0KGTy==yzTe1)1;`%Dd3;{Uhz6;jGE2P-C&<)}Q`Lyfy9v}-~d^e{n8Q*r8 z`1h%kj;EK!PKVd!CWJwJ2rWqo;q5__3oWB{C9lU|-Od!TQBWE(Qs=7Rir>MzXdW<3 zNIc*23He_jY2!&(ma0(9J;+!noC>tC#7Sd zR5>$zVG?DmKzIz7+q9B{RZwCw7Ys_|h88u)+pzs$;j5rd1ay<&;B*!2EmrBmY>YyK zDM(ZAl-ZDFse86LY}XvZjiYw+roB4V9Q)QD@Wb=Vdd`~x)%bAwWcGEcw}9+~N7cB9 zvgx*JrPZ%XK^fnf!|LzCmSGB|qce1Qpuux5@@l5uTW!6SP|uwPOb;bQj2UMOl=eeC?M z&b${hgKJ^1I;W~mtkVx+OPae!8;hlKR+Zh!Ut142vNzrxL*8OpA=>&&fp|v34)F5z zXGL=D*xDZgKL%qazx3(~)MBpDVQr%03vCu`R7Qz@FYu8s@S0)<#RflL&Fj46sf>D@ zknJ7j2o$UAL{PoV6X`(kFRjtkG_rxWT2#?tM#(nJNbT1Fn0*?^Q^xO75!3gU*=#BB zswRwGCW96TWFf{M>7idY9$=-Gb|UL`m71eZst~T07Jm#5Z%R7jpEEDHck%2*9n9Za zof>a;F%!#%yAcXY{KmU$=U9~JA{J{p=dEd*C9yhVPM?X%Ww5r1^(RiS>PGyq>eh z6}(Lhfkqf~<{fS%<=8Y1&p)>XcWg#N1HFk1S(7%7@l9ql!VB`264-HDg~ln^7ga;a?Gz^s8 z0n5^rpSa#HZ;H=K%9PAm_8D*rFU+=oc+&RGp?lWDzYGY7qP1XU9fUC#$SfCF+pqER zz`pO>GQ=%x6tHtXR0q(%kzvgPl@Z^Ss&h(GP=hy;F$oaW2#17BvNIkKKU%v(yyG61 z?4=1g=+;GNhwd1d?broX3VSTUZqmX(Exg9N=WVPalQ{o2gC}30uGheRZc%K=lARj z*Y(mj7dK?&e4GpDAV{(6>_z-s=WH3}rY*YPG#o(-X82(tiL2x9qy`#2=u zKm>e45GH38`YrqrJl$$HZtNS32io0ezkH<2&aT&PNAT2m$J6qNq@B;LHYdjC8+PFa zC-h8}>2C0{miZ$;UdDDLLI~^%ZgRdp9zT^A1_dvf5%Og~f(^eoTI{KV!*=zSN!|Hf z3oya8c+rexPyhK3zfXTc2+EylqxjChFr@WDZ`^q`a%~7|PYG;R%KS>PDK@j1(bFvN zYALKei~k^Cx~J`zT6&@cRI@Ep<39u8M$~A8oSYtZt;GE$x^eanJ*;6;NCXNp4NE~O zv=h2TUvJEK97>Tw84Wg+hOmNln##~cg<0arV9lMoFA?V|(N2@}I|c#xxL3GzxozG5 zfURZjv@bn((mwH(YgWQV8PgBLz$-YJ6v0@E4$||YX2~}PC>%3|e|A%26icel5EiF1 zvlk(c5x9|v>%X2GnW2C3>OuRHr>?Yp%w-wREjR>s1Tgw^-bB&;~Vf1RL3o8;k22!HTHyEErvj!9apz9JfR!_;vGkJ zZQCAix?)QppLz0yc7#loufntN)&mm;E!aTjIC4{;r?1|m=hq`%HfWwH zFTE5Dp7lCBv|GR}jd{rar~_HBByJ%OYEuIS9-`tI`8ms`gBDgGX3MAb2T0aHGgFlG$y~A8)m15AOR4v$mkfcO?16> z8)Q~=i{ollK|%%|vg)J-^^KQL9k%wlYlrQ+r6}805u>}#H3A*m%OFyU5Ff_B?w`}L zlCDJ)t9dMAjK$^AE{7zrgkLh}sB%mJDOx{=apg_NC;oUPrb}Vv(ikF7t;d`~Q+zrF z5dab|$cIaOs_+!nY%`*j>K!IP`uy+y(XW;Tz-01eUHYME$ZumTHI-X80^TT!e=I+8 zj4<>IvR)aJlepwBtHteIoe60bv9;oTd-K%RtE70{h!HVO?9s@88VJd8+`8wUcJ8&0 z(osC~-1YX+PdwG0zhO>b=K?dthK#~~;SFJ!n76wjNj8U3fsK;DFSxbR$U8;}HQ7cS zz;o0F;C%(-4gw0W9_N#rgzekCkA3Nh_KC-zY&%wA*xI&NYr@f)(>rIo*Uy=A$X_^f z|2=2z>U4m}u1`ps{l6_(=y`_(D8=&9q+*OrrGbfBoPZ z1gHE(-3euW;t40GK!RAG!}7*a+u1$e{`iZ}wLkvq3+Z`@Z>l=l7?Tq07uAR z2KU4x+<$(*wcq{Blg29qXE175RTp3SR=Lr2OkAGigTLKz#F+)Erof4*SN4URa0vsy z1d5-zZj2=o%x{1knsfi`SDv-9`=Rj=%RY8;pE+~x>3~zWDiLvmb2pxXZ`{d|1;nJ=Q_s>UZ0xt@8ER7j7D#cH8a++q8nISee4k_Zr{^H9L%yFL$zS(`Pg@8nuxu zS;bYBJGQWmfdHX{F(v#UP6+ko@m}%*A&n9U384q_OhO5vnC<|Haa^7a*w{#xi)2Zb zRV=HGM$^lkTh6)nt^X=}uf4zhopbKYXl7)cE8V&0eBb`|UVD}QT6^vCkvUW9c8weX z|H9FeL*S7+94C#Co}zT`U5_0OgWd)n#WFis-{6qI8hX9~nyQ1b2imJl1*9jQ9VvN= ztK5=P4zz<;jUb4?cy>T>NjIEY>V$XR{$Mz;Ktnr9(RQehNU_6_uhQpL>enju5!2@A zFaPC`8hxIol=Mva(EU$@$B9?daF~{HkP3O;bPV zFY)7OXC~ZnawR;9^aTZ<7J`We`E~M=Z4i?Xr4*C)5>mOw`4!PS`LS}gz|evO?3GEdY7$BJ6cJ(HP%j2fK^28&$r;*fmu z!!s^wdeXq8M+!9SQ;u9LzOr!yR+_;$&x})MR3Ap&uW2t_w6U5BEHF zJp9r7?+Z^HAB1@tz01}QNxx$R)T0G*J))E0tJ#?tVoUy0Hd-r&uJ<2ls<=! z3V@^-u+Sa8CodU6*n;-p$~zcca>^g5MDzV~o5FkVd?>v4zK279miEk3Dw-Gd@p=IC zhem|lCmpGyZ#^21@LV(+p}x$_gik$jH2m2IKS9CHyo_$KxKVQu7FXyXQk))MRD+Y* z6o%!RIYe`c);~>g!@2NOfxL7?ekAuWMRE+tIFKAA*q8MfYu&l0a@*EzTvHa`*<4LdjEw zR*l8nGkIpLiqBCYM_+@tCGQLw_&2I7?-OhB$;Jaj%pJ=Igrg)MLQ4_Wk=|2L;?f)4^EVw2v!F}{+JFYhesed zn3@gm{n#Vn*WUH<@Z>U$?B;27PEG)$?j~9BzAv=z9Oh!lO&%80Rp$)+0kXIMDzG{o-y>06^FH&2w=0 z_>4nyC}=rOsop>Q(EZ`B?|hWfyxVxry|+p!ZVkx%DO$GejV($0B|bzz(T)b@lg>03 z&u^E|8;}rsY2G_jmt{4NX0 z&<`GE>)~iRl-lO_Cr@%Z@d*Tlc%Ou+4o6)=ri1V=K>GuF5kLZJ0_2zL~;AmX< ziycsMZK^<9b!IU(?zJ{uxR_Ws0&k2HfKu$#rSZHT&&v^=i+t8+o(*&8SyWc#kJrAM zEbYGi6$S5LA&-G*EuHU_(xT1Lno^;qP>#`c_!32jxh??I`f3?odOekuo$W)KR?a`zDya5){d(q~>E#JD4)pf1fJFR#r|3i`hA({F!Y_!O=D z?rq*gBUf^E1o}7{m`6*RQkTJsj7<2Iu)MVijvT35nP*0Ncd%i5_`Tcj5C7#I9}LI) z(_v<23)78Jvp5DCZLtG`4uVT^5}kxH8qz4;)@Nzg`e$3}BnYz6f-c&Yx;q%TA};As zwqbMl@cmDQpZOo}4|g4;1#L7^M+#l$&oQ!$V$6Ztxt+3|&1oe&kK|j1$&ghnYiR_@pUX}`w+DBfyZ5bR+Wnkq2 zMyR$280#-IaG@0W^vtI4;A6+a&-~uI!^aPw2pe~8r+@|W)3pUeGsjWfzKrN?D;pNn zP0@&#SBR6`F|WQ#I`B738^VA2_!Hq%hfh=Hoz{a;k1$Qgvf_Dl$%KH{a!uqZ*JM$f zO!A;_pkMn0tH5+0TL-d6wz9)AET#`qr+5wFBi5gs?#ze3dgMrW+kH=jdlqQN0R@bm z9b3XOWnB6;RfYL=dXArTBTK`9ro}sql!(y0W(FNGjm`Hh=#=6DO%mwx(=I59?X3rD zYM_Ps?LP-Sv3-4JoM!4}DpzBhqCXrgad4(%OXh_9s9ScFkMd3aDH(Ruy8U!sJMa6@ zX;GY>Edh232ncJ}^P{62RYW!pK8V4zjuFO*#?_6>=Y-9b`b~d0f*;YNXkiQTnUH)ajM5^p5w16Er{h+wZzPeDZWx88~+sAvskz zo(|2I(y2H1(`xoV`0LxkAAjJU@Y&O3s9VVKZlHxlNIAm^(0{UzT$~5DZwtA&ZJE23 z5u7-NK2f|nH4_%swuE2)z$e0|kDLhK`2{ZzFS>kNnC&jp;FVUD@sCF&0Y_skzp2gj zGXZR(g|pDWUZ%|;U-yUO3OPEg+CH&32=BU$G9!O^N4WQ3Kdf!sPEHGcnc9%GUR;T& zpb(MLutFnt0(2<#4V%HkgYF=#bT?CK`gr)kx4k!f@0YwL{GAtG88*%?hr#j^^DF{B z3|EHisQuIC4t!^TIR-3oJOR*H&tnh|#tROYKB8Nf)EreUSwRvd}zCHz0T| z56mb40HZERL_t&nkLWM0SfJJHYvKR4#uy{Glfa7zoLfjhCam)D()88CgnwMZA>Nf4gbj? za7fW}i-r>XnN1)FL(+%UNOz7HDeGys3Zu3UZWJTV;r;XO(7`s%OF2j4*`dZF`lD8q zv(|(W0T95h=|3?cK1sqX(EYVa&7)hHA)+%2s7cHWyA((YXNx<&9qXra1nbctU$bM` zx^*L3c%u_ZK0H!DZi)z``PJpEG#dZ1*MzzG>Ck`2`$LBu=|>-WG~D@{kB4h7+a6wZ z{Z-+X=j;jB?3xcdHcf|ln)~cgN|d*M)7)*G73axplQA$vzFT@$0AKV#Qn_;23l_a$ zusERA&?jjH^CQQOgb#n}(eRFsJs9rVf0VXwQHqup?_o}Ll}6bHHkiYWuccIXYk`6+ zZj&qzZ{fzTg5&@xUYdtr>0J{3{F9G`duWl?SKNF}_`(-l7544f7Us}D8tqC3L0lZt zxPVYB0cB@n!3ypos9>VBbL>389P2x}D*3troiwu2UkOhhI}z@p)c?Eg{7m@3XC9+@ zR$8^cdAqD;XE1`AW3{-bJ_jaj3z(1AfFfqFEW1I03yu5{VfV2!ptCuA`q-)P9=ZwoV6Q-J9OHW%LIN5Y2=EQEU~ zAU@e4-P*i440i7fr)ch+P81*>lfBS$NVS6=**b5-AGBqLJIeSIzQ`x_y!tW0ntbx} z*a;CNXo$~?mPH;L+@?>-3Qo93TNWVW(~d zU1g^CK6H%NN>&X~p@!pIhq_grX65--y2cRcnLay~MX57qWTA#g`IokA4E-;ALzun# z^04ymzX|7KNRkK{6OgbbvJCJdEG5Ehq;4B^;>DN(mX9(!tVwG&<$io z*l9FFUcN)4Vb1=Nym>AZGF4yCtGYE78wKYj31;cd6w8?M>0Ib6PdW7t9S^c&S7V4fO^3Ae&0%^?|!?*M#dA#19R z0_|;S>>zmc{Hh%ILQeEJ?J+;RxELNgewy~wFOj38zG0rbH%lXH&}z;c9gwsDGeFG0 zJbpVG&@w5o6YHWn7!H6!`!5#`*9C{yVTAM$)tyD12|Cufc3~;h8PJkPbE*v4HI7+o1rwqx-E*;jiiKeNxk~817F`T9} zJDfRWGmSZO>bL}9UN=Rqs=Z8uatU2+;-o&tohz+4N2wY^~##{juWy9U3q|MEQkoOg#V zc!1=FhPRAxqk62`XUt_`q^OboJ`b)?5q>rP;u{r-;ChUmO0_768RqbY7(hb;)Xck^{edt|%O_=@UePQ*EJ45HQpAF&k z2|6OSPvEo`_Ak(GaN7C>MZ@R^3+Hr^I7^UEbOT@l$V7-NLY%*j4=hoDvjQupuW@84 z`IZ4Mf})Y!?AFjFr-J}OPSygD%IJuXL!}D{9%TERLZS{Uq?c$=Knp9@0jPaFYy#V< zFgle5SSUb$XUL&$+!_uoEr$cNM}6w>kw7yHqmmL6{9Mhq+Yj9ywG493`Dvu12 znxzr|aHue*33yH)tGi~y%=~8R2S&KqTBqq;^a=Ck_>U{s7N`NyF8MCKmVaafuTCEO zq19Q&1wu2l!g_u~II^-74$(&S)q@K(?JWi)nFXa2ByyyHk*Pwnu#!{5+C4 zdh80AqhOB~NN$-AYs=eck>g@GPC@7tWk6Qxw7f2P-7b?TSqq*r;AdqGh_ny%5?(VO zmB-1d6aS$)GBrfxV9J03ixtd~)7*ZS`q`zepq<&duta@Zrm}GQSgZ)$!N^A(Z(6!|0P0cnBUTSg9E`aptU%8^+Dof6{xKbav!71q%SVK<4hZ*en^7hBDd}snwGn$ zh_gWC*r#w<66m3_5U0GEPx!Y=^Xl=KFO0IWDxLKc4n4`p-b}|Sdj3`2L4BHu{g4q*GOr#%)(Tn5rWW&2t2PI2Bf>wq}Er{ zX>$866TeSe+pyp$P}(?&IE*O6?>V)hW_~i#F zRQWDouLCc+hx!1zFjCZqQ4~h8NGTi0@_8PrP#P8Lz*3!KJ5*3XqiLRgknUN}Vw}$Wm9~U7{ZInGkjK<%gSrMopEEjGrt}3mqjmAiT$sJ8 zb1Y+#J?Cmvn7nI(yOn}XX)h0fght^TJ8;fWi0L`jRMVi#-Il@?(Zc&7Rh zn-}f00LHX-hN821q}+j1#BE4}7hjsJtSw`0*`H+8N&zmwHhCegt(a}0_}pK<01mxJ z4tnr~4kd66-qV(`o6*yPB%U0nJ?dfW*3j8| zRT$iHM_Bmi-C>sIFzGz6I48+D5*yI~9NF{|a0)=A$XdsdF*VA-jnTS}xOjx9qj@%C z9(l_TJAn*vy(>~?pbYAWym4|sTlm#fEZ48$y_6R~H%MWJ&RTE$0k+L{G-LF~!6230L_0iYaWECh*D%9m)}U+%fnqD#sQu~CDMIJ@ z=e#@gsi__xLJj7MGdGwu#YzTxWdhz2Nd!!kt2|?ikJUvN#Gac&j zs#k`veOFlg&}|_cI7nkOnkU7OPq&pBh+(M zD)LEk$XAo&mi5&KdwMF5^OSDiwnY4kn{n0I4ApfH1Qkluu!n}APnTq3 zy`rQI+dfzA*08WqH)zO}Sc(9dYz#x6c?4uy4JQp5DPm!dCwZb}S`ak-!kg%zklC>C zf!o5|V~@~5mpb0&ElIlXm#a&_il!`l@S{*U@>S-&tt&hy?`%09j=|;B5gL+uKF6p< zX?A?Dp0R7fNK3N_Iu?s*WK@BsjaCM3B`1!IqT!=(8f|)bz(ZUIr(M+nh{`whK~se4 z0+kQO4GDN6Kb$>8tIEtvM#FY6j)Y<|vP-F7$6kKc096R}!GYxrjNLp!RUV;VmSvDM zKN_)Ab)Ge0J~~r~`lr0H?@{dBPpyMTZMwKl1BLi@#+b!{F5?klmWCg3iYKaqbk51t z09_sxR;K$NeoPEPnj#>5q4&nIJW?iFA8;XurJo>8uNbEhBX$g%fn z+EBJcX2zf$Ew81z@JV!2d=g`mWq+o7$H(j7xhr+v9Xd0h)1_lSED%=fj!4zUywqt{ z6E;NoMXGL|7GG_rMOf_6X*H<~4RmraGrw_|S6GB|4)N(^b8=}k+2b_aQpOq4S+`T` z%owD3^jEOVI$gVF-c9n9@@;zYLv+AE#60>=Xv72x8;;Oy6$< z`kdL8R^{gXycs)Q*0LlTRkbusYw5Q~J5I&9a+;1tazf_m6s9Ao@;#<%RXL<+8lgrF zQ$La@6ckD_)TLV)_oK(l=oXr!Hc9c?kM+y0#Be4R$!M@T%64KQ z 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%0AcaGH*sj&^87&GWcXCW0+b9 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

tdbQL+b|Xv@|JTmx!vd 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�p|+RVtkQ(}f` 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 VIc8yMN%kl&r7W*5S0Q8m^?zszM)Uvx literal 0 HcmV?d00001 diff --git a/inference/worker/plugins/calculator/main.py b/inference/worker/plugins/calculator/main.py new file mode 100644 index 0000000000..63332d4213 --- /dev/null +++ b/inference/worker/plugins/calculator/main.py @@ -0,0 +1,88 @@ +import json +import numexpr +import re +import math +from fastapi import FastAPI, Response, Query +from fastapi.middleware.cors import CORSMiddleware +from fastapi.openapi.utils import get_openapi + +app = FastAPI() + +# expression query parameter description for model +PROMPT = """Solves a math equation but you need to provide an expression\ +that can be executed using Python's numexpr library.""" + +app.add_middleware( + CORSMiddleware, + allow_origins=["*"], + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + + +# From Langchain math chain +def _evaluate_expression(expression: str) -> str: + try: + local_dict = {"pi": math.pi, "e": math.e} + output = str( + numexpr.evaluate( + expression.strip(), + global_dict={}, + local_dict=local_dict, + ) + ) + except Exception as e: + return (f"{e}. Please try again with a valid numerical expression") + + return re.sub(r"^\[|\]$", "", output) + +# NOTE: operation_id is used to identify the endpoint in the LLM, and +# camelCase works better than snake_case for that +# .e.g. "webSearch" > "web_search" +# another important thing is parameter descriptions +@app.get("/calculate/", operation_id="calculate", tags=["Calculator"]) +async def calculate(expression: str = Query(..., description=PROMPT)): + return {"result": _evaluate_expression(expression)} + + +@app.get("/icon.png", include_in_schema=False) +async def api_icon(): + with open("icon.png", "rb") as f: + icon = f.read() + return Response(content=icon, media_type="image/png") + + +@app.get("/ai-plugin.json", include_in_schema=False) +async def api_ai_plugin(): + with open("ai-plugin.json", "r") as f: + ai_plugin_json = json.load(f) + return Response(content=json.dumps(ai_plugin_json), + media_type="application/json") + + +def custom_openapi(): + if app.openapi_schema: + return app.openapi_schema + openapi_schema = get_openapi( + title="Calculator", + version="0.1", + routes=app.routes, + ) + openapi_schema["servers"] = [ + { + "url": "http://192.168.0.35:8085", + }, + ] + openapi_schema["tags"] = [ + { + "name": "Ai-Calculator", + "description": """Ai-Calculator API""", + }, + ] + openapi_schema.pop("components", None) + app.openapi_schema = openapi_schema + return app.openapi_schema + + +app.openapi = custom_openapi diff --git a/inference/worker/requirements.txt b/inference/worker/requirements.txt index 66295963d3..ecc6d95abc 100644 --- a/inference/worker/requirements.txt +++ b/inference/worker/requirements.txt @@ -10,3 +10,6 @@ sentencepiece sseclient-py git+https://github.com/huggingface/transformers@main#egg=transformers websocket-client +langchain==0.0.142 +text-generation +numexpr diff --git a/inference/worker/work.py b/inference/worker/work.py index 7b47e00f90..24ac29bda0 100644 --- a/inference/worker/work.py +++ b/inference/worker/work.py @@ -7,6 +7,7 @@ import sseclient import transformers import utils +import chat_chain import websocket from loguru import logger from oasst_shared.schemas import inference @@ -106,9 +107,24 @@ def handle_work_request( work_request: inference.WorkRequest, worker_config: inference.WorkerConfig, ): - prompt, parameters = make_prompt_and_parameters(tokenizer=tokenizer, work_request=work_request) + parameters = interface.GenerateStreamParameters.from_work_parameters(work_request.parameters) + prompt = "" + used_plugin = None + + # prompt, parameters = make_prompt_and_parameters(tokenizer=tokenizer, work_request=work_request) + + prompt, used_plugin = chat_chain.handle_conversation(work_request, worker_config, parameters, tokenizer) logger.debug(f"Prompt: {prompt}") + # If plugin was used, lockup sampling parameters to "best" known values for plugins + if used_plugin: + parameters.top_k = 50 + parameters.top_p = None + parameters.typical_p = None + parameters.temperature = 0.2 + parameters.repetition_penalty = (1 / 0.83) + # parameters.seed = 42 + model_config = worker_config.model_config # Only send safety request if work request safety level is not 0 @@ -182,6 +198,7 @@ def handle_work_request( text=stream_response.generated_text, finish_reason=stream_response.details.finish_reason, metrics=inference.WorkerMetricsInfo(), + used_plugin=used_plugin, ), ) logger.debug("Work complete. Waiting for more work...") diff --git a/oasst-shared/oasst_shared/schemas/inference.py b/oasst-shared/oasst_shared/schemas/inference.py index 2704ff0203..bba6e23e55 100644 --- a/oasst-shared/oasst_shared/schemas/inference.py +++ b/oasst-shared/oasst_shared/schemas/inference.py @@ -3,7 +3,7 @@ import random import uuid from datetime import datetime -from typing import Annotated, Literal, Union +from typing import Annotated, Literal, Union, List, Any import psutil import pydantic @@ -117,6 +117,82 @@ class SamplingParameters(pydantic.BaseModel): max_new_tokens: int = 1024 +class PluginApiType(pydantic.BaseModel): + type: str + url: str + has_user_authentication: bool | None = False + # NOTE: Some plugins using this field, + # instead of has_user_authentication + is_user_authenticated: bool | None = False + + +class PluginAuthType(pydantic.BaseModel): + type: str + + +class PluginOpenAPIParameter(pydantic.BaseModel): + name: str + in_: str + description: str + required: bool + schema_: object + + +class PluginOpenAPIEndpoint(pydantic.BaseModel): + path: str + type: str + summary: str + operation_id: str + url: str + params: List[PluginOpenAPIParameter] + + +class PluginConfig(pydantic.BaseModel): + schema_version: str + name_for_model: str + name_for_human: str + description_for_human: str + description_for_model: str + api: PluginApiType + auth: PluginAuthType + logo_url: str | None = None + contact_email: str | None = None + legal_info_url: str | None = None + endpoints: List[PluginOpenAPIEndpoint] | None = None + + def __getitem__(self, key: str) -> Any: + return getattr(self, key) + + def __setitem__(self, key: str, value: Any) -> None: + setattr(self, key, value) + + +class PluginEntry(pydantic.BaseModel): + url: str + enabled: bool = True + plugin_config: PluginConfig | None = None + # NOTE: Idea, is to have OA internal plugins as trusted, + # and all other plugins as untrusted by default(until proven otherwise) + trusted: bool | None = False + + +class PluginExecutionDetails(pydantic.BaseModel): + inner_monologue: List[str] + final_tool_output: str + final_prompt: str + final_generation_assisted: bool + achieved_depth: int | None = None + error_message: str | None = None + status: Literal["success", "failure"] + + +class PluginUsed(pydantic.BaseModel): + name: str | None = None + url: str | None = None + trusted: bool | None = None + execution_details: PluginExecutionDetails + + def make_seed() -> int: return random.randint(0, 0xFFFF_FFFF_FFFF_FFFF - 1) @@ -128,6 +204,8 @@ class WorkParameters(pydantic.BaseModel): seed: int = pydantic.Field( default_factory=make_seed, ) + plugins: list[PluginEntry] = pydantic.Field(default_factory=list[PluginEntry]) + used_plugin: PluginUsed | None = None class ReportType(str, enum.Enum): @@ -252,6 +330,7 @@ class GeneratedTextResponse(WorkerResponseBase): text: str finish_reason: Literal["length", "eos_token", "stop_sequence"] metrics: WorkerMetricsInfo | None = None + used_plugin: PluginUsed | None = None class InternalFinishedMessageResponse(WorkerResponseBase): diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000000..cfd645f04b --- /dev/null +++ b/package-lock.json @@ -0,0 +1,6 @@ +{ + "name": "Open-Assistant", + "lockfileVersion": 2, + "requires": true, + "packages": {} +} diff --git a/website/package-lock.json b/website/package-lock.json index 01507235a8..108d34b29d 100644 --- a/website/package-lock.json +++ b/website/package-lock.json @@ -8,6 +8,7 @@ "name": "website", "version": "0.1.0", "dependencies": { + "@chakra-ui/icons": "^2.0.18", "@chakra-ui/react": "^2.5.5", "@dnd-kit/core": "^6.0.8", "@dnd-kit/modifiers": "^6.0.1", @@ -2399,6 +2400,18 @@ "react": ">=18" } }, + "node_modules/@chakra-ui/icons": { + "version": "2.0.18", + "resolved": "https://registry.npmjs.org/@chakra-ui/icons/-/icons-2.0.18.tgz", + "integrity": "sha512-E/+DF/jw7kdN4/XxCZRnr4FdMXhkl50Q34MVwN9rADWMwPK9uSZPGyC7HOx6rilo7q4bFjYDH3yRj9g+VfbVkg==", + "dependencies": { + "@chakra-ui/icon": "3.0.16" + }, + "peerDependencies": { + "@chakra-ui/system": ">=2.0.0", + "react": ">=18" + } + }, "node_modules/@chakra-ui/image": { "version": "2.0.15", "resolved": "https://registry.npmjs.org/@chakra-ui/image/-/image-2.0.15.tgz", @@ -5049,10 +5062,7 @@ "version": "0.2.8", "resolved": "https://registry.npmjs.org/strict-event-emitter/-/strict-event-emitter-0.2.8.tgz", "integrity": "sha512-KDf/ujU8Zud3YaLtMCcTI4xkZlZVIYxTLr+XIULexP+77EEVWixeXroLUXQXiVtH4XH2W7jr/3PT1v3zBuvc3A==", - "dev": true, - "dependencies": { - "events": "^3.3.0" - } + "dev": true }, "node_modules/@ndelangen/get-tarball": { "version": "3.0.7", @@ -5463,12 +5473,12 @@ } }, "node_modules/@prisma/client": { - "version": "4.11.0", - "resolved": "https://registry.npmjs.org/@prisma/client/-/client-4.11.0.tgz", - "integrity": "sha512-0INHYkQIqgAjrt7NzhYpeDQi8x3Nvylc2uDngKyFDDj1tTRQ4uV1HnVmd1sQEraeVAN63SOK0dgCKQHlvjL0KA==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/@prisma/client/-/client-4.12.0.tgz", + "integrity": "sha512-j9/ighfWwux97J2dS15nqhl60tYoH8V0IuSsgZDb6bCFcQD3fXbXmxjYC8GHhIgOk3lB7Pq+8CwElz2MiDpsSg==", "hasInstallScript": true, "dependencies": { - "@prisma/engines-version": "4.11.0-57.8fde8fef4033376662cad983758335009d522acb" + "@prisma/engines-version": "4.12.0-67.659ef412370fa3b41cd7bf6e94587c1dfb7f67e7" }, "engines": { "node": ">=14.17" @@ -5483,16 +5493,16 @@ } }, "node_modules/@prisma/engines": { - "version": "4.11.0", - "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-4.11.0.tgz", - "integrity": "sha512-0AEBi2HXGV02cf6ASsBPhfsVIbVSDC9nbQed4iiY5eHttW9ZtMxHThuKZE1pnESbr8HRdgmFSa/Kn4OSNYuibg==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/@prisma/engines/-/engines-4.12.0.tgz", + "integrity": "sha512-0alKtnxhNB5hYU+ymESBlGI4b9XrGGSdv7Ud+8TE/fBNOEhIud0XQsAR+TrvUZgS4na5czubiMsODw0TUrgkIA==", "devOptional": true, "hasInstallScript": true }, "node_modules/@prisma/engines-version": { - "version": "4.11.0-57.8fde8fef4033376662cad983758335009d522acb", - "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-4.11.0-57.8fde8fef4033376662cad983758335009d522acb.tgz", - "integrity": "sha512-3Vd8Qq06d5xD8Ch5WauWcUUrsVPdMC6Ge8ILji8RFfyhUpqon6qSyGM0apvr1O8n8qH8cKkEFqRPsYjuz5r83g==" + "version": "4.12.0-67.659ef412370fa3b41cd7bf6e94587c1dfb7f67e7", + "resolved": "https://registry.npmjs.org/@prisma/engines-version/-/engines-version-4.12.0-67.659ef412370fa3b41cd7bf6e94587c1dfb7f67e7.tgz", + "integrity": "sha512-JIHNj5jlXb9mcaJwakM0vpgRYJIAurxTUqM0iX0tfEQA5XLZ9ONkIckkhuAKdAzocZ+80GYg7QSsfpjg7OxbOA==" }, "node_modules/@rushstack/eslint-patch": { "version": "1.2.0", @@ -24192,13 +24202,13 @@ } }, "node_modules/prisma": { - "version": "4.11.0", - "resolved": "https://registry.npmjs.org/prisma/-/prisma-4.11.0.tgz", - "integrity": "sha512-4zZmBXssPUEiX+GeL0MUq/Yyie4ltiKmGu7jCJFnYMamNrrulTBc+D+QwAQSJ01tyzeGHlD13kOnqPwRipnlNw==", + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/prisma/-/prisma-4.12.0.tgz", + "integrity": "sha512-xqVper4mbwl32BWzLpdznHAYvYDWQQWK2tBfXjdUD397XaveRyAP7SkBZ6kFlIg8kKayF4hvuaVtYwXd9BodAg==", "devOptional": true, "hasInstallScript": true, "dependencies": { - "@prisma/engines": "4.11.0" + "@prisma/engines": "4.12.0" }, "bin": { "prisma": "build/index.js", diff --git a/website/package.json b/website/package.json index 8a24359337..0420dc52d0 100644 --- a/website/package.json +++ b/website/package.json @@ -26,6 +26,7 @@ "seed": "ts-node --compiler-options {\"module\":\"CommonJS\"} prisma/seed.ts" }, "dependencies": { + "@chakra-ui/icons": "^2.0.18", "@chakra-ui/react": "^2.5.5", "@dnd-kit/core": "^6.0.8", "@dnd-kit/modifiers": "^6.0.1", diff --git a/website/public/locales/en/common.json b/website/public/locales/en/common.json index c83f4f01aa..93270314de 100644 --- a/website/public/locales/en/common.json +++ b/website/public/locales/en/common.json @@ -59,5 +59,15 @@ "users_dashboard": "Users Dashboard", "yes": "Yes", "who_are_we": "Who are we?", - "team": "Team" + "team": "Team", + "hugging_face": "HuggingFace", + "plugins": "Plugins", + "edit_plugin": "Edit Plugin", + "add_plugin": "Add Plugin", + "save": "Save", + "used": "Used", + "unverified_plugin": "UNVERIFIED", + "verified_plugin": "VERIFIED", + "unverified_plugin_description": "This plugin has not been verified by the Open Assistant team. Use at your own risk.", + "verified_plugin_description": "This plugin has been verified by the Open Assistant team." } diff --git a/website/src/components/Chat/ChatConfigDrawer.tsx b/website/src/components/Chat/ChatConfigDrawer.tsx index bfb33b31e7..348d898551 100644 --- a/website/src/components/Chat/ChatConfigDrawer.tsx +++ b/website/src/components/Chat/ChatConfigDrawer.tsx @@ -114,7 +114,7 @@ const parameterLabel: Record = { const ChatConfigForm = () => { const { t } = useTranslation("chat"); - const { modelInfos } = useChatContext(); + const { modelInfos, plugins } = useChatContext(); const { control, register, reset, getValues } = useFormContext(); const selectedModel = useWatch({ name: "model_config_name", control: control }); @@ -130,7 +130,7 @@ const ChatConfigForm = () => { newPresetName === customPresetName ? customPresetDefaultValue : presets.find((preset) => preset.name === newPresetName)!.sampling_parameters; - reset({ ...config, model_config_name: selectedModel }); + reset({ ...config, model_config_name: selectedModel, plugins }); setSelectedPresetName(newPresetName); }, [presets, reset, selectedModel] diff --git a/website/src/components/Chat/ChatConfigSummary.tsx b/website/src/components/Chat/ChatConfigSummary.tsx index 7ca12af31c..ccec5b41e3 100644 --- a/website/src/components/Chat/ChatConfigSummary.tsx +++ b/website/src/components/Chat/ChatConfigSummary.tsx @@ -13,7 +13,7 @@ export default function ChatConfigSummary() { {t("model")} {config["model_config_name"]} {Object.entries(config) - .filter(([key, value]) => key !== "model_config_name" && value !== null) + .filter(([key, value]) => key !== "model_config_name" && key !== "plugins" && value !== null) .map(([key, value]) => ( {t(key as any)} diff --git a/website/src/components/Chat/ChatContext.tsx b/website/src/components/Chat/ChatContext.tsx index 925916a6ce..9513ac0d4b 100644 --- a/website/src/components/Chat/ChatContext.tsx +++ b/website/src/components/Chat/ChatContext.tsx @@ -4,14 +4,15 @@ import { InferenceMessage, ModelInfo } from "src/types/Chat"; export type ChatContext = { modelInfos: ModelInfo[]; messages: InferenceMessage[]; + plugins: PluginEntry[]; }; const chatContext = createContext({} as ChatContext); export const useChatContext = () => useContext(chatContext); -export const ChatContextProvider = ({ children, modelInfos, messages }: PropsWithChildren) => { - const value = useMemo(() => ({ modelInfos, messages }), [messages, modelInfos]); +export const ChatContextProvider = ({ children, modelInfos, messages, plugins }: PropsWithChildren) => { + const value = useMemo(() => ({ modelInfos, messages, plugins }), [messages, modelInfos]); return {children}; }; diff --git a/website/src/components/Chat/ChatConversation.tsx b/website/src/components/Chat/ChatConversation.tsx index 23ef864400..6fa803832c 100644 --- a/website/src/components/Chat/ChatConversation.tsx +++ b/website/src/components/Chat/ChatConversation.tsx @@ -2,6 +2,8 @@ import { Flex, useBoolean, useToast } from "@chakra-ui/react"; import { memo, useCallback, useRef, useState } from "react"; import { UseFormGetValues } from "react-hook-form"; +import { useFormContext } from "react-hook-form"; +import { useChatContext } from "src/components/Chat/ChatContext"; import { useMessageVote } from "src/hooks/chat/useMessageVote"; import { get, post } from "src/lib/api"; import { handleChatEventStream, QueueInfo } from "src/lib/chat_stream"; @@ -14,7 +16,6 @@ import { } from "src/types/Chat"; import { mutate } from "swr"; -import { useChatContext } from "./ChatContext"; import { ChatConversationTree, LAST_ASSISTANT_MESSAGE_ID } from "./ChatConversationTree"; import { ChatForm } from "./ChatForm"; import { ChatMessageEntryProps, EditPromptParams, PendingMessageEntry } from "./ChatMessageEntry"; @@ -34,13 +35,15 @@ export const ChatConversation = memo(function ChatConversation({ chatId, getConf const createAndFetchAssistantMessage = useCallback( async ({ parentId, chatId }: { parentId: string; chatId: string }) => { - const { model_config_name, ...sampling_parameters } = getConfigValues(); + const { model_config_name, plugins, ...sampling_parameters } = getConfigValues(); const assistant_arg: InferencePostAssistantMessageParams = { chat_id: chatId, parent_id: parentId, model_config_name, sampling_parameters, + plugins, }; + console.log("assistant_arg", assistant_arg); const assistant_message: InferenceMessage = await post(API_ROUTES.CREATE_ASSISTANT_MESSAGE, { arg: assistant_arg, @@ -105,6 +108,7 @@ export const ChatConversation = memo(function ChatConversation({ chatId, getConf content, parent_id: parentId, }; + console.log("prompter_arg", prompter_arg); const prompter_message: InferenceMessage = await post(API_ROUTES.CREATE_PROMPTER_MESSAGE, { arg: prompter_arg }); if (messages.length === 0) { @@ -112,6 +116,7 @@ export const ChatConversation = memo(function ChatConversation({ chatId, getConf mutate(API_ROUTES.LIST_CHAT); } setMessages((messages) => [...messages, prompter_message]); + console.log("prompter_message", prompter_message); // after creating the prompters message, handle the assistant's case await createAndFetchAssistantMessage({ parentId: prompter_message.id, chatId }); diff --git a/website/src/components/Chat/ChatForm.tsx b/website/src/components/Chat/ChatForm.tsx index da27a5808a..71862285fe 100644 --- a/website/src/components/Chat/ChatForm.tsx +++ b/website/src/components/Chat/ChatForm.tsx @@ -1,4 +1,4 @@ -import { Button, Grid, Textarea } from "@chakra-ui/react"; +import { Button, Grid, Textarea, Box, useBreakpointValue } from "@chakra-ui/react"; import { useTranslation } from "next-i18next"; import { forwardRef, KeyboardEvent, SyntheticEvent, useCallback } from "react"; import TextareaAutosize from "react-textarea-autosize"; @@ -6,6 +6,7 @@ import { QueueInfo } from "src/lib/chat_stream"; import { ChatConfigDrawer } from "./ChatConfigDrawer"; import { QueueInfoMessage } from "./QueueInfoMessage"; +import { PluginsChooser } from "./PluginsChooser"; type ChatFormProps = { isSending: boolean; @@ -45,7 +46,12 @@ export const ChatForm = forwardRef((props, r bg: "gray.800", }} /> - + - + + + + ); diff --git a/website/src/components/Chat/ChatMessageEntry.tsx b/website/src/components/Chat/ChatMessageEntry.tsx index ebe0831f68..f1ac16a2dc 100644 --- a/website/src/components/Chat/ChatMessageEntry.tsx +++ b/website/src/components/Chat/ChatMessageEntry.tsx @@ -100,7 +100,13 @@ export const ChatMessageEntry = memo(function ChatMessageEntry({ ); return ( - + {!isAssistant && parentId !== null && ( {isEditing ? ( @@ -167,7 +173,7 @@ type PendingMessageEntryProps = { }; export const PendingMessageEntry = forwardRef(function PendingMessageEntry( - { content, isAssistant, children, ...props }, + { content, isAssistant, children, usedPlugin, ...props }, ref ) { const bgUser = useColorModeValue("white", "gray.700"); @@ -188,6 +194,8 @@ export const PendingMessageEntry = forwardRef {children} diff --git a/website/src/components/Chat/ChatSection.tsx b/website/src/components/Chat/ChatSection.tsx index 97f75cda23..ccf1aabcd9 100644 --- a/website/src/components/Chat/ChatSection.tsx +++ b/website/src/components/Chat/ChatSection.tsx @@ -12,7 +12,7 @@ import { InferencePoweredBy } from "./InferencePoweredBy"; const ChatConfigSummary = dynamic(() => import("./ChatConfigSummary"), { ssr: false }); export const ChatSection = ({ chatId }: { chatId: string | null }) => { - const { modelInfos } = useChatContext(); + const { modelInfos, plugins } = useChatContext(); console.assert(modelInfos.length > 0, "No model config was found"); @@ -27,6 +27,7 @@ export const ChatSection = ({ chatId }: { chatId: string | null }) => { defaultValues = { ...modelInfos[0].parameter_configs[0].sampling_parameters, model_config_name: modelInfos[0].name, + plugins: plugins, }; } diff --git a/website/src/components/Chat/PluginsChooser.tsx b/website/src/components/Chat/PluginsChooser.tsx new file mode 100644 index 0000000000..531d0d6dcf --- /dev/null +++ b/website/src/components/Chat/PluginsChooser.tsx @@ -0,0 +1,220 @@ +import { + Button, + Text, + Tooltip, + Radio, + RadioGroup, + Box, + Editable, + EditableInput, + EditablePreview, + Image, + FormControl, + FormLabel, + Icon, + IconButton, + Menu, + MenuButton, + MenuItem, + MenuList, + Modal, + ModalBody, + ModalCloseButton, + ModalContent, + ModalFooter, + ModalHeader, + ModalOverlay, + Stack, + Textarea, + useDisclosure, +} from "@chakra-ui/react"; +import { Cog, Edit, Plus } from "lucide-react"; +// i need +import { AttachmentIcon, WarningIcon, CheckCircleIcon, CloseIcon } from "@chakra-ui/icons"; +import { ChangeEvent, useCallback, useEffect, useState, useRef } from "react"; +import { useTranslation } from "next-i18next"; +import { Controller, useFormContext, useWatch } from "react-hook-form"; +import { ChatConfigForm } from "src/types/Chat"; +import { useChatContext } from "./ChatContext"; +import { PluginEntry } from "src/types/Chat"; +import { get, post } from "src/lib/api"; +import { API_ROUTES } from "src/lib/routes"; + +export const PluginsChooser = () => { + const { t } = useTranslation("common"); + const { control, register, reset, setValue } = useFormContext(); + const [selectedPluginIndex, setSelectedPluginIndex] = useState(null); + const { isOpen, onOpen, onClose } = useDisclosure(); + + const textareaRef = useRef(null); + const plugins = useWatch({ name: "plugins", control: control }); + + const findSelectedPluginIndex = useCallback(() => { + return plugins.findIndex((plugin) => plugin.enabled); + }, [plugins]); + + const handlePluginSelect = useCallback( + (index: number) => { + const selectedIndex = plugins.findIndex((plugin) => plugin.enabled); + const newPlugins = plugins.map((plugin, i) => ({ + ...plugin, + enabled: selectedIndex === index ? false : i === index, + })); + setValue("plugins", newPlugins); + }, + [setValue, plugins] + ); + + const handlePluginEdit = useCallback( + (index: number) => { + setSelectedPluginIndex(index); + onOpen(); + }, + [onOpen] + ); + + const handlePluginRemove = useCallback( + (index) => { + const updatedPlugins = plugins.filter((_, idx) => idx !== index); + setValue("plugins", updatedPlugins); + }, + [setValue, plugins] + ); + + const handlePluginSave = useCallback(async () => { + if (textareaRef.current) { + const newPlugins = [...plugins]; + newPlugins[selectedPluginIndex!].url = textareaRef.current.value; + + const plugin: PluginEntry = await post(API_ROUTES.GET_PLUGIN_CONFIG, { + arg: { plugin: newPlugins[selectedPluginIndex!] }, + }); + + newPlugins[selectedPluginIndex!].plugin_config = plugin.plugin_config; + setValue("plugins", newPlugins); + } + onClose(); + }, [onClose, control, plugins, selectedPluginIndex]); + + const handlePluginAdd = useCallback(() => { + const newPlugin: PluginEntry = { + url: "", + enabled: false, + }; + setValue("plugins", [...plugins, newPlugin]); + handlePluginEdit(plugins.length); + }, [setValue, plugins, handlePluginEdit]); + + const limitPluginNameLength = (name: string) => { + if (!name) { + return ""; + } + if (name.length > 15) { + return name.substring(0, 15) + "..."; + } + return name; + }; + + return ( + +

+ } w="100%" size="lg"> + {plugins && plugins[findSelectedPluginIndex()]?.enabled ? ( + + Plugins + {limitPluginNameLength(plugins[findSelectedPluginIndex()]?.plugin_config?.name_for_human)} + + ) : ( + + + {t("plugins")} + + )} + + + plugin.enabled).toString()}> + {plugins?.map((plugin, index) => ( + + handlePluginSelect(index)}> + handlePluginSelect(index)} + > + Plugins + {plugins[index]?.plugin_config?.name_for_human} + {!plugins[index]?.trusted ? ( + + + + + + ) : ( + + + + + + )} + + + } + onClick={() => handlePluginEdit(index)} + size="sm" + marginLeft="auto" + /> + } + onClick={() => handlePluginRemove(index)} + size="sm" + marginLeft="2" + /> + + ))} + + + + } size="sm" /> + + + + + + + + {t("edit_plugin")} + + +