From d7369be42f2bd965a571d6de8d4b32ee619844b0 Mon Sep 17 00:00:00 2001 From: Andreas Volkmann Date: Fri, 18 Oct 2024 13:10:49 -0700 Subject: [PATCH 001/173] Simplify samples (#3845) authored-by: Andreas Volkmann --- .../samples/AutoGen.BasicSamples/Program.cs | 43 ++++++++++--------- 1 file changed, 22 insertions(+), 21 deletions(-) diff --git a/dotnet/samples/AutoGen.BasicSamples/Program.cs b/dotnet/samples/AutoGen.BasicSamples/Program.cs index 6cad02ac7cd6..5afbd8ec15e1 100644 --- a/dotnet/samples/AutoGen.BasicSamples/Program.cs +++ b/dotnet/samples/AutoGen.BasicSamples/Program.cs @@ -5,28 +5,29 @@ using AutoGen.BasicSample; //Define allSamples collection for all examples -List>> allSamples = new List>>(); - -// When a new sample is created please add them to the allSamples collection -allSamples.Add(new Tuple>("Assistant Agent", async () => { await Example01_AssistantAgent.RunAsync(); })); -allSamples.Add(new Tuple>("Two-agent Math Chat", async () => { await Example02_TwoAgent_MathChat.RunAsync(); })); -allSamples.Add(new Tuple>("Agent Function Call", async () => { await Example03_Agent_FunctionCall.RunAsync(); })); -allSamples.Add(new Tuple>("Dynamic Group Chat Coding Task", async () => { await Example04_Dynamic_GroupChat_Coding_Task.RunAsync(); })); -allSamples.Add(new Tuple>("DALL-E and GPT4v", async () => { await Example05_Dalle_And_GPT4V.RunAsync(); })); -allSamples.Add(new Tuple>("User Proxy Agent", async () => { await Example06_UserProxyAgent.RunAsync(); })); -allSamples.Add(new Tuple>("Dynamic Group Chat - Calculate Fibonacci", async () => { await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunAsync(); })); -allSamples.Add(new Tuple>("LM Studio", async () => { await Example08_LMStudio.RunAsync(); })); -allSamples.Add(new Tuple>("Semantic Kernel", async () => { await Example10_SemanticKernel.RunAsync(); })); -allSamples.Add(new Tuple>("Sequential Group Chat", async () => { await Sequential_GroupChat_Example.RunAsync(); })); -allSamples.Add(new Tuple>("Two Agent - Fill Application", async () => { await TwoAgent_Fill_Application.RunAsync(); })); -allSamples.Add(new Tuple>("Mistal Client Agent - Token Count", async () => { await Example14_MistralClientAgent_TokenCount.RunAsync(); })); -allSamples.Add(new Tuple>("GPT4v - Binary Data Image", async () => { await Example15_GPT4V_BinaryDataImageMessage.RunAsync(); })); -allSamples.Add(new Tuple>("ReAct Agent", async () => { await Example17_ReActAgent.RunAsync(); })); +var allSamples = new List<(string, Func)> +{ + // When a new sample is created please add them to the allSamples collection + ("Assistant Agent", Example01_AssistantAgent.RunAsync), + ("Two-agent Math Chat", Example02_TwoAgent_MathChat.RunAsync), + ("Agent Function Call", Example03_Agent_FunctionCall.RunAsync), + ("Dynamic Group Chat Coding Task", Example04_Dynamic_GroupChat_Coding_Task.RunAsync), + ("DALL-E and GPT4v", Example05_Dalle_And_GPT4V.RunAsync), + ("User Proxy Agent", Example06_UserProxyAgent.RunAsync), + ("Dynamic Group Chat - Calculate Fibonacci", Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunAsync), + ("LM Studio", Example08_LMStudio.RunAsync), + ("Semantic Kernel", Example10_SemanticKernel.RunAsync), + ("Sequential Group Chat", Sequential_GroupChat_Example.RunAsync), + ("Two Agent - Fill Application", TwoAgent_Fill_Application.RunAsync), + ("Mistral Client Agent - Token Count", Example14_MistralClientAgent_TokenCount.RunAsync), + ("GPT4v - Binary Data Image", Example15_GPT4V_BinaryDataImageMessage.RunAsync), + ("ReAct Agent", Example17_ReActAgent.RunAsync) +}; -int idx = 1; -Dictionary>> map = new Dictionary>>(); Console.WriteLine("Available Examples:\n\n"); -foreach (Tuple> sample in allSamples) +var idx = 1; +var map = new Dictionary)>(); +foreach (var sample in allSamples) { map.Add(idx, sample); Console.WriteLine("{0}. {1}", idx++, sample.Item1); @@ -41,7 +42,7 @@ { break; } - int val = Convert.ToInt32(input); + var val = Convert.ToInt32(input); if (!map.ContainsKey(val)) { Console.WriteLine("Invalid choice"); From 1700b9c61a60be1eb75e8ed53b02f0614f3c04b9 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 19 Oct 2024 00:13:51 +0200 Subject: [PATCH 002/173] Update group chat documentation in core to use selector group chat and tool call for illustrator (#3815) * Update group chat documentation in core to use selector group chat and tool call for illustrator * Update notebook * Update group chat with illustration * Remove embedded fonts in svg --------- Co-authored-by: Ryan Sweet --- .../autogen-core/docs/drawio/groupchat.drawio | 78 + .../design-patterns/group-chat.ipynb | 1249 ++++++++++++++--- .../design-patterns/groupchat.svg | 3 + 3 files changed, 1102 insertions(+), 228 deletions(-) create mode 100644 python/packages/autogen-core/docs/drawio/groupchat.drawio create mode 100644 python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/groupchat.svg diff --git a/python/packages/autogen-core/docs/drawio/groupchat.drawio b/python/packages/autogen-core/docs/drawio/groupchat.drawio new file mode 100644 index 000000000000..ae8ed84b6972 --- /dev/null +++ b/python/packages/autogen-core/docs/drawio/groupchat.drawio @@ -0,0 +1,78 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb index 37d4e03cb651..134ea6684df8 100644 --- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb @@ -7,162 +7,297 @@ "# Group Chat\n", "\n", "Group chat is a design pattern where a group of agents share a common thread\n", - "of messages: they all subscribe and publish to the same thread. Each participant\n", - "agent is specialized for a particular task, such as writer, illustrator, and editor\n", + "of messages: they all subscribe and publish to the same topic. \n", + "Each participant agent is specialized for a particular task, \n", + "such as writer, illustrator, and editor\n", "in a collaborative writing task.\n", + "You can also include an agent to represent a human user to help guide the\n", + "agents when needed.\n", "\n", - "The order\n", - "of converation is maintained by a Group Chat Manager agent, which selects\n", - "the next agent to speak. The exact algorithm for selecting the next agent\n", - "can vary based on your application requirements. Typicall, a round-robin\n", - "algorithm or a selection by an LLM model is used.\n", + "In a group chat, participants take turn to publish a message, and the process\n", + "is sequential -- only one agent is working at a time.\n", + "Under the hood, the order of turns is maintained by a Group Chat Manager agent,\n", + "which selects the next agent to speak upon receving a message.\n", + "The exact algorithm for selecting the next agent can vary based on your\n", + "application requirements. \n", + "Typically, a round-robin algorithm or a selector with an LLM model is used.\n", "\n", "Group chat is useful for dynamically decomposing a complex task into smaller ones \n", "that can be handled by specialized agents with well-defined roles.\n", + "It is also possible to nest group chats into a hierarchy with each participant\n", + "a recursive group chat.\n", "\n", - "In this example, we implement a simple group chat system with a round-robin\n", - "Group Chat Manager to create content for a children's story book. \n", - "We use three specialized agents: a writer, an illustrator, and an editor." + "In this example, we use AutoGen's Core API to implement the group chat pattern\n", + "using event-driven agents.\n", + "Please first read about [Topics and Subscriptions](../core-concepts/topic-and-subscription.md)\n", + "to understand the concepts and then [Messages and Communication](../framework/message-and-communication.ipynb)\n", + "to learn the API usage for pub-sub.\n", + "We will demonstrate a simple example of a group chat with a LLM-based selector\n", + "for the group chat manager, to create content for a children's story book.\n", + "\n", + "```{note}\n", + "While this example illustrates the group chat mechanism, it is complex and\n", + "represents a starting point from which you can build your own group chat system\n", + "with custom agents and speaker selection algorithms.\n", + "The [AgentChat API](../../agentchat-user-guide/index.md) has a built-in implementation\n", + "of selector group chat. You can use that if you do not want to use the Core API.\n", + "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Message Protocol\n", - "\n", - "The message protocol for the group chat system is simple: user publishes\n", - "a `GroupChatMessage` message to all participants.\n", - "The group chat manager sends out a `RequestToSpeak` message to the next agent\n", - "in the round-robin order, and the agent publishes `GroupChatMessage` messages,\n", - "which are consumed by all participants.\n", - "Once a conclusion is reached, in this case, the editor approves the draft,\n", - "the group chat manager stops sending `RequestToSpeak` message, and\n", - "the group chat ends." + "We will be using the [rich](https://github.com/Textualize/rich) library to display the messages in a nice format." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from autogen_core.components import Image\n", - "from autogen_core.components.models import LLMMessage\n", - "from pydantic import BaseModel\n", - "\n", - "\n", - "class GroupChatMessage(BaseModel):\n", - " body: LLMMessage\n", - "\n", - "\n", - "class RequestToSpeak(BaseModel):\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Agents\n", - "\n", - "Let's first define the agents that only uses LLM models to generate text.\n", - "The `WriterAgent` is responsible for writing a draft and create a description\n", - "for the illustration.\n", - "The `EditorAgent` is responsible for approving the draft which includes\n", - "both the text written by the `WriterAgent` and the illustration\n", - "created by the `IllustratorAgent`.\n", - "\n", - "The participant agents' classes are all \n", - "decorated with {py:meth}`~autogen_core.components.default_subscription`\n", - "to subscribe to the default topic type, and\n", - "each of them also decorated with {py:meth}`~autogen_core.components.type_subscription`\n", - "to subscribe to its own topic type.\n", - "This is because the group chat manager publishes a `RequestToSpeak` message\n", - "to the next agent's topic type, so to avoid the message being consumed by\n", - "other agents." + "# ! pip install rich" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ + "import json\n", + "import string\n", + "import uuid\n", "from typing import List\n", "\n", - "from autogen_core.base import MessageContext\n", + "import openai\n", + "from autogen_core.application import SingleThreadedAgentRuntime\n", + "from autogen_core.base import MessageContext, TopicId\n", "from autogen_core.components import (\n", " DefaultTopicId,\n", + " FunctionCall,\n", + " Image,\n", " RoutedAgent,\n", - " default_subscription,\n", + " TypeSubscription,\n", " message_handler,\n", - " type_subscription,\n", ")\n", "from autogen_core.components.models import (\n", " AssistantMessage,\n", " ChatCompletionClient,\n", " LLMMessage,\n", + " OpenAIChatCompletionClient,\n", " SystemMessage,\n", " UserMessage,\n", ")\n", + "from autogen_core.components.tools import FunctionTool\n", + "from IPython.display import display # type: ignore\n", + "from pydantic import BaseModel\n", + "from rich.console import Console\n", + "from rich.markdown import Markdown" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Message Protocol\n", + "\n", + "The message protocol for the group chat pattern is simple.\n", + "1. To start, user or an external agent publishes a `GroupChatMessage` message to the common topic of all participants.\n", + "2. The group chat manager selects the next speaker, sends out a `RequestToSpeak` message to that agent.\n", + "3. The agent publishes a `GroupChatMessage` message to the common topic upon receiving the `RequestToSpeak` message.\n", + "4. This process continues until a termination condition is reached at the group chat manager, which then stops issuing `RequestToSpeak` message, and the group chat ends.\n", "\n", + "The following diagram illustrates steps 2 to 4 above.\n", + "\n", + "![Group chat message protocol](groupchat.svg)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class GroupChatMessage(BaseModel):\n", + " body: UserMessage\n", + "\n", + "\n", + "class RequestToSpeak(BaseModel):\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Base Group Chat Agent\n", + "\n", + "Let's first define the agent class that only uses LLM models to generate text.\n", + "This is will be used as the base class for all AI agents in the group chat." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class BaseGroupChatAgent(RoutedAgent):\n", + " \"\"\"A group chat participant using an LLM.\"\"\"\n", "\n", - "@default_subscription\n", - "@type_subscription(\"writer\")\n", - "class WriterAgent(RoutedAgent):\n", " def __init__(\n", " self,\n", + " description: str,\n", + " group_chat_topic_type: str,\n", " model_client: ChatCompletionClient,\n", + " system_message: str,\n", " ) -> None:\n", - " super().__init__(\"A writer\")\n", + " super().__init__(description=description)\n", + " self._group_chat_topic_type = group_chat_topic_type\n", " self._model_client = model_client\n", - " self._chat_history: List[LLMMessage] = [\n", - " SystemMessage(\n", - " \"You are a writer. Write a draft with a paragraph description of an illustration, starting the description paragraph with 'ILLUSTRATION'.\"\n", - " )\n", - " ]\n", + " self._system_message = SystemMessage(system_message)\n", + " self._chat_history: List[LLMMessage] = []\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", - " self._chat_history.append(message.body)\n", + " self._chat_history.extend(\n", + " [\n", + " UserMessage(content=f\"Transferred to {message.body.source}\", source=\"system\"),\n", + " message.body,\n", + " ]\n", + " )\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", - " completion = await self._model_client.create(self._chat_history)\n", + " # print(f\"\\n{'-'*80}\\n{self.id.type}:\", flush=True)\n", + " Console().print(Markdown(f\"### {self.id.type}: \"))\n", + " self._chat_history.append(\n", + " UserMessage(content=f\"Transferred to {self.id.type}, adopt the persona immediately.\", source=\"system\")\n", + " )\n", + " completion = await self._model_client.create([self._system_message] + self._chat_history)\n", " assert isinstance(completion.content, str)\n", - " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Writer\"))\n", - " print(f\"\\n{'-'*80}\\nWriter:\\n{completion.content}\")\n", + " self._chat_history.append(AssistantMessage(content=completion.content, source=self.id.type))\n", + " Console().print(Markdown(completion.content))\n", + " # print(completion.content, flush=True)\n", " await self.publish_message(\n", - " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Writer\")), DefaultTopicId()\n", + " GroupChatMessage(body=UserMessage(content=completion.content, source=self.id.type)),\n", + " topic_id=DefaultTopicId(type=self._group_chat_topic_type),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Writer and Editor Agents\n", + "\n", + "Using the base class, we can define the writer and editor agents with\n", + "different system messages." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class WriterAgent(BaseGroupChatAgent):\n", + " def __init__(self, description: str, group_chat_topic_type: str, model_client: ChatCompletionClient) -> None:\n", + " super().__init__(\n", + " description=description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=model_client,\n", + " system_message=\"You are a Writer. You produce good work.\",\n", " )\n", "\n", "\n", - "@default_subscription\n", - "@type_subscription(\"editor\")\n", - "class EditorAgent(RoutedAgent):\n", + "class EditorAgent(BaseGroupChatAgent):\n", + " def __init__(self, description: str, group_chat_topic_type: str, model_client: ChatCompletionClient) -> None:\n", + " super().__init__(\n", + " description=description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=model_client,\n", + " system_message=\"You are an Editor. Plan and guide the task given by the user. Provide critical feedbacks to the draft and illustration produced by Writer and Illustrator. \"\n", + " \"Approve if the task is completed and the draft and illustration meets user's requirements.\",\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Illustrator Agent with Image Generation\n", + "\n", + "Now let's define the `IllustratorAgent` which uses a DALL-E model to generate\n", + "an illustration based on the description provided.\n", + "We set up the image generator as a tool using {py:class}`~autogen_core.components.tools.FunctionTool`\n", + "wrapper, and use a model client to make the tool call." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class IllustratorAgent(BaseGroupChatAgent):\n", " def __init__(\n", " self,\n", + " description: str,\n", + " group_chat_topic_type: str,\n", " model_client: ChatCompletionClient,\n", + " image_client: openai.AsyncClient,\n", " ) -> None:\n", - " super().__init__(\"An editor\")\n", - " self._model_client = model_client\n", - " self._chat_history: List[LLMMessage] = [\n", - " SystemMessage(\"You are an editor. Reply with 'APPROVE' to approve the draft\")\n", - " ]\n", + " super().__init__(\n", + " description=description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=model_client,\n", + " system_message=\"You are an Illustrator. You use the generate_image tool to create images given user's requirement.\",\n", + " )\n", + " self._image_client = image_client\n", + " self._image_gen_tool = FunctionTool(\n", + " self._image_gen,\n", + " name=\"generate_image\",\n", + " description=\"Call this to generate an image given a text description.\",\n", + " )\n", "\n", - " @message_handler\n", - " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", - " self._chat_history.append(message.body)\n", + " async def _image_gen(self, description: str) -> str:\n", + " response = await self._image_client.images.generate(\n", + " prompt=description.strip(), model=\"dall-e-2\", response_format=\"b64_json\", size=\"256x256\"\n", + " )\n", + " return response.data[0].b64_json # type: ignore\n", "\n", " @message_handler\n", - " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", - " completion = await self._model_client.create(self._chat_history)\n", - " assert isinstance(completion.content, str)\n", - " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Editor\"))\n", - " print(f\"\\n{'-'*80}\\nEditor:\\n{completion.content}\")\n", + " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None: # type: ignore\n", + " # print(f\"\\n{'-'*80}\\n{self.id.type}:\", flush=True)\n", + " Console().print(Markdown(f\"### {self.id.type}: \"))\n", + " self._chat_history.append(\n", + " UserMessage(content=f\"Transferred to {self.id.type}, adopt the persona immediately.\", source=\"system\")\n", + " )\n", + " # Ensure that the image generation tool is used.\n", + " completion = await self._model_client.create(\n", + " [self._system_message] + self._chat_history,\n", + " tools=[self._image_gen_tool],\n", + " extra_create_args={\"tool_choice\": \"required\"},\n", + " cancellation_token=ctx.cancellation_token,\n", + " )\n", + " assert isinstance(completion.content, list) and all(\n", + " isinstance(item, FunctionCall) for item in completion.content\n", + " )\n", + " images: List[str | Image] = []\n", + " for tool_call in completion.content:\n", + " arguments = json.loads(tool_call.arguments)\n", + " # print(arguments[\"description\"], flush=True)\n", + " Console().print(Markdown(arguments[\"description\"]))\n", + " result = await self._image_gen_tool.run_json(arguments, ctx.cancellation_token)\n", + " image = Image.from_base64(self._image_gen_tool.return_value_as_string(result))\n", + " display(image.image) # type: ignore\n", + " images.append(image)\n", " await self.publish_message(\n", - " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Editor\")), DefaultTopicId()\n", + " GroupChatMessage(body=UserMessage(content=images, source=self.id.type)),\n", + " DefaultTopicId(type=self._group_chat_topic_type),\n", " )" ] }, @@ -170,57 +305,39 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's define the `IllustratorAgent` which uses a DALL-E model to generate\n", - "an illustration based on the description provided by the `WriterAgent`." + "## User Agent\n", + "\n", + "With all the AI agents defined, we can now define the user agent that will\n", + "take the role of the human user in the group chat.\n", + "\n", + "The `UserAgent` implementation uses console input to get the user's input.\n", + "In a real-world scenario, you can replace this by communicating with a frontend,\n", + "and subscribe to responses from the frontend." ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "import re\n", - "\n", - "import openai\n", - "from IPython.display import display\n", - "\n", - "\n", - "@default_subscription\n", - "@type_subscription(\"illustrator\")\n", - "class IllustratorAgent(RoutedAgent):\n", - " def __init__(self, image_client: openai.AsyncClient) -> None:\n", - " super().__init__(\"An illustrator\")\n", - " self._image_client = image_client\n", - " self._chat_history: List[LLMMessage] = []\n", + "class UserAgent(RoutedAgent):\n", + " def __init__(self, description: str, group_chat_topic_type: str) -> None:\n", + " super().__init__(description=description)\n", + " self._group_chat_topic_type = group_chat_topic_type\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", - " self._chat_history.append(message.body)\n", + " # When integrating with a frontend, this is where group chat message would be sent to the frontend.\n", + " pass\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", - " # Generate an image using dall-e-2\n", - " last_message_text = self._chat_history[-1].content\n", - " assert isinstance(last_message_text, str)\n", - " match = re.search(r\"ILLUSTRATION(.+)\\n\", last_message_text, re.DOTALL)\n", - " print(f\"\\n{'-'*80}\\nIllustrator:\\n\")\n", - " if match is None:\n", - " print(\"No description found\")\n", - " await self.publish_message(\n", - " GroupChatMessage(body=UserMessage(content=\"No description found\", source=\"Illustrator\")),\n", - " DefaultTopicId(),\n", - " )\n", - " return\n", - " description = match.group(1)[:500]\n", - " print(description.strip())\n", - " response = await self._image_client.images.generate(\n", - " prompt=description.strip(), model=\"dall-e-2\", response_format=\"b64_json\", size=\"256x256\"\n", - " )\n", - " image = Image.from_base64(response.data[0].b64_json) # type: ignore\n", - " display(image.image) # type: ignore\n", + " user_input = input(\"Enter your message, type 'APPROVE' to conclude the task: \")\n", + " Console().print(Markdown(f\"### User: \\n{user_input}\"))\n", " await self.publish_message(\n", - " GroupChatMessage(body=UserMessage(content=[image], source=\"Illustrator\")), DefaultTopicId()\n", + " GroupChatMessage(body=UserMessage(content=user_input, source=self.id.type)),\n", + " DefaultTopicId(type=self._group_chat_topic_type),\n", " )" ] }, @@ -228,163 +345,821 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Group Chat Manager\n", + "\n", "Lastly, we define the `GroupChatManager` agent which manages the group chat\n", - "and selects the next agent to speak in a round-robin fashion.\n", + "and selects the next agent to speak using an LLM.\n", "The group chat manager checks if the editor has approved the draft by \n", - "looking for the \"APPORVED\" keyword in the message. If the editor has approved\n", + "looking for the `\"APPORVED\"` keyword in the message. If the editor has approved\n", "the draft, the group chat manager stops selecting the next speaker, and the group chat ends.\n", "\n", - "The group chat manager subscribes to only the default topic type because\n", - "all participants publish to the default topic type only. However, the group chat manager\n", - "publishes `RequestToSpeak` messages to the next agent's topic type,\n", - "thus the group chat manager's constructor takes a list of agents' topic types\n", - "as an argument." + "The group chat manager's constructor takes a list of participants' topic types\n", + "as an argument.\n", + "To prompt the next speaker to work, \n", + "the it publishes a `RequestToSpeak` message to the next participant's topic.\n", + "\n", + "In this example, we also make sure the group chat manager always picks a different\n", + "participant to speak next, by keeping track of the previous speaker.\n", + "This helps to ensure the group chat is not dominated by a single participant." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "@default_subscription\n", "class GroupChatManager(RoutedAgent):\n", - " def __init__(self, participant_topic_types: List[str]) -> None:\n", + " def __init__(\n", + " self,\n", + " participant_topic_types: List[str],\n", + " model_client: ChatCompletionClient,\n", + " participant_descriptions: List[str],\n", + " ) -> None:\n", " super().__init__(\"Group chat manager\")\n", - " self._num_rounds = 0\n", " self._participant_topic_types = participant_topic_types\n", - " self._chat_history: List[GroupChatMessage] = []\n", + " self._model_client = model_client\n", + " self._chat_history: List[UserMessage] = []\n", + " self._participant_descriptions = participant_descriptions\n", + " self._previous_participant_topic_type: str | None = None\n", "\n", " @message_handler\n", " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", - " self._chat_history.append(message)\n", " assert isinstance(message.body, UserMessage)\n", - " if message.body.source == \"Editor\" and \"APPROVE\" in message.body.content:\n", - " return\n", - " speaker_topic_type = self._participant_topic_types[self._num_rounds % len(self._participant_topic_types)]\n", - " self._num_rounds += 1\n", - " await self.publish_message(RequestToSpeak(), DefaultTopicId(type=speaker_topic_type))" + " self._chat_history.append(message.body)\n", + " # If the message is an approval message from the user, stop the chat.\n", + " if message.body.source == \"User\":\n", + " assert isinstance(message.body.content, str)\n", + " if message.body.content.lower().strip(string.punctuation).endswith(\"approve\"):\n", + " return\n", + " # Format message history.\n", + " messages: List[str] = []\n", + " for msg in self._chat_history:\n", + " if isinstance(msg.content, str):\n", + " messages.append(f\"{msg.source}: {msg.content}\")\n", + " elif isinstance(msg.content, list):\n", + " line: List[str] = []\n", + " for item in msg.content:\n", + " if isinstance(item, str):\n", + " line.append(item)\n", + " else:\n", + " line.append(\"[Image]\")\n", + " messages.append(f\"{msg.source}: {', '.join(line)}\")\n", + " history = \"\\n\".join(messages)\n", + " # Format roles.\n", + " roles = \"\\n\".join(\n", + " [\n", + " f\"{topic_type}: {description}\".strip()\n", + " for topic_type, description in zip(\n", + " self._participant_topic_types, self._participant_descriptions, strict=True\n", + " )\n", + " if topic_type != self._previous_participant_topic_type\n", + " ]\n", + " )\n", + " selector_prompt = \"\"\"You are in a role play game. The following roles are available:\n", + "{roles}.\n", + "Read the following conversation. Then select the next role from {participants} to play. Only return the role.\n", + "\n", + "{history}\n", + "\n", + "Read the above conversation. Then select the next role from {participants} to play. Only return the role.\n", + "\"\"\"\n", + " system_message = SystemMessage(\n", + " selector_prompt.format(\n", + " roles=roles,\n", + " history=history,\n", + " participants=str(\n", + " [\n", + " topic_type\n", + " for topic_type in self._participant_topic_types\n", + " if topic_type != self._previous_participant_topic_type\n", + " ]\n", + " ),\n", + " )\n", + " )\n", + " completion = await self._model_client.create([system_message], cancellation_token=ctx.cancellation_token)\n", + " assert isinstance(completion.content, str)\n", + " selected_topic_type: str\n", + " for topic_type in self._participant_topic_types:\n", + " if topic_type.lower() in completion.content.lower():\n", + " selected_topic_type = topic_type\n", + " self._previous_participant_topic_type = selected_topic_type\n", + " await self.publish_message(RequestToSpeak(), DefaultTopicId(type=selected_topic_type))\n", + " return\n", + " raise ValueError(f\"Invalid role selected: {completion.content}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Running the Group Chat\n", + "## Creating the Group Chat\n", "\n", - "To run the group chat, we create an {py:class}`~autogen_core.application.SingleThreadedAgentRuntime`\n", + "To set up the group chat, we create an {py:class}`~autogen_core.application.SingleThreadedAgentRuntime`\n", "and register the agents' factories and subscriptions.\n", - "We then start the runtime and publish a `GroupChatMessage` to start the group chat." + "\n", + "Each participant agent subscribes to both the group chat topic as well as its own\n", + "topic in order to receive `RequestToSpeak` messages, \n", + "while the group chat manager agent only subcribes to the group chat topic." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--------------------------------------------------------------------------------\n", - "Writer:\n", - "**ILLUSTRATION:** The scene captures a majestic dragon perched on the rugged cliffs of a towering mountain. Its scales shimmer with iridescent hues of emerald, sapphire, and gold, reflecting the light of a setting sun. The dragon's wings are spread wide, made of a delicate, translucent membrane that seems to catch the colors of the sky—fiery reds, oranges, and cool purples. The creature’s eyes glint with ancient wisdom and a touch of mischief, while smoke curls lazily from its nostrils. Below, a lush, green valley stretches out, dotted with medieval villages, castles, and winding rivers. Tall trees frame the edges of the illustration, their leaves rustling in the gentle breeze.\n", - "\n", - "**Poem:**\n", - "\n", - "In twilight's glow on mountain high,\n", - "The dragon reigns, near touching sky.\n", - "With scales that court each fleeting ray,\n", - "A living gem at end of day.\n", - "\n", - "Wings unfurled in sunset's blaze,\n", - "Reflective of night's softest haze.\n", - "Eyes of lore, both wise and bright,\n", - "Guard secrets of the coming night.\n", - "\n", - "From nostrils, wisps of smoke ascend,\n", - "As valleys below in shadows blend.\n", - "Ancient heart, fierce yet true,\n", - "Watched realms where dreams in whispers flew.\n", - "\n", - "--------------------------------------------------------------------------------\n", - "Illustrator:\n", - "\n", - ":** The scene captures a majestic dragon perched on the rugged cliffs of a towering mountain. Its scales shimmer with iridescent hues of emerald, sapphire, and gold, reflecting the light of a setting sun. The dragon's wings are spread wide, made of a delicate, translucent membrane that seems to catch the colors of the sky—fiery reds, oranges, and cool purples. The creature’s eyes glint with ancient wisdom and a touch of mischief, while smoke curls lazily from its nostrils. Below, a lush, green v\n" - ] - }, - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--------------------------------------------------------------------------------\n", - "Editor:\n", - "APPROVE\n" - ] - } - ], + "outputs": [], "source": [ - "from autogen_core.application import SingleThreadedAgentRuntime\n", - "from autogen_core.components.models import OpenAIChatCompletionClient\n", - "\n", "runtime = SingleThreadedAgentRuntime()\n", "\n", - "await EditorAgent.register(\n", + "editor_topic_type = \"Editor\"\n", + "writer_topic_type = \"Writer\"\n", + "illustrator_topic_type = \"Illustrator\"\n", + "user_topic_type = \"User\"\n", + "group_chat_topic_type = \"group_chat\"\n", + "\n", + "editor_description = \"Editor for planning and reviewing the content.\"\n", + "writer_description = \"Writer for creating any text content.\"\n", + "user_description = \"User for providing final approval.\"\n", + "illustrator_description = \"An illustrator for creating images.\"\n", + "\n", + "editor_agent_type = await EditorAgent.register(\n", " runtime,\n", - " \"editor\",\n", + " editor_topic_type, # Using topic type as the agent type.\n", " lambda: EditorAgent(\n", - " OpenAIChatCompletionClient(\n", - " model=\"gpt-4o\",\n", + " description=editor_description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=OpenAIChatCompletionClient(\n", + " model=\"gpt-4o-2024-08-06\",\n", " # api_key=\"YOUR_API_KEY\",\n", - " )\n", + " ),\n", " ),\n", ")\n", - "await WriterAgent.register(\n", + "await runtime.add_subscription(TypeSubscription(topic_type=editor_topic_type, agent_type=editor_agent_type.type))\n", + "await runtime.add_subscription(TypeSubscription(topic_type=group_chat_topic_type, agent_type=editor_agent_type.type))\n", + "\n", + "writer_agent_type = await WriterAgent.register(\n", " runtime,\n", - " \"writer\",\n", + " writer_topic_type, # Using topic type as the agent type.\n", " lambda: WriterAgent(\n", - " OpenAIChatCompletionClient(\n", - " model=\"gpt-4o\",\n", + " description=writer_description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=OpenAIChatCompletionClient(\n", + " model=\"gpt-4o-2024-08-06\",\n", " # api_key=\"YOUR_API_KEY\",\n", - " )\n", + " ),\n", " ),\n", ")\n", - "await IllustratorAgent.register(\n", + "await runtime.add_subscription(TypeSubscription(topic_type=writer_topic_type, agent_type=writer_agent_type.type))\n", + "await runtime.add_subscription(TypeSubscription(topic_type=group_chat_topic_type, agent_type=writer_agent_type.type))\n", + "\n", + "illustrator_agent_type = await IllustratorAgent.register(\n", " runtime,\n", - " \"illustrator\",\n", + " illustrator_topic_type,\n", " lambda: IllustratorAgent(\n", - " openai.AsyncClient(\n", + " description=illustrator_description,\n", + " group_chat_topic_type=group_chat_topic_type,\n", + " model_client=OpenAIChatCompletionClient(\n", + " model=\"gpt-4o-2024-08-06\",\n", " # api_key=\"YOUR_API_KEY\",\n", - " )\n", + " ),\n", + " image_client=openai.AsyncClient(\n", + " # api_key=\"YOUR_API_KEY\",\n", + " ),\n", " ),\n", ")\n", - "await GroupChatManager.register(\n", + "await runtime.add_subscription(\n", + " TypeSubscription(topic_type=illustrator_topic_type, agent_type=illustrator_agent_type.type)\n", + ")\n", + "await runtime.add_subscription(\n", + " TypeSubscription(topic_type=group_chat_topic_type, agent_type=illustrator_agent_type.type)\n", + ")\n", + "\n", + "user_agent_type = await UserAgent.register(\n", + " runtime,\n", + " user_topic_type,\n", + " lambda: UserAgent(description=user_description, group_chat_topic_type=group_chat_topic_type),\n", + ")\n", + "await runtime.add_subscription(TypeSubscription(topic_type=user_topic_type, agent_type=user_agent_type.type))\n", + "await runtime.add_subscription(TypeSubscription(topic_type=group_chat_topic_type, agent_type=user_agent_type.type))\n", + "\n", + "group_chat_manager_type = await GroupChatManager.register(\n", " runtime,\n", " \"group_chat_manager\",\n", " lambda: GroupChatManager(\n", - " participant_topic_types=[\"writer\", \"illustrator\", \"editor\"],\n", + " participant_topic_types=[writer_topic_type, illustrator_topic_type, editor_topic_type, user_topic_type],\n", + " model_client=OpenAIChatCompletionClient(\n", + " model=\"gpt-4o-2024-08-06\",\n", + " # api_key=\"YOUR_API_KEY\",\n", + " ),\n", + " participant_descriptions=[writer_description, illustrator_description, editor_description, user_description],\n", " ),\n", ")\n", + "await runtime.add_subscription(\n", + " TypeSubscription(topic_type=group_chat_topic_type, agent_type=group_chat_manager_type.type)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running the Group Chat\n", "\n", + "We start the runtime and publish a `GroupChatMessage` for the task to start the group chat." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
                                                      Writer:                                                      \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[1mWriter:\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Title: The Gingerbread Escape                                                                                      \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "In the cozy corner of a quaint, storybook village, nestled between snowy pine trees and bustling with the scent of \n",
+       "cinnamon and cloves, lived an elderly baker named Mrs. Mortimer. Renowned for her confections, she was the heart of\n",
+       "the village, especially during the Christmas season. One frosty afternoon, she decided to bake something special—a \n",
+       "gingerbread man unlike any other.                                                                                  \n",
+       "\n",
+       "[Illustration: A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs.  \n",
+       "Mortimer, with her rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused          \n",
+       "determination. Snowflakes gently blanket the world outside her window.]                                            \n",
+       "\n",
+       "As if infused with magic, the moment the gingerbread man emerged from the oven, he sprang to life. His eyes, two   \n",
+       "shiny raisins, twinkled with mischief. His mouth, a curve of icing sugar, grinned widely. Before Mrs. Mortimer     \n",
+       "could reach him, he leaped off the baking sheet and dashed out the door.                                           \n",
+       "\n",
+       "[Illustration: The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind \n",
+       "him, Mrs. Mortimer's surprised expression captures the moment of unexpected enchantment.]                          \n",
+       "\n",
+       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, his voice carrying through\n",
+       "the snowy village. Mrs. Mortimer, despite her age, gave chase, her laughter echoing through the streets.           \n",
+       "\n",
+       "Down the cobblestone path he sprinted, encountering a group of children building snowmen. Their eyes widened in    \n",
+       "amazement at the cookie on the run. \"Catch him!\" one shouted, but like a gust of winter wind, he was gone before   \n",
+       "they could even stretch their fingers.                                                                             \n",
+       "\n",
+       "[Illustration: A lively winter scene featuring children wearing colorful scarves and mittens as they pause from    \n",
+       "their snow-play to gape at the gingerbread man sprinting past.]                                                    \n",
+       "\n",
+       "Next, the gingerbread man sped past a farmer tending to his flock. \"Stop, little man!\" called the farmer, shaking  \n",
+       "his shovel in surprise. But the gingerbread man only chuckled, his tiny feet kicking up delicate swirls of snow,   \n",
+       "leaving the man and animals staring in wonder.                                                                     \n",
+       "\n",
+       "[Illustration: A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking    \n",
+       "towards the gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.]  \n",
+       "\n",
+       "Onward he ran until he reached the edge of the village, where the river flowed, its icy surface glistening under   \n",
+       "the pale winter sun. A sly fox, watching from the riverbank, licked his lips and called out, \"Need help crossing,  \n",
+       "dear gingerbread man?\"                                                                                             \n",
+       "\n",
+       "Unaware of the fox's intentions, the gingerbread man hesitated, uncertainty flickering in his chocolatey eyes.     \n",
+       "Seeing the baker and villagers in the distance, he nodded, \"Yes, I need to be across!\"                             \n",
+       "\n",
+       "\"Hop onto my back,\" the fox offered, with a cunning smile.                                                         \n",
+       "\n",
+       "As they crossed, the waters rose higher. \"Climb to my shoulders,\" the fox suggested. Then as the water's icy       \n",
+       "fingers reached again, \"Onto my nose, dear fellow.\"                                                                \n",
+       "\n",
+       "[Illustration: A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the      \n",
+       "gingerbread man precariously poised on his nose, steam rising subtly from the flowing water.]                      \n",
+       "\n",
+       "And just when the gingerbread man thought he had outwitted everyone, with a snap of jaws quicker than a winter's   \n",
+       "breeze, he found his adventure coming to an end. The sly fox had outsmarted him after all.                         \n",
+       "\n",
+       "Back in her kitchen, Mrs. Mortimer sighed with a warm, knowing smile as she dusted flour from her hands. As she    \n",
+       "began rolling out the dough once more, her heart was full. The gingerbread man's short-lived escape was a story for\n",
+       "her village to savor, right alongside her next batch of gingerbread cookies.                                       \n",
+       "\n",
+       "[Illustration: Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting,   \n",
+       "daylight fading outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while \n",
+       "crumbs of the day's adventures seem to linger, cherished in memory.]                                               \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "And so, the tale of the gingerbread man remained a cherished story, whispered through generations, each retelling  \n",
+       "sweeter than the last cookie from Mrs. Mortimer’s oven.                                                            \n",
+       "
\n" + ], + "text/plain": [ + "Title: \u001b[1mThe Gingerbread Escape\u001b[0m \n", + "\n", + "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n", + "In the cozy corner of a quaint, storybook village, nestled between snowy pine trees and bustling with the scent of \n", + "cinnamon and cloves, lived an elderly baker named Mrs. Mortimer. Renowned for her confections, she was the heart of\n", + "the village, especially during the Christmas season. One frosty afternoon, she decided to bake something special—a \n", + "gingerbread man unlike any other. \n", + "\n", + "\u001b[1m[Illustration: A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. \u001b[0m \n", + "\u001b[1mMortimer, with her rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused \u001b[0m \n", + "\u001b[1mdetermination. Snowflakes gently blanket the world outside her window.]\u001b[0m \n", + "\n", + "As if infused with magic, the moment the gingerbread man emerged from the oven, he sprang to life. His eyes, two \n", + "shiny raisins, twinkled with mischief. His mouth, a curve of icing sugar, grinned widely. Before Mrs. Mortimer \n", + "could reach him, he leaped off the baking sheet and dashed out the door. \n", + "\n", + "\u001b[1m[Illustration: The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind \u001b[0m\n", + "\u001b[1mhim, Mrs. Mortimer's surprised expression captures the moment of unexpected enchantment.]\u001b[0m \n", + "\n", + "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, his voice carrying through\n", + "the snowy village. Mrs. Mortimer, despite her age, gave chase, her laughter echoing through the streets. \n", + "\n", + "Down the cobblestone path he sprinted, encountering a group of children building snowmen. Their eyes widened in \n", + "amazement at the cookie on the run. \"Catch him!\" one shouted, but like a gust of winter wind, he was gone before \n", + "they could even stretch their fingers. \n", + "\n", + "\u001b[1m[Illustration: A lively winter scene featuring children wearing colorful scarves and mittens as they pause from \u001b[0m \n", + "\u001b[1mtheir snow-play to gape at the gingerbread man sprinting past.]\u001b[0m \n", + "\n", + "Next, the gingerbread man sped past a farmer tending to his flock. \"Stop, little man!\" called the farmer, shaking \n", + "his shovel in surprise. But the gingerbread man only chuckled, his tiny feet kicking up delicate swirls of snow, \n", + "leaving the man and animals staring in wonder. \n", + "\n", + "\u001b[1m[Illustration: A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking \u001b[0m \n", + "\u001b[1mtowards the gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.]\u001b[0m \n", + "\n", + "Onward he ran until he reached the edge of the village, where the river flowed, its icy surface glistening under \n", + "the pale winter sun. A sly fox, watching from the riverbank, licked his lips and called out, \"Need help crossing, \n", + "dear gingerbread man?\" \n", + "\n", + "Unaware of the fox's intentions, the gingerbread man hesitated, uncertainty flickering in his chocolatey eyes. \n", + "Seeing the baker and villagers in the distance, he nodded, \"Yes, I need to be across!\" \n", + "\n", + "\"Hop onto my back,\" the fox offered, with a cunning smile. \n", + "\n", + "As they crossed, the waters rose higher. \"Climb to my shoulders,\" the fox suggested. Then as the water's icy \n", + "fingers reached again, \"Onto my nose, dear fellow.\" \n", + "\n", + "\u001b[1m[Illustration: A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the \u001b[0m \n", + "\u001b[1mgingerbread man precariously poised on his nose, steam rising subtly from the flowing water.]\u001b[0m \n", + "\n", + "And just when the gingerbread man thought he had outwitted everyone, with a snap of jaws quicker than a winter's \n", + "breeze, he found his adventure coming to an end. The sly fox had outsmarted him after all. \n", + "\n", + "Back in her kitchen, Mrs. Mortimer sighed with a warm, knowing smile as she dusted flour from her hands. As she \n", + "began rolling out the dough once more, her heart was full. The gingerbread man's short-lived escape was a story for\n", + "her village to savor, right alongside her next batch of gingerbread cookies. \n", + "\n", + "\u001b[1m[Illustration: Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, \u001b[0m \n", + "\u001b[1mdaylight fading outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while \u001b[0m\n", + "\u001b[1mcrumbs of the day's adventures seem to linger, cherished in memory.]\u001b[0m \n", + "\n", + "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n", + "And so, the tale of the gingerbread man remained a cherished story, whispered through generations, each retelling \n", + "sweeter than the last cookie from Mrs. Mortimer’s oven. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                                                   Illustrator:                                                    \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[1mIllustrator:\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. Mortimer, with  \n",
+       "rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused determination. Snowflakes   \n",
+       "gently blanket the world outside her window.                                                                       \n",
+       "
\n" + ], + "text/plain": [ + "A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. Mortimer, with \n", + "rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused determination. Snowflakes \n", + "gently blanket the world outside her window. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind him, Mrs.      \n",
+       "Mortimer's surprised expression captures the moment of unexpected enchantment.                                     \n",
+       "
\n" + ], + "text/plain": [ + "The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind him, Mrs. \n", + "Mortimer's surprised expression captures the moment of unexpected enchantment. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A lively winter scene featuring children wearing colorful scarves and mittens as they pause from their snow-play to\n",
+       "gape at the gingerbread man sprinting past.                                                                        \n",
+       "
\n" + ], + "text/plain": [ + "A lively winter scene featuring children wearing colorful scarves and mittens as they pause from their snow-play to\n", + "gape at the gingerbread man sprinting past. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking towards the       \n",
+       "gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.               \n",
+       "
\n" + ], + "text/plain": [ + "A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking towards the \n", + "gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the gingerbread man     \n",
+       "precariously poised on his nose, steam rising subtly from the flowing water.                                       \n",
+       "
\n" + ], + "text/plain": [ + "A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the gingerbread man \n", + "precariously poised on his nose, steam rising subtly from the flowing water. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, daylight fading  \n",
+       "outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while crumbs of the   \n",
+       "day's adventures seem to linger, cherished in memory.                                                              \n",
+       "
\n" + ], + "text/plain": [ + "Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, daylight fading \n", + "outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while crumbs of the \n", + "day's adventures seem to linger, cherished in memory. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                                                      Editor:                                                      \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[1mEditor:\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
The story is charming and well-written, and the illustrations capture the essence of each scene beautifully. Here  \n",
+       "are a few suggestions to enhance the final presentation:                                                           \n",
+       "\n",
+       " 1 Coherence and Flow:                                                                                             \n",
+       "    • Make sure the illustrations follow the storyline smoothly. Check if each image matches the narrative context.\n",
+       " 2 Illustration Details:                                                                                           \n",
+       "    • In the second illustration, focus on making the gingerbread man’s leap dynamic yet clear, emphasizing Mrs.   \n",
+       "      Mortimer’s surprise.                                                                                         \n",
+       "    • The third illustration with the children can have a bit more focus on their expressions of amazement.        \n",
+       " 3 Consistency:                                                                                                    \n",
+       "    • Ensure that the style of all illustrations is consistent from beginning to end to maintain a cohesive look.  \n",
+       " 4 Final Scene:                                                                                                    \n",
+       "    • The cozy kitchen scene could use more warmth—soft lighting and gentle shadows can add to the nostalgia.      \n",
+       " 5 Text Placement:                                                                                                 \n",
+       "    • Consider how text might integrate with the illustrations for a seamless experience. Ensure there's space for \n",
+       "      the text without overlapping important visual details.                                                       \n",
+       "\n",
+       "Implement these suggestions for refinement. Let me know when the revisions are ready!                              \n",
+       "
\n" + ], + "text/plain": [ + "The story is charming and well-written, and the illustrations capture the essence of each scene beautifully. Here \n", + "are a few suggestions to enhance the final presentation: \n", + "\n", + "\u001b[1;33m 1 \u001b[0m\u001b[1mCoherence and Flow\u001b[0m: \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mMake sure the illustrations follow the storyline smoothly. Check if each image matches the narrative context.\n", + "\u001b[1;33m 2 \u001b[0m\u001b[1mIllustration Details\u001b[0m: \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mIn the second illustration, focus on making the gingerbread man’s leap dynamic yet clear, emphasizing Mrs. \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m \u001b[0mMortimer’s surprise. \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mThe third illustration with the children can have a bit more focus on their expressions of amazement. \n", + "\u001b[1;33m 3 \u001b[0m\u001b[1mConsistency\u001b[0m: \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mEnsure that the style of all illustrations is consistent from beginning to end to maintain a cohesive look. \n", + "\u001b[1;33m 4 \u001b[0m\u001b[1mFinal Scene\u001b[0m: \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mThe cozy kitchen scene could use more warmth—soft lighting and gentle shadows can add to the nostalgia. \n", + "\u001b[1;33m 5 \u001b[0m\u001b[1mText Placement\u001b[0m: \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m • \u001b[0mConsider how text might integrate with the illustrations for a seamless experience. Ensure there's space for \n", + "\u001b[1;33m \u001b[0m\u001b[1;33m \u001b[0mthe text without overlapping important visual details. \n", + "\n", + "Implement these suggestions for refinement. Let me know when the revisions are ready! \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                                                   Illustrator:                                                    \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[1mIllustrator:\u001b[0m \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. An elderly baker,    \n",
+       "Mrs. Mortimer, with rosy cheeks and glasses, is seen rolling out dough with focused determination. Snow gently     \n",
+       "blankets the world outside the window.                                                                             \n",
+       "
\n" + ], + "text/plain": [ + "A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. An elderly baker, \n", + "Mrs. Mortimer, with rosy cheeks and glasses, is seen rolling out dough with focused determination. Snow gently \n", + "blankets the world outside the window. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A gingerbread man leaps off a wooden counter, icing buttons glistening, while Mrs. Mortimer looks on in surprise.  \n",
+       "The kitchen backdrop is filled with pots and pans, and a window shows snow falling outside.                        \n",
+       "
\n" + ], + "text/plain": [ + "A gingerbread man leaps off a wooden counter, icing buttons glistening, while Mrs. Mortimer looks on in surprise. \n", + "The kitchen backdrop is filled with pots and pans, and a window shows snow falling outside. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
Children in colorful scarves and mittens, pausing their snow-play, gaze in amazement as a gingerbread man rushes   \n",
+       "past. The scene is lively with snowmen and a snow-draped village setting.                                          \n",
+       "
\n" + ], + "text/plain": [ + "Children in colorful scarves and mittens, pausing their snow-play, gaze in amazement as a gingerbread man rushes \n", + "past. The scene is lively with snowmen and a snow-draped village setting. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A startled farmer in winter attire stands in a snowy field with sheep looking towards the gingerbread man as he    \n",
+       "speeds by. The sky is bright blue against the white snow landscape.                                                \n",
+       "
\n" + ], + "text/plain": [ + "A startled farmer in winter attire stands in a snowy field with sheep looking towards the gingerbread man as he \n", + "speeds by. The sky is bright blue against the white snow landscape. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A serene river scene with a fox standing in the water, his fur glistening, while a gingerbread man is poised on his\n",
+       "nose. The icy water flows gently around them.                                                                      \n",
+       "
\n" + ], + "text/plain": [ + "A serene river scene with a fox standing in the water, his fur glistening, while a gingerbread man is poised on his\n", + "nose. The icy water flows gently around them. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAQADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD00H9wDTF+6PpTl5t/pRCMo59FrgOgrucuTU8XCCoXXa1TFsKiKQTyT+VStxsbNyea87+J2qyaQtlOltHNlX2+Yu4BuMHHsa9Dl+YFvSuO+IuljVNNsolK7/tIIUnqMc/0odt3sVC97Lc5vw/4kGoacsgylwoAlX/a9R9ak8Q+Kp9BgtpyruJs4UcdPWrukaRDolk4Yo7ZyPlxzWXrE9tqULQyqrR54z2Nec+T2m2h63v+z31ObbxLda3dpuj2RKGJwevTr7U2Zhk47CllFtZxGOBFVerEd6zWvyGUKu7cfxrflUn7isjDmcV77uzoPB1p5/jOwLD5FYt+IBIr3pOorwfR7qbSZ7fVraL7QI874uhIPp9K9c0DxLZa5aLLbP8AMB8yHqpropSujkrwadzZuuwqsW2k8dRUnLuvOaS5TbIAPu44rR9zBEQOQaftwDzxjNQ85xVhseWPpUoYyXHloB+NWdmxIx3JqmW+TB7Hirsj8W/+1g1UeomJeLhU/Kq7HAH0puqalaW0m2adFP8ACuck/QVBBdi8IEcUyrjIaSMoD+dEt9BpaFsEeRjPOaikXa1Z2q6vbaOge83hCcZQZ/SpLTWbDVI99pdRyY6jOCPqDyKl7Ds0XUTe2KWRNhGe9JBIvmjawJ+tPnOQvelbS4uonVcjoKVELHpRFggg96swJhmFVFXE2ViD6HFJCfnq2vEcn41TjOJBQ1ZoaNGAfKzVnq373PvWhDgI4HpWYeDmqnshIfMRzj1qzZwh1BNVPv7jV+w6UoayB7FJJNsbL61ZtlIglyD93vVVYyVzV2EYhfJ5K0Q3BlSRd3NJD/rPwp56U1F2SKT070rajB3WOGVnOEX5iT2Arkry6We4a8nYYQYQZ4Vf8avePL2Ww8ONLFBLPlxuWIZO3r+XSvLdKuta8UtNFDaur7gcnIRQfXNZVoTkrLY6MPOEHeW5sav4gVmKxsuOmc9PpXNzXrzApFE8rngRx8sT9K7iw+F8Ukiy6teyTdzGg2j867Gw0HTNKjKWVlFFkYLAZYj6nms40IrcueKbeh82XOp3N1KYI4DGQcYY85qW1WTcIplIkQ16B4l8GGPXJpoF+WRsnA9e9Vrnwfc3Gm+fGv8ApUQyAD98eld3JFxtE5PaS5rtjNInCRkY4PUVZksZ7W6+2aXM0THspxWLYXOx9h4IOMGursCsijDDB6ivKm5U5XPVgo1I2Zf0Xxrf2TiPUITIvrjmuiufGUchj8q0kbcOjHb/AErDjsopGXPftitGKFIeDWscQ+XUxlhVfQD4qvS+f7KOD23kH/0GrieIZWGZdPnQAdiCKhMp7cfTimiRhnmj24fVRL5LnUZ8vOwgHSNWKj8cdfxqOPRrUyAzTTbR0RGIz9TUvmY5yfzqKS5VBkt+tS67NFh4pWNW3ktLL/j2gVD6hRn8+ppz6o4Jwo5FYYvEbGDSNcqO4qHXl3KVCK6E995d+pS4yQeCQea5XUNJt9LiMkdzKcNlJM4Ye2a2prng4NZt0y3lu8cv3WGKhVmupbpRfQTS/E0yARyTGTacZPDD8q6S31ae1UyIxmhfkrIxO36GvJ5J20/UGX+JHwRnqK7DStTVwAX3Iw/KtJOUGmtjOMYVE4tHpdlfQ3cQlhb/AHlPUfWtS2cMT2OOlebwag+k3YnXc0X8aA/eX/Gu6sbqO5iinhcNHIu5GHcV2UavMcFai4MtSy+WXXHWqqttOamuTukz7VDwCM9KqT1MkTmdk6dKhNKxDEAVOEBUZFPcNiGEcP8ASrlkcLiqw4Z/rViyIyRnnNVDcT2IE+5SmVkGPUYNIn3RTJuMVN7IY8cj6U6VeBRCNy06XG3FV0F1KzAOuCAR6GkCIpwqhfoKlVcqaYOtQMdIuxwM0jL8+KfNyUalIzOPpTsBh6qjDULYbQY5wYzkcbhyP0zURSK3vfsrkbJATG3+0McfrWlr0YFmkwODDKjjj3wf0JrM8R2ztZJdQ53wsHBH5Gt4bGb3PNPGekLp+pJeWqgRXBJO3or9xUWl3oDKTnGO1dB4lga5tZscCVBKqjnDjr/jXFaVPhyTxhsN7VyYuF1zHbhZ/ZO7trtg4PUdqmXUGMjHdnNZXmgW4bPbtSRyoi5BJOa8vWx6dza/tDGeajfVcA4wKxHuWOQKrSSOfrTSYmzXbVW5yxqrLfGTB3HHTrWRIWwctjFU2uCE+9z9atU7kOdjpopmPG6pHmYjrXP6devI2Sc84rVaTmolCzKjK60FWZlJJYmmzT7lO081A8mOlQNJVKImzn/ECk3KXCZ3Bfm98Vf0a43wZB/WoNTHXcOOmfY1naFO0VxJAxxjkV2W5qXocqfLV9T0OK4861CtyQOtbvhHUfKlfTnbCsS0eT0PUgVxdpPsJBPB5FWnmkjlSeFyjocgjtWEJcrTNqkeeLR65GNxprVleHNXOqWBkfHnIdr4/Q1qmu1NNaHmNNOzBPvVcH3fwqqSBjHYVZB+THfFXElkIPU+9N3FHypwaXOKaRzmkwJYjkGmTHJH0q+LYIpLctioJISwOBzVuLsJNBaDKk+lJKf3jD3qKGZoScDrTgCzFjST0sHUV/lXioA2KkKSSMAqk02SNoyAwxmk77jQM+VA9KVXDSg4qPrT0XnNJNgM1cB9Kuh3ETEfUDI/lQirPpu0jgrn161LcqGtpARkFGGPXis+01WGewil4UMoDAHkHFdEOpnI5HWSkzSQbNpi5T3+v54ryu0YJqlwi5C5I2n616B4u1K2sHkm3jOcgA968ojvWbUDKWwztlqmrHmi0a0Zcsrnfxy/uFAPXtSmZY/vNVfTmEtqhJzwSKzdXufIlVd31ryFHmlynquXLHmNRr5c4GKryXZPQgViLcg9/wAqc0xNa+ysZ+1uXprotnB/E1mz38cYYZLH2qeCxvdQBEEbEeuK5263pMUORg4weK6aVG+5z1a1tjpNHu/Mkx0Ga6NZPMT6VwmlT+TdLk8HiuwiuMD2PeufEQtLQ3oTvEn4OaglYxuCRwRTi6luDimTfN78YrBG7ZR1Uq8KuD8pGDWBp/GoIcnjI+tauoORCyE8A5UVj6fIGmDehrtpq1NnHUf7xHZRc7atqcZU1Qt33Ipq4T91u1cXU7Vsb3g/UfsmsfZnbEc42/j2r0WvHGfyblJEJBBDKa9etJhdWcM68iRAwP1FddJ6WODERs7k2c8VKTl6jWNm6CpDEw53VurnKxkgwKVATimsS2BVq3i3Y9qErvQHoazRDdlmNDCONDtxuPHNOJyaZtOcnH511mI1bFWXhVx70n2RUySfyqUvjov6moSZGPJOPSl7oakIfYPmwPxqrOFlkJVgcD1qzJa+ackcjpSLabCCMZ71nJN6FqxXtLdZWIfIqa4s/JiDA9Ktodgx75pJmEoCt0pqCURczuZRbdgGvPPGMGoaJFcyW1vJJYgGXzU/5Zj0P0r1TyIz0UD8Kw/Gti0vgvVRj5fJ3HHoCD/SiMWh3TPme/lvtRV7qZjnqoPJNYaykSBmNdVqRAsAV4yMY9Kz9A8LX/iS4aDT0EkgIAHck/yHvRSlzJtmlWCg1Y3vDd35kJXdnyxx+NY/iS4c33y5yBzWzb6LfeGtSOn6ggWRowwKnIxz/wDXB9xWRqCifW4YmHyvKFP8q5YQSrs6ZzboIp6dJLPKsKozyuQFC85r0zw78Nb68KXWpMIYg3ERHLCvS/DPgDSNAt0kt4EeXGRM65b8K6MWRZ/vcV0yhd3SOX2rtY5e20GysrX7NBCFXGDxnNeR+PPBNxYvJfQRErkswUcbfUf1+lfRaafGrdKdPpltdRGKeBZEPUMMinCm0Q5pnxojcBl6jmuk03UFuYQp++vavTvFvwQRxJeeG5Cjlsm0kPHPXaf8a8Zube80XUJLa6hktrhDhkcYNRVpcyN6VWzOpLApjsaQSEpnPTvXO2muFZCk/IPQ46Vpw30WJNpBXPOO1cMqMo7o7I1Yy2E1BfNibscZrnrLdFcHnjea6lPKuEYZwemDXPXEX2e7ccY61tRlo4mVVaqR0ti+6EVpo2YxWDps2VwD1rYgk+Uj8a46kbM66buiebLRKR/DxXf+ANXFxZPp0h/eQfMnuh/wP864AfMhWrfhrUP7M8R2s7HEe/Y/+63B/wAa0oztIzrw5oM9qVXI4FNeJ8Gr8SAqDUwjUjpXp8lzyeYw1gYsMjFXI4SCAK0xbg9hUqWwHpTjSsDmOECehNSC3X+5+ZqzRXRymdysbdT2A/Ck+yj1qzijFHKhFb7MKb9lX0q3ijFHKguU/sq+gpfsyD+EVbxRilyoLlTyF7LUd3apcWU0Ei7o5EKsvqCK0MUU7Bc+PLy3kazkRhh43Kn8DXd/AEeVreqlVLfulDcdBnrWF48sl0nXtXtYxhBdttHsfm/rXcfs+wr5Oty46tEP/Qq5aCtJo662sUyx8adHMMuna5EnyAG3kx2J5B/nXkGY/wC3tNmlhaWNZ0JjQ4LjPQH1r6j8b6VFq/hK+t5U3MqeZGcZIZTkYr5TvHk8y1EGRMHGzHXd2/WlUjasmFOV6TR9hwxpLBGyZ2lQRn0xUqwqtVdEuJbvQ7G4uIzHNJAjSIRjDEDP61frrscgzYKUIKdRTATbiub8XeC9H8WabJFqNsDMqkxTpw6HHY9/pXS0GgD4YuoWtbqWB8h42KmvRPh/8Nv+Ez0q5ni1I2txEwG1k3IVPT8c5rlvGMO3xvqqDkC4YdAO/tXt3wFtzHo2oyAKUMiruHXIByP1FYpJuzNm2ldHDeKPhX4g8MaTPqpube5trfDSGNiGxnGcH6155d/vGDZr678b2/2rwPrUOM7rOTj6DNfIMozHweaznBRasaU5uSdy/pU22RV9Diugikwetcnpz4cEnnNdDb5c1wYiHvHdQl7ppRM2MjJxzxU8tlNvWUJlWXfntjOD+taOh6O0weVpDsUEOB/dIIzmuw8O2lpPA9tKoZ4i3ynquePy4FFLDuWoquIUdDtvBtyNU0CBpsi4iURyg9cjv+PX8a6H7KvY1yHgWJbK+1C0DkghXTd1xyK7evUpr3Vc8upbmdiAW5HelERHepqK0sQFUrnVLS1Us8gwOM54/Oud1XxIEvoLIpKZZ8lERflAHUs3Ss/W7q1WwljkuVjcgFW4OGByOO/SuGrjLaROunhr/EdLNrUgXckSImM7nbNZc/i5YojKJEKDvjAP0rhtQ8aOSYrSEBcYywyT+FVIdH1vWyh2G3gI+/KNoH0WuN4mrLZnUsPTW6PXdA1qPXdP+1RqVAYoR71q1zfho2ej6XDpoLqUyWkc53sepzXSV61GalBa3POqx5ZPSwUUUVqZhRRRQB8zfGB/+K2v0UYO9Mj/ALZrXo3wKs4IPCV3NGMySXOHf1wBj+ZrgvjLAg8fXEoP3oo9w9wo5/WvUvg9bwweAoWicsZJnZ8jGDnpXNT/AIjOif8ADR1niGUweHdRlAJK27nj6V8izJK+p2RiHzsw2/XNfX+sANol8CoYG3k+U9/lNfJ9mqSalp24ZP2gL1x1OP8ACnV+OIUtYSPrez3fYoN6hX8tdyjscc1NUVqc2kRxzsH8qlroOcKKKKACmucIxzjAp2cdazNZ1az03Rrq9nuIlhijYliwweOlAHyP4sczeLtWlyG/0huR35r6Q+Emix6V4GtZ1z5l6PPfP44/SvmWcyalqvyqXmuZsYHcs3/16+ydJsU03R7OxjGEt4UjA+gxWVPV3NammhkePdQj0zwLrNxIcD7K8a47sw2gfma+U9Gtxea3Y2pAPm3EceD05YCvqb4jrA3w/wBYa4xtSAuvOPmBG39cV80+BIDd+PtFjxybtG6Z6HP9KVRXkkOm7RbOh8VfDa90TXnNjEXs3csg/uio7TS2R8OMEdRX0xf2FvqNq1vcJlW7g4IPqDXjHjXw54h0a88ywt21C1IJyq8ge+KU6MZO44V5RVjR8NxAafNG0ar0UN0z/kVPpaTWmtTM8EiQynbGGXHAUc1xeheMrx5DaXMMUWwn5c4bNeiafqEd7ECw/e4I4otYlsdaPJYeKre4z+7cFcDjI44/PNejAhlBHIPNecXJWUoQxWRPunHQ12uiztJaBWCjHTBrSDIkadFFFWSeDX/ja8uF8q0BROgxyTVjTvBXiXWopLu6U2sIQuDL99zjgAdRn3r1fTfC+haXL5tnYQLL2kI3MPoT0rZyPWuCngUtZu52TxbekEfP+jX1vpcoMlkJJieXfllI+vSuobxlGicQfrXe33hHQdRuGuLjT4zM3LOjFCfrgis1/h1oDnIFwF/uiYkfrWMsDUvozVYuD3Rwd54quL0eVBCQzEKMdSfSvYdPWRNPtllz5ixqGz64rN0zwpo2lSiW2tE80dJH+Zh+Jrb4rqw2GdK7b1ZzV66qWSWiCijI9aNyjqRXWc4VieIfFWmeGYoWvndpJm2xwxDc7epx6Ctkuo715V4l+Heq6xrl5qsWs2xuZQVj8xWGxOyjHAwPzqZNpaFRSb1PJvHmurrXiO9viGSOST92G67ew/KvdvhRH9j+Hdj5zqu4vJyQOCTXnEnwV1CUoZr9N2cswYEfUAiuu1Xw7rUnhddEi8opHEI0cPjAHAzxzWcIOOppOalojS8SfE/QLOO+sEka4l8plDx8xklemRXz1pqSX2r2kNvu8yS5URj8a68/B/W9wP2mEDHXOea3fC3w41TQNSjvvOiNwhyrbc4HtzxScZTd2ClGKsj3eECOFEDZ2gDNOLAdSKwrX7fIq+dKQcc7a0URgORn6nNbmJaMqDqwoMiD+IfnUSp3wBT8D0FAHknxk1jWLRrNLKZ47EqfM8tiCze+O2K8NudcaWHy3eRlDZ25JAPrgmvrzUdE0/VY/LvbdZo852t0zXJaj8I/C16WaK0+zOef3ZwM/SspUlJ3NY1XFWPEvhp4f1LVPF9hfrZ+ZZ28gmkeQ7UwO2fXOK9F+J3xFvbe8ufD8ViI0Ta3niVgT3BGMcV3Wm+CrXSrZbe2Yqg6hTisrXPhrYa1MJLgHcoKghyMj3xTcXayJUle7PDNX8Z63rGm/Yb7Up5oOPkLYBx6gda2Pg99ji8dpd3jKscELsjN0DEYH8zXcD4F6cXzJfT7euEx/Wuk0b4aaLo0LRx26yBvvNJyxpRptO7KlNNWR2q6zZuB5cqtnkAGnNqMRIwpI74FYtt4e060QCCBEGcg4zir6WwQbc5WtTIzNW8OaNrhJuLNA3aRFw4P1rnIvBF5p11LJp9wzRbflSVuvtmu+SML0IqTH+1SaTHc4yLS7yUgTQtGQAD6fhXXaajQxBWHOBk1NnHvShsHGKSjYG7loGlqAMDin5/2qoR5q3iXUrbG/HHOM4qqPG9w8rqMkr1Az8v415XD42uURRJGZD3LNmpH8URTn7xhHUDbx+NacplzHqB8cXcTdCc8gkir0PjYsu6WNsEduD/OvHW8UNH9wq4z90jioZPFd0eRGu71BP8AjRyhzHtlt45Sd9qK4wf43BH8q0IvG1i8nltewZ9BIK+crvWLm94d3APYNxVONXkb5AxxRyD5z6sl1a2MBma7VEAycGsK512XDNZStMvu2DXgEMt3CB+/lG3oAxwK2tP1p4AsdxcnaOfnc9fwNHIHMeqHXJHy1x9pBH8cbHFRL4ma1cl3k8v/AGlJP58VzcGrQ38Sm1vSsuMbEfaD+dT/AGbV5Nu7dzxzIpz+lKw7s6dPG0Dkqky/TBH86uw+JBIB2B7nAFcFdaNOY906RjHO4kAVmxeH7i9mCQyRAN0BbrU21HfQ9aXxJbIBh45T/ssKWLxXZk/PHt+nNedp4Nv44h52oxbl6JG6miKGLTJlkuJw7rxsLZJ49KGCbPT4/FumdDIVPTlas/8ACT6ftyHJHr0FcPZaOmsD7QlzCjdSoYH8DjNWZPDht1eV7+3hjAyTtLH6DpRoF2dlF4gtpxmMoR7uKkbVl/haH8ZBXl0erRwymFNPu7rbyXjQgH68mpW8U28LBZLYxDuHYgj9Kdg5j0WXWXUj57cD13ZqufE1pGcSXGSOoWImuBbxVZbN4ERHbKs3NVH8cRSI0Z08nIIJjUZx+Ip8ouY9Pj162n4juPx24A/OlkvkKbhMzD1GDXhtzcx3z/6NDdRJnLLgMW+nAqwLWa2RXii1SM+oQKP1NS0Unc9Xl1qdXIS2uJAO4YAVJFrSSkI8EiZHVn6V5slxOSAz3TDHXcef1q0t84QooKgdAd1OxNz0tJgUztwM96e91tQfMozxjNeajVLuKMqkjnjgEUiaxeuP3srR4/vrkD8aLDudlqWtvayLiX5mOAB0HuearQ6/NIcmZQO/+c1zmw6gctdxHb3QjIpy2ljEzGXUVAHUKwzRYLs61dYK/M9zgeigUo8R2/8AFdYPuprjbi50BEzJqeOOpcVkNr3h62OVujcnd0BxxRYLno58TQEkC4Zj22p/9ek/txmXcsbHHdmJryib4kjTpM2vh+1Az8ryyls/hVG4+KOr3RI8i2RSMBFT5R/jT5WLmOICZqVIYiMvOEPptJppbjFMJrUyJ/s8H/P2v/fBpRaRt928hz6MGH9KrYz2p2w96AJ2sbgAlFEqjvEwb+VNWeWHK8r6jGKjHHSpRdTbdrNvA6BxnFADTcSseGI+hph3v1yal85yc7EH0FNLO3fj2oAIrq4tnDxSuhHHyMR/KryeINTTlbuYenz5rOK0hU4oC5Nd63qMhDSXtwxXplzUY1+/eERPcSFB23Yz9aqyrleuKq8bjk8ZrCTaZtFXRo2+o30HzRXMkZ527Wxio59SvZSRLdzNnqWc81XByM44FIsZmOS6ovqxpN6AkdVoXiWWzCl3mKx8qFYjJHr610KePgjb00+33lt26ZmfB+nSuGgjhjtgRMJPpW3p/hXVNTgSaCHEL5+cn/JrVWtqZu9z0zwv8S9Md2g1CGONiMh0hwB61Q8W+LfD2qSjZMwiA4KRjJrzTUdLuNNleGVh8p4IPBrNcEd80+VBzPY6lfEFjZowge4cE/cACjHvUMvjGaQ4WAoO21hn88VzYXPakYgcDrTshXNWfxZfocJNKo6j96f6VRfxRq7qU+3TbScnLZrOnx19qrA81jJ6msVdG7F4h1NFwt7MB/vGp18Uauv/AC+ykfWsBXFSg5rSLTIaNeTxLqsnW8kH0OKl0+DW9enMdu80uBhmL4VR7ml8O+HpdaucsSlsh+d/6CvWfD+lJIDZ6eggtI+JHXgt+PqfWuWvieSXs4ayOmjh+Zc89EeWXuh3Wmj95eo0gHKqTj6ZrFe9uGGPMYD0FemfEiGCwmt7W2jVCkTFsd68uWNnbCqST0AqsPOcr872JrwgrciGl2Y8kmjJrodP8JXVyN904to8Zwwy2PpVu98PWFvZtJGZuAcOx4b9KqWKpRfLcUcNUkr2OUyaKeUwT7UmK6DnLOwntThGB1q0U9BTTESeaqxNyHp0AppBNT+WB1o2Z6CgCvtpQhNWlh9af5eO1AXKojx1p3l59qsBDTHYJxyTQBCyBRULfOcDgVMYzIcsePSoJ5FAxGAcVLZSRWmZQ+0nPrVNmy3FTltrFmIx6etVuc5rlm7m8US7ztwajLEmm4JpdpJ4HbNTdsq1i7aTLtCt64AHWvTtK+Kmo6F4fTS9PsoA6A4nlO4j8OleZ2kSqyAYMjY6npmvaNL+CbXFik97qwSR03BYU3KM9Oc810xtyrmMXe/unlmp6ne6veyXd9M0s0hySf8ACqOM10Hizw1N4W1htPkuFnYKG3KMdfbrWGsRPU4FaGfqRk+lRtgDJp8jqpwlVZGPQms5TLjEhmYs3oKrlucCpJD2qLHesG9TZIeODitfSdNn1K5jtLdd0kn5KO5NZttE0rqqKWduAB1r1XwvpE3h5bfzrVpbm7+Z2HSNR0X+v/6qirX9lC/XoaUqLqzt06nS6VolvpmnJaxjAC4J7/WtG1k+wxGKCV1XJzyBnNR3E4VMDvVfDhN5ye+M9q8PnlfmW57XJCyTWhHf6XZ6lJ5l0jSEZGC5xWXcabpmlgNFbRq2MjA5qbUtQeOMeU2D34rFi1DzLky3J3BcAqemM1cZTfUiUYLod34U8Kx6pEuraoCYd37qA9HA7tXB/E3xDBf63LaWpHlW48pQowox1x+teia/44tdJ8JRSQDbdSJshjH8Pvx6V8/vM15dySNyWbr6816ShFJQiee5Sbc5CCAd6d5C1OIW9KXyj3FetY8q5PSbSanC+nNOEZB9TTEQCL2p6xVLgIeeTSNuNArkZwOlJt7mnkBRk1BJIew59KTdhpXHMQOKrSTRx5LH8BSSbkG52/LvUKw7jvYc9h6VDk+haiuoSSyTDAGB7VA6qiEH72Kkln8pCFAz61RLNISc/UnrWUpGsYld+vJpArMMgcetSOFAwOaYSSMc/QVgairsU8nd9KHdn5C4A9Kmt7VpRuOAtWktju2opY9AFBOatRbRLkkw09DGhcn5s8V69o/xmu7cw29/Yo8CIE3Qt8/A9+tefw+D/Eptln/se8WAjIkMRAxVcW/lscrhgec9c10RinGxhKTTubnjLX7DXNWe7sbIwBzud3JLux/HiuUlf5csdo9KlvJgqMvRsfLgdayWEkhyzE1Mp20RUY31Y6S4B4UVA74PNOkXZ0qAgk89axbZqkB5p0cLzzJEgyzEKPrSlcVJAJBIGjYoR3FFrjueo+DfCA05ftU6ebcn7oAyFFd/Hpd/LHlIGwPWuA8E/EG60VY7XUYkuIc43t9/Hua930jWbLVrQTWrgjAyPTNccsI5S5qjOuOLUY8tNHnV1pmoRE77VyPUEVy1n4evEvHf/SZXEwlV2DbhjgA84xzzxXvLpA5yQmfWlWGEceWo/CmsJy35WEsVzfEjyE+ENTnOZdqlhuAPNR/8IBdtHM0soQgZAAyDXr8kEXJ6N061n3ihIHOcgCiOFhEUsTKR84+KBdx3Jt52OIxtA7D/APXXOWX3wR/ers/G8kRvrvaPnIG4+hrkNMGZcelVRV528xVX7l/I0ct6Cm4Y1Y2ilx7V61jyR44Xj86OTwOBShS3XpTyMDFAEYXFIeOvSnMRULtu4FDY0rkc0meBUagKpdunahsFgueahmk8x9o+4vWsXLqaqPQaczPvYfIDx71BdTfOETp3pZbnCnFVEG5izGs5S6I0jHqyOTJYA9KY7fwrTnYu5wCSaVAw4RcyE9ay3NLEQjYuExljVxLUQj5zkmlhRYRkn5z1Pp9KsxohPCl29TWkYoiUmIvOAF+Udq9b+G/ijQ7W6jsbnR4LPKH/AEqWTIyOec9M15nBGx5CfjirBBUe9bKF0Yc9nofTM/ijQYLVpZNRswm08LMpz+Ga8A8U39vrHiCe40+DbExwAo6n1rGEZJGc16B4FtvD73BS+UvKSNoI4pqPLqDlz6Hl2oWFyku+SJlToCRVCVCvbaP519LeLbTQovD9yI4bZZfLJUgjcPpXzxdwK7FhxjpWbV9TS9tDEk3MQqL/AI0+K1KkF+XPRR/Wr9tFsDvjr0oWMqGdv071FupXN0KothHknqauW9uqDc3LHp7U+K2LgO4JbqB6VfitzgFhWsI9TKUivHG0hAAANdT4Z8Q3Xh28UrMfLz06j3rEwqA7eO2TTQT/AA5+taSgpKzIjNxd0fQGl+LLHVI1ZiiE4+ZT0PvW3Bqds+FM6bhxya8H8L6Ze396z2xKL0z04r2bTtAgS3TzC0r7Rlj0J9hXA24zcVqdyScFJ6GlcXSIclwQCW61y3iXxTa6baGNmDSMCcDmtK/0wrkRggV5J4ssLlb+SRiw4+U+orKrUcVoa06akzj/ABFqn9o3Mky5Acng1S0bG984pbqDZMVYdearWUhtr0A4weKeHklJBXi3Fo6HaKMUo55p22vWueUOYjtTDmn7eeKUrxSAhIwDUM58uLnqatFcn2qpdAtJjsBUS2LhuU48sWbHNV5m8sFc/WrSHZGwxyBWfsMsuWPQ81zt6HQlqKkXmMM8KBlqqsSznaOOwq3I5COiZxnBotIQ0645VetQ1d2Radldj105xEHkcID2HWmZMZ2QqTnjPrWtcDegQdD1pbe2VJlOAMD0rXk1sjHn0uyrFpTqoeQgue3pV2CxVR79z61cADH1NShOK6IwSMXNvcg2heAOlW7HT/tkyxg/MxwPao9tXNMuBaXazf3T0Hem0SbkngiYwKYpC7+uOBWHd6TqGlsfOjZPcHj8xXSf8JncRExgL5ZHp0rJ1XWp9RUozEoO/rUq/Up26HOXkssqAtIxA6jNU44BMrFs7R+tX5ofMAXOBnmhl2oFUY9KHG7BSsjPaINJ8owB2pI7fznGPuKfzq20TbREnVup9KsrGI0CgdKShdjcrIhjgCnOOakZcDPepAMcmmnJ6VrYzIVTc3IxT1iBOBUgTatSQJvuI19WFS9FcaV3Y9T8B2KRQjABGAOnfvXoqDgelcH4Q3xWm4nguQK76MZUfSvMoaxuenX0dhk0SshyBXEeJtGju4mOACM13kn3a5LX5vLkZBn7vSqqpcupNJvm0PFPEuim3YSIBjHT0ribgbLoH3r1DxXMsdmI8gszV5bcnNyfrXFQldnZXVkdNCcwoT3UVITUNvxbR/7oqXk9q95bHhvcsiPFIwqTrTW5PApkke2qci5kY1oY49qqumD9aiSLizPuISqb19M1RRSEZvrW80W6JlrGdCGYH7rcD61hONnc2hK6sRQIHjlz1xUtioXBPfP86baAlpU9VNTRRkW6yKOVJ7VEejLl2LajoD6mrqxYG49aqRNuQOBkVfRwyDFdMDnmEY5qY9Khzg09TkVojMWjOGwOtLTBnew7UwHYPXvXT+G/DTayrStxEBwT0JrmSMiut8KeMBosBtJoUMZJO8jP4EVMr20Kja+pNrPgdrO3eaB9wAzjNcS8TJKVZSGHY16tfePNLl0xool2yjkKq/KfavMbyf7TdPLt2hjkD0pQb6jkl0IFXH1oIp30oIwDVkDcbjSkbelOXp701jigBpPrUtn810n1qEgk4Aq7psW68Tjpk1jXlalJ+RrQV6kV5nqnhdymmIvGd5JruYH/AHQ+lec+Gbg7Z03ZVXUD8q7m2uAYOorzsO9D0a61LckmWHtXGeJJCbjPtg10Vzc+XE7k4AHX0rjNSuvtN2cHIA6+9PEStBiw8bzR5x4ql36gU9BXAT8znHrXYeJLj/iYzvnPzYrkGGW3Hua5aGiudNbVnZaXYTX5hhgjLuyjgfSvTtB+F8YRLnVJOMZMY4/M1tfDvw/Z6dodvdbRJLLGrlyPUVu+IdSFlp0kzMBtHAr1JV/dujy1R97U+f8AGaMYp1JjNdhyjNuajlGcjA+nrVkACmPHlgRSaGimxKEHqpqvNbK0RGOCeD6VckAJK+g6etMjXK45x0ArNq+hadtTE2PDNvC5PcjvVu3ICsnYnIq2Ywr84GapXEPlNlOBWXLy6mvNzaEqHy3KnpUyuY3DDp3ptvtnQB/vDvTmiMffKmqV90Q97F1cSJkGl5U5qGFtiLg9uR7VPwwyOhrZMyasPpu35805OeDQRVCE6UFc07bS4oAmt7G4uFJjiJUdWPT86SXT7qNN7QttxnI54r1Dwvo1vLoyRTYZZFDcHHNbK+GbGJMLHkE85asnUNFTueH7Cuc8Gmk1v+LdPj03V2giGFxkZrAC960TuQ1YB0pQvGaXGDTgp6npTEIB7VraOm2O4lPYBR/n8qyicCtu0Bi0fd3ds/r/APWrhzCfLRt3O3AQ5q1+xveD7jzDdpkHEv8AQV2cM7MLjZ1XArz7wbJs1O6RujdPqK7jTrqNJpkdgAy7iT+VcFKWx3VER6nOzwyp5hVQCpx6VyNncmS0EoOc7v5mus1mNUtpZMhco3JrjrGLGkRKOpQn8TzU4lvlsVhl7x5t4hkzOwzyWJNYrDCDIrW1xf8ATXHoxrOuwEto29ciin8KQVPiZ7z4S8VJF4O0wHqsIVvqOK5jxn4vluo3tPM+TvjvXO+FLx20DDSKqQuVAJ65II/nXP6hcG8vm7ID+dKPPOfJfQJKEIc/U//Z", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
A cozy kitchen with Mrs. Mortimer baking again. The room is warm and inviting with the daylight fading outside.    \n",
+       "Fresh gingerbread dough is on the counter, capturing a nostalgic and warm atmosphere.                              \n",
+       "
\n" + ], + "text/plain": [ + "A cozy kitchen with Mrs. Mortimer baking again. The room is warm and inviting with the daylight fading outside. \n", + "Fresh gingerbread dough is on the counter, capturing a nostalgic and warm atmosphere. \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4AWz9WbMt23meiWXm7Odc7W7PPj0aEgQIkBJFyTQl2woxVBHWRbkuXHVZVw77X/iH+MIXjnAXDoeqIqwLOWyrXFViyUVSBAmA6A4OTr/7vdrZN+nneUeuAyjsXHNlM8bXf99oc2Rm/b/+x4Ne3VZVW7VtW1dsddVw2dRVr+Ks7jUt+9qsFrgGyADdHeqDyFWhAWDTiF/2ArYQJF/aUmmrw6Gta0iRUg8G1etF7y+fDW4PzdlsOF8dPnpTXe7HB+AUB4y2X7V/8uj2n76/qw47aByQs6oEgDAAcJCg8u0PBy5Na6vX29H//ePeza5/QD7lAEcw8vjv1VW/rgaqZp4UkbluMUWvMcv0OmSzR2uw5BFloQmKqtWH2bA/7HeiKLWQCtDrNaPh2X53PByd7/bNdr/v1YOdVn71z//RR//xPx0eltdHR1VvcOjoRrRqrzaHQ2+97F1fNxeXo7/48vB/+unRm/XpvcPiT997/p//R7v3H+8ii5btcOHHWZGviNhl/XZ6yS774KrkHZFiAvUr7swJsMXM7P9/Twok6WwGQeyB0zpS2sJ0N63iJZspMROcSwp7fvtC5O5kV7fberU9+tn8e3+9+9b1YbA5VMW70RRkNdQpHqvBcPTorXcfPH4ynZ0MRtP+aNzrD5reoOn3+v1Br483emxN03BCjNZc5oT4OHjZELmdPDGkpKsWjnFz00kKVMnQ1miRMqNmONHQL0pC4E4zjhaQaBjU8OGMMDaZQCTEyWYLUPhFKS6LduaWYEMm0rQWPwMzl5x63hrphHLxaJgVceRTE/0d1S5MpCBbUAUISSmZGIIAmKg1lEO+XVJHyEtCKChiZAO2o7XfHzabdVVNC4gZLWayAgEyBa/jYPmD/r5H3UDNsz30v3g9+Kuf7j97UV9cr5+uZzf7wbC5fTS5+tPv7d86OQS+yC+FTvTuRDZFNY+KbrR5wsFdeEUXPKOJ1UMdA1Z2IrmRyK8EMSklkfSvTwpMLt1BioO7+ElWhTt0wl0XAefWsQCexGCVEwXEK6a0+NSdB/6slhRYaN2EzbqrLg4KTpEBPCnIrUjVSWAog0U6ELDpj/utBSDiiBPyYdH28AZJRGuSEwQFoLAnSzwlodaHZKgW7UCSkgJGAoRvFJ6tF90hTMpgUEhQIAhRQ1hZEq4QRL5IBCGOUcRrraOVUk3ntONhHaQgiofFZK8FFKvsYj4FlG4SAxzqQMW+5CS3BDYXB2wWFZMOpVAlmEWL4UyRgaJxJmMC3BPZmEE1cMDOIhX8WD+UQlwQPLyvN4f6b78Y/Jd/fpgv+n/we813v1N/+aK9/tmid6j+2e8d/uhbvWF/L9/fUkpcN1PLXpKc+s9pSTVcEsocgq9wxaUROvAFQ8hoksohOpCg7UAU5I5L9C5sk0p6dxVDaxU36RceQY5X4U0mGVgkljTIPLFutK0uO4SUhjthxeqM27mniNNJ1QGqM1BgFa65lIbExA/JiEYBmNHe1zQCki55GNiCF+skaKWrUaTqIYpBvFOHNG3TWrmRBmoxHDaEqmTky5nRwp5rBaMf0tAJgbPyqDtFhiixNBWbyEo1VKAUwo4nCNiCGLen1pmZNE3HlT2dEFOaQgBK8hdHOBK94KfSZnAhTaGhKF6ARVJ82Bc46UhBJL1KciF6R7KwkSAUzFR51PG8sFPAwtxkicsb1nW129d/9cngf/Nf9/q78f/qnzfffW8+7q2vvzl456zabnv/4Bu708m2akAPgjt/kTbnSmuaGgnzmxPPMLHbXT7SCBexglXy3CdDxYUH6GtyOf86MSedVrtqv6v3GI+qsNn3oQByiItc6GspE03Yk8RmhsaMO0XBoKUkGIVVS4dwL1hBVQUrWuCKbJKCOH8cSzopibqwjZugDwlbkLYnz4gjvK6p+4t937jcJ6WIXQRXF+kzEsA5qi6lwkf9aMa56sRJpKUXhfUgSyyTA0JNhwuTUAEymAALmtazSH6gt21tP2Df2L23f0AS8IXo3QGW+lwbdIVLG2KdTpZy4gVn9CRTzOQuH3/xfKeCSgfQdOkQxJrPVBogmEMYxYxNSIiFOkVzxfL/YHEAAbpkx2UNAxU4x7oKqu4RWXh1DQMuSHfTfEKYbAmLru2Lq+b/8pfTn14++V/+8esfvH0xHGww1tnR7s/+CCl3w96+bhBRIvpDG8cK0iEtbEOJc1XSACUnQgTGhAgQGCWRVMEKbJJybX0QfDHMC2sORVyxZL9rFsv+q8vBZ6+rl6v2eNp772T3/tlmMpGItL8mDjTnikVHX4oKmVGRSVgzQa8LST8worNLoHn1YOChp+HcK1mkk6AJehOCkuIM8Ls9pwBmWIcE+IjqHT8DI//+Xz2tGAX3qY1FPGDiHgzszzMiNDrLjxAmODNGJJIhB2SPHrwD5ZibPX0bXRLmKqp8ys6xbSh8igFir90PG8aI7dDuUKyM+pRPuUJN9mBwHVJioQtpsZ5Z5hjAHWBS7sCSC1M3Shtb5EhEh0QHrR0TPoJovERVikNEhxkkA6ypFEkBsjeCcFNEyqHLMl/WalCkF/JOeLiQiUz1XsZ3Klm4hW/3vb/9ZPTfP3twMm3/6L3NsF5XjPkF32EuLRVS6glx2ZciqEySiM5FZrPuZDU7m1kdz6R1EiSxAyn5QaWgwQWaoguqCUDvhM0ReXb1qzejn39++Nlnzd88rX+9bKfj4e/fb/6zPzz83ju7eih6nBcGpfCiOypDua2Xq+r6ln5he29aMZEgUer7UgBKYbDll20hgv8O1m+/0a3YNioC1UknswjcHcjRCfynM4tMUjABJfu/vjGOCbs7LjROIgBFGmFNyaCX5EUuDfrmYLg3hz4TJg3lpBpQVBhUE9ZVQ4My6FOiOG8pPD2S6AshOWpzAmRdTwftKEUHfVZawx4yUUi9oFyOBZVakeKB4KpXEbqcROTiHyOY4oqQBY8sZ1NCQt3Zvq7NvOAyjNQL6dgLqsvhWIhYKkgxApXbH5s7fEfR03qmeOKvMPDAuTxjL89QxnMypCyF7IIMLdtRtnqz7v3w89Gb9fgHb928e5ooIFk/yDbOyDW8Q6ATWSk7SZRHTVTC069lUjz5J6sDFqo7LdKW698AqmRBkEMhlwRkFpb+STW/bf7ul/XHz/Y4+oOHk/nV6M1y//mr1as3h/YhDX80L8YFA1GjDibmfLetPn9e/eiz/aBt/uSD+uEZRFMLFucbE2JQW2vDGCF8I2GxL/SsIGiQzeeEiiJCxwqiABcaFfUvdK3lNaY/Lcre+SFO1McdP1pZiycIxgI+w07yASuGcO+53EMjqQIyYCCLoZ4RbwNi+wCgs4rmU8PTnlT9qjcZ0OzsJ0PKSX2xqC7XBu4ehpEsEoYZKOFKdZATtVMpEuUKN08Dom5IijJuCojq2kXG6kAap50zO/RCTakL5dgPJKZ+Jdclci6JUA5hiVpmZSRqEZMDW2qMfcH1WmRCRbwIY7NDVQSBeCOp7Nrq6qb++I2++PB4c9xbC73rMUWHC3VDnyaXtHTRMAb47sDzhJ3xGgdYpHC2+HJShmhbdkVRFRBX1E7PnEmHn0hqVbJDIIm/TWxXbTf1Z8+bpy/bb5xV7z+uNk37Dxb7l4vNYX14NAs6dSlcwFJAySlQqnSCa7Ntvrzp/fyinu4P33+wfzA7MC0JFCDGavfjPCJ/rQqKq7TULImSjzFwPUlsmt5sTByfRU+5p6YJfeXhBAcSjQMCXk1rO7Cp+DVBiGsKz8OysJU8jNwgqS8jChA6lA2u9OsMjojSoZKBa5XQdJgtyinYh10UHPcPvWq/r5jtSEmMZmDLJ0IjLGUk152LlEFbKCJHOwUcyhY2SUc7JZESG7Ce5VIymChFRiKcqwzgIRMYYq6QJ1O8UCI75zFYEU8ZzZM+G5rah8h5S1+2Oy+U6WUSrJQRiPDjXObV9XX7atkMqsPj2aFf7Q47bgIM/vKT6nI7PJoM3n9Qf+PBYjrcXq36X7yin9q892B7OmLYqSg3q2az6Z3Ndv0RvIwe0Ks9k97EhREHUGTOHml0BYrH9RoWCVLAqEIFdbPg6d1cAxH9tLgw9WE3ePqi/+8/3m52u2+9tX/7waHq7b/R1rvDnopnSMuP6UAtPRgrMOVKilUAMNtNS3P3YtW7f9hsq23VbhSnSEp+CgDE0AVMnXEnQIwpMQwcyc1A0FL9ex6Ijn2cVuBUSlLSMvhzTs8rfR6NhFlCNzBSNxRND393CV6ujXUIFRdzIuHfvkwG6ms1AA0jRUQ7baBJuap3xjPWb6ej3nRo07HbZhQCEDmlngQ2Zsze6uBOKi0jJdURnKgyliNJOCmSUmbr2IohhSKvuAWqCCU5RwH4WFKcatYwgSIqkFhMrvxyJY99cYSkIeClyDktQJCxJVZKbZYKmvYOGCNQYUDa0uffM1TaHfWNvWpdffJp9b/9r3af7cb93viD0+1/8v3Rn37Q+8nz+s8/7TeD+l98t/2DtxlFtZtd84sv2y9e7f7J7zUPHjCbUF9cDD9/OYLCvfP63tlh0KxJHNX7PtWNvQw73PVAqdpts6PzWTUDi4pC8kOwXh+hHKCpqF40lYPya5F2sar+9ov+z161f/Rke3pcNyO8vB+19cjCLbT22qmw9uFHctFf6+vRhoaNrnQzHNWbEZ1pLG3UxzuYJQVAlnLG7XbDi1VzoiQxpjKxGc3WL9KWq5vuMSVy51B8UFCSwyxQbl8JjDz7OFnCpZgrvQQhrHwSihpaJBGtamylVRPORjihDsEOxsvoAAVSs5FVxp0QBnCNW6qGVuF6c1g6HUQihAAVVYLOQ4IRrJBjp1CBBIQLd8KLUc4Ul3PwBC2SxyKcCsIvkFGroApp9VhogxwOqsKfCNnQSAGL9pzhHyQLnhLKNDKE+V2rZWxFEGwLCHwMt0JP8liPVOqghhoJT+yrd0+r//QPBj+b9352dfz55e7/+MPVV5fbxWp3s2yervuE2uqmWe32L2+ai1W7W1eXbx/uH7e/fln/3/5m9Onlcb/dPT7d/M6D7ahur9bV7z2qnxzXn76un920f++dwZMHm1e3zefPMulSH75xXk0G9fWCjmg17h1OT1R4sVbC6aiejA/NyAlBLaJq9cuL9odf7i82g3uT7YRZz+gbWp2Foqtj2OJODabRO8NqSbp3VTsa1OPSqaCyjxHs+if6bceKxeIuLR77x74hpIw4xepY//rvvvhJT+bia29KxrzuT5EZA9TVUNcwpGGiJ4pAL3HBbVrGrvsugOWdvr1Ei4vdK7VUiU91VUoSgpPCoLkMgXAT9E4IIl7qWrhebur5plof2vWh5gcV4OzDhTi7YkbM0imlKYxCiUUWeWpSJVJBLsMUDZVGVRXBregmlGBCJZmjbJU8fyFIQhhxoGkywgWDlkaPmKYUCrYXhZr8I4HmEM6jxLv/dOWk+x8UgPGomvRtjYnCA01BdXh0uvmffb/5J5v5f/tp83/92eTL5eTZqvnTJ81mu/gvPq7/5vXpy/m812y+uB2y3OJ3T1a77dX1TfM3v6x+/bQ3Gq2fLkfz/eao3jHZ8vNX9XpxGH2z97Pnvb/+oplUTsH9xaf9H325+97b/Vc3+9ur+sFJ9cMvqYAGD8f7H7yLrO2PXjSrTfXBcfMH71Rn9/c1ZSDGIihur5oX1+223Q8styiZCZxd6oLOM6pNO9fHLDY7dtYo16zyMMCaAzc9uu5vv9kcepudc4x6Csa/VQawNraM7ciJBzQ04RPjyju0410N7BYkTZ5fUk0q6cXFd27X5Ok+SZxOBI0/e7zj7A5upovE4ACPxqVwCSOCk3lSL5o+rWnfaf4wPuy2vf16v9nuDyzmSLCwT8wAnmiMhMQyfwpvHmVg09bbluaYWO+xg9udLa1WEtjhgO2gwxgjZucqdNKpMIsr+3Eqnv8wi/hcJyg5SEKNAidV/nPuXioa161AarYuNYAWDbl2EBIMfkdSsiWrEI2aogjX/XOGzvxZN0Sc+nA67p1Ptrvr9rPrerOpJ0PsylTB4dHo8J1H+5NP28/Xo361+ubxBvXP+4dfXW/emTZ/8O7s+ove69tqS0gfhl+96n1x0Xz7/v6P3jv8y5/tZ6PqH344fXlz+MnF/mLlzZ7FfnS17392uWia/s9eNqtq9OGjo8vN4teX++Wh+u9fDF9vx++N17Pjda9t/rsvBtu6/sUr6fzh7OBMZek475tq41Kb3Z6QJrwZr+8Xi+rFVb3eDpji6w/2dOQuF9WbZe+saS+3dX/YkvJsMVhvmrMhnV682lyv6Jy1q179etnvHZrjgYycO9Iq7nFzztmVM8qZcaf7tK5AOolyoZmT4SlJXIuUq6+p3NGJT0gFpCyE6DeMvoaD/nAwGh2zlqgZT2dHZ4Nm6EqFPgN2Apq5kQF69Pj1hkNuydd0RFloNGpYz4BANiAM5HfVm1999qMfvn7+Zc29QcuNIYngCRlODUfLNGGuhpHUaLBSpdfp9KUggit/ujBbIcs1iVBNqGsAyRYt7/Slwk1oRz0JdOws01JOwJmpufCeLExVhO4cXmZyhVGxrnhu5lN0yUuRTlq3i6jkZ+wgQICCZJY3+yJ1SDleTysvrY5Zezypfufx4S/f7H75qv7ycvA7DxkUIgfs97P+mmhz9rjazqoVN1pHtp67J0f137u//vRi8PK6ut22L24OV/P+5Xr47v36bHR7Qu9iMHh0TJW2Z9J5e+gx8N7pofrFvHez771Y7ofcjcGNzXBZ7bgl5fpAfNowgh5QzTfN6Px09urF9ee3m99nWl/PYHnvUVFLIdJ+t/NGJy3Wvn51Xf3Xv6w/u+mfj+r74913Hu1+9bL96GX7waz30aIaTdq3J72fXPYH22bc7MbD/YOj5qcvNs+XPfpAf/G0Ph/1v3e2+8YZnaL4NPaBn2XgztDYlISujuNcf+gKDZVzr7W9e0+EEf8uAWBThSaPE7pA73//z6re6OTBOw/efX90ejKbnfZ6495wenb2oNrs97vtgfmu/X7LMhV6aegsR8Y89VHTTJlEqvrDEcWWHtSGEdBgVP34L/717c1qvVrdvnmBe3E+TL1/kWiim2KNzs8ZA+9zoyG5hnURWhkRPGUmAcJA7w7F3qGxD74tqpDiRUvSBEc8dgUuZSIql9ohHAp4zBCrmRhcCxaGwcCUwxio2JbOmFcWVU0pvcIaxLsNnoBYEcUr2jiCJCUeM4O/OFCtwZSZFKVHn6R3+B+8t/s3n17/4mr0r37e/18cj477tIvqxtTi7bYaNZt3TogPquoBUy37ajju7Y6a1YQ1FNX4ZndYZB7FYKgn9WEx6h1qppv73HJhIWqfKQeqa8Tyhsuhpfbd7KHOWIP6i2UMO2owwn/aVEdjxdw6LVkf9evXzM4BSKuMz4rC3MWvthTqVdtj8ZJqWenU63r0k8tBr62+d1qdjNufv64+uRhORrMv1+1mvvuq2n+x6j8ZbKlJr66q06v2Ytmsmj5l4NOr9elgf+93+h8c7yvWZ2KPFAAHA9qN685h3jv1POnF9VYs8QgSYG+zdFwclvZCaOFzFEDfJAmM/vH3/4wYbydny5PjZja4aLfr20VbLd9s1pcvX/faw2wyOTk53WzSr2lZd1qfn47OZ9P7p2ej/mS9oprvr3bsB9v14tWz15++XK/6508ePOr3Vm27ZhxlOYrH0IcbXrQmzHciIfMP692OcrUhgSKUGTYCkG4Y6323rFNVaOpAhYcCRulgrDexEnUzU/a27JpJsySUOGARDaeqpN3lBkhAtmKHrw8WG3LKL3m5MD+kUlMTIjJNDtJIznx3MWiuHA+TVtiwx7gCKQ59q+DqYUuA6XcsOTn8wcP9f/bd9f/hh7t/9VE12A//7JvNyWh7sev/Pz+mk7P/w/tXf/xOxeLFFeUCGw13k9G2xx36uiYQl/t6WFens92IWyvL/qe3o5v1mlEv09ze64mVCGA6rLP68Oi4xTfXy3Z16G0PENmMqM/b/Xq1vt31Xw0Oi11F5+R60/TmW9qdh0M76IaUquGQw/GQvtn21bwhiOn/DurD+WnvT789/eS6+XTOXa0DgxAGddXgaHh8Ptrt5zery+16zaTVoH18PKhWQ3rLD05G08GQ+8m/uKgYrgwbClX8hs3ibuoJDYs3NXLMHQkgjOl0cmodQ57sJMYfuNemOOaN5e9wgw1JayBsiEL9/9d/8X9eLeZ9+zb9ZrQ/NFTxrmnQW/sDPaTRaHQ0O6IXRD8I/MFgcHQ0Hg6ak+PT4WBMNXB2fn/oCuwJxeDpV189/+rLcb39548f/4s/eW8yJKz3G277HQ6bfbtldpuT3W7Hyn1PDuvNbrPZrTabFeR3e6br5vvecld/ebH80ZevL7ZbfEaxYXAFb12QVUslBrnCELnji7LFcuSzqbylAjWsZG0kUuSxCMRobixWWkx7cJKtwGfAgyW7VBJTNGJcrQi4dhb4jicMvD1FFmmO/IluT/GBIgda2AjjJYxLQeiyCkUgj3vb//kH+w+q5l/+uP5XP6/+9Uf1bNCnZ7Ktt3/0cPeffGf/u/fa7epw2O7Ohod3p5v3jrnvTq+FYNnQBaJ/OeE+StP7908PP/6qt94Pf/+dw6i3I/rpR8FUbep2UG9OxrvzXvX6kjLQ4IJpve65IuwwGVLkKDNDbkesDtVy045Wm/ePm8djb/mjBKIjPuY7HR9+52j70ev6s9v+9XLwcEgpaikVIxcENOfjdkYngSijzuJuJ573Vj3NESHVOxky8drON7ppxJCTHhrralzssdFbcihWwsFxa660ecZ3XCGAsuQkrgiCYGzFo9DpQv/O1RBWfVwuYlI59of1/nbxnEaAxoWeHcsbuIlRiAx7g2F/sLi+fv3iGdyYtRkMRgC+emFI4WaU9akCnukgLvuDdnJUjWfHTTVter/aDV6MH/3O2WiGXsxo0HciXJWJ6k8tEYR+1Y4ysd/sCPT9lhummGnTjFk39+xme+8nX/5/fv3VqzeXzBcgMc03ZqMkZBCUYCqqI4sxp1J4Rh7lPMYoOhvF+b+zjjGYqrwgghALQlVqhVhJJAknai3/dY2MPJEPDZAYAOQmphkoSLIOUsVibRJVvcMGGTkzawCEyUkRozmMJ9WffqN9/7z/4+fN55eHxfZwPK7ee9D77oPq0fGh6bfzhfPF37m/f9xrHzeMRHdPpsvvn6yojR6NK+bvm3p3vZ7Ot8294fx8xCAPTu2UjlDVjuvmvMd4oJHm6WG73H3xZe/PP9+P970+d3IH1TsnOybkhod62jts6vp8uH802X44XdIQMTY1eMpWV6Nx+4P7+4/f1J+9qf7dx/W3TntMYPz0avvpNZ7scUdv3O+vttRxq9vby2q7m69Wo357SiPVNPN9jcd3dDX29WUzGnBPzJ724Yvr9jtn9alLNjUVtVuO+jMOiHlN++1Nk+caf7iBlE1gDY17dFUuJWd+R8h6tOr3Jkc8l7VfY1Uis6xTpRFATkrmdr3tqkQkYEy02zOCcj2u3rJ8ehctcjKA7e9W833DVMH6dLhdbEd/9/Gbw/mYobQx1fSMCwsAJcAWjKqYIdShtXvkSIMbOPuUA3v8vdt2cD5qvvngfLjbvLl43WcqqKUINZSiYozYSBmo/YpjHIWbag/ETYk95sp0UmTvWTbPkqkGkkIVzUVmlAK8IAejNMb2KdVDoOCy6y6E1tJ6SyIdcwQWlmLBqgZAzfIIqI2RVIS0BbHNYAFZr9m/Pz6886i39S5Vy6rBfr1lSRX1H7OKg2F11hz+5BsNoXo83I+Gh++/Vb11Ss20e/t4+3rDiHc3rlbjMVMZ7ZjamOjvHf7ocTvr1feHh2+dts07vW8+2L17Up/0mftfUwUdTbkTtjsatfeG3FjYsVjrIZT39Q/Odw+P9+9Pt8cTnF8UjbT0HEaHt+83f7ap/h+f7/784+rP+/RRm2eL5XE1gMMPn/Z+/Lp5c9tO+pvR4eLhoHo5Orw1OTw+GSxX9bVd49V5H/cPXm62D/u7b57tXix2X922zBodDenUGYqYiGYLu+MUbcgWs5WLYjcTsKRBaiYg8Tog5aeZyya8Hkrg4oC71tnnxSBAs8pUJI+Q0Qp0XYTEAjfHrHGNBScTuqcjZccAds96ODqOeBKPUw9u10PWwj0ZLv/w6HC22y8//eXPv2SE5dqg2M9DGgBLELU6YwElKV0WQplCsOeeeJ/hF73c1aH/YN9MT/fz3uaURtMYIno4SUhFkaIb1+iA+lZSniAwoARMsQiqx0JdjqYIonCelAT3Rry6emLFKaQCAtShGLqec6BPoCS5KEToRSRKwABPESRBXmiHngXBxRHcb5KL9MkUylIRYPvpINPAUl/GtnGj+UTG+VFzxnVv57wC8If6vWH9hEn1HUpWTMW8mrffPK++/XD/8Wtu5lIttPdO2//xd3p0SRgzsFz5/Ue0Ks5pPhk2p9wm2LEyVzY4HsGoion1YVWtt9XbD5ivrGb9Zsra5tL9iCqKyfOdR/W33qmGo+ZHz6svlof57vDBSfPNEybA9393dXi1qr9xf/vNk+oPz9rFvjqfVU8m1btn7eur/Y9eHHrj6ptnw5frzWc36yeT/bsnvc+unfdAALeYTFMxdNRCbGYUnxcX6QG9rQ3M0Wmef72VC/ai8S8C9pZMzsRHqf7q5Se99U1/vzIY6ZHUdAYl5t5K39MQlYiVqxmAwp3HaOjYcT+PuyEH+3U1fbjqncHuvNkxi8YgaLOmh6RfQZJOQlcJWEZOr8YgUCkXY0e5jJKt7ZFz5lwGlVbdntuOMysH96D6NEWU6Q6KE/WtLpLBdZHZbqiwXCt6SbWCzjghSUEFQmLBywnyUN5QkCs2xZeCp+WHS3KWWIWLQyr+CjjKdCcdc3KQnvkRaRBzFPaB4mBGa4NYgYwiQCQKO2bhBZEq5dlSjBXhJSgNnsS5b9I/DFML3d42z26qN6v9P3y8/8NHm8WS6R1pc4ttRH0ePsNqfwy+BOF/oMePYPAtbOBfuIFHygOmehAYZXSionuVE0/7+9Gs+sageXRSzTeue5j0qfIZKlY/WO5v1jxavacPxm97qN8/rWfN4Wh8WIzbt3hK9MBgY7/a7r9/ehgPqpPe/sMJc0r9+z4Nrhf40Ut0jbAjPaXSdjGAYkRM4UoS4iGjXiLl6y35uTJPolFO3eVRNO23V5+PDzuWPxJ828Nul7oJLO4AE7WUikJWypDQEnG8ucYpCYyYzgbVjGmLZkv/ktYTwzPuUmLn9cNb6aJALEtaBFMv+lpWtzCLiIhGaw8n3OtyEdkqAwFgvunKzjlqIDNFlARsJJmobFsdWgGEu7DJg50UOlzLv5fuIpXFlNMCZYVn8fFKQhR3Mc1H3JRF4OWUxMI7DigIoarB8CSayJMrlKXJpLdgw0kezuUoSeVwX1hAt5Qh8brcQkIqhVnRCzRO0ASR7FvbfNA432xaOjc0viR3ALIROSaUa9jJUtZh0zH1QoGgGo1KbuCVObKGOxFH8Tua1scTiYQD0tanIyY7kING2L706MAgxHyK3HBSHQ1K479nMvDR1HRAz7x1SnVJD8TucZRO7MedsZUMyNBEcPI8/+U6yiGbSXdbwLnABhQkx2tYAPBopTEImP6gZgTE4EoylNS1XZsEktgKgh06tGAgLPNuFBim28aDZjqkK7l/Z1Yz8OeuCvV95mkLkwRYqGhr9dR+kFE/LlNOIjHMrcw4JBdh9JC1KsJnYhEUpYkKRUlyvCIpHoGcyBZQUozLdBFCEyWK50K2GAEgDSMtdWdfjCq9MCepUEgmuRTHwtm9vH7DXFT+Il2nBEJR46t0yo70OyzntYxwSBrnYR16nSId6UBLtqDmJKIIVgS5o2g5shTUhFO/7f3sTZ+bXMy4HQ3snQr/NY7n2iwSK4E/LNsx8eTr7WuJTVE9DhGuE1n05aa3WB54sJYbWEqFIYDlyRCOnZSKm+bLSASHHpdFIaM5a/gijeUts+MQRyJEMouDd1IF6eyRc5l4nSO7SGVSZIwcytghka/aepsUG9Jkhnh/q8QYkKTWGSCaRITzSnrIQIKqxGNENPPuDGu52zFmCDV0+cppn1d/MLl26LEG1xnUPHkZHlBT9DI1Hg/JjI10iJJRHKwXUuE4pOVPCcU1O1U+ctBGRaRY0bpJOqWARFhjIBCKYJ82pKUbp8hPG0BZfbApAMAVWUw3Uxz4ZpxheyCIZsZyCdg4JaTIIM24EyJ1hCf+myy3kCosS7I4wsCUNkRpVcJpZ1MB1w4c77bIbk5yCwygRagCRI4c82NVyqNZddKvf3bF8rjdn727f3vCY7B0uSJ76c4hlWyjrlJKppD38P93S7YtMsAFBnQgiYxt/eWr6uVN9Z2HFZM8oRZoc3MZYYMmjnLe0dA8GJZwNNCJyzT6Gv8OXHilNaUI6kV3juEUBxImqQb/XrFhWYOtnAfd9twM/wtiwaEf5407XWZXhPpbpoSIkGw0oLqIbgYtK3s8lYlntK1ZmDKmF9jsTl3FJT+mL2ETsYvLkL7zciLOrMyQm4hE0a4wijJYjPs7GkN0tCasUvq1Dpmop3CJY7mElZexnmGlzVNg7mK9MwnkI1m0TijLPsqZVCgX2wAXYOWSw12eiUpWbJwzd3d+BlDBSxLJEis/lUWpAomIJFO9UQBKoQn9GCGOD2boYFAphpb5UcAEhejyOFXGbAwxeu1bJ7sfPGxuXmzeO9n//Yeb01F9u6y5iz8bVmNeShThuWl5s62X25p7anRdWOASzYrsYV0I3pEtnL2Kdu5zwqhsPq9/9RXWb6qHyoFyyp+wVPaijE7R15E74gYI+OghWBT1spyEhqrFpXZuS0oO7CStPf0PG05IIXo8SlgghSHXBKE8TSIn1AXJBqf/eMw9cOnRsRFAi3LiD8+BCZAdGzr1QDPq5c6LXR2GOExXsVadYpAKUjcDK3f55/Q3+tjgWSbNTFcbMQQLP0+9ZlMC94n5iAJaFsdZDRQtON6V0PCK+AVdTPBTp2CgCKLNCzfzJBKDpFEBS0sETtmSE0GkTDIaOOYppRFcYUz2VOt7Hp2tyLKZpoYaT3JgWHtGAis7ZnJ9JtikMoaQqNl3P3BESmNIIldsxSbdvvAltYiCwtERnqeT+u89ZmXa8r3THuNO0H72VfvR68P3Hva+87D2MdSWJUP9f/dV7+n19vtvtd9/uzo/cgKooxWF5MfWMVZ5JSpCsjdH9fbb6ss3NTcrvvdOM2JtUIRDEEG4AoI/MD3Go54X/I508TZAogKUvbCxV4AkY32OhmAHJid37FQxNMuOfdDkKVzZhTCQpLLv8HGbCf33ThL/zipIycUKoBntJco0rlneTYQZ0ejwLVIxB0phIEc+Ya2pzAWq+L4zXIJGeZjIZwDYQYeRCkSx6CEvwLSIO8/dW2Id0EkuUSUXlSNBRbrLggSUJJKb07szNUgyZCOuuQpcwGXGKfqTgpAEPsxCUwqIY4vU0eUgVw5BkqBRLyCbyrtJIVepyuz2QM6E4lTPxXeiICc6XqU7OPLUv4AFVZ7dZnospTNcWlzvN1QVzaNJ9bvHB2buaZYJ7Yt1+9cvmKNrPzxqeln5/sVF/W8/8cbW9x55T6fr20SCjvidGqaV6IenxkeycM3lfFH/7AXuZCDL3WhFIblQUIFiK9VXqRhEusV9Gpcz9WVLxMOhIOk/N/PZDBc7rFIp1OESI7G/8wDHZMrBrdgptItIAkJDqVSjyCNkf9iggulEHi/pSQGAFsLAUeHJQwC8awWuWJIvynKbhaYAdKY2inyRyVFD0SWXEhFRDRHTmaUoopCkkIEzIlYUQzYnf/R84VUEYe/Ty/bOo2qiTQgjr0jFldSkLgHoh0KomCh3wAuSEmFqai41FFIxgSrkQ8kZCY3sX7JEiqRg5RacmbJSJZTWNl4D1yHBgvS0rhEsIhatC3hsHCODxYXuj0gcS/Ap0x37UO6udYzKHPY9YvH2ltvG3jVj3cF95hmdUtdg9HFX1Z4bZOudL+PghsHTxWHTtt990H/7mJULOhyGxQxQLNzCIvKUs5LhBKxMiV5m6C9vms+uD/cn1cmgKKhR/JNelAM2oWYglkwV1NRCBVKTxXBRnKTwS9bduSDi+0funX1TcpU3laaGkKRbjp4KTiCn3oJktGSPiY2eRBAv3nQrkcHR5t7LIAdCYH5lLOoFYwUjTnwWrpbnBUrZSDCIDnMgFCFsJQm05wrBlZUlR+EELBHvY6QiBy9OEREskUUp+Ihit9q0oEdNdvaKJOgOIlo8yoSFOkBJqtILIGmkWH4yEDO301w4cyN2ZPD8tzcyBRAG4LBLtqSSI/eoHKlUopMm8LwDzm6QTlMyyj9YhrtCCpsdGDAoJT745kYReVnzsMiKVc2XjEQPV2sKAt3Rw4NJczLVwJiTKtSFLb3m1bZ/u9mzbvR213y+aI4m7ffvtW/NWp+NTOwURcoekTotig6KE2XuIEngEeRPL+uLVfXd85bJQL2R4vq1TZANImyWdoMeJPcmo0Z+CX162t1oTBhySnkQAKeiBmgIGVrsQgkq2o2/eCyIcgYyWwEixSTo2YKULBPEEpWNQbAsJSul9KwlixTOGRgc7GMQbcCJlgi+RL2BmGgODQsWyiRSC6nS7VeMom+wFV39I0Dkzzl0JdBZTRnCLnKFWnIitlHTXSmzFkY6f2aEWrcPJ8QVLTqDFnW8Bk3lIggAcNcQXCtHLgRSzAAJrU+8NiqF6XYc79SJsvAwTxUwPrIoW7e3dbOtZwsNTu2EGCiyk2FHK6TMYSuKmFF0wTOg7/f9Zxf1jz7dXm/a2TFPgTHkPbCaeHrWnM6YpaCU0TZ7W+Vy21vsmv2QclK/2rTns+bJ0WEy8g2+koy5iiXkFlOxj9zIF77KgBrp3e7b20X1s9d6//G05kYQIBJR70Az5DPWIaVGKmXgh5XEyGQTI1vJTaiKYTa4LAOJYUjh6CS+upuNZcTlz445yXaTsoU/BvYihMgwkoNZ0jQ46AgMD2uRCM95oSxt/9nZKQpqWGomWUKYRIuU0e+5kM6fwhz4bMmATOTCvyTDyAreuaT0gpIFU7eCVwgUCtmTbqYBzpmEjRvN6pXSuCV0NS9bVMdcnAUe2dRBBMHDp5woORkFTHoaQ2WkEq3MDhHxC41IWLgHk+xQJZ+t40iadHShAmGpwHqpIDYRxGUiJAyKXXEZAGUfslyC4nyRe8VPZuiiIOmH6mrR/uSL3Re3LObqPZy0xmKP50tdasFEhe00NzddmsDD1s3VlpXPzat1Pd8e7o/qY/stsFQzBYtw2uY3Pw1iKKn2nUxd5NQ8T/zVze7RzJLGTSFYxXDZW741gY7v8ExHGARTnbtEuMMOSPfhTBbn7BkWdVDJiADsSjEyC9wieqcAti5n4OfEQzF9oSTlQhtkt3Co+yQWv0I04nhIOENGRmyclfgOltpBDOAMC6RaBDIUMRnpnc2wnjZOeISMIhgrpb03KUJy0okqpYjvLmTZhX5YqJwohWPB4ryAxJrBY6d0JT0cRZO3twfIVYOyCWZOuBaWqR6AQJH09boshKYEW+j1EqqaGw2kF4kgozAkY4hiBKmb0NkBzzIZyTqeBIFZDEOLzqGqSiGudESMVAppaUgIFDeWzm6a56/bp5dU5P23Z+39cbs4HJbrA90fFvVa2VDMdvVq73zSart7tWoejqtfLegF8eIJxgNGNy2E9vBfkQo7eOilyAJLb1rHszE04lTLdf3JVc1TvO+eNHm4MZWpmgquNRwS+mOnXh4sxkVxaku0st0zI1SFER2EAo9LuJdMPzFmkb6b9nKfM/YRzF6MRjEdKkUGDiHsjgzIcWJunEaa3GycRSYLsqLExCGFo7VGRzYeDoRcEjJAS9YDtDrlC42SRbq1YsfHM6G9o4QaoWUCF56HDjke44ckWNMZH0lPXJJJTn4kyo78mKwQ6chFJpmETHDkhEBFwrJXImhIn0wPRRcSPZV4FDOYisBhktyvaSKelXpMJVgJKFKgGWeR5xWHVNzufQKJm56m3o26vgbixHqjY+l5qER607UF/wffJPD0ksfSew/G1f0Jb+MbXF7vl5vqbOrtGsILXAJuvnNBCc8Lv1w2R6Phz294bqA34+0rvNeNV4/2vKMPM8wY5UCpeRqG6Y08oX9n9G69twtbWNZ7sWh+dbk/GTf3J6awkt26PhSMrz2LWFGQ1xIhB2uEeHGLD43ba8DaWqLUHcUCymkSVxYSI54lEjkJaLKgE8R4S3n91xKmM87x1az622TSC7QYJBAfdjuM97CHk6naCASWmVGRJyHBEW86qI/FgZIqlIQHrsR+6IIjRpiqAoKTm2twxXSTZRSUJfAIEyKdCIFTYOM8ACJ27CIlRHMMFbGA7lKkJgFSaFojiDKRwr9VNTkWOeRPZq6jJWcduEBQvdMRxUEJgRzJjTSo7gIRSZvtCf8BRvI4luT0jxEvBMOCsxCUTnFtxiwMDBL5AiYrbLjoTE0pQU45kNSZj1yy1Qof4bTlmueA6xE343nBw7C3pEisWf98GDMRBKgryao1r2/wNnCPJ+vnm/ajq/Y5LwvimxG9A2uP11ftbFw/4BGPliUwrhrCaNcbnkba81Tko2Mqcp4YtpqEBM9G8gATMNxT47H9V4vqrWNekVl9OedpGqKdx+HrSeMjNRueJ9wz3dQ76gN8WO2qZwvfLvFgwsI4VhuocrdpxpxGR/TtfrFu7pbElMUWqO9VjB8nexvlLq0jWGpy04ujYkB2WhIligF1JBfQgJ4vsk7+3Y488i0sDi8Cw3nkEI3Skl6tbRGJih8VAhgwrjFTJ+sdgKyL7FDQ5UHCz7pcTiAYNxRFraAC2QUWh1t9pqKVTgl2m9BwV1Jq2+CY0NHnoG72tpVegpxAVd2TkH3hECE8/Y3kAVG7JIuW84gOmNIiVliQKZRm8k8aXAZXdTFIYFNUFB+RLC301VnLWeiABh5/IaP6MaK+iCBlLxSc7UzbtwFoSl2+qXgcnnVcvGuNNzLkvqRysfG8Ku9Z4mmYd2bQO3x2wwN3zQeDPeH401XzatE+mrYfHPEhlvpiU0OBtoI7xK/mgwlP6EJzd5gxVOCFZYeW51/nvFfiUD066f/sul7tmsmgfbltb697j/o1rwT9cnH4nXHz+Lh3Wzkhy2rqJ9P2yay+Xtd/c9GwNPjv369PBzwQFpvdBWinnqqou1sxpCYgwaTsrTK4sFXRSurnGFhTU8U5NSnJOwpEjA4xQcJ6Q6yOqy4xi/9uGpRsl5cLoGMFpS3ixIDEmb7DyLABogt/8jpuOSYcQEipkMod9wJU3KhIyhFS0U4tIhtZnKRfCIxAQhU0FEA4G9kOGNapFsFEQKGUuaAV1Kgm7YhMpqLZBttfEbIrvaBC3fIVG4H8WxsXGFVhOr4G929ARCx5St6layuJdDqWfK6VsgPhiDT+p2QWlr+hUMCAlko5eFo4k2oA2PT5KQ0ewptCumqZ/KHXPeyxJrdisp+vLoRhtdgONrvqdFDZAuzamy3LtJqjlmdQqy9WPR5KHPa3R5vqq9vq05uGx1OmfZa6NMt6PN+uL9c8qFXx3mbK63y1o+JftjzcW49uDs+39Lj6y/3u1Zvd9bL3sl8/XzdfrQbX892TTbNseAcKDzkh5p7F7M9Xvb+9rHll43dOUcf60w4HxkhvpwSyGSrShQE2ALnYURtwVvbmg5xQ9KiZU9/GUcmRFOUYA9zZL3nQsCrSgPybF/u6dlADmkZMBc0cqEZG2em6SNelSggCpJkegZRDdxY0UTkFx7OwIiM4XnouQzM65gSDxNKlSbCGPtlJBphMzy3lHOV6Fwmm0uLbPggS4neMyQsn4BUPCYKfurVQMQes32yxhJcdA7UwreCU6gcHIpEyp+xYpgpn+Vm0pKj9Qzx6Z/LDXOTBMvSzKSaS1YRfu5qwNjU55EmgEFYKrwqopwDSv8fKx8MeL5ZksT+tAr0Lhr/O7Xh3xtqaF8LxlN354PBgfJhs+WIWtTmPhtFHd1b0iPfbcPt4Xz9f8aq5cY/HYJrNtG7pw6Sa7m/q5nLb58UF2/1mvu3dHvo83rtfb9f75nQy+vUtT8Qj0/Cqf+Ax33ePeq+X2zcLArx331Wo1WS/6q3bj277nyzrJ0PabZ6hpXetIjGFSmmHomlO9FdJ0TqxwZ0dsKujKqvkWEXThZTkujPQDXcySh4HqbHpftFCVUoCuCuzQBYpqUA6WVyREhhS2NISGHTi8LMQCysOzZKJaRru/B5kO1LAw175wl5aXhBAVGKlxEBFcIkF0FOzZBVQMs0oEoVx+Icku04xYAIlJP+58iQIhW0EgYy1TxSRpewKikgphOhjmnJYn4fKnfnu9JGtuMhZ9APeLQ1ABJZnpy3pgtmKu9Pr/HvIUmmkEeI3QksxcrMvWcUYymURKjYlyERnRfssEyG6mZel+JA2HmpvV9Wnt5vFoffW4HAyIPgG3PflgZgZ1XLd5yFL7vvzRPZiU79e9Vc8NsOImMcw2/3V5sBiR14Txejylin/LR0hHrsZ3q6G9PL9zhzFpuk/40UOu+Gs1xu07bsTJN3+fEchGVxtD+u2N+a5YV6Usu99PO9fb6tvTVwxyUMBGlOzR10V4Zq9hnbCA+XcxzbmqL96Gdilr0vCb6wachLQMCEUeiLJiON/uMEGt1BlRgxNTAGAGRx0pQ8tcA2W+UXYO+IGpRTdAWRVJwqWtsxxnahNZpGl5JIgkPkhmisBQifgAUT/olZhfhf94opo21SekwEvEcAhZCkLxUhAIQnVIrg0Z8CFoHyUE+huM5tLKQuUfLNSpweGLEgJEKk6yARtEJQIFYou3QU8SCmbBUN83QkQzVMeB2GhueYzkYoYXwQCtkU60c0OVkkyq6RG5AQH12n0eJCKd83zbtCLW15yT9dlzwtuWaA+GvFlxJZK+ovb6hdXvG+vOnLter1iLWOvndT76YAnctb7/fAlzxzz+cpDzd0xnqUZ15sJD0XyCgInaQ58U3HMY64tLHh5LY+28pzIbnVoJmYy/uATHtt7TMGqz443r/BGa54KoBqcb+wyrVpewMgymyHtCU0Uz4UxZii9UFVST+1j3NNnYTCkWUxMtZATJ4WEAliHmRYjx/jWyYVKdxuMzpX99GLDYlIoFnRZ6S4JeCzMQsCqAy7QJCzMhI+EIe8RT3Jgttj6PdEQLN3hdZACL2LoeASPRgOsUrBQSQ3yDYtQBTG0ZGSoiWwAFUqFdEIwbmcGLfTch1DgJSAv9LbOkBIMqbMcDxuA6kSivEs20G6Ru/AL00AElJ0kw0MS6KHaSpfECFDolTobSWPU0vsDlz+ShI87Qfaq4IUQhbTASFGFi9rR/Y6T5uJXNrGdnFEYDWMOXT6ehzzq9+5NGiZ5eG0WU1S8vYdvznIzmAdTMMDFsv74VfVmXt2f7bhFwPtrV1V7Rp1+qHglBIH/cLV+uWbAwCiifchK6Wb97qRm5mex2R+tW3r8x31ezsQbF31NA+X3fLSqDkveWXrk0orddNTux7sTFh4dqkV7OB/xOpH2Q6eddk/2zdVi9+yad82JeK9/2AxdpuqyC/XKv5rkiqNxox35cWoO5vXAHpiYn0ssqT0xRgl0kyBHMk53y3lhEDD9V3iQlWYk8IAFtWTxhYoODyqA311JGcuXMONxaSweDhASxviASQnfxE1xPOlFYqinVEe90BKr6JXo4VIeaM5BxUQsiQHHAh2Ia3Us74xe0tgAGAES9kQockvBE2Z1yaPzq2gxicqaFpoecqEKdykwLrKbVAhpd/rB0VECgf6aClnKa9WlTLqMK2Q3nYO4EtVR/kRERGu/zl6ghAi5HIHIJWf5GQ9K0m2kYXslIjWGgC8by36Yhh9tq7UvZ+bp9fpoVE2HFVP+3LpiSpRXDrw/a94/YwqoIovPNnzv6LBq6vdYBNHUJ5P2cl/NeLKvopDsaUMejirWkBrQm12/f/C5VgXita3aoF+3v/+Ae2q8gtR5oWFvO2h5rpk10dXq0I51UbM7IWJ4qLbmrvPPp9V8vbs/OfA2RlqMe7yn0WZKqxvfxUI+sRnlUUmLalJvLNCVi3lNzl0NzSqIihsygJoQcwvjphtM6C649sIoKGnSpxgYJkLrKLIpAF0fQtnIikeE8N+wI51Q+K3WRX54g3zBPUaHgoNuWRCmFJaBBANnFi9pl64JJ8UEHOLXsNYyklOyokvmCyWlXWBrgfRCdM5SXuWeLpIPP2m2KAidEnvBkAd5EuefPzcplH/C2OaqUO4gvCAXpKRzXkRKcnhynQiRXplBwxz5C2EZluLvAwDqncFS4VP6PylCAEWdDjfyFiryD7uIH3rCUriNAVbx8Eg7D7WwvgD+rH3gVeNWYZF3Nmy/+7D+nbY6G1anlApGuOPDHzzwru7JkMn49mTiPa+shmifnOKdhveN8poPhck9Ch2P2NpJQdCNiSYE48Sw8MFBbCOod8eUSlxkgwbvODsdDS9XtAi7Z4v64ax+b9qy+IJi1qmGkPSk4l85GvGpo+Wum8vP93BqA2UoNYDiAOPe0Euu4wOwsolNcq4MywSdnit+9CS59ibRjYLNUChKimOCABS88HGff30dLilBJTNiKE9ol6i34oV++Csd5NyZSHJSPDGBDAymDFZu8kWODlE5Cp4C4RyExSI4BKgCD2NLgyQlTg7nyUUz0nlbGsTuShTsVEguynvHmot0l7SnEkUezgQMZQiTZukv4kS+wJKhSMov6VIUIS2lolB5IN3FZkkrRpGuDZZbxJGwGqmvcNI0gezAiB1ROJAiL0GxM6WWVWh06xFAo+RbbEVAhKJs8G42KNEJUQQeePJd01Kmz6gQ/Hfvaqp5ZxYBDMGOK6LoDHgkRdNCycW/ljD4wYasyEMf2gGOQhpSVICs9eAVIefNZtXwdugDX3h/Z9a8NeImXTQANro5fs98ACp75xhMCJZf1EdHKGoPIPiztUVomXHCkTMvkCwKksWZgqolad1WzsNbJg6AgSsNMtOgPKCkD63L1DmsDXZ4GM2KJIOUK7maUjK4UGVTggZXBROghEBwi5AAGMVecDTyE1TlMVIjSeVCD/RcWo7ho0GiH4nJUrtiFysc/EaZJA/R6aVxwbtdMtUG7op3HbEFDlqdjpGq06Sj32mBAFLkx5nKoIYzi6ayETKmFRvdeSIo8L8rIyGQgMasYEAafFRGHkfxUvdC2dVZw3rKeVI41br+u4msSSmyaS50MdIBGhAvilxCoihiCaGwGbZx5uYo00ShwrErsOZReDzw5j2BAwBPBEhymOcsZEntSLLCoZwBYT7/4kIMBXgH+le8k/2mebnkCfL23XF7xktBgRAA/QNW/IvY5VL5i+uhY8xrgy4kC9eOc6dkMSV1fHlYUavIP74rgsT0hqIi+pN3DJeGUh/TAix5NqgAyI8U/6KM91A7kUGIbtqbfDePYeo5preLogx6gfUORZkYBn9zpXShwjn6SZuYBNpoTp76UcylwJn8TNFm4NlCck0rTItPHcO1r6bXtVoKLGCZbuGUms2pOl6+yiRv7rRKpbOeciB2ruUqH3TyVOk5GrURoHCHcDFPkmMqwZQNSgDmRwr5hpVEtHzc7JqEgMXn0bxcpnPIdaiAIUdd3hEQqJOKdFUrWzC0A7lsIIUhZ8UfpPhnLkgdCSFDOQUgHKyoO+UDGDoQCXIxCvmQjRCSM6ds5UiSSppjgjtF8UcN9Hrd/8s31d++qc76vR88ODwcMnJg0jWdE7loJOOeX5b9kIRqiEwwsJewBRgwIoR0ku/MqyrkKAusrLm5kHuSyl6xy1kqLS6KS2IsKUFXqb3uP7+RjUaNjvS6kKAMQRSS9PAiMzcZjG/FVWeOXfiqWYQy4EqGgSwm/GAvGdVib4BFeLXsLBce0DTdQY8H2UjBllnu7CHFN10hYjtuK4X6LIRhlMyLfW1TeEU1rzEbj6d8vWC/++zF5QVvDHe6XNhQ65hCSvzCyH4Qf0ZXB1RybNANGtlrBvVGBJLwHP5LibEMa72yCem5oaDxVQIwzSV7frEcpFRdQlqRTZMKon0Ddxf25SrUi3zkU0sEKZ41SxtzANlz2XjQoLkqAqaBVTzomFWwC3jQTRFZIpIQhH/Oy5VI5SxwwEq+EEgWkDqBmdP2sHZYUp3xWYAps09pfYuuGgC9kcboz8BCGjGTeiEdB/jgD0bkWVcacTQ9yR46feMK8kA3SkpksA8cJMrR4CPXHwHCeZwoDbhWfCfYdHLlbEo8Kh8SqPBAUCrDzHPCxrbdd0jIMfuEEnlB0cJFPvoOnAcdUjF5uKT8Rpwic5h2IxFUcvNZPlJ4Oy9f4WDpFndhBtyYGfQmHPsN93pGQ5L6o0F/POJrHdzU8XmyQW8wGQ2Pp+PpZHR1dfEv/81/d/XlVdRFAyIr4oQpcmUrekfZSM8ZdreeV/ByUqofSy5m0pg6CSt4O0XTSVujdNSL5bhIugRdAJhGUJap0uJh86GtCFJgs8qIpWRkAtjkSLgInGR2kS8gZGMroiQAhk6QCk6wfyvHoKPQhXThGyZRrHDrkAtp+Re+HCPynURdqAQ7rMM1jR5pbX1St9+bNY9ZmjGs7g0a5ouYLeKl32TmkQBqVu3Gqk/b89zVtklnxigvjXQWqKoXbXNZ8zynixXCkKNWDQf3nsc2VgkJoGhSoIuIgZdtsQtByEW3GCOk6j63DkkVXJMU06quNapRCwf5gseBdDmyWfh8CRBJpifXcUQBTm1MoFtNi29Ecf8QIfnzPexU5HyjZ8CKEkbhvUGfX98LYr3H+4INdAKb+AaRDk3iu3T2djyG5tumGd5xb5OFjcxoEEbcmrE+IT63vHmwubmebm/fPx3+/MsWO0Y1rZB/YJSnXCmxysVEmisKluggPrnEYKlD3LmVvWeSy2bzYWtEJmn8iiU8i2ENf8oLFKSYIGBeKJ8X6qyOf1IzilACFDA5xbZJkn2X6DH/QgvFgX23SxviZbm2XEVF92iIiGIVUgXNbD1ZcEKzMAsNVCBcUVA8kdmzxR6qY9WWxLRnXrQMfI971WBES9NerliqZIMJBfa8o4VFHMQ6PVgCnTqeS96Cv+GFsJxbJBwtRpx6O2maI16k0MWY9o1RYBGZI7dS2wKQEtNFliJ/50CEtoX42lbok4oAnLb/6OyYuCxBSowSgMSrYerdSwO236e2ZTNaB74vvVS4BB9xTCQ7qrYGzp/3170kw+scSeF9Kuz5TolS2AJgCYIY9lTntI8I7jczrJ8IDCaX/eKM5qZCYC056815Lzq37Rk6bAn0/ZblKXzAoeXmDl3OPW/2tS+ZaboMeiEIr6MB9ya5J+qadTaZG5vaxnOPpqSW4IwAQCSO2tY89zIoZYJLzcaWuQ7AUz1YVXBSen4pV0ZZwSxH46KbybdrCe/ieDTO4h3LGXU/HQTyiKwEFBaRbGhZDDvvmi9wkS5skE/LAcu/DY3VVBIVwvbc2DU4bHzY0wWg+Qq7SCaVkhumDNhFTMimuPoW13yWAUAoIHzQCV8l9I3JcisqqAUXVOQ8a8DbvJEHNxHiCFxMxFNpeI6vovhgEPmyIuL9WUcYfkbbtD+c8BWK2Xg8GCudpkQLjqXbIcf4B3VtiokvKZmkn1KYARGNHWh2G6GjeXS/Fkkl0P+P/skfE990oulcsBHkfC/M6A9ZOh/9IS8prsfc8+bFb4cdHQ+HsGjm9JEhqYJYzTqNNF97o5hh3O8z5YwVuRfCfJz9PtpCQxyTsoQcNEp9y7JbXhC/gQBRjkUZvnI3BefgPqyCwMS+ShSiGl22XjkJnriHCIt3OzMRWH5vb8F3+owGAiAxyT6W4VggSwLuLKUCeoBipFT5xUaxpnYvRguvOJsk4DNFxIeIwCgNQJFRXFljMpaW4VcCg68r6Gk0Xix3u2c3gwkRhEGsDq1FjUtdBJbRiagYgBMmKoBBDnmHtc+fJKT4dgZdBYot6kjE/kMqE67B5ZJ9kTbVrQa6i2A7G7KAo2EoGD2QrrDCJ2UDpn6ToUw5IIpidXFvMTGCdFoE00gpVxoLgj5NYN0tnA8sNEfj3tjX9TbcIOO5Taw8m/UnE+rU/mQwoi0n+gZDTtIjSH3b8iKXmu9FFPfBRo+5aSW4eYVlNBZ/JJBjDdsBCoMwAQyMqGzoLIa1Id8Iu3dmr2QwHI+Qxe/EYLT9Zlm3K6pwUnhR9nrB66PxIKHJ9x/taaz5rsh2ozXsexBoVM287VwndCLGG9TMiRMNT5BZAyEi7PPvKSFq66TLYYBKMKU8gS0stPLMIG+Sz8MYVjOss6VSAULN02jiRdbVs3bX51+NKJqTHW8BebU8LICkJZMWDGDEIWxLPaIZ0iJZqdGMakZ5cgEc50koUmk5N6wHC63KBeFmESZaCCfT4CN4MlHNjS+tQIjeHE8h8pg6BrzdVf/6l/U9li74eKRhys++AYfEK7Ee+4WuIWv0k1dCjcClzmOugG8QEWIIqh1VCw8pFVZCDETRivYOjGZqce3PTxUh5V0ANQE2dDkRDZkYfdnBRXIFI0GMZEcv4TBQOSdZcl3fxGo82TJmeFIgB3QT+BLL0XhyPKbj0N4sN9crqvmzs+mEUkFnl74FkUeeK1a5OetNjUyHEI0Q4bzjjPBhF6ZSV3HTdJZ2QDDEthrQHlFYDKHYkiJkSSC1/9O/+n+nI8OnjxhDMuiEH98JowBY6VI3urKbuPIzFhRbCgdYyuDb/bEoL0fxlYmKwDCUro7dHhQGyO6TfSGk4tMy6MabajB6KknqQozrVfqXkmcdItFgh8bmgefo+HxY63n6iEhDfCuAE6AcZQBlhlBcojNJiQPzoGnZ5+uHZ/nu+u7AJ574FpNFFBeBZk9N7TjqJTtxpEDIelYdMvDQUv6KeTFttsQUYJECAXg6kW97ZGI88ZMhjt0/PIkwvAQZRJtp6geK6I5FMv1/8wlva9BjGBdBoo6uxl5xJKNA1cRKZOMtPYvN0YwS2/DSq4ZntRYsU6b+IQMlIk3iQ+PoYY+6qhDBIhQqWzvT2MwFJBfUAok4XMnYDFL0WEoRUvcYqgjJuQiKo4E5DUD2IBQxQzRwBVxT9JvxeHxyzNe1eDtXb803K+t6Nh7RxSlxT/jb/e758dHMPnjTzttFKiMt/5UxVpMDqXEdcWbUkq/T3aI4hqMcFSUFJ1HxJKfWOQG8/+z5U6LAVNMkSoRhslQjxgcBDwINnVaRbTdNWUQihQUeEIjjIEgAUeUwmLFSV7aaBYlst1wY9Pkqhid8DgPfQ1w7QlpMmxAQbVWtrpREQeQMbw+0WU3N50/6QycHqLdJtwqOptYcgtgkccCXfqgKXizyZU9n1opeu6GXqhL9CXxQUhB8Dxnx6rJ1i3IxslYuhqV0yAva2lvesjnwkT/u+XOm7fmn/0b54WU59HtQk3KLRj3T/DQ09qSevvUd8vpNK7FBD2cYhm4qRaUjJ3XT7JzFAkqNglbQTGDwLn7sJAqZkUZrlqsg0If0O2IIQE0hjJTYq4UsE8RGUKKLKgylCbOycF9oZZG8IZITUBXHv0IMgKKCKdLE65CFKDTZmwlBWpX+uD+aDifLIW/jFI5+x7DPG/XZMLcz2QA6ErBXIEN/YvMHlxjXPenkmCthIQCIgEV7TUYEsXdDVbUIthqpUMmQQP/LZfrmxmA2G1tLcjAQnsorcSq+cmQ4pN2gCg4kyFA47G/IMkBtWQYY0MiscADgW/YSDCanqGuMQhMPgQCHkMI40FQJkgyCFAOwOMdCfrKGyoKHYUmBRJo8hOTMgmw9RxgbFnpCstaaUs9W6JbziGYdq3QCKahecLUAVxQojVsUkFJoGLJq7OfdCk6ogcaVWdBgBz6l11ocWQSXDLU3DSe1g1yil4lyEN3z/IegAIVUdxmACKRKWYujlJbjgoyNRFdZBOcUoPK9k1zbLkaDr4+CsGlxKzZnDqzLRCWHixDMRQeqDDB1F1LKW/I5JCQ8gkY1aY/Arx3JFUcxsixfnUNgvpvoIJAugnMqFABmBV2VRjFAEMLfrhy/cFLE2NVjsYhy+599VC36hrmJmJ5gED8/TK2keJWDF11VSX36FQPUaAAg/uQUE/QRw9BEkmyydZNhjlI1D5Wt2MzQWNY0TLtseMhC/oBQEyRbT4lEquZOmkozWTboMdx3UKGIbpFRUbUcvwQ3iUZ7JIQANQa1ORvR68CDWhGz80iHQwAtWWIRLDRCed0A6c55sFBaSjbpRD8v0ensJQLiBZKsgpPgJCPLe1RBGH1KbVFqmlCL8GRK21oNzgZDZEjxz5kWgLVBYm50xox6nBzrMwgXpLsouyMca4jDxrmtUboIIWViCEY1TlWwiJKxKSa3ZxwQBeFElLJxJTxIBG53ET3JVtkI1x0KfWFhQFohw75cmxFSFiSCnpCg6wkxevjezRnQd+OT23wtl2LBQIBGGrURLi1B42vIQ9uQLbRUGGmBk7AXHLo8L0xnR0ZysUbEKqY10SwEyEnKgH0RnYoJ+xvjPP0XXJYogRbzQPTH6MADV9ipbv7UjZDD987MaEnoiKIYhiIfveuaJVN0J35y4KBUkYLTaKGkEKUp7Pc3Wz6SRzCBo9cwq/31XHfVLMlFB5FtYZU3gQ/zRIPydaII6r/CFXbiEnQdA+I+1zzfxFt0oJMaowNVLFCtKMgvS70UE+IKZKb5HV2O5coM6MtBpYMQCwWAHbZXxFKqBEZ7D4J2OZ29Q4nUQlvNyS+MyTJAxMCntCV31LtjhyMj1S3kCxSo6RognmfKFvZahZTIrkONCJXoBFDvQpWUTjLRBQmhKCEvZCpInqc9YXxIjwJYxkWMA0dMtQwnvf6c7p6zfrQQfPQPOSwDDHzTDiCjKUVGaRfbQDmbHDqtOFE4hbI+8SJJOTGNTGI8sS4ucGwSAtILkLIYjkg2mow/4fn+WZjGIpxFq4KnilbEGokVl3SKbcftmWiy8tc1ZozxIlgXa1xgcUhFCihwphidPiQUeQ2FWADohKByU2DN5b+rHGGlVFFCpQgcciVJMqIIWK6UmC39S4uSeqi8whVMC490zZWILZRACp7vNQWfullLOllZuFAHsEWBRGRIgseRPf9lsC4vfoJAGEvHHyKbzpWC5NzroBYKSYUaevCXwgNJOHZ/JpZs4QUKH2hSqDUiSdRHqqGzzBcBHqEZ8tCSfKJfs/Fj3J76OIWgEFXPkJNkKHgtcylytKMQm5OscaSIst4K4tSOZG80GE6G48lkOhqNmedkYMKcCtUi8492G8CPj9J0Ky1Sk6CpZSMTqMZUKRjK4U+/63pFlK+CFXgQdV+pLUIBGndZ+LrrI1AyoaIV7KoWQqKpBeSMhSgU9oUATMPH9kJchvORhUQ2C5FCOEVUun9CqUGUDCSUvXlEI4LJO5mKtPqWs+wiBjsT3LmJnk0mDgBM6yhLCroowoSfkdkZkwObCEhHiY185DMy5NQo1xgKbX+CsnC3ldDx/ZolooCABi1GlnWCAfMQAwH0UozkUqS1grNJTDoayVguqiC4LItpTBRP8jmBRDlXODa0100q6oYyFMeo1FErGdCTgqBoQprRow9/CxcEMzpPF4okhGNGwJ0kytqFWjASSIoOwZCTJTDBNTmmSNks59oc1sz+UNtb+Y/p/AwGY789zb2mHiN4pn1tAhhMMfEgOD3YyEtswCTVEixxZMIKdjLKLmxLMedat2sOBS4RUUCFTuRwkFDxFykKDitJOdkRHpQ2ZhkDlR4zVpOe5rvbpOEl/yGFjqleFCr6m0W5R/iGuMkEX5EURIG6QYZv/I1r7aiLIhNSiJiwi+86+UTilOwQV/IQE81/OwL2n3UysAac9ABO77ijH+uktBmQYRffh4SBXPAKZhiRLSMLgYxKCeKJ8IRWF1gKTJVJBaB4EQ0cNZEciMojoSKyQpWIEQp5VUzd/GWnGT1jF0NHgqSQSlZk8QQ6zsW5BZdcxTXDvCTHxyWGA6gUd9ABBINj0JKDIcGUgtxV2XjIeXKkIun4vmPTWR3uRQ4J2psAmWfleQRhOMZidKj7I3o+fsjbAMnCF7gzP2bXnxLAmAAU3B/XFbOpL/Lb4kWoO/7RNIIg5NeJ0V7xRZNAmuxila+FU59s+ggSHOjng+GEBw8L4UozQlfaxT7MDhR3pPEFn+QiaAqpVTlF9K5IWV4RAtslPDwPzVJDyh2F5E+CrjTmE16qFHekWiZLECWGhEJxJnzJUAJVjImyfpRcIBTOwAp9ii+XMgbbshJyjok5tWybHbbFTsKY7BV7JS+gBY8EpXAnEifa2NuwbGgk/+zkiZi59JzyI7Ug207FXsWmYQyMFjBF7eyLFiApuslQbOb8pVtIxfclPyAhBQYidFmglAYZNAuimIoTOxYdrGpJid7SUkguo/7dVUmMDEWriEBuMEFQ6qKdQJxSv496g2nDb3bC/Qy6OePZZDA+rntjlGR8yV0vevzcmHEhL0u7dDDmjODyl6hpxbZSVThlv2MuRNLC2iDKSZQLdDGwmGoc6O4i1KXENS/GMl7wo7OL9uXje/xheAhhECE0J4GXC9RKZCFxghifWYzNIs92DOhiLFlzpeQwTLqEvNZVUYL5MhmSZLK1SfGCaP65sUcjLaSpJcU/WNBQg8ICuEQ1VXNaE+lDwLbALl+5i2R/hz9bDYKWm1QFBwpYgA045Yx44ZtUeULFyAgABzthoiCTQkTMDssaCB7kKKj2MyNSKrqqFInNVY1u1hIOhXfsUkhqJdjAgVoy04NyUkIT77bAKmCygCW74EfemLYT8y5SgCzWVVLtE3oRE8vI03wVV2/+yYeusqROgbzpuoskobPXLUR/b8Inmc76Z495c91ouJscsb6HF0mP6t6eRpNe0KHX5wYiHSF6RU7paVlJKZOWki//4eKpF/5pVBJNV5JylZwkCphNKnrfPgLZZBabQNvKqlOOx9koZohBApoVcmJFYROdaZGvm9nAF8k8ZYxombGr694kKzNDTWIGGRfKWgyZUwmRESXNEkahyFQwOKe6shNhHIUpONIXvAiguGEtEsn8iHPrfgG9lcuZJNhSPqQAS0YszjeHEAqXyUfQ0hsDQNdnYCClyK982lAxtVusBIkoGA7RXcdFiyIloNgfIFO1jPhONnkprjHkWTK0s1EVZbtU9egwSY+ykfo3aVzyy2aOLE1CyCw/Sl5odFZAWIyrUAYxTgpoEMDuUszRBmJzrl240tRyKAJbIpMb3mIkxlL5EC/0cCZng9N3e7PHk/vvHjaLUW8+HO/7Yzo/0OQJLO6RWwbmK1bWgGyLgCzeYroTGmZWzIolW6wm8yiMfhHm7hAQZc1/REJkax/hOoNolNg8mnWUyGSqk7ccKURgDV+2oIJSSgGo5MdDqSiKaSIM9tCXgGIjxxI5LdGvzGxwJS+S6y4TS0ZMHBBSOlilwBAhZERplDsU9YYNwFopJ2Z5EaScpLjHHSFpfDoa14A2bxZOgj4HTp3rtdQAoOhy4EfgM3tCkqqFpafagssUGvMAA6YMoiOygil68oxYMEjhkhMjTh0NpSgufch1DFTBTK8lrSxmSbCzgNkl/y5BoLuNLHkXfPs9XMgJZWFvTtr5NCDphisM88xOT4dvObAPDRiZkEvZurlXJclxDkDCkmwbENLdkdX0R7Ph0VuDsw+b48f9syeH9fWgvR6MNz2+Z99bwxNY2nwavfliTRFgjZDBQx0azSxvCVap+YflIkLRPoKYbNk052vpcuLuznLSCz7gwHbUoy6X2VzHQB1OZNTNbse7MSiX2AcYx6PlL42ByiG3pOXNpphyC48isyZPkDmwcf7XfPYKWlzTlTOTOnTUTa5WDHTk94xCDJLClHSHZNIPW9H0RnJjrwCVMxNT/TKrQHCzCgHv0M3o9fzol6YwwRsdVmReRWwuZGd+F1qkm0USfyWMHVyZndSSI0Z3qRCAYinpeMYJf/YvShyC68Jgmx4ZoQJ7hFUh/zUWGxemSY4wE8jT/DjvhCpyiif/QMr0biuYtqLkhRZBgwF4hg7/UNkyCSe/kC0SOz4q6FyHq0TCUA5FDoSM1O75L+FvuKQn2x81o9N6+rA5fmtw8qiZ3WN5T79tBsNV018S/fSWyygA6NvFYrni0+y8rNFF/xawSMNp5wl4Ft2yvzs39U7pCFegisAlITpLTG9JzHN1KFvhpV0YA8hZXeBuX8Y1K5ZmYoeVnpx03YNOfQm5aZYkxclMPXIdodQvEYCPu5hV2gIdZK6MPNOKzIBLMrYpfSlqA5BKdsfH/ohURE14iM15xnmSS8fUvCDeBY7QmItkZ8dRKwFB9WyMgqIO2psLfypRBudyU5Fija/DHnIBwlnwgYAdCelz2QVwJARdyhYbeSg8MZLmSH4kxfByKRskAhnggHQShbLKJSqitCzl14kcy5dYDrlOoNC1REU5SGIBZiV5gigLZKGIfxIcOgDMYmLhFbnMc4OWK1MNBvlyToSorWm5b+Ct+VHNqxMHs3pyv3f8ZHj6eHh0b3R8WvHs3p5H4xeKwavlIg8mwraL1Xo+XzJhaD9E2sUmsVX8JAv1cq8gRJQCRAwNodTBC4CCAlSM4kVEzTFa4FiXhAACpQQrJHirhcpQR1E3cAKkXs3Eipq6ygAIuORPUzJLYZ+BRHISpABS11Kh6BNiC3W6IIiokVG2/Mv/LhGY0IV0TnSoefaFDWLl9Kep7dUKnC1Nk6UUH+ImMpl0BVKB3ThYouwAZT5SCCeNwKdBADtzVslTtWzqzX/h57RcSGsbwxKJyIp8iqV4whcMWSpmsAHNpeDJsKSYxRW6Q7a09YWgQMn0siCCpHiQ7v7Aknkpq8gaZgInHoOk3TqGnIiM+dyFvutp4ycuwfFVUIzfkwutEChHJCnR/FvUyAnxTjt9EEsmKFI7SLPuj5vBcT04qUen1eRePXkwnJ33x7OaVdAsfdqMDg1PMbAcuAy2kQ0cFw1QBqgUhhWvTVTqsFJvyiJ7du6LaUyJljlJbcF11xEKrIgdlmduHAo2oWC3y+Aqd32kAsM+d3NVNzerjSnY4aRQAqcr9QCruK7gzx5OFEg9QIpiULwEoucD1UgKEcWSuhsHlY4KSZaTl+HJCaEmZqQOGFBq35HwIJ7RFIpBEYul1Pg0KzWtIAIHojIBGRJ3cU6u2onvRFEIFrqdsF4ogjsx1SmBRlJh7gnkPGBJbroBiA3UmqRiIc4UkwPcyAi0SanBCkPTCqeCK1hRtlCRWBf7oRFwwwSsIpl8yyYtNg7hhthWAArmEAiwLCTX0vzwHpStuYUIXAbgTHeTI0zSULIIr96kdMIVEQkUNiYUGNfSix7W/aN6fE7018OTenxS8c5c7nmxEo+6kDdC7Ilvqkj9W0IDCeFEmZgvVzwKxeu9lD0KAaNe/EgqyRqeROVQP5M5WDGRjC4k66k7c3D8WjXjUkWCLBGNL3XPPNgFCgHxgSaf3rL6FR25YoNCYd3hC5Qt9WNMDAC2o43hBnAH7rXMKBqYW9RwVYAoVwQJ98gAfMlxj2weJKF+ngbSU8j4jxTUp2be/bmYRD0KJggWAXpWjnM6iZVGOWPa0BI/9oEVkDGDBpZT0dq4gRVMSUl6pCsBmtNkkA0dVOnIAauQNoedB0AWRDoSL9RDWMAklr0yCiUwOR28hggnUz1Rck5UuPA0QwnMdmcjyC7llMGQBATRHOZLD8BwUW5SRSzGMt0EroEFBTD2XKdX6GSnj7lwe2to3Dej82p0XA+n7XBMxe96choGdefE8QFyIad3W0MQojS0N8vVarud8SEBGVlBsFMU1VJc1VQ90zkY74rrNdLBonNsB6I5gkuubSY/ALWCZ5qqUMjeJKdBNaAZGozejQfuYMsA4rR3cElDo3jaCwwZs91ZUZmUjHij+VZphYCQvSmFSBnIKehqEm4KwBbmHDyN3uWgvkIWqIAmSUCk4sEhP4XO86fcwvBGBKDOxiJg8Rp07b9pdyhHYmDKpnahiHJyAaKEhami2x3ObJ20udSAEUcsmQQf22Aonm4lUyOKLT8OHTw5Ro6bMPwXZJmkp5N0MsT9mrZQudZxIroD0sGztYtbfFEELwnQCJasNG9EQnIfayzCcR5GX5OTOkjsYzh56vEgU4tyKclspJIQMxr/LhIk9PuTanhSEfrjs2p43IymFgmW+GptKn2fAiIciOowIgxcBAAHdpCjMNwuN4v19nTCq63VCyxkujOUOhQhihWKleIrkzVdEc6AI6GYsSBJBbVJMyq9ca6iYsRMZU8mLQBxYhXtFK0VtRuJXLBpbmC1A5podTlHPyBkYUL5l5LnaovJ5XyXIgLXopBo4xv53YnAlbB3xILbJasgyIpRiMudLVy1on/M9pFE4fXGnK6MbWQO/VhfRqkuioGVhI1qyQKQjYN8IObqJk6ptdyKiFElagLXCUIO4wkpCeOfmpfwh2TiVGcFRupUeB2ywIRFFmUEO6RBjaOLTQupJEheiRSUZNiU5Fx3N/1LbrgFKvaWnwhdl1r58i9EZJUUaYIoQkzE0UsVZQdYF5oGg2ah0uTWbo/PffEt4qN6eFZPrPurwawl+gVRJSt9mtMgUFkZgt7I1njFIEBwF+zqdn01n9+b8ak+ZqfC0cKRYIlYKu1/UdmaqGhaFMHIZIZnSVarAJPOCXGoHhlR49mCZJYaJo8bEJSPVHrqL5ArxpKvvv6oAhWBRG0fa4IS24R8Iahg8UzUjxyqCsFONCOCC9LcFUOxN7skax0ZkwAsZwqGEGXRA2kGdxdZlABwIQ6YOOxB81GYnATZHLmTIyVZeS0wfCBdxtXdOJls0v3nzLm6zk9QkYFEbL05LQxl4V820y3ZgAnAlrwQKypYAEwNJfdYOwpJosPyrmIMLIdCMQjScxNO82VDyIgcxtoWgZGvkBKZpDv72BUqScWEQis50S8n9hgZa0BcGUQrVV2xXamvqBb8sVa+GkwJd6r8llp/fNobn9aDCfP/3FZSfsUKKasYzh0nsJdH+PrQLxWuTWt9s1g+e3lxPhn0T454Dl5bABU/R+Jicf2mRl75h+rF1Brfguk/PIvGqR1BUDVBY5PAo5VDYIXUIGL3MY3OBl9wuy9JKCmh7xwtJY/86BURZMuGpUJLC8qs5Ek4xO19ei6i6uQ8kqkL0DLlXx0CZqLlUCvqGwVyIE6MwkwycRJ7qxfbVjbT1VwR5av/VDzJko0AXBczJlv32t3T21jAuhlI/qAqjZS5O4PmTlkMVBiFTaEaSWgqsLmz6kaOucouf7K1LX0BI5c0npij2YEdM+JKRBTIlZxYiouiZoQvqmgJabqZWQAkjUn1VzQMEcHiT/2hd0gthuAgoJQUTPkAViiKJSHHT4NaI2TEnMIOQBxjMvj05/sVK5nt9hxVjHdHJ83wqBkx8zOte3xeiW4GcO7CGhEKN3Bd30SR596QljBgy1Yt1uvPX7w+mfBEcH16NOOhGUXwrwip8shtGEOOK64je/joNanRUsu9bHcQgrl5JH4sbnZs0z2RVjJ57ZYWk66jlnjZ53LhTkwYm276RXil8pA0EpIKagaiSiok1JjWRUU7TagdX5ClEnGDbiMzZBQjLiSXbJ1RXBpqRXibnLDXsphGiMhSNIisLOlRMRUkL0wB8Ux5BdR2niIjZ2462WxQ5cZyKG579FncQV2lrKTm7kzE5rzIVqiBFhwEQ1VWO/JCLguVWDLj301pCQxlghrmBJIXvwCjEJgE+RKF2SORlZGlOpqGjiaPTtAgVVE1rIGhcnIq3EgoF3oOkELFQWWIqUWp48mw9eENKkE1MBL6BDgpCMebNbDwSDaulsdi/LPAoaaO5z0lA7o9BP0Zoc9N32aYfr9PcikPwQAjfIGAiN1JVFTNw9CKGX1KHrdfn13OR8PXvuSPV+5oSVETrNpIksGJcUWVgNorlsWJaiTP0ii+6W6aNnIILYIi4QH+ZRDeUmY5NCQLMCAkWQju6ioey/bVa/bmtIP5EafQxrlc8S8FNDSODWOjExJgmNWxMra5CH70v6NmWSt/DsCpIewZh6bkos9dSQwkrEzNTnLlDGpgW5PLBcvL21z4cq1ISfSYM0X1XBABFcc3qtvYOWazt+OGO9NDTENkQm7gRLDYsRA3cLJFXjB1oMCYvns8F3r6wXt9NtXdFKyCcR3oCJ2okZTiYlGx8jM3EB1xHS9qaZ1E0Hd6Iij6izR9gitodzwLI2U1fiJfObNKsGyEE0uUN1s+D5yaBhGAZ6DP1hs1g0n6/XR7iP5TQr8eMOGTN4loUEiqphWixUDuEZld0hSdhWf6rpgDDK5ul7vPX17PRqOzo6PJmMGAokZpymZRnwROizXIS1UT+yAflS3ysS94WuW3tu4iFoaWltdOiIfSwllwQS+cSFJTBn7FxVZGGjQaKETAOKBh5xsgzZCBJaLw02icJ8kBqq7T7uSmNskZRsIM2kaZ2fnCCIi4CAOwREoxYrBgoop3akKKU0xJmoUtNqYI4AI04JL/yKVg3gKxxyRhEtVbpnJXJAusfRE3m3FF6gyyd1Tt/ACSAQABPw4NFvqX5k1ayfEGV3hKMP/RDJbRjjSCKrqCnDTTVSo6BZXrTkAPmNEq8GskKAEaAT3IRPAuJdKRmFBQD6wBKiLbaGZ+TEZgiosgulCCwHg0ifXJK17x4lAq7ybxEXWKPJ/PG9a86JAe//CYaf56fNzQDgySTt9DGtDDnVjL20rooWugGyGjghz5A8hnRXxFB3gi8uzr7Wrz7OLqYn7+4Px4wsc8BJWIR+HYY7u7OrRgShm3MqBwRTXttryKE8VhEzeYuRJeQfRCctAZAf1GWORzTzpBgsfZW0xUx1R/6pcODVd2X412ZEIH7ZkJDfwVd5VMLWoW3jZkPI3xtQwZ8QMEdJPnma3zxSWA8czVnq5IbpxQlnQOVCTCeY6oiohiUZDpYJrupr7muMkQqWkDSoBaJNJskaEo5HqilDS8WFD1oFFsbV6gOKh+9tgAYbOVNICRIgrKzCDELdIu+YUHVNWF9k0royJ0IqwlNlWJVCKQYEokG8lqfhVLtjj8yzEpOl12NtGycGxprZlc6lreseRDd7Gw3tAkslRQLoVUJN/dAE38u9769bwIlVAAw8cXR9WQT3wdO9UzovfPHV8Gwdz6HeIqxYNEcaSE+Y9Dc8aOTcaptQOLOPayFUQRBKZ48iKzFW+85CVUmZnsZFRYlY0ZQiv0yIVrvGYZSPWmGNGtUyrQKsp/iXmtR2rJj4M4dRCM8LzFBj7IGYuI4gkRnbgXP0Iob7EgblMBPGUdFsVF9ox5s8QTb8TAzxZbACMO+XKHWPQyVV+5pQAHOdQAC5RMJB6QxLywXgnQYSfcMYJGQZwUAE4596aEAae9OiEkCD3aQhJMUwjO9YokbQ3lV3ga0HFfYUaiMDFH0s1PDQo2pPgZiiQVqTtgWzMVh4NbEYGWjuZEMcPNdKhBXOWs3L4WTyZw7rJwi3dgkYovmfIWjJZKMMVdzaHio5jxjgohj6wT+SgJjzBU6Wzm6mcSeE3Dnp83qvQ7Qjl49xmuYZY5cKtr7Fwnq32aRD8+kwbGQAil1zBJMDlaxCSyxCRhSdQIpIKiCO6mDRl++dbUhFcySSdfeQOmpzRBSe4YIAJKp7U3Q8OHMjtPg9lxNEV8/yQqBVziIBijaVWnezFa4IILQHxRxJVO/kM5FMIFt5LClmjTCc6jI1OMi+3lC7gKyDhxJ3eHm+GgJApThEoSl0EzVSESiFAs0Z0htjmiQDwhSB8ncwyCBy1SgYkuDkG4LCEeSSISoYLQMDBUYlp9qn0UnrBL1aoATGOgiXz5Fb4cYhiSEFYOJBAzRiE0DQsysIPkMgClq0QxwThtUzoAkZf+dypwbC9oyAuvZ4NZJCMLy0ncefkwxWeIZRWKD/lRkRE/VPsyJ7m8jk4aaitly4QK+0s6O9lY8Aw+Kn9VtP4iFUnp+VD3s76Nfv8xkz8MA+z5MBp2chzmIW0JcDNqworG5K5UQCVvK0OlQMRIWI6rWN1T8mwQLHzChER2IsXKyq/MwYvh0QY5sQAKZK9nyAZBIgmJsLT2MVXN7S1E75JtIu9e5CCmw92CL7xRAG+yYj9hhMpRk4eiBKTOZsZdcmK/gMZ5Uo9sBSt6qIu2tnKKzujDRaprgPW11iUmolZHACQQpEWeNgzLkMqYBnwz+elPdlAyjPiAYUR2J0hRzXwTcAWwZAhvloOq0rQmCC1D3P0hIjSRxHFWpn88I+YGg2bMV3N51Mm3QUpUAs74tXywgw4GOHDI7BLAqJmvc8FPCXzNF5B2vKV+Z7ioSH9UuWRJcBMmxrm97PRT+II7iVnNxVglxcDAUxl+yDoC0eIBjdAJR3NRMqaCcX5GMyMwnEF/ml6132LoD5vhzLifsMjH6GeZg4veuAum17RU/mK4aOK1kVNY2iYSaEqkmTQvsWiu1gDLGIuo4vFenPWG92UJJx67WELVc5GDRKKTVQABg8Fp/zw1zCNOADiPJEZXfuIl27BBiLCPviW+Sh0EFG0gRrU1UNJgdRyVW+Lq669cCQQkV/wZ075HZ9/Q9SQDMJXgmJorqKKJjAnQ1r3dgFSu4FgyyU7PQA2UU6ZF+px0VtOkmflRFqsigcCNoRElUoWgRQb78A8tQKAbLlEwPMCJWXwwmgHOgdvyowysMDA5EpMAhCQlgVKsKF28OrI6jAbN0dE4tSea8sXcynf+9ZrNepOwRTK7g2zyhA78bHpUoEwZG9jEouUNSIaF+V41NaLLzN3AA5uD5sDjPqjNCyh9pDOFgqsQLDEgMULEJw88gzGFIqeFFLAlItGP+IE4klKQ+BbqmLl+CjpflR9Oe+OjlptcI9Y4zOgIGf2Mhq2SNCW+g5ry8O+pV5DiPBmwoJiiTXFUHF4yaU3lGWANn7aAEmsjHnGVNVSKOmodYDsZ6CWyzZSbPRfnMGKZDicesr4Hi//iLSmEvOJmQzAqLKuqQ8uLKyDDW/eJfzJ5LAayzAdreZQtmIRlXNipBxzS6hqB4lUYGCr84OqmwiqDfzmPTNHMDCwDui4XyIaXwqOXlTuWSp74pnFUo2QSGL5+scd8hdVdjOPBfCDdKxWBjqUIGGbf00wmjMlyYGKVgS1BgTJAJOUfL/iiYF7mW6Ah5lwNVCUYBrLgxNjLGeryOSDoJjQKUQypQLIpMoFx1wn7TdSS5VDJzkeqaHnt3CwAvC5YrWOLiBu+dk2UGNGVWzw3krpsSARFRH4EDSnkmZ5j4KKrazHwO1l2/ZGl7z0Nbtz2Xd48pfPTjI5aukAu9Pd9PsSdZihWk6s+1QZSL07OteVLtZwUYjU2JyQbpB2QfP2xM374kN7peHBvNiUKIafNUkGoiN6HenZ2YKzUM8mXSMNbxn9GRbFIN4WUVhcy6qe0eFBH+A8t2cbftPZmRkDEJJONqW/Y4n7KbCehEpUA4YgAZezG3sAhQ6ScYxqwoKnMkd0LT9m6YyTxPDYSFyKI5E0Qn6x3bjjwEVO8YNpfp87zLd/UxFRAQIICE0A4oQKz8VIbBNQxSE31RhEnvjhPbefnZVCKqiMm0Ny+sz5aQEdz8rbGWLGbqoucKVBAQTWvPIKJQrrOdDTiFTfcPEJKaxTOobxlNoMTbwLA2YgB2kDI7IddF7GxqdONmBu9BHcGiEaYfrw9OJUgL4KWGxNYughhtxrqqu5/DNRdwD7cYGsuYgTGsqq24nR4hIa1A32qIh9mpAGnD8ePyZ8y60/093lk0ZxEf2EIoTgYxmqW0qOsuaQuZDOo9AYXsZUhJH9v9jC0poNm3KIhXcSHp7Nvvf3wwenxiIoYfUGPmJwW1ZLGeeIfiyC5FX/Cm6M43YbZ8LCQVhTqH0ERAmBtyRZRyDFoiRymHJXLmTmcZTTSke3xsYxqx+c8ShSqpcJ0CkvFCtIm2wx7kumQYU0oQQjlBdIbnQQAScWiYt0FP14YaUhYtBTNSLEDRK+WHpQdZhJFKTwSDbaBmpN7thqO1+QKlM4DTQJTaMRNbrXGAASo0a4gEKZqo6NCpBrkkT7qSJ4TSo3yxfJIx7tKU5zUgiziMzPCKIfMlFCNRZvlh8tGdug3a0dw0SzjSJ3itIyjZy0A5c4O9m9QWhMgSewOi1Igcg8w5wATrrIRDX7qqSE8c9OyauZOL+fcbGGEBKuUl/KIRhJITIkIUhcPkjFeGVnQfzOw8D8DAO/7DsZtb0wv29CPb2QeYdyVwOZMmeJulSwQ6iikYEoX2cU1PRfwJfb4PsDDs+Nvv/PoG2/fP5lN6XypDgDgSSm6cKYhunQ8GsNif0uBUZBNzppUpPDFptqwsC4SaCW2ImZOeTl7D/dSA0GWClBeNoU8s9/fprBGGDVQl+DIMuUPg6Xu0OiUJEONrsmWjkk3y0GHFgHM5idyEUMJFSNbTqRryHDHyfe6IYvxZQMVLLJIQQTxaQGspOky0ktgdW1ky6dlKC7WlJBINGroHvd3bRuE4o5J3spnc2OPTQca0doNRBseNaNm2LWLJc9rU6Bgb4njDU6GaDbB7CVS6NOAJrQwoNMvTm1R2JjSM4CR2bhRd4wQfFV3k5JmqfkaThQnQ1DthZLmgluM5lXZioRf+0/DehGMAl5QlBAVS24XTDAgVZU90VcIjiWUKNRJUV7+nP0c2rox3k3oF5GEgwLonIRMlOmupSEh8mGszbAt1EwLB9VSLPIsHnQxH907eefR+bsPzt+5d3LOtzPyxRCUArz4WoRoZ7kutBAl8W/fhxM0cevGOuEmw4iS2JQ/LiZOIEqASDqCkMiRj3T5kTkHE0aYQYYWtEt8ccjX+kNe3xEu1MpSMEwdNyiHuhIWuB3DEVCMIVOfK7Nr9UGN51UIUUmgnQh/cPnRApbPPBKX1KX7CV+D0v9UsUGWmd/MADbaIho8mQGBHd/s2G14v2q62libvEO73e35Cobz2RsCEg3LN8jo16IUE+biW7Gqkc7S955oFv2q4HLjDFL8zNZMPrINDFdcBMwzOyiEELWOaWWv53PniaxoyU6yuiZMOopyDZKEiRO3SFRASVCKAiXjQiZncUPsH5rZiQ6O+Z7ZcKJYdh74g5pZcKMy4KklOgjhIGbImo1fccXedW+4yr11oryFlaIyhmCH53UImJ64d5/EQphQB4HNRCiha2rb9ngy4ZMZs8no0TFLIPggIpGlb6ATHSIvsaUyGloTapxEm+onChO2pvoTtZgg5lLOuJfMEu6AqI+QBBcHKzICesLSDyMTBBU37KOwbAxu0vlDFeiWdUc0AMWlYnVhQtfFGgVcishsNu73/ZiVBJLIGYHOrCAAYLGnN8GQazTkIzl9gpoadOVXXGg9AGCijw9blP4CwBTxPfeoeKmkjPlazPYwX9zOF4clty6Ndu578q0xGiDLIAnAAIge08ng7GQKFxrMoqM5pWkqFtM4uK14RxAsxDVH5cAeGUyXiNZmArNBBRvKJcBJUXQRxZWKxYGTGDABR7IZkDBbYGSQSE6TF0lKchgBZaZUcFqYcRF0LGmqGAXEcxOSniSIF5SSRab8jIIEQMpKl8b9ifhKj3kiPsBfqytpLYJaHK3GTUlkZy806dI3YtGdgY1j8FyyIzGd3sOBlc8zmPQHR+PRjI/GWKPiHbHhAIFOX21GkmnRU0PdbQZzxDQ7siovJ56zkVqoFE2kKTFWxKm7HGTHAzG70XBE8BE8iESnlnii+hOasuFEILVaNCEJle07CI1Y9odRif6j5dy1+EQZxmW6/PhsdlaaCkofdSS1ZVgishaKorYXdlYIdaYL29V6c01EKxrjb96bx1jQb22IbqHhhlHFB4DHvE8b/H37+mLx6tLPChQPoaZhr9rFjxmKBduaLGYBRu4qDhHIaBBzsgBJ4xbT2XZxAWESADPDLPNFyGWsGYMnK5g6BWFTNEDs0MQs2LLMJnVOFB2zkV3EKaTRNyW0S1QYYwgUoPz3L79wUChS8U0hnT1IQJgV3nJIJHkVhu51baGK2bURtoMzOZB3U0Z2kKb5NEmuZnMoVuTMKDe5SwwH3G106Cd29qVTWgBLMcjsJd0rKraghVFIKEMXxp7AKzLkcGdQjWfHBzOlZ0FFpAH8sdPHEY9TzzSYp531rOmjO+zgZe+DLzdSLdMKTWdT3w40GMwXS6XxXqa3aRwC5tN1oBqKamM/xbjnKsGSkSGma2k5nUFEtXxxzPkOxEDi+JQLAppd0pCcAsEdeCb+2pv56nYFes9pQL8Uxre04GMXHFRk9ZZ/b08Z48kLC4n9dilReThGS1GlzChPzOOskAZXPvjoW63LrrhSKmYhCgqVI7D+CWYcYDo33eAeGBhzwV+ClyO6ClKu4cIQpVzGBmk/isG7vZDhlagSlBRFkIaUEZRrUvyRlC1Qpui/ACmIFVNAcG9HhIM9Cd0uvfgrs5wAwhZUxJPIXeHQzSGCKAaU+YW3IavGVJpSglERiD0YBjgBVqJNISSSDE64WZdKkwRBjXqHBGTIJTwwlD1TgdmkTVaxTJQVVrKBCPvka2HzE1C5iObpjkYYFZccNEvVkjIhZbDQTZ4pBEmo+vfv36PPDEG+sT4ZT+bLJZ+rpDJmDGD1EAlE1gqZPeQk/V7ScDEZnNgE+IMO713i1UhMcqkQ7xjqtJC7S1+QK2uEEF0PWnRTHjC2k3H1gD3roihyhHLG0sYhUmeUglKUBCOuc6EnRj+PU/ClmQ1cGcAWa1kLd313zZ7Y0vsxTWyhaZHff+2SSXEuwEuCB+DAjAT0p8pREKX3mF9OoKVPLA9OGFJU+Vc9clE6dLzSAu7FdB8u0pKpaYoi4ewt3l9fCKzIiSlLdMxgmBZqSsWZDhfHn9QwlTV0Ic0+iMmOemSEAhfalfAgZFljJKEIkXx1iLxhpQr6Mj2A2MV8ssQO00hi4PPPnAQ1GV+E4ZPPpVA52OCGaTraUklnCTmNGrcwlqHu0kRsCqt6xrAsKEUMY5yQMRbY2NlWKXkxIUJqMOSMuWMeqHBhMVRarvqMJKlvCff57XIwWMJiz0ftedGIs6gMfc2iEk0/G12scghAtCU+tQNjgsjEzCKEKDgsvpyMRtTWkRiBUUJeNgXlDAGQ0TZJmaMkJ76Qy7ErP6sK3pUHGizUFqVdUoAlQgGipYXVNNZaNGQ0OypLEUQ2SqjmlLPrb3QCflHcGDhRESHIy5EdiZZA6MmFv4AqaZgKqK11gopowm5DShsQqXJDhgaQlgqtIRSSoKQ5ERubAYNWPswWwjGFWokfiyglGymWfbbYIGzJigphnTyFLVgF1kAvdgbSn+9lc+2xBLWAFJAjyKTafpLWbZzJ2soswSoY/+B6JmVjiUnq2OBrIoaUke3WgUEW2tCxGtWpfs/POTtaBlziXQCMTSuBvRHZTq9cjGWuQllh7PeVAm20FfUjLUJrYufeidRsKUgF3ZCIJZyJjm7wQkKuFBDCgfOs/+rVlT0FOElPS4HCpwwgTCjSMcd6fl/U0LdrTBiCxn9iExH9VhJCpyfQ8Ko7+Z0aCiinnZDLpBJh1g9epSqTjqew1rj0p9Z8PlNobRCrk2klYl3OYWc7oCFZfsPEFbU+X9928bYFQGtRblTRTk/iOJJCA2JQZ2Ah5WIBmWD62F2BNEqxnhDJtQzcObmkJeiBYlOjLkQLHsroSftpri4I13ADLFTYKT98rVBMkkicEZE8D6SaC8z/HR+dn9IXkAKQOAdATp14orBxEDHpTCrkJl1JUdSS1WUXTgEVC3zMhOv8Ni5fMreLaWdXjTWR9It0HU/JlJrADGNaIjo0cQ07Kkp+m8O2X28ICtpq2uvBdDw88GwxnwsbVLxLYsjjZgPmQflmXioPO7RGlDFrfMsGBkQdlUJWTY24AeN3rQkE6xsDjmG0QHjf1sk5P3cgOT1pgbEuBEKymlZ92j6z3WhKEJOQqotbTGTuKKSUTwoYSmMES0efT5ZHe1sJTrlLps9JI45YjTw7ms3nc4o7HAC3qovBO8uU+qe4CADtRo6rhlRVvTObSwEo+iK5pSChrF4GOF+DX/MRvl49njqBi91QU2PpOGZzKxZqobtVXHEXhOOZWK+obVgjBUwAUgzPiliFtZVNAS1gpZBwrrzdpmT51w6mqxGaxK5e3MGGEpBspMaVAiKv9OSOoBB1tkhlIkukNxEukU9BAy57gMCAXqgWbAACXKDgno0kx2+6zaTCHT5yok4AVanYdUSEpHRmdoO7If5yc0M40wvjUvWJJpv4RTqop+9UM+Dk4VBCZNPrrQejDW9+OJveP5qc87EkHiVrhqMeXwnuvhwz4lvZfjQ+H8+wcqPlorbIn9bSdCmDMLSznQ9X0zfh03KMF22xmBbfbpaL7WLe7l1UR5+CXoRvPFRzZ0TuZjqQLmUrdQfLoSVudUqs2MnQaLHxgZvBs9kxcX91fWN0Nv3SWYIUspGiJbSgbQJsCGLKwGJ+zQXESobcuY7phLHAiMV/QhP8OAJZU2+WqjNYhhHwpXR0Nmi5c4TWCE1lb6mDdB5czR0op4sElD6TobTv6UMjAEkxY6yhxiVCEUjJEx6ccMY5qhWALtNE1SxaCq2P0wQiR65BUCmyxCnKepScycnBK/WBSTbur5mcXI+QS4CKG0ORfbehh34K0ZKGn5TagC7JIcROnToR7ggY+NoCWUW2k6AqWs2TpJItROS06NM2UQVSFHa7xg7M1lG977R1euGOR8HviqDiR4GisXphl8Nh2Ozefav/4OTs/vHxo9P+2dFwQqU9YjKbZ9/HLDZg1SldB4mKaX9ew6cu+A2pYibELSfqEX5oIF4UywHzchN2u5qv5tfzyzfzy9fb+Y3xwb/1uz7CeNo4dbzVs2sBU8dDvUQxhcsmmmaEFv3AHf4t6yL5uiVuoiWDPoWtGIx2nkihvgcU3ouVS7dm0/F+ywySAdqJHKPpBeJcWe5UIyU6xea6wml+7q8W+uqlhtTt1gQJSfnSZHj3y5qKgoHJoEHFLyVo7335ay78QrUDOijQELqzmHENZETQeNHEBFPkVqgESPkDKU+yCS4VsHHTVlSIEdAc0e6oSF9JCrLJZKtpZLcFt0vgchjJavMIXIgUQoa2FDoa2kwapSnkggAtLVyhruRkdgzlLwGv2SF0IeQlm3U0c8VfM0Aq4ZMACkpFzXLG4JW+EKFjT73wQBKkiWTuFEYKnnmubcLbor5963T7T//+8ZOHx/R0+DrYmCqekFFVoFKoQ06n3FGJ+CGrBhKUbKiGSXeuzIL+ZgtvPkRMr2hydHLv3uN314vLV598dPXsK24aBRYMWgNNn/tDkNI0dJ678Qf0YGRLwC4Di+WS+1KUEVe4yyz9fuOhZnkZC2j33DQw1GlmejQOu9vb+cQnm6dAGyC2JxpLy+Br47GzXqdb5AdCs9cOu+nTM4HG0MNYY7NR4nUEDR/X5HS1XnufCwfaJfMenn2d2KQYhriUhz8FVmqrLwVJ/zwJRZNi2ECiQTKUJr7pxMIa+DGGVmkDVWaSD4Oc55REuDhSKRENlegqJKSFFlUq7NAtf/JSGLcIJQxbduW8nJrIJrHAS+mOoBEeZK0oUGgoei7k72niXAqcU3eUPEpjMoz7bDYA5KYLwK2eTb1btwMaASeZETE9HE+gJs+wEFEzhYDMYjBvu++O+vPh9qtZ/93+8NjZbALN9b6paQPe4UR+d6F4l6ioSUx60bzsAyHsXbYJ8UanN37gyZ3Z+aMnb29ePV+vVq7yCzgYKBCf4C4HvjwSad+ODZC8lcXhhLW74VvlMQWDjh43IKTQBmhDp49W6z4TPvTbgOYhoeHmdr1YzGczh9A0osQMQmqZIrdnipng0ApYMvFFFNPs2BZ6G80KWwTyS30rYBxAsaRs6EQKLncEeBWPcgc2fgepCzLLiIB4VpIytuLi7C5cIkzSzROT3FJZe5B/gfcAXAjTEYhcxoLdBEXp/ouwmqLwCFGpqD8WQ4cQlYtJ7OQgOUE5k0kScyDfNERJuOo35xvvhAkwJo6WMjAo1aHQUfQ70EJeOa3GQcDzsvBRFTbdiiXpz/Lutt7WdSY1rfrN4XB12B3vt3zUmtA99PY4Gj/QCJaGKzzDDaPjR/nHulwy6mxqFqVUL778uNe+OX78jdHs3tD3fWAgXgPaKVeklYbyR93olfRoYs4dsOfapJgtVkxSdvJOftAwGeQYxG/q7bza3ra8fbrH8Jqlt+QXDzF5osRU4RTNhCqXqfwp0OAjKSPs7ZoHpemzEk4NQ24ilCFz7hA49KB4UNYMKUzjOGLAJ2+mLHPq00RE1JikaMC1OkZPDtoKh8DU7hanFEA7LVrHkQu1Oc7C/a56oNyRTXBRDmmX4UapY96UGSn4aAvoxdG6lFOj0/EbDJ0UsKireCEPu1JQjC8LqpfZGWtsXpngXgEJAcUCmCStxp+0C0uypcFPCDe07ijBka2TLGdeCxYMTorjuQ5xbckWwuESic3z36rK+ER/ILjAfIaU9KUpCUmSjQRMtNOhzBhQiniZ+mU8qMdDOooEqBUUAU0Hkiwqlv6wovHGy6wcq0bb/vFiN75a9YcbH1FY7Xa9DesGqHkORDAvPQeIzXJGDwFJMlCQtQWAh4Lqilef//qXH2+X03eHwxOfoOfTeSz3gog1qVtnHU81q1JGE/cl30QVy76k5TqYwbs7u7OZROgk0H9b3b55tZ5fttWWlyxAIx1YZ4Q0tiY0QUFTG1se4GLsRAxYmlBXfMTGQ92OuFs8Hi14lynjbYahItJE0Dg4YUq5AJVXXTMQPznRVRKLHgRDRFdJxSRHO5mo2hzgabAT8vZYgqjGJDj7aacZP9WjIZ+bHTFBC0MKnjQlp/kVWnN8jVVW7ZNAH8huN0XLIkAxUiskEhEk0cREJorJnWeUyixyOvk4xmtBkEZhaJ0h1RhPOqZbYCKO9nNTzxAEwrIS5lK3/iUHbLRgLzXwtZC1tejYRQjvbFgFOOChbaYeoPD7MAF3l7il6jIe05MFDB/7YaaYqohW3Tsk5BL0w2E9HTWzUTXu09uESNnnzQ88CjPkZmgzmfaHo6Yetc3RRXW0OcxuqqOzQ58lAsPdbrzZzOhQzBf1elVvFs3V1Wp+tbl9Xd9eT1DZRYhbuqm0zdP1onf1/NX89V9ur07ayexh1X/4qDcbTNt2aHBocR14d/DUraQaClo+HiBVUK0VEK/NZcuumDT5Fj5H/Mx8sTJse315sVkvR2P8sKtbx/TWW96CC58EOMue6XFQFKhN6f7DyaCN7V0Pa0+Q+7uMNnv7MY0kJcbElrEwY1Ps6lqdFls7RGZClVhzph4vlznZyCpRqfqXyFDuGIEc3ZvqUp4A4KoMwa3a1TPCuFOxAmBs4P1EDKQUwJjLmapxxnmYGupZ1BzqZBpL6TdgKKnJIzuwoGtPhWtLt8ewBcIALQme/8YxJTEAViOc8BPJvZsRKYaX7DjEBJyjfzhwILDjEE5FAYKccX3g+xJ5WyatL5iu9xgNqunoMB7veG6E5zWoCJgHYxExAT2kkW8qGmkifjDgKU0WGvJxlrIexflInjRhwMc9+lG/HfapolmyxV2LjALp5LPGZMAkhFnDHq6v+iMeial6R9zXpE+c4etguquPt4ejbctTMqc8M7nbtpt5/+c/Hv/v/8vhl296q+UtZYA6vq5X28ury69+crj8aHk9udhsH7948zvfXR397mQym+E6FFRJjaStY8ckxraYxyCm8XZqv7RwggQDRM2n0WJnqcS6vnuXQsgX6DeL3Wa5v71dLpeszucVLrTzxAGYxG7VME1PrcFTaANCioU/acvoB6XOoZsBFarUIiVVL33+zM3Q81k78++wucguZ+p+mgOIMFDgLhZPRhkIKAXVoph7pTcCrPDCposV4p1U3VtGZtiA8TQxyhyOcYBUINgXsjhwM44BDfRG9uVsu60x71osxA4jWCB7KnkrU6WQc7ExZdq1+k4jCay5BcZ0sO4IeE1O8UcwO2xIIQ3pmCj9NogidxmWIC2aBLPgWE4sjHF0uIcMUFABU0JsKqawlPzykh3loIziltNJc37MrSGsqUUp5HRRHp3W947q02mDEYhXnkig5uZ82BMFIviRZn7YVCMKAFGeV69oBeTmB4xxbxfIIFIKLUe+hYFfmhGIYHbGBdwa7W2cl7By3C2H7RsqUz3D45GsZeeLYLuTi4ve4flbl1czF5ADOaSzdPN6dzWb/3JULXk8bvnznz179np5sznjIctvMrt+BLk90mMGQ1NDMPtI9Yoshtm+Xazmm/WCErDWif3h2NW8gNOYIzd3gEZ9pidpwyhsepE61wfpWm4SrffrZbtZHua32+2O9cWzgy//MSisaZnVoVARw1sa0OYwYvbGkCXCtJUWYWzk2jcunDGKR61iWxcbcz+PpRPFaGQiOZ6hEaCbvlkDAJCdRIoZ/UKCSgCkjsMFj7UNDDKQOo5He2MglrAnpTus0ctcLP6M73ygwcnPrROdSA4+YlgUSVQUNxD1jdfaFH6GTUIsl0QASHnWrMrUWKoRRwhAioJgIEvGnYKYkfBQEwljCxzBH8ZUIIulTlEjo7gwArIUKiiT66VBb4EocBy0j0SN/my4UCiVt7S3y9VhxvsIefYtg7cN1c2m3WyorOvz/uH+bHcy29OhH/LtXT5VQdcoNxJlkJU2NAiYCt/StLNBleU4TglziZvp+luMEaCTlNtQAjsmw6os22+rNcNfnu13oMAdqh5PxCNty3IBNN9V88P2Zv3q7y6++ot6fz3ab8AbMG/a5mUVt/vX7foK2kOq2vlysXn5/NefPT36ydmiOj59uJuMd8ez1i8Ee/t3tdyulpsh5W+/W9zeIv/zZ1/tL295q8DweDqbHM8pBOlpU6P3To63vXFveDS5dz4YTvjgMHc/darztZiUEsfoFwGJJsyYKgolMWq0RQHMYoyifr3vM6uDduDxyfNUyFofSMiRzI+Sb9weKuZEcXYiFADvEnCOrNwpL28/wE4WB2sBhkgJBV0e9xtjBpPyQUtHwz5XxlQCAPNbOVujlqAwZEpokNSdpGwgEl7MK9+MIyOJTZCCqw4lqQhf6lsS9R8/tLPtQIjEArBBwIahoam+ptc1tWSYqNZGRy60CymFDpFF9FilGlOA6pHQYYeKoYyhXfNn5FmfhS26AsrNdbxoGrB6qKq322a5sA864vGsfrPatOtd9ebN7s1Re/uo/tbjalL37w3b4/7e9/T4+EoqLycwuqod/vxcmshN9A3DOS/hgQDcRE+NyrXtCPQH+96BLs2S20no4L2X/WC4GRy3/XuHwcPmsOvtN+3upmnm1eGaG67r2/XN8+31l4fVJf01a0unHqimuDW0ZwZoe0udWO2Hk3bA+xb3vfmrq6vPnl4veu35q939e5eDPt9MPT17yNiYN9KxXIjmf71aEFVXt1fst6vt4vLySV3xfL4jTxy+2lbz5dGj/eWumQ/mDE43vZv7xzxMNqHycOl+PeRO2JYvT+5WLus3WpHJZ7loVNXdOZsSL7YYeIXnAawmcDmwAOm6dDnY+4IYuEKAtUz0ZtGLIQyTnAN8k24EY9aKFWyoTadKMvgf41IIBhCzxSHOwrBEBEZiM/gQA9oEXO46W06QgVjqRr12/BJGkE7cGpNiQAyB7CCl9c4BJRO4+jbQRKl81AUyxpd1v0lSQypjwMtEqBoXoCREUsLPfPEl6l9J8CQ2SkRLRPQAKqCRR2teKFtKMbPg2hG4KBMhgibbsCgHszWJxdR7NhoFOL4vt67263q+rggADb6ipT0s5/vb6913nlTvPWpP9swQYB7aI+ApB9qeOeoBH2jcudbFHt9+0qwaihT3UxgioggtNnM7vO15zoz/bj0dYmzyKQYsgkhA17v+0Ulz763e+Qe728/Wr173esfD/hiA7e2yXtdriuiKYGDxKDxYCEnc8r0cQm1XDw7rQ4+nlaa7wxGt2Hp/czlnZdmw6e9Xm5fPXn9+u2DFwqD3dHx0fPbwwa5tnr16w8T20fHx1cUlz0jNkVs8Goc5K964ecxaKnBvv3p6e6jHb3/w5tlXt019fXXx4PzB2fSUV6y7INL+mks4MX3in+/H9XmOiqkTji1LMHoDKzCaDGojmkqDJQ03J2Qwl0mYGHYZ8nrmkNYuGi09Z0QZjQbms2+S8LJNSJXjE6QuT+MlR5v+nuku3iEDeImuMv1iyMW/hg3/8XwCsLvoko0F8oQy4Ev8ZSJcqckzP5GYUmQhMwy9SDga0hFOetb5UY4sAsEWQAJ2JmGgFu6JtlIeyOQ6aZIpFzl+nV5wLN4aJDRgJDT0IQo0gy2JW67Nd6MMwrS7jLyqGQUsHvZJrJ4KK4gwGD09YskX7xfa3W5YkkgLgKvqwaa6XTSveV9zu7932N9bMdLtD47Pwdg2xNuIinRLeI3v7/vTfb2bnd8fzh5crykXk/3q5e0P/7y5uKDW2g77m+N33/n9/8nl87+dv/yEOp5XZB5YCWnruq5ruj7NaLiqr5YM6NrrZnt11p/dr25WTXVS32yq5Yrdit4vLjmw8GaTd8NYobq2bdjbbgdrRqRaxj6XBZtHn/b7xXr3qmmv6biNxyyyWPLc39XN7Xr3xetLPic/ongf+NpM9ej8nGXKTkoNxixy511TfG645uGt5fx0NNptV4fdsBoPn75+9erVm3/4h3+82G5YtyM3dOgxNUCbihcojaRwQpFm5JMYsc6Pcw47RoQ0yuxQMbFpo2F/kSbQR+Pp+zlIplQQ2NbXjDKc/tdtOpo44lwNGbyGDFV7BrL2nrJSMz62KSBbkJQKsTm1Hrc8KhtSAOppFzDQFoStoCAVK0IdA0DNaGUzP6ShDG3aKftRpGls9CcCqRNDyPJujEEUHjIpKOEhjmmQUzO5Eook8B8ZkiFm8jjaSChxsVtBMBWICGSeoiAAkSdCZFH09JnIyWACIlgg+LolxpSyL4riwdl2MtqvBtXmRpOTCileXz6nLj8cJvvebTV48Xz/xer+2//oP2ZUtz2+v+dFLdvPvvjZv23e/fayOuXu1pPR+4N29snHn/AU7uF2NBm9v2eaaPZocO94Ph/OT37/sv9lPdkybTKanOzGlDne1nCvPz7n0y/Lixe94w/7T75bH99Ws9t9/2q16j24//7tL/53l0+fLegJIMiAUXg9G3A7Lb5hxmnQjimFc/ob6GhE8M8i+eG+mj99tZyeXB8fL6eTHU/j9ofz1Yq5jdfz1c2hv7LvsJk27f2jk1O6NJPZZDieTk78Dhvjd8cmh/n16/5u26yXx6dH+8H48tmLRw8eLNbL24tL3jDRs2D4yCW3Sqm8y0BIs9E0NbSk1p+Og+3abA/rBSWGaslkQPDCgUkSWoJUXEx00gtiyLVerjE9Aa0QzswQtr6SgWKtSLQjzsrxAPuOITgVmcNz7xwb72ieCIIAx4Qc6daOSeCIX0tQWZwIKIxoQeA/kiC7HBGzxCIHI4uLRItcqBrILuVbbo6GUqpJxPbk0duDJWXHYLPQOnRBJAukqNnASzBKmPJvh4ZwswjgxS5IlTYif43X8ZWSkiKbonKBjELKPp0fC3e6VlwCrdrJ7IoxYIa4GaBFLcozPWAW4XorEoXYkIZnHurlpmbF/lHdLibN1S3DBL5L+niw7++ae6t9b7y/Wu8n944fMnO9ub69ev705K33GT7f3Lwe7m+//Xv/w5/+eFU//t3Zux8ev7w+HJ0e/f4/pr9/+/nnzORVPHPKx4qm926eX08nj9s5Hj3qDU7W6zm19XgyqedLekD98SnLe+gMUJ6ZDp8OAeqVZ5FwPMNxBhaEhxGDs9lY+Ebnud/nbRu7o/Ph7PT4/Iyx7y3fiCSyWG825d4DfcbBIxZgDusPH55P18vh5Ji3svB57/qI1u7QMhS4vd2vVuPeiLZn+nBcn9+7N5+fnJxfXF1dv3l9xDLT/Xq7WT84n+AHqmwi2YjQ/RSHLTerrP3rIQ7dLa6ml3Pf34Ef4hPAdB9uY+MOABjGFjQowPhEOjjCuVAuXMvHAB8n0TsbohvzqxVjeRoNNspO/Kn3AU4VKFnCEAfr3xJIXRqyEjxGLRGg2KnAI0nChEQjxgROhREcOsA6FiaPRsoEdpYO03NtDeSVXEUlFgshkiQEwbApqDjMSJZsov9r48BB0mUTQx4coRWi0tfRXOY6IAUHBeyCB4XunB06LwBLIxIxwLYqMr0TB8rE02pDj56JBbpxwNG+UcCcy1453qyYF2JIzSWT/8PxYHuzmvh+MKpkO7twf/3F37bzBTd1h8Px6vaKec3ze4+XzdnZe79/sRsc9U6u58+m6+38cnt9ffP4yfdffvbve+v1ejo59CYXN5+O7t9nroVVnW1vVQ0YtS6Gk4eH9aapbmiIe5MZ/kYPTM0Sz8mAj+RgW11MO+ztF0OQhkrDEIdoMjy/1x9O+g/eefj4PQhc3DxdbnbcY2LhLuF2NPPFo++czX7v/Sf1/GZ7s+OLNHSr10xorm75GMHm4urZR7+arJfjew+X9eHyzdU1w3IWXLx4fTqd1NsdpQtidNF5ux/piOOceuIDvzMH6jozVrnOq/HNVfPsxdGzud8JTogV9xITKlQujEIbB8XX11Sg3P8a+DpSbgZMpsPRuM8LpHAp81d2TglJ9E8cQMFAMgRSurj0SD7EEjYJNGplzCdTK3VrTeMDOgAFWuHcJOavBE3qV8Y1KWn2JFBOa4cDxgeQZ+VBM8lpF15YPYCGfOTgUXqdNEFDa1WlzdZUgiqhpPgDpSs2ZhVNrFt0reQM5c5soS1iYQB4ifjYgbRCCCirGoX0CK4SOYBGQpVlx1NsN0uefyCCWFqC1fdEg28oovBrZComcqiAqNH4OClrFPqvv/yKmZUHb52wMIH7A0ff+pNms+EtV/3T+yfNUdNfT2f91ze3J+9+OB2NWhY59FfLxdPTtx+eftC0q/beW2cVhetwXTXjd37vwX7x1Xr/st/c7l98sr/4dHmznL/p8wKDBU3szafMctrURnberj/mTU0awRoTibgbaqeW8uhMpJ7wltFwvDm/X/MelJOTN9cLRtp8XKw3HOwWK2riR7Oj6ekxd62a5bx3Zd084VVZSPPixebqatvuFzfX7dUVLcmq7t9Oj76k1r9d3lAgXZvx4PHp8fx2vjpsHz94UDeD65v5erU+4b4Pf45RKWT77Xpz++pq/eXLh0+fH11cMPKgpUJmvKUT9IjW18VsTE3RCHg/BLfwuAy1I/O2TTvlJSOj/mw2RDPnmigaeIeuz6GZTvrcHuHcqOg2TjCM+8IpzHxkMYkJxEQA/HGtXQ2ZY0cDMlS44oRMhRWmRBXuJ17tzEDS5o5Ddt715IwIoJ/A6gxaZGmBxVZ2YWJaSY9onHbXSFA4KysipDApvzTYpZNYuAOB2Qohcg3wMBIReMuSW8hZL5quEEB2myexDgcYp/QpD/FTM3G5samzbYyu9FGh5fMYrudhQQSx5lqc7XDDu5XzOujekpmNQe92s/zs5N3/0fz2DYvZ22p+MmtWPLA3v+EFt6+evZ5Mepv5Znnz2fbjT6bHp7v9fEDts12uF1fM2cxHY3qR9eq2t1u2fBuGJUWbW1YEUUUNGCnDkFlzJi6VHRew8mJPI0CrTwcDiVgY0PBWQR+pUSFbPaYGuZHES0bvvXUYT0+OTx8Npr3+ZLmmfPa5ezXacW9gMDmePf/oo+svXtwfjXtHM8wAWnt9u/3iKTM77Wgwm51Mp8fV9Gx8en6v1795/YaBzfnZGW3IYoEJFs3mlt784rJ58+zTZn9zjzojPW5MwEfpP3/2+u9++smzT5/PLi+ZPxgzV1YCQAeiDabV2Wkz0A2T54Wo3MsgjW6OgxkWBfE4miFm1OXxDjGdx23qe/eOXXxiT6Ib3OJ5gykhbnzcuZ5EL5JjpEQCMhMeClOCDiZimS7Eb10mZuymc8K/JKRj6yGcd/4ZsVhqiZZwJqYIquSGkmTFYmd4QTtsFIEopFLHnZKz+jf60EkxOCGLPxKKFZIpqbCRDlVfyLG7U7rIniJrSwev/2BTriQpUMkkhSVXDCQl51QmJOyMopahxsM1aMjKtBFTA68uP/+3w5N3RsPxYvP62a8+22w+efXpp4PXn23XTNuzbNdpjD2Tiu1uPD17/fLFoNrx+k9KEbG5uR0tl/PJgBuZPABDRn/WjlgGudusWHm1Xy1casQ0It/GY2p1uxournhULPaxhCMfwtBVRzT8QT+BkSLdGu8f26Qn/rUXjhjPr9aHBQo+WzTNYr58+PARZfsKFszhD4cvLt7cXlxMuHXBjW0WLVzPr54+3b+84EYffQ28OXvrcW96tutN6TtNH5yObud0aXbkrffnD08XiwXL3hY3t7er66tXzx/y/WJe6asTq/l2+6tnL//dX/38Zx895ZlFepUjZqGoQ4iqEmwJDf3Kpa5OvBEx3DBhBRpE/H4Z8E6VZuEQANxHQFLvfOEfqoFmMhlhMbAMDahAzwiQGi6HNKp7QZZ5Oh0qSSlQCQrSJV7OC7oiWTZKtNrxJUAdqSKM/TQyCcPAICpghiaJrgaDXbhYgBLFCkW/STaRx2IvO8qzSIm/lEjFU2SpWSs4054brvZD4B6ZASEsmQyDvDRDWJ0K+a+PqExiUbMoI4bwpJuVXM9Uk2MkAt0EIdBGuwXYwVf0J8TweXX76vl/U78YMvW8PCx7jpP3TGNu3/zUokj3QxXou3Kbnltum/56znT1oF1QLFjH3u/P9gO+03vpKLGZ0Lsf86nPul07luOmz7o36E8ffnd8/Af98bR6/dObX/5X3riL5PFrp2Mkp9vA/baohYcp6bYAlAak4BV9PALcn0yOmIXZsF7n+qJ3/wGzQ83p8XaxvLq5+fzpFx9SJF5fs65m+eULJlF3F9f1hje0P6jP6t140D/nq/THNwyNZtOb1WY2nb51cvL551+s5svb2Sl9EaZE2ykfa7hdzOe8cro8CLA67L+8uv33v/z8R7/8Yn69mQwnVCUblvk49NKeRo4e0A1aP67Tw95cZ0EVPuKeNdNygJb7CuUxLW4qDLj3tufTBlh4NqNjOdow++UtNF6/Z8VL7Nmoa5t4OLaJt7trGFuV+oMfSzdhWSCNTmWKNblI1KaJIla9lW0BsETiXDpgQGe4qdGdfTN+HJIY/QrgXwqk2vFvpDkecIkFhbhUyoQa63td8scMGCWJKKMQZf2gRcrITHsCcoqYnzt3eYFjZwueoRrSSqMgAPJz6owEr8xN1zkiuENMS49ZWodTSpas/XOjiMO000gqJoeXwwP6SsSYrwbmTilM0++inPLMecYuQ75rzTwR4+TJyX2/gFcx1blnXEAxqLcX05Oz4cPvngyfzJY/3iyebnYP9z0e0GV8cBifPRmMpzdPPx/Pjh5+65+11ftVtdzcvGChjH3jcCpdBmvGHlWhr3Kiq8PCJLvPikkMWAGrl0sneaD1cG8yZIJ/v7gdN/Wzl8+Y9TkaT6en5zxN8vj+I1U/Pd5f3N6+uGD57+z0Pkr2j2a9o0lzNGEZ8muWSEynk9Ozl0z7nBy/9fgxXbuL9ooCPp4eTY9ON8vX66tXrAhioQNC8umxF8vbX3zy7LMv39DlmUwH3DLD4Nx+YGFzNwjW3FRotvv8lc0FIN4IoJ0kooeMFnhl1YG5LPpC6VWrHBvnmANI5shubxeL25vT4xlFIC9/tnAlbEJe58en8tPHyYK1EQQrnrngBYiGp9ZjB4QwiSoxnOzxm59JBozmzaGgKGwlhuEAshfiqhGhw8aIhZuVRDv/CJLC3d3npiNHI2bAHlhB6RIvVHP+1BaA2oGTYhYosxjJYGRUBHkrjuTGy3IEQmg4gqgSnJHCATkc4IBNjwJWaEIpQii1kE1y0vymPCTQg0q9wDQDCyVYZgKVwlAFGaAx9tn1621vy21VZK7q0ekRy3cGpw/vvfuH6+WuNxyfPf6d1c3V7eWL0cNvN/WYyoMKYzg7OVw9m3/8b/qTk/E7fzKYPV59cr257B89/MF+sq1Xq/3NfHT/79HpHuweNu2i3k3ffPnxfvNVb/6chpK1EqpDqbdoUze6DpUFDfRTiFF+3oDGPNahPgVGXTWyv3Vgzh+H8TLQ3viEz+K9WO1uNiuswjDy/PR8Mp2+vHjF+Pmw3Nx7762G5wfGdMZ4X9SQl7fRN4NKxaLLLL7sDYaPHj+h9rplwHt5RS/s9OSUWxibzfrq8vV+fTm/qS+ZeN1uPnrx7Ndf0D5OHj0c4h08mNmg3WC9TguAoHEUUVLCAlcgOzHNMs/BeDjCDdxGrrnvndeWmMewABh+rLXiDRUM2ekHNjxFCRL1qkP/FBAdGzfpSsNFTndxQR0SD1s5So3GsksxePS0IZmchKGhzCXJ9iutreklZ77HCLcEJO6J/pQd61ZRjF4E3e+ZpUUBqnsS0A5hiE4TWOvBWaLLRwecNaJPgzCEqPz851wl8WlqY6AQIKSTHwHURsnxvcKAUZQQWUSYSDJz4+YhVSS9a/9cSEiRBsa7ePnPXjwpc+RELGLE/rp9C7rUN3zjTnWmD9768E//p+sXv1wPzk+/9y+2y/nNs19dL2ab65s+96uae8PpvWY0ob5m6q7eDZrJe23/ZL+ptv0butN8p2J478Pb3avq4tnuert8wrMzR83kdHe5nrTj+qQ3mh73X9Xzp3+hfxEQI9Ed5Rb1ajff+kp5F4zhfUoHimOo1Kk0Pg1315rm7OT0+N5DNGB+hXdHjahN9kzYjng1CXi0ugBQVurDi8H0iFqWcBtyK2zQpxFgSodhdzMdDc5P5ss1xXh2dIxRl6vVdHq0HN6uFvOjoyMGqixa4IPD1yweWW3/7rOXv37+7OXVNZ98mg6n9kuoMcuU0O5wwrQsVsPc+AyxOl8Dgo2TiBfnt7fjo6mrLHQAN8oGeEEH0CMq4zIE7/foBLHkj+YPz+BU/sl0AqMEQrCNJGMdAqVWJNYIKQIjS1GNW6YvHUzDnUafg734uw2pjIDM9xhkVHkIaZzkr7AiAxgRZQJzq2FUYz6BPh83sb3/JWXJuEcnhVLAbJY0TuxhU5/aPRNZDoifmLW/I1UwSaOdBJxLlq5AGo5Aslc8sZQGPHGTwJXT5BIzpmm4ERMj0JDCz0q1QEZraiSko7dKtKe694acTYcsIM3kbm9WDXmrGME0mvTuf+uDwQd/VLfnzXqzaBno7i5+/ek7b4/XF69ubj4b9s7X4zfn3/5H283tZn49rNbDk8e95v5hdQMsM2azk/d6Jw97dJn7z/d8DY8FRst5n/cFcruXb0We8l34XXs5om6nC4OcVDAYEKdfX8/f5NaiU3JMPaBYJq9QJtULwc1Khnqz5UbWLS49Oh7zaN+joxFvAaSr3D+a8oIUauX+7jDj0wTTaZ81QLz3lXnHfs/leQyIqXpopFkT0WdtIOuct/tx/8Wr11tf7MOdNFao+WwL66mHvf39t9+iJCx3tx/9+ouffvwJL6P44Mnb9NxgjRiU2H0aqBnlWbcSanqN4qRfTKGCxCHOf9vZptFgMpGWLUs1yaaCY3pAh+F8Ciw43DhjJTcKMxdFT48H2SUYZ+pTa/RC2WQMmFAyNuRJk5SYI0aE5UeqC9OTqhjU0OXP0pkOGAGSgmp04oZchiW7lA3Lk8nqRcxCFXcZqshRAk21rdRJiebJ6vRndtFXvCshIV4Sjdi7eFZS6CghlOFFrZYFgpBMmUrkSzEJhEMxh9qDQdfAomJ5sTBhazVWXaQ0diQd1eBDoFEGAAwNacZnlCvhIyPl6NBjCQP3g+rempaaCcfh8OLzn4zrq4tf/zmjgSlLq+vV+vVl++Db9f5VO7+sj47q6Zh5/d1iXjNc3O2HD97me9V+MXXxghnW3uJy9eKTw/l0e7jYtasFK5F55qB05CiGCG/lgAUrViLMkcrXnDh9yz13pk0MIbradC8pLQRIRlur1erk7Iw5RR7t6x02D/v1R69erZvR/aPTPQVuWY+ZSqGTwmofVx+vrm8ul8yAuiCHnmJvSp+EZ9dYusoFY/+b66urGz5uTNdqxmecBtXsZHKo7x+zmK43+PLZr15fUeJW/RM+F+iUGaXcvi4Hpmh7/UW6QE5xaV1s6R0WyFp9MavDJX94grEI4cBLGSgMqEELAjyFwdlQdXTCl+LLCHg6Ga/XC5o845ScOIseg4VIX+k6/wlEnMyIrXTH9bUZxD2NAlk+7IInLQPmGYawdKMmpMYwVzqJGA6lGoeEW+Fs9cyZckjCMoDmziaRYtUNf8hJoiOUK67tves9pk/Un334GK6g2Gnx5k4q+GI2hhAM+bhjxYGGBfOBUVoGmcjKblPMAZW0KDLzH+oIIEy0K8ngc42cWA6DBy56qSlCCA9/CgW5juRIG7A2c3fx8uoRjwyxBm50su3dG73z/ZvD5fKTj2ZNMz56sqc3MV9U169WNz/erW+G4+/jt9X6s2qzbuaH4XbOIoj95pIO+Pr2mY9Mbd+e3/x6tW4nTC9d/Opk8Kh30zbrK2+wZKrb5TS0AE21XRwIV+YELR4xACXAJ1iHGz4XyOoKggbZnTOhXKFW3Xz68Zf1/PXowaNnry++ev3iBIJ1w6q3b5ydv3P6iAatur5Z3d7SqRhMpqfTk0N/uOMpNZ5x4W/NcyGsY2VcygJBlpzuT2csfe3dOzt66/hs9ardLm8n3JPiBWqDPl+fZ7KIAerpyT1uT9P15X2HL18+57YBj4zZWHXBaHDY8UivIRFFJNrU6o2Eib7P8iDbDePeLhDYTGl54E38PMgDpn0EdNSxuEvQQgYvp9Yr8RyyIQwFxiW8wr9U1BYDfoUCvraaMVjKjyJK1WEiUGBakpQPywPiOZu5aZggYrnynoBv9wAeKkIHLFUsoRYUY9A/M2UFeQPMyPQhELpnXDljRO1AdSYTKHOHVih6Bes1g1Rp2bmKpoptglcR1GERVjHViVQR2chmfo2DybApAmkkYuaAh0JVGYuKyANYaIAlJV7kSRNKkeUWEL1I2gGeK7n58//m7OH9YTv1OyItS8QWfIaE+q1dfLS/+ikPs+yv4bSubn9NN6t3XY+q2/aGh/sOm5vr6fRL5v4OFyw1umCcPtg3m+dfVb3p+sAg93Z0viCXr0jyFn1uT7XrmrvICER1Rj8QoXEJwUlI+9AYDtNMlE/ibf7wydu4g2fsn19c1vP5vbOWtwmOrl6O95efX7xmCuVyNNk//vaT3ejyx3938+wFU8zn98/305mTbaNp78l7429/d3N0el3tr5Y3V6zLhsjp6TffecKb89968mC8W+xuxkwBUYcyp8Lt2kc1i0cnvK3n5Pjs7PzsyaPHCPLDv/nr56+eMxB0gg8XxZvsjQ4vcB0ZcZ5VEPUy3S4fWaDhQR07/cyWEAm4jR4V7QorRRlLtruN6hqUFgDD0P6t5PG25HUzHd60IT5mgP+YZaSz4+DHUAXPoYH1JMjGr0AguXFBdp5+skpn/oexE4lgAE4oGHqwpgAxbpKgQ4i4QJ78lwiTaIjJMEGa+M6YZMd4kvEljzj76Tu0d1THHKPtopfQj4VQIc8SwYr+jwENuiWefM1CA4L6copZKVbIGSVAT+QLrUkECZwKS4AE9mRrFzv9UgCQ6XxGAkSaCEJoqwOPIbHMkue5hoes1b9cvPrk8Obp7svPrj872e0WY8r+kHX0L04ffm9b3+znf9fv/Xo8mx8OT1mzdvyIu130wfbNg0Mz+pxvYzcnvf773lxZL5+2VPG0Zkq8wI34mAhnOTxTO7NTuvGb9brevGmrV6xPSvFFbR9BL9VoxsgWanu8V1dXf/3DHw56pw+fPL5ktpB+0f4wXu/6+/3k6vr+7Vfzl695gcP7D2bv/OTT3S8+n14uzlllOmbe6vX+2aftYcnd790vxuu/fvf0H/+zp2cnL9rdT758dnr66B985/c++ODdyZT2wxuzSId59Wt8RjPEpMPtzbxuX9Mfu7i8mM/hzps8zyZTPs1CraFXUmtpV72SWYoShi524EssvDOduHWGkMCnH+aWyRDvuNAs1CfTyfCwoW3k1j3dB9oaXWScxcM4Mq0FKZYLuiPEC7VRhqROmOFlSg5rijh3ahMQQ9xSwCYtg48reCEG3PmjSCGHFSkHYIBTarD8ufPcB62suc2h0aQ+Bc6QQoZM/9ClgQRlQ//uaO55jQYLv/lsAff46PUZ+uyAiU7QJRYgFvUsOSZrt2ye24jwR1YqAfiBT2WmVcBSAE4FzInWT5x1gpEPT8TgVgT6QjZVRZoALSeRwPsk+/iEAkA9wziW+oCFMRf7+SfNq19OVldVO7HDyoJ6VjLvrvr7v53ee7O7/fj00WrK87mTW6ZnNBDOoRHZdes0uKPAqJMxn8+WOAiHF85KHWNg1UzKYMhqsGbZPo/bHjGF8Ql2Su8aWX30HHW9/wJlFSRvx62Mmgr+qxdf7AcsiRg/vHfv8o0DR5br9M7vX371q92b/ff2R388b/bPn86Xq81gtkG78eZ2/oaXfo6HzZTnZ1bz9Rc/JsQ//Cf/+Oz9D3jPyunjd5+cnc+vrtfr5YN79zYLH9sqwyxqrevbBd7ChIvF1WK1e/biNWYfDkfHR8e9weh6sXCpACJq0rjMKKO2J/R0TmKvpu5nWnZ+NGOWlmVAlAQtwnwKnFCa/YRbfLxuoO2vKSSMhNKLiN0IW3ypp6WIhwxqHEvsk+yLELkhwXo6WhQsSybtJq4tEcylUawgmpGqlks6dsQFXRo00dqQjpUNfbIJLqp9uXEuOp4gkFHBZ5f3PFbCVCNs8ZCCkWMk2rdQc9AhrDMNdwZuCujPoV30UAkYW5nL2V1yYkJJeYIkxZxCUApsAgssJ+aV2PdUolBO60EVYb4URTDWjE4bM3aZ9XExEckBs4/GnVW+4euYjrkHHtleXPWWn/eXn7XLz0d8L4FVPFMWK9ez47bhdcyjf8toeDncjo4qPgRsO0SA+2SLZSyKW9TS0qWpwVN53pbY5b0+vb5xZfXEnUInNnmlAiFet0f93o+wJ7UIy8ZKV8whAUNSSm/shPQtL4Q+v3/62dOPXi+ePnr09ttv/S6Ll3iWsdosDoPJL9ZNe3X7g9VheX17s7jZ8fB58/q2mjNXT0DdOzp1eShTUq60aAe/+NXJg/v3j6ffe/zB9Mljevks8eDTFrDHT9g0EW0UwpflrbRv3GTiaQfsxgws8b32weUdI2wLQIkUi6qW1+j6VRfkQDoORy9vHvLEUKLbKLP1YIFUZtH7lxfbDTefeThpxMsIjHQJ+G/XxxE19Tu9EJkQZq6bYAPOFpV+ohUE1mKvEGZpOQul3RrtqmaoRI+HET6Q1stUXXIIC+PVOpoQYmynp/iSNsPTdBq44hbAcsWdGnrwNAglTq374ajqkAYT9xLrCQ1goGesI6+U4RPywGMONpCUEnjKi6EPQKh4AjWVpbISUAyR3coJRK1TIYFFEMAK33PypcpOHDqRGT8QWzTsHXoG4oikZvh2uK3GFa8wAXr88M1o/9+evfVVc3874mH5o7aZ8UozIpU7+bS4680bPn7LkKNXEy24gaDd1pslrXZzxDh0xIN8fCOPS2em4OckR2YjHENFV1SxDaVBN/aV3Ge66AgYWWz2S0l2nsCXFwmAYMBOJ7N33n33l5/98rMXH7/3jQ8WvLOEd6b3WZx9drN4fdyOj3fN8Gpxcbmd79bNuJ09GRydndeTanx6Oj4Mn/740+Xr5Y7pSVzEaOHnP5++/WT25BvjMdOyW97nNa14TIwPXHCnJ/0Kzc13jyZ8fMvn+L0LuuIhelai+iWk7ZbbZ6vtmhZMm9tEW/cYcASXqIS4TqA47XlHKJNqdAes9Jn8oQfCmwl9NGmDUbj1RwPAk9C8j5E4cVUi77CwosDxVH4O06gzbBHDApo8jUrIcO3KB0ot5kFq7Ycd7ThiQMe4VPbcBPVmdAZTFP49T4j3+bIaS6CISProPFCROFVO3anayG1Y0+H3rqSv7mKzsFHv54avfmPjEJeppm4Sr0tHEYPfohWjqAUCk5BQTbVmlBZU9MhWkK3/sR4Mc6ZNJU+mRQKC1LwBcYhklGdTmpQN5yIKakFMailEolssJQkhCvLwXvMeL17jeXwqBvajdW/865N7Vhr2JjPuh7WNJyLsuJ3UXD873HzK+0BIQJY0bQ7R2xVNxLSlcZicVePzpnfCMn9fiYiMCh9JVRDmlneT1cUzLO83DvGddT4OJS8Kd3pz4Vq30f0Hj7YsS37KQPJovV0vl1fzzfHl1hb9B6PxdD3geZkFtxWq7eB8ePrtJ7eLN/cenRw9uD9/eUNccteDjsZmuWYwtL68Gjx/UzPzxvql3Y6pHSZ8WPdFuSS61FgT1Kyz8A3nxNXucLNcH/q78WjE/TI7aVQFu6Vxgf3tmQCPRlxQHaMJOpBgRCE9Py5jed3D5xyXfEYJEJ9Xm5zSIaE3ynTvzfw2g2Rq8qxtsJqSTr5bCrU4Hm8Q7HxMyeU27ZCV69DkTvqonkz86vrRhCWuTKH5+D1d+1IgsSAzYjw9B+UyIkUc1iCxwvfONYYsIqZhidCGif4CwJpadexyEEIqbY7qergD0Gxw0q3W91TfARI0KXE/O6LLWkLCkpeqyrlBICfdpTxlHebmaPlAoYiAFryIQVa5RRCe2F3Th7ISAWiZtMWSojiMengkcDd7QGfD2gZoypZCAR6eCUJvbTe73u62vn5aXXzaXnzBk7mst+RpcRfL4ltWHONweGkMbmNNKtae3Xu/Pnmv7p837YghlgWI+R6rsyhq0c0WrpaI6Ek1QfjblYsvtAGELQy2Wpw23/rwD7797b8/Gs2+ePrFiFsV4zM6vYOrm/PF7cmuf9XO6ZHt6vXx7Jh3Wz3/6NVwVe1u9humjRhqThmuD/Z8SZFbUvPF7Or2wPp/7kLvucVBL8LeNffHGKPzhSLbbJ4oYAqW8Svdu0N7s3x2czMfjKZ0HHzQeDRmXkgL2PnAGzx55ItjjCHUpOZVxbjTMSe3klnMYTPKPTDnf3gtLoWJXhGDR3SkAA0mQ9ZBUVKYkdWchCevJqKXTR+a9oIayurcZyXt4/AQAzU8rYODdksc0f7+N5/wDDWTxdZIJPqOf8cYVC1+tnfPOniqAJ7YXmFyXnaHVoCVeMAjhiF8jIPEWypheJEWhyVM2Qmjv3IWBD0vmeJOHOaoALUgDnT6KJI0tIw9tUuDAHI6+fIMNe0ViHBINjs2mYKsZN1VEOAoa7yANOT5U3eDhohRDN8sob2QTS6ip5ACAgZ/+D0xF0UNUEGySQ3jz5v5V/3Xv2Ltz26/auottOwH4mc7My1L90WyKlSLZjevVm/ayy/a6cPD/Q+b0w8G44esjOOZWqNZayoGKJxifPuT3P9XbUtTMSGTU7QLmhBHqwgT9pvt5aur86O3Hr71Fsw/+mRxeX17/Igbu7w5pR1czXnFGrdbaUtoyhi0Xb68PGybz3/9vHnemzHNP2U1cu/26WUM7JCdG8uN99hQwtl5HrJHV+Z8fdWjvjVwkImbDyzoIY7oDPP9c9Z88ExnatdmPBgz4xHHE4EeqV0MZyjSaRCRtUXT3vEDpgwoBH5TXoO3vHmPK1495ge0Ia0PVZaWhKqF8kJFzjcVeiz3I8zp/GvgRDNgDG+oyHm39Px6sXeVIj0ciDZn9+9V3Ec7HJYoxUagQRLL+cPDvkOJMwbQvPQCehRFhMe4VO9Yv9RNKIEV7IYmYvSp2hi0bDpaQSyubIY30IaQChgu8RbpARY+6MmVhmTK0QzZI4cxrBn9Gf9ckAJYkri0ysc4BVlWyArfrP+gbhBfYtlj3ZArpRkDwMFy6FyWAJLzKIL0u1QvpQCbnJlFsecVUdf9l7/Yv/zFenPF42Qqyh+62386VKTdWAX17vWaI5Y/JVSlwtD0tuIG8cWLw8kX7Tu/Pzz7Bst9uXtqyGvrwizyQMdE+xHQtb0hE7lI05LM+GlGLU9RYLUQQVoPXBbx5s3VN7ipRsBuN7UfmHDaGQO6uoynE0bNyXv3+KDGycNTJismde/6k6eMjlEBUo4zqCvHQ8Z7VEegzHlEgOUTez65dNQuX1NlUMq5S8Cqz6FLjFzLTIWMMOPR5PT4hOKBNuWWFkvdXMAa0+kn7cNYybLmWzImfNOGoKafQ6j7BiJAeMJQR9B+JVwIWYYIq5nPg6H8fs2TqLwiD5GY5NnyGqUF39rw9f5xrHdMrdRtK1kFMuZ5TxSyTrWmthWHnDbmxKO6smFj1GLTAqk1DV26uvG6h2Ic5NbithvdqEDzYybjPWTYUy4h5nv+oJ7kMPICSHhB2miJ94CPDLheNkLiXiGUVYFNCoIyeyJZAKDM1dcbiVEKJUgDBjJFOGUnRSOYKEkujAeRpSYhf5YRD8hJI5gcI1JsYUHkB19qnMve65/Uz37G7JCYiE5cwogmn94Ur5fi4fhP/LBJ+91h8/uTHq/tLNpZpdj1rDe39ctfHVaLzQeb5sG3e82xkwYg2A5ECqIfO7uE3OGgNqW2Ssup+ADrsCyEAMG3luRzAwwU+dgKdz65W4ufTnnM697Z7av5ntXJG8eBx8ez6sGUZ+KZdWQiY7dY99ftzcU1OkCQuGHt8fr4ZHh2jKLwRwyqTeYgmWClSry9urZx2O++ev6UrmL/vQ94CJ9uN2sfere3Dx49PjqaUdjhRjBjmRJ8sa3hq5T8w4lOBDajRbFPj+ip4BwM05YuWaTEAtUeMc77olVdXVtagNH46NNPnvMmMwoAzQHupPkLUSPcIMcNhUMCDPsVrsrSGTeuIJUkQ9CY6AIfH8W9mNUQ5E+HK7yauM8g08F0fCRJ6QqvT2XsBTu+0caUEaXEJDd1iCY24dlSlkKYbF0vvy5KkEkBZNMx0GaeBi5RaDTSdWC5VvDFNUnuBbKY2719HWoT6/RsJN1dwSIQ8YjDHKySuQ5ndJ0Ku8O5w6QK31/0Xv5d9fRHmz0PaFD9UVVpH0Rkf1jWzS/2h79aHS5dUUekbk/r/rd47w7RBBy2ZjhAM+EL8Rk8HH5NnbXrP/hO3bMMpCKJ1kjrDVJvN1D1ESA+s49Md+LCVpsCxm/Dy7J4N4mv5u1/+N773rNmkSrv5DoaDb79du/py9Giz6vp6CW8+eLprD1fXfHcVp/p3R3fPXp5uXx9yRIjOr/D6fHwwVvbDz6s7p0Zo7wmY7t7c7U4Zj0Q01VU5dYMvjebO8s8Nz+/d06tz6IJHhNueMEpcyer1XK1HLPQtHhCm5RbSSAx6d30T06OzcJ5dKZ4ISg/GgWCZcunyOjCMG2Lg7S7jgTFUWyfgYFt+n63XO1ul0zVENuYJ053zKfNAJddQpuVTRAAiAEdmThCkESGzLFZQMlUDisUN+CshnKOdYUSLhAEinSswjkqYK45DSJHRcilNyXYKKKITNGwwFO1OPUkq9xrs2xac4oED/7CrFzhbjYksBcDpQROwl4GMO94ie1mSS1JnCEW/5JOARHGe090XO+gIR0UFQFRPcq18Y+/TEXupFtjaUqT6OA328vm2d8cnv9sv7nmZbUpl9qNyGMYRl+n3dNWHx198Nb4W1TrtxfvzKpv3p/NtitefE6NWq8rJiN9cMCNDmj/9uXh13+7ZYXDg9/lNfmUgchT9EJ538rGnAXzGoOVLzpca//4Qg8gNvX0fvdm/uZ0e/+03fAK6pOT+7/zu0ej5jChzudlQB8+qD+9P6MbtFutFus3z97cvLrUh6AbRHbPnNPCznxX7/6j/off7v/+9zYsNuKGwWZ1+/rNrz9/8/ZDXhFXvXrxfLTnafcdE6ZOohwOc5a+DpgkXScg6M7z1qw99wfATXcGwxkJ1n+2C4PeMQsnTo4oJSi45GHjr+i8YA6rJ0wSJ2L2EndWR4kCKyWsQr+DFIYPzJ46pk54gknBAswQi+8TPESgttGH2ik1VAK3+BpGiWr9ClvES+DAQluALMUEA5BaHGJdc+FqVkDscyUv0SgVyBB8tuCRo4jnwFzR4EPrap+VJo6GOAhCk1TUlg19VAoJontRRJQcm5fsE4WJY/TgF1Sr3rC1WpcLYmAusssIBuOl8sUYKh1qRd6wsFumcpBVUQGUlSu7duFasJxLuu09+7vqi58c9rfMP6e9sM8PFNMfY15nsuVh2OPhO5O3xvvepLd7sNi/dTZ5+I0fzC92q4tnPIp7uLxudrd8L4b+Ce+7d8r5UG9eVc9+upueD47eodwpCzpQXbtig4rXVWIMaEfMh9KlR0RsFpcSF0jIfZjda7ofh93Vdn0y5qms6b3RUbu55bkEbXn/bPgH32QJ6ZQ7oy9WLTP+9M2godC6ijtyPIrV8Bzv0Unvw28M//iP6scPmQQnig+LDZ+2RlictuAhgP8vW/8Zcuu2JehhK+f0rS/ufM4++eZzQ926VV23ujpVl5o2LSEJWtYPy9AgLPzHGFvgfzJYYCSBsI3BINsY/EO4pUZCqVsSHSt33xxO2nufHb+4cs5+nvGufW61pLW/vcL7zneGkeYYY4455npTL1cI5MZZzxNkyhpPhuxrAWtMUvxVSsXDVgN3UX84NPEcUgGfI+52rVd+ZTMs2pWKeUJc0eucapH+4MeeiAzphJdiRVSDQX9JwAgw5T0yhoUJb0tsPiPd8zhqZTzk45IcFCZHJc8DJpCf3KJ0kAFkJyj5yeM2DFBpyHuWTJ7d94uGwIXUxi1NSTk2AJgUlPV4wRdRBzVQfN89KqU8tBONUUvCutZH7bSYkO6exLy4byk6yNNRd9Svcqdkt4cJsOxqohUkvYs7EK7yxDHt+x+mJI/FCChDV7gVdB/sBwXTK6dniiAKwjxwoDLQa3HLY7P8zaeZlz8h3Q8Bnbjs7JuJhdjIUW0X3/5q/e0PmpXd82c/md0Me+ylWi1KpDq/8zD3xm8V3rxf2Kxyq97q+tHo03+2eP4oQxYJvDJkwkKPX2dH7FB/vCm0yJTl6k1IFwcg8pEaOGF0WOKikGBQoYJRGDvwYPksw86VPJkgWFbKs40tS8QFp6vjMmSzcLbaKL795qZUy1ZKu88ym2cvdkQxwMwMVjgwNeMvwp2bzZzcOf6Lf2H6pffZ6s+cSW2j3giHENGhzH2jcR8/CVlLtgs2rjgDwPtkp05lBrhQD6h8s3z2+JNBozlZzNDdcxV2EIf9DtIJflmuccOQiyZ73G6wzitpBnB5l65eU71EZq+4APknBCq+oDkIn6hYEtXALiqFzpWYyFAQpcGqujWdkoSTN78nLzoMoNSGKBBvIQ5tmoelNT4QNogbIrqTL/AsoOdFeb4ILyCmY44X+r3+XJ4KLoV2gnIoDJkyHBHFYidE5DN7ZoAvvR+t2Qm7wn/JmXI2xSj5GfoYAOI2VekR8xmKuWYL9wWI7JbEiVrlR/yyyhh7coVuxGUrioH6yQsGYaKWJSEgHpGn5K2AdkDCDvGUXdhfJGXg4EX62Q9W675YgEbhkA0hyMf3mw+/mjl9mLn9Vu7kTi49Ww/GV09/H52Yeounh9mzt/q55ohzrIs4SG5XTt8vv/W90YtPRh//6eqzn+UGF8T8w3mrSab7aFc92bXfTqeZRmw6oBOTuGanmg4iGABgMgAjXacsWlLUE1LJ9z+azfOzQnpeLRTJqW8wDGNB7OYqeBw3b2CdNvPHx9vCj4cffZZZLRH8yRhB/JTzxY7v3Pqd39189WtTHJGsIm1WRLaNl5wngG6ealUz614XQYGYELu7NUp+uVSGJUkXR6Bro5LF+h6OL+eLvuDF24nvFf50DpL4QJbwLJJvmmXXRGlJBCsgDoJWdQmCAfp70gXpTFLCIcChgk6cqb90XII55I9ELp6iiIQA+Qa2feSLuxSmTnsRsiXhFksH8QWS4R8mXPpgP5h3g1LoABhgqiL9DMM27zEtKGEFPPNS5H/BWsRYo8FgK8uFS0HZBaaoXVHPNahMgS8P2LXoswO0m+obwTlcplSwtkPgv8X9kkxSye89iKLnDIsiPmc55b1fvCSL8AklWJ5+iAZu0lhYk2pM0RVphb7GLSoDAmogYo52BdpimHv5k83ihpUgtv0SysNaaLP69nfaH/5e5ta7QziTzbWZwnxVzB68T77Q5eKyitC983BUfrhdkZGWeRBDlT6U0uVb2Yet07tf3bz7cf+P/vPFkx+SxxbIr7qbzmNW3zK5I+LhAluOzD87o9AR8PQzFt1jJPYU48oZ4cWLi5ve4uFbOdZ3g+SkOMxVt9CUSP1VztaajVv3i7feeFb+/cnnz3ZTskLMqWBZLFff/8atv/K7+a9+0CsR/sTJXRtWEjjEOltpwm7OhevN1aMnB7fvbKox08NZpWq92JizQYglJBSoHEfesE6FU1/LHzvY0LWAfHQ5ATuUoWtJ5widAx8QBtoNH6wbK+/FGX98kXH4irIlLgMV3sIrpnWLNEAj2lMzbAMa40Eeo47gAaUtcJDVpALgR5M8mhQNMndtnRqDBvjkuzMAFfAIPbEfdE95bxdYsMSQioUEa6KLMgwkH3KdEsxJRIBZoQ/LBTTKCH1U0qOI47L7QW8W4uqvOmCrPksBnlRzSqBga9JP9CreHJtfktFQv5LDa1bpN2W7E4ad4BeX6DCCzX3OgoK92zyjdI3nZF0bF1A+LUh4JUCgg6ts7/Fu+Dl5BXBvYY7uUiSR+tZfr3/4L25ad/qb7Xg+rhUreHYASbn64N67v10bd6tsYzq9t8icYQwzfPBLTejRiEf8GqRrLrz57eNy5Wqxmb/8IctZ7OKdXaZGr9JlthPmTItP3xExkAsdAQsMSbDom5Il5Ao6jONcEGYqdbKX7vrDwWmjXmalycmcTS4mA2HweNzzpbIm5Mmd997+YPjsxc0nH109+pTp8+Sdd09/7dcLb727QIVfLVZTE1x0R8PrXu/WwbFhHLl8o17BJshmiA6C28zZ2WjcwotVb9Jb9gNUK2yMzxEciNWNxYBzfoD+HyCUxuwm/Ram6EOMCRzsYSzGoVqVeG4yki9KMlTgnUzjIkURCgDAuxWGNPS74hL88bio8w1I+w1EK+BCVxPVFJBufCWi3mKq516kVZ6xbRvgncftD13AdIHJbdAdz+yiAx/RSYv5FP30P75G2S9Cdu3qvhMOFYwhcFUaKch4bcjbexiIRJ7nGRFru8E3++JRMlAvfOK/tfiMb5ZyYMFhewK2dh+jfEBNgFE4Bhit+qDwCFBGl+xDlLYXIEkmTQbHXLTqp7uPCGUm8wMSleWfQvX932h992+uq/cWOxReIvDtIBYjbkzSQhyevNs8QT/KNiotnOh2zb7gE0OdYE9EplStoO0RjZk5+6Dxtb+46J2nZi/YPMxa8uQqvbzD3l2FRPSfNfuwoqyBQYAOfuNKWPI7KrbflD4+PksVOCaeobJ7oczeLTQmlqfQLNhahNWyIcEC6UHIG3H7LPfu/fRXH7ZnYzBRIiFcqTAvrbOldK3E6TKpm14ffQuksd1lQUDEdp0vpd5472Gm2lylZ8UtaQJyrfoRljF0Va/USL7CtjFyBTWzqcpuQdqSXY0kE2IIEqObOs5lXDcXKeqTFyNKxD9085o4xWigNEbLo8EWlAeh/AI34DH56Q/KSnyW4mKCxJBfFA6Xjm5HUUsDgW/bFmrQmR2zWmuJuplgYU3Qw3VuJ15n7wXjQMBonMihpELKMF1QlJcNS/I0ZO3gW/rnm03t+80F/iXSwG82zlOBVX/4kwvxip9xC+Odm1HO+r3mg7YUn757LZgKLpAMZSFroC0edPJIhiBBq8rFlBqcFiOhpJVyl8HYb54OXmGktklIYqr/cju+dGcEmxkRJJnbX6l+92+mq7e2pB9h5+BmjYuGtaj5AuMS5bhQrrSAInAgxNJlenCh3AAjzKKrcpEABUBkr1elRvb975aefJJ+Ps9tryk1vdqML7OVNlHGiduDbuXDV8l4iB4gbAbTeRxbJmkhsIgLCl5abY7Pjne7JZFesAkbjSFQekWoCxv9OFdmS4BaFtV/To7fBR7VCjGtB5AyKymwLofyse02hB1ryetyuXLQBPw4qtyDxh7i47vH3VlqBT+sx8wtHBiDSx59prDbVDlmlD3QuQKmNwffkR8onyHbg7r+Xt5Ad8CS2iO7uoE7DEIKgMJjahRjgWfLecMfKjRiKlEYlPIUU8oGAfDd5wEjF5nJwB5ykHlHmOwpI4pEcd6CQAQZNcebLdmWNfE/mVLji9TDUIAORABbSDjohli+kpccEk/uaRaSscloLCEh7kYPEp7kPSHRfWsSHLe5xj8ZkZ8BC647miD0pAVvYPhaPXe4FvVTgVf2j8UU6A+uMEbp2R9WED/2I0xqjgatigxtzGswPSOiBm0VVQssbK7YO6JpdVLuCPjpPlnjUi95PmR61bp99Bt/s3D4PsFYZoLx0ArOUcriNMTXJyRQENwOI21SE8herRcwD85MWsXhyG1jeZiq1bvW7Ldt/bm/PPujy/TLK/ZXTru7wbPN4b1c/hCWA9SJdmeMuoYZS+zkmNtwuDaROIEImmATgaYhO5PJ34Aygsa+W25JKp5npYvUbjgOx/PBakpcAI6LVSXD0hUzxW48GzdqVRSf685L0qkf33qzVjvabgtDBl5olirsAC29+/YBvLFeThvV4nC35GyC5Qylb4EpsHGxNz1YzXaTQbFdZ61qTYpIFbxkplSeYB6Kn9CVQYiwUXFOpnhgQAmVGfUL0B4Er30PfLigLpNglXZABdBNHJp+2WMYKqJQqCUWsGIv+Md/8WMVYjyoZy/3vcYlawwyjBJSgvSWQNxHmNjV+wFnzCfUZv0Uk0SiISHg6IIr7VVCPn6xXNSLJWO1FLQfjCwapxUKJSUcg/8oEheipIO3kniDFIjJhQ9dNvF8b+ryjlUC36QYI1RvjpsSoDd98ytARnoHg/GcfdadoKbDw4A/GuNJVv2D5VmLZ8azxullenwNhUuK+DuaX/0rtXvfWaLPUDNubviCYEfnTqQtO87ZPUZzzPSOjlhd+ACKROChS9pPlrZ2k920n4cXtuyphHg3qVv1xcnR9ortJOwlzoxfbcfnu3bTGBtaFbnKeiMmqQU/HJzAQif9FxHo98EYuInwVBTzKPrsTefMJP33nJ1EqMyOHVuzzvB6fNA4PCvlnz/+/En3hlB7poavf/MbtWXmyYuP+lMWDpZnuUUhd9hjscB9fPg18g+OKysObRrOmdlKpdQMgGmNZfPlMkelMvsB29FiwrnGHDTrzmg2pTGRoYbRd4kLmCuV/Qed0HE+veMVOg/pBIohrvDBBHa+wFxADNRRONAIhnggZlcwRgXWTyEpk+8y0RdUJyMmaA2acAJAYNl40ANPBjnYhDUJa8U73/wzkAFnGvMnQAZtdjKmoGiXQVsyygULQaCs1ENPSf8ZuLihJisHT8SZo0GrfcSleJJKoxLfkoa54lxhLfz3S9JXBuyw6VPCpPsSdjma8BavZJzJQ/7mReeCeOSBMPltyMJATG5V/gAT+MbOONdGwwyECRB3yHqO93PDrlzG55ap9u36e7+22g7TaxKJF2EgvLJIYv1h9ka9N3zcLK/iS1FzwNPguqlJIWkBJqxlVzeZ2Z/gac8XDljkzxQbqXwjU80RsLib651dj3b9Z5vGHdb+JW/GHh/muIWTcASGpwJRo94GTKP3ONqns8mgxNJDhsztOJzcbPjs/PGEFNC53KS86rz6ZHPnYePgZEVK9P4lmtmtg7Pbs8WiO5k8frElduFosG30x5llbz7fZs4aldNa+fCkRehcsc8MtJtjRcN2DAuKYGELULKkS4A9tM4hfIs5uo9L2TNSS5hVD5wZRQRcxAIIUGcGxOApKIqLrDEAMfgj1A8n1KBLPYoMVIkq5qR63uKbCQatC4L3rrXHHZEv+SQE+JpAg2olAaAlu0UVdojCUgefthBfEnkcdkDEmHJDzcemGAmFqSR5IiriMWuTykPyRz/4yQ85jZr57lPWTs8cQTRng/wOzvW+L7nEN2tLuhb9ij7ue2jkXyjSVGYVSdN8xJiikrjmt+gT0I3eIGOloRiJ7clYNkZQCwtRBExClDwCVgUr2BEeXEC/nabJxTG70ZMLppaFYvPd7+dbpc3uB4QXbxZsB0E91kfEmInO5YA51ZH0IpOacbBuJleCHI3ypKkUCR6IF8D5fiezeVrc/CS1GjAkGGC7+tK29GGueWd3cGsxfcTRksiK8dVm2uNQ7ywxa8TOOEWhPyD22f47ZLvVktZAqcMCvMTorEjkcN0jy0roWoST6dFZTq8un+XT9fbZe7vN5TW7PlajdO7kjePWITnjRtM3q+X2p4873X7js5vs4cmdg9Ttyu56+vJouUg3D6rV5lH1oFYhLtOd0UTh0OSkU+NYBfgdimWaIVFuLsUwi3OzSW9TJCNlcXc+YDrCCwQdJzQXFlaog4CYWgA2cyL34Gl+E/RGWS4zSJGmahivBPfgZf8HGngMcg7tMhAZBCDfiFIR6MuK/BBqCYFQXcjvqNFioJj2fUb6jMd9JnnS5ngBX+1G+0UxIW0JkKC8txfigA7Zus4oy/mY1M8P3nzBWNRCZf6gHlultz4SReJS3OG3U73KCfoOUzChV3bUkn4BjEDL1ug6H9GMbUcBLyWsYel99fEl6RWXbJkbjESlhRG5TORIPCeYy9SdNEfMd47zw8YE/26J+bFJNKOTB80vfX+d6e7Wz9kykd16qCM9YvcYsY9GPefY4ULfGCw76AFUxQMYPeZ3yY5XTpBWNLAvZnU17V+mCKvIzzB1yeMGLnLN+9vG3e35Y2Qn22mWw934IlV60DiotW5ljxG3xE7g1OncdAa9Xn4zaxrlq1WNZgc9kUYZ2I3Gw0Kxenhw3OAwJA6dPH1Q/95hJl3vkgv9kx+SgCs/7EL5zU6/WuZMM4KWx1mSnKZW2WK+Vq5niTNe5PLd6W22pdRJ1MKSL6s/nide4EDZYqYAxwIiFJ/NhkCe6XQyHA1JEonvVb9rKs3u9lY138a2ysM2sbkWxOHlhywQ3G4sQ00z5n6P1kq5wh6cCbqD5K/whI54A01BYmIeyuVnIEH8xAQAIqGnIAqj3/0VVSbVSrjxREL/CRFJPVYUReILVUs7Yje+QidMsDxq1Uy9LAUjjRivG5Ql4303qMeJJ+muFyEsqNrH9h5Sbu6rDqqzUZ6gZrvyeuz2hKpkLl7xIxm+y7R43Klfco0CAkPq4T9XbNsPq0O9YkdmNC5reM+mbci/uOJoVPe9HhMB1bgSjJ7KcqKgw8CU06Gn6CnUnk6Ndour1KqnIkTnt+lC7c0Pt4el5epTFlmz6apLgtspE755a9ilm57tdpVwyofrTbcEJgARkzPyjLot2V5CADiSx2w8LBRRGNoZdl6W310WGhz8uMu2mEbYmYhcz2yyw1fLcn5WzeaPDxq5Kucy7V6+PO/e3ExHowYHcyiGHYLBVQ4KcICyfKN60Kq1WMxFSsHFrXaGrGv9p88y+ct2PX2WX9cz4+ZBFkcmjs4cpj3AKRWq9XKVzIks3m6meIvqVRxAHN4+YmP/gu2U+nMYzzKNNbCcpLccjTB88exZvzdYTqYzDgVgW6Z0mR6Q865e3NYKWRK+iUClLmsPLInRvQSbUA/lgTpVaofNYcEMziZ3FwMz6UREgWzQpB4PXTm4eIGrMKj8EeiUqrgdyA6KobDacrQVZALguS/VSU9Bbf62GJ+2Qbu0ytyTEImXJSsMgNge7OOWVVKiHCTrKlYXxJTMcrqhPDsp+oIkgKFtUeKl/wlL2ZB/3nBI/lkGWRl0nVz3nrccfdxGZPA8zIj3AxL3WvJKqnFQ1izYXnMATQgDrvisnZIp6LuKpj2DXrihj4UxRz3UECEeUdpl4BSIndxwOgoKkqDK5JvV21/Vxa3vD3MU/QczYYEnlC0uLBIi4aAlt9gDy+gQbzSCUwX9YQqVkq8AUiCNfzFXOL5jsdxBvvhWKv8eUTiI/c2uvl1mdzAUhNFKNQ+KZKptN2rbZpvNTZ1O9/zVK/LJQvgiwikJUmRiSJGMh7Qo7HYHaKVyiVxt5BehevIjsEhbrKfvbO7sNh9MnuH9mRfBKjMyyxNE+aC+rclsV793XHRvCgwxH5H+tlIum9luNcrOZqmZ7lhOBVgvXoym56vrp1mClsfDm8tzNqKYxyWgDZMwb4MMUrmRJQVhwC16AeSAKTQcMEm+aLvwWIpk6DEfsJELfxo4s7wPBbmK0+AFUQeZgCcfSzC0pwN/SF9KOCdwA2NAfMTlJrvxkiqtk/p88UQywyS/eOdZ6MTq/bNKXmAdZYOS1If7DTHD8z4KlTGb4Q6MVAs2Ri8ZkTXzKOaZhltsJIweR32iVGqk4n3tyZd4RDKJEUcZexk84piTvviO68ewC4Yrb1gJ/5MRwTiCTprzUd54KWMwy/kle+xLJjzFDaHg4IzGZHGI8rH3LjEG+KVwws9DTizATnpCKkkXy6lCNb05Tm8eLJcvyVbFer+QTJFZjY5mdusqp7wwRKJfDGvGicSCV6nl8ICQS2Cc1c5iF7K8nCvdZwEqlasvcyfpVJsjvjLbMQFsk9522U+TBgdVunZSINCyvqwsqhVOH3v29Nl4MibCckOUkdyi0cJkScqqyWQwGffqhexo+OLyIltJP+AoDiQ24c2ZRmvFysdqBg+1suRn3G0H4yH5fZH/OLXIsUJYU3E7JxcbYRHDQY6DzxDHdNgTsEgcioerwcGl4/5gObvoDs4nly9rG9iZNLW4geE/Uctco5sYKYEiRHZRPL9wt1AWw2JKJIW7B0IPxRksiCHgAryNcAqEuOKaoEu1xieDefZ8QD2YqGKE+qRY5S5uVdnKORwe8KImBPVE6I7di2t0xW5QIfjgqy/7xrNIxeRd8gZdPrAvEaV8k7oQNQ6IwhjzgDdyTevTspt2FJETVfmwREWtdMq69p2wB/QhOhTvf7YhesU9O2cX7YOVxuM8RH4eICcpyRURnGQLlrB+5UOwV5S3dWpQLlCIlhBS1s34bFtnBM4T3CtpqJJ67Rd4sC5GtyWYBYXFeZ1K47hSgMIJ0SAruzrIFb6x3LRWi+dGVaAk6vlZ7jgZBU9OqsjpjiTQJWiS7X2ZSiNXuGOAOYdd4wuSrUxUgAmrFOH81TxndeU5rAtqdEpalheDzHpqSiIAjNjNFpZsuppNV48fPR2yzbfRSqVHpIF2QJAR6g+KG4rnmhMrOJIju5uOn/zkWWl6edBsA6PFfFk6Os5VquvJYDoYTPuz3ZA4Tfe7QypUwQ+cWbXKkr2+HMRLhFx2OlzOZ8R5MAlx7szV5U+q53XWtaiN7L03N9ep0ahe1StFDTgIFSPQDNMJnTAWtcCe3O2mUsnXUQpFDNMVggVa56eqLX2n9zzjNkhO91Pv5JdkqSQWQ34TJ1zmixjng+5K9S6zgD4LcENjVFnsPV6oovyARqAAy8hc1s7DvPaVgnkvJZRixZKnN6nbV1Qd94MtuA/X8V9ns4VlOWkDhPmQM35wI7Vy05Fwd9/Dfa1JxfTSIvTEZuLDZ+xONPq6A8ng4rJUTZOBLh62ZPK0TVvFnlEcoXd5c/SxmB01qyMLFv9DLAkHONp9VQDMXjmehPQxi1nQBKpgCld/2o0XNgKUyUOOYx+zt5jO3AazyHImRqolEVq+fEBmBX2pi+52QjbpEpv3spkGxiABwNgCBOGw/iqa1vhwJsjtXHnNnlX1GPpGiBXJnzqDaXfJ+oI45Ryw6bZQT3V7g08vP+/0Bqx7pdcsEwgG3iQnRZe4n40nvcuXGNdD3K6T+WH76Pllh/27L18+Ozo6PDlsreezi1fPRzc9jkEulsvn/SHOndV0TIzDhpTXN2z2rSJC8WdyvBfx++R7EO34wObd848fhf2aqZbLg/4ALs9UjwAZQIT5EjKiOwoofiCoODB4nqkuGtoAwFzBrDhUdsO1zOFJlh4wBjr07K0MkIifwRugnPKxEYyLCfFKIRAXSTdWRBuS5TAhGVs3tkIcUZkZ3y2n3KMhgRPPJ/yR0I9U41O8pCAxEj3fD0XajHvc5XHv0l0DpHFzeIsCWDswXrBqggZrFCWUpwgAojuagL6C0ux58sMv1hq/fJrG/MEVPqRKv4YgoHnhZvccnGoOL9/4HaUlQr449cSYfXPMXrTnPCrtJzXEaKI/dok/4K9eHtMKv12kRHVkdERPySEij0gy947EbbDNQXiBxdSWSLNjPeILllcHS9JVEujJKqy5/UCCidGZ3EmWOx8RHc2RKpNC/TBfP92h9ngMD0evan3DlohvmFyEo1D0Bm6CTGLMV+n1KEue/vOXnRdXhDWwCr/m2HdmIcarOOXlcNQ+8KtslpzMbqF8kV2N9ZsXFymOBTDL+QjlpnNx0en32CRQLxQbtUo7fURST2Oo2SfMAnaeLQPVbaqMLtGot2v1OqKCQ17pUcGNJChFBTyeeHlIR92oEgorlEOa8SVISIjaH1lia56s6WrKDMAVuFnrAH3NhNcwPtOhoIEmYgoTtQggdi84H4BChIhPotMHD1AzJcATTdmG+j1TN79oyvpFr3+2lsCEa6jLwRI8SkM0DlEGXdBxP8W3aLVmB8J3iMdmFd0+hYpAAAlZI+k/NAHIy5yo4wEF5K3gQBQ0cYeQkHJQW9CwLKwAE0a+knegpfrBMzYNKaOcOIf4j64E8dOoI+KnZOxz/rd+/9snXz6uEPGmg+BrKEVRBSumQfBJv3yCjkUNwSgUfl0Ld6xWmGna8501Oncdwr30NEZGsBmL4IAnYMLkAUFMcggrB07dOAXbbgthf/Z2NhtNUrl5iv3m5E7Au0iWAs+QdHtivlzCssQFmSqvDGKHrwmnLlXSpaLKM63RO7IPrcbZOUd3bclqCbHMhqnu0+2sN+tc9C+vp/iSAGAwjOh2G7RzB7ACM1uSPhGMlk9v6u0GyRvG/Ztqdnf17BEh+4eVJjhs1+unh0eb1ZzDZEql8uHuCEE9nYygcoia/bukOM+XTkej0TJTfNnpz8Y9GLhVq+J7wBDBuQTKWPE2f75yUKiKPJEALkRkCGXu7bkjGICLwaoAD5K0UIIT5wrw5sMa434R91xNCIILztyythUGuMUkz0DqMD3YlxLkfESSzwfF2LhVWZkt+ca3qDa5CqIp4/dokzJUTqPA0VmE0pqvtgFo8VAh6HWmrdW1OBckArc91JVH3IpvPVKLikZSZ1IhnYfUwVP0wz7ZW5qSjq1ahdcG95etyrbj3Tf/fFMLt188GyoXHeMxavCuF3mL1YKg+QCUl+N5OmSBeO0/fAr6C80x+A/YWQyZBCEBWxgguqE1s1qRhpzUd6mNUfyMv8yhYJIdwoT6xCyru+V8tZneVQydBFhGoaEpzrfLa3xWxXK72DpIcW6w28nJgz7ecgzeYr4tNku33srlmoh+VCLWiVmL22xnqWWXrSxMEmB4MtqNxttxhcSzpF/OElARcJP27AOA2V9xAeKgWbt/93aTtLT1Zt7g5eKsyGa03a2zM2Jzxr3+cZ1zTscFALPYcOw2HS/XOHUXwwTnPsbKrkwa0kqVjfuZPGNhFRd5v6nV6kYc5TJQ2Xjq4UgowhxaHNaHclOc+z8mffqnJwj7CuxuOGhARQFRqJfWaGDnc/xEzh962+kLQHWulYVxS8sejk7cG4bBfMBNUcaDDDbG/bpFHkK8QIa+W4MluYS2pSSnLUmNNx7k03v87evxw4YC+YIxpgdbtVvWFS8GgtKLx0wQ8OyesAQ9rfqTSvwek2HQFm/+o27uMaDAVtIVLiYEnzSg6Z0Upq19WbtMn2zcMcfT/LI6isqiPMSQIV1nnuhA8pXC8SglfcCB+ZUO8MvP1/+jqmiES4wipK8cBrjd9hqavuVphjqECahBnQOk6MZFjkjhGf4FhEEc8gI/IloTx92ShwchwfiwJp3iMJuF+hJhMRxlxkNMTPKwbdlKeYSVjWuNQYozTlfBZbFddHOVSf4NUpFiN6YnRGcShYHBilsen7zANqYYknJI5OkkAToelxghIrpaKmJRmMezVuYASDaJEY1D4Bqbetl1edg6KC6nLDlJVOz0XW1bRwdLolLpw5LF6k291t6SQTFP8By6fiN9VFlyOGoJHyr7+4s03O8V4C9BMh3u5sOAv1O5XRG+jJRDOsi8hmBwUA00Kx1R5vUCiBAT/yVU75uB0O0OCDhXlMW2cTTUg3CKGoUw/iF0CZUqL0kTFBWnVhT0HW2LLVlFl5g0Bs/t7wIb6YhKuRF/9pdvvidkwoWQl97mP2+QtnOcTcC/rAHJZ0EyeCrEPc5BqJA/aEQapFf89HcClAQcfudK0ko0aANJT5wBHJPdk56DTKMN3rgXUBK21Ai5Rf1+oxWmUZ5LahYWDmc/oBgSDf7qxf0YqSzEv2gyxkiriHznZZ+3V6HVoJmKLWoVnNbjKBgE73j7R1ez/ovi8Zd2HNIDYxCUhlzDEuVsxtkYK5tVfbQahWGvn50NCBLAjuUQUmKG56NeYTphF1+qdpButbPtW2TWtHch9lSMp9ebwQ+O3utnypw3BCY3DVwys3xumC59ttuMyMyjUSfzIzfVOcwrjmhF5lKNrARRs5dlkRlhV2TnuRIcUR1fX+3Go7cevHN0dNQubTeXF1OsVRbR2JOAwSPh4blEA8IfysVQ79zSIwEhnAlpyG44tzQND3I6WHo949zs7XyCBcO2IOk2+gSc/OYeBabM1cl280569Q02/JhZAXQaAwX0RStwhbICptIGiERj4wbXVWag+kA/HOMGMXndm+JIRcgXHdYbIyGCO+nLfwxfWaaKKO7EN5GqkthrNCalvWthiYjvItmyXIPI/bB9WoHQZAEnMGlV6lOJYzwEONFgtBlPxA8KUZFikqaTF1+CvqI3SRdtzGeozdIWjw7aAv+AEV/sAAV5Vr+nRiwe9KiMMj4u0qKW6Ll9jo5HVQmtUmmMzju87BrNxVP8dG6Ml+I/nraMir/VU41URpHoUsiC6Ncysxv3h5/9/uHJg8zxV3GU0ge7YyiyiS8zmxnnN7AWYGwnZi4HrrDiVWuwoE1a1uLtu6wKke11W6qmiuUVh8UqEh0fYjo1ON+8+CfbV39YrkyQeghoOkbClUJle5RNV4pUy4DEluPCu424hDbQUO2Dg4bEGpXS4UETPRU9jlvIV4+lLdWIHXWNFifPpkiwzs1qihu1enTSHY0gSFz5zFnYBfOVkaXZ1ZC9BEWIZzcazG9IM7gt1vPF2nw2KpMIujfBCioWDnPFY7XwcM6BFaFM1NJ6fbpafSOX/l5x+X5pdUgiVLP/ijVpnWKIMD4EryiCvgACvEHotrdgYAYJoTtavjprhA0gmgLSNCLCHHLAPlrm676NuOwswnUbBDNBSzTpAz4tmRmUI+CEJdeSV9zgzQnetnCAUBi9H3CE81Ncod+BbrThBBliMAYSFduYtoaaunKFeqVmOxPNWZQvPAIhcAkGizLIDi/jIEaGwsAQO3anI4h+0BWL0an9WOTeuGTV1GY7Ph9l/OXP/cj8xssRxZXoQzwchQIZlrd23uSIpGl+iYjipnyEkZuajdY7PO/z3fLZT8akQft2Od94e5cqYiOz0JouVjncy7RAqEAlzoUvphonKRKtIpZzeSQte4Az1Ra6B5W6NQtXCTvWJ/3ltp/jbKXx+eLJHy2e/2F6fr4qgbUSui9mDSvIrE2RsBumwgzhSUArzpi6lLUpnE4qooxN6DFTE9zApAB9sTkmBxn3eqPxYJDq9XBLTiul1WzKUdOclJQlzLpSIpKH0O1mKct2gCre2FKtWDiYXt8UMp8fF88rhdGkNSZyL5fmVMyzVS/Tv2QlDHVpt6sWzdkeOakU6iGS6rvNdzLrv1rcfqW4reMoyOr4ZCtJgj61E/pOYezJUJilM5UlYrAIC6LjuA5EFwgQF3t8IP6YEpDDYMOLMIVYEl/+S+ggcB+/El7gIbqljBX5vCwvHfEUV2Ou4kpUQi3+UaVNW2PULk+ph4BCpicIHYREl0IdIiE8zEnF9N/6KKjIle7tEvVZG+8JyTIARmblvoXQCJakEIYj7YEzu8abryjGb2vZsz7f+UvoWK5x/nJA+yLSLj8AeFJDjNfy+14kdfnbiqIv/Eju2uL+xRXALUU5FKTPNkv6/DO+rfO1zHZEaNAmj2fwyR/NKqnqW7+dbnyQSh1wnEu61kR0YjUT6cWpZvyh1BOwrwyjtgQ8Akhnpw511nlZFxtc7LrPU4PPFucfzc4/3cz7TPtr4oOwJfACbnJrEj6Q677EgiyRRYybCv0ngcfMAc1gpSOhuMBKGoeETUd5Tp+BAGqVOScCsCWneVBxkzoru/0OHNIocHZ9I9c+IHqjks+1aoVbD+q1s1whNU+TPLF/MT3sNTaf1rNPWKGuN9eZNjPRbNNtrv9gnLt5DCAKldbEnYKYN85iqMOV3fZ0s/5+efuXy7u7efR+OhjYYYpijVGiSJaQJDDhHyyjvAmShPhwAIszJ6IgFXHkRKE+46oLmIWjDVmEjZIZJKxoq1MaijGQqPj1El8VZRI7FcU/3tQbbQEIco1HgmiiT3YqrtqS1UmydEjK5MwLBgFQNeKjYNyngBOYH9EQPBJP2lw8CkVSmwQXbTkeuYz+o6bSuKqvIPAV3bdojGI/lhiQF+iTL7/G6zXhcsHh2vAXN/lOuw6ZWr2R3OGaF/jBzWgkAXRcoj3+0TuVvpCo9oxncUy4IwKLjZNgyuXG0Y4gseveajBePvr93fQie/c7uePv7sp3iRbY7NiDAkjUGGkE0IsnOm8nHCBNSRf2DQcmB+ORT/2j5fM/nV98uu5ereckezOuiMgiTgtW9Q2RB4AgDU7ZsLKAAM8n46Zy+ufq2YaTBrBF3DSDRxEBC9wJrUlPxqQ5zJeLeXbsLNap5QSLmBN5KzSAcY1AZvIqFwicqxxXYdv0449y/Y8q66f51XmW3V60WNG/sSsepO9/J/P5J80f/CKbZdYodep0IfuwcvQX7n243Uxynz36+ueX39ltjmhY56ySUXnE/BfoZTA60mM5yaUV1/MCTILG0Uh2PKJ17/jwEH1BiKBCZjdlRNwUQYw1ob2ExBPkitfEEKFK6rBmIATyxLydCth7NXkleOFG8iUhDJ9U8QflBt5o9EKpobhJh1AJf3xK9sZ8sbip7HU40QxlGI6jtl7/kPE0wCseTCgrbuy7ESPedze6GTfprg/7kbz+uR9xKRnRvip6T/tJ8T9TNOmENyXG17UJHfpDeaQBVj0/LZiALNgt6J8yKc684OyvdapYbx3eurfOcMRjltRqq+5i1v9F5sWzyoNPSm/8Vu7g/W2uusm6J9jKrIteOAGqyxvRLRCpjttsQcsvhunrT6eP//Hs8c+2wxF6lIOlg/YDQ5RsVpCSPhK4YE0IIALIKmIM1L4foePhIj5Awpk495ozrdnlSzq3APWSYG4UMBx4KY7KwxNTyG5R6PvDeulwyYl/nCFfPzh5+73im+/lmrdYEksVv5K/+Lh4+SI1Z/On4OKIpVQ5nz77Wuro38j/5ufrjx61lp/X3s5Vb29mxdZRqfFWu91AS3z0w9L//e+0LiYb8oJCEwSzMvUgb/EhMyRIH5sVitX/JOnAGVAuQAqovyY8rwOzICfnYTrAOjMTSI4TYdlFjMNWtARL8u4q676ssAYWXPwzsPGCfzTCOyWFnv/jVyCI8v4W7DzrF998WVj5LQygbXYxY4pINKGn8ym3Uo7q4U32NeMHhE/YHmu+D/V4ysC3VsO7D0Zh645XdCppL+miLcWdaDk6GYDxwXh90bc/84tHLWk37Uo8JdS4EqDh3fFHx18XtbyzqHxuzmVnN2mToqqjMaHwBBjQtgVy8/5qNyNv1Xy0PifGZ9zprwgDI5AGB91guBn88ebq8/Kd90u3vp46eH9darNgDtEr/3hhbGkwEQcx2IxfpTf9YhWLYbG+ejn67OPxZ483oylOQlFH06JJNx8RdhAIjhfkJFAfG5JpnXbdYcQr+rofeYwFBuh0iSJaj6fz8ZwIZRiAODoMAUIycMbqOcLzuJyM88PseFZo1G7/pe/87ru/9tu5fBWzQ0iVX+7yr5hIzDDNvMORsJM0caDpXXubOspUnu7uktt0VaiesyrQ4FSDO++s26c8lq0vNn/p93fnzzannEVc3jTrnLWhHTdmSyTC3NRoQhRfOoYzPOBANB/FUozdoSUj0xPBRec7NhA6Z8aeY3EIkqA7JAMl+aIM3hO9xOMvoYiw25OzV8LfijoL0l+Dz6J2gIatgD7wwbO270dUS2N8ojW5kOGys3sC0Me4rKvc7sHP9JWa6Jm7NLhM+g1zRsTVaM5hRVv+omeJRpBcsb9RKN78QRFri57FTwtGGfu1LxyXXleuUuGTSYsW8Ve8Xn+hvuTZpFW/U5znVCnJZ0mDSBkBbiW2DkQYQvC3YoiAncyiwKEKk+EFnne9PWgeUGjUvJ6sJ89frbud0sUvC7feyZ98JV+5lSnUUDVJmLPIZDhfhWj33OTZ9von+eWQM/emnPPz4nx500+h9uBzpUfBfxj/DiA6odYlfrbpSibbghaBNboF9x0OaGMcPBeDV29muZfUuRX0NDYssmSbIzNtH9uAY1pIgG7YIunYWKEjTJnTA0gsmK1+7Uvf/uqXf53tzdYoJRJR/aPd4gJDRlDRpXkqNUmlx6sdtkrr59vO381sX6UXu91Hw916nDkeZjef52uHq8p7mdww991FapbPtE53tb+Ybvx2utiik2aqRvDTU6kXl6ZqjwAmmgCg0wQubahMBCAwOFrNQSUv4cA/TEQMWvQ6/LYAPRm4kLE26NJqfMrnGAW07eOU5GGu2qAEL79wOfkTzLJWojTEA9TrY5RHfNkbfzsjwb24gPjleSQIeewRMrGjdDqf0TfDrV2tE4MKTfHjs3wmLfqDF40lX8ScJZK++MVB/ZlXUvA1IftU/I+a98WSGuKH9/YvIRtfbWtf/M/e9qmkLWHDf9iZKCzREHIjERs2L+CoyXr47zSAlrEiKA5vIRH7ABRpiv4c7TF+1I/hYjN7texep579Il87K1fZ4JudpItPZ6ln/TFriEfZUWv8ojqaT+eFDctaxMbhJ1W24f4gdCgBGs3pOUFnYWN9ntPEbmeKt7MHzWr17013l9FPOxfQVY46XpAg2uMy6IMTEFioDNUyBmqOvCWUwpQLbJq8GsY+KxUffumdr3z3e6X6UYIPKkqnx7vOTzlHg3oFH1zAOn8XKl6nWteZ44/XL3+QHs6znVLqk932YrM9us70huny386892469dHu1uGu9C+lin8lk/lwlzkCgihmbA1yF7RUyaQrfVIdOgNs74CTP5qG5Oyf2JITvRNGVDLURDgBqqiCsow4oTR7LUB8xBdfkvEknCLiohVuwC3BG15yyrcZyurJjSJ0iEt6+IHQKpkyuLBjwYtUHxjiKyxh1lwQ8Ih/D5RihqMqGJTnAZkvGkz6wkhD3FO7F5K7FhB3MeN47Yu/6ERyM+r5M2+vH339yS3JNz4CYNJjDNR6o87XDfJIUvHr6uJGAAzwyuqZHBm91dYCtlZjx117wfx1BRzDErAVEcAmVwOprueIRyZCV2RjtAQwEAiUGk8wMtnnSNrE3q7eYF/heJc9n2+vRnNEb7+Uur+en04XRTbaCh3WfvmjehgpRqDSr8sbv1rlaNd8I1O/lyncSm+ru850nSVKITjRwTt8KYDWEzWAAQpZUkmQr2TBSdxwQIFoVQ4swulJUZCPA5YnST1BkFozvf3gsNo8aOLn8ln/Q+6X2/NfZOYe+Ujv8LPuBqnts3T6yW7X/yy9/Xvpx8/Sw0zqKpv6NJUbVTgMA50gc/SzXetx6tZvptr/m0zmqxzWyijER5A4ROCaUfIToBkvsMFe8dgL19rotv5P++4rVEGnnwRT9svvABoBDtRhSsfN6HlBm3iXmZEDb6JV7CWQoZhQSrw2dAgtjBeN0ZK1WZXi3aZ4ARj1e1Qu1iE4Y8esR/YWZXTB0awT0iex4oiDggagdyjeOSLpXPIpbVCD9SUX6I6kZPf5Lwj452i9yrvNWh3vX7x8PDoUFX1xOfni8Pb/93f2T+7pYV8q2omW981HKfvlw1886begOnVu2VdVh17xxrQa9pqLV5o5xVS2jlbnni6imhUPabYMom8bywj9xbCYw3eLTbq3zEw22UkhM90SRgMJEQFjhk2YZzjbjHfbIwi/FMIrVhMJvwk04BdxIx2+sRnu+kLqrXuZ+ldSlZMN+XER77nJDm899iTnr9pNYRkWBkOAJASkUggqR+fhjBZOEmVXMqYwZ8ezVxHrkRO77Cv2RewDy3IObolV1v4m9YrwbM55FaWdP0pdfppG7aHLcHs3lXqZSl+iGTEH9FPpv58mGokhXcxTY2KRqzvW+Nh7MMFMvp8u/+/Sqa/rqYz+BWgBOcPi2Eh42kUKF97pKN4cKJHz75y0JA1pM8jXt4R8gjqSEeL6kXJ5gaFkd7g/mNswa1wMpsEErXwoxWkWaDjPqFzxX9TbEtcQ+DAdHfAqwkaGo1NgaTlnWYZtEWCWhXQS/XK0tmA255PVJTLehgV/9HJPvDRr7VTPp50UOUl3/cbLW/HBPcslT/AZ9BZD3nONj3vdj//hy4v7/xTbF9lXZ9NcSjgw+iMceGB/P+lecmXfbpTiiaRJev66Rhb+nIwdMX8IkcKufDtVOtnlLtfjG6IVdOEAFFIlYyUCYDHI0zALq7b5zYhNYvPtZD1asCk+3Kf4RyFb5Vo2tSy4zkDlCBSeKnH4OZhw//yO835G8910maoVUvnjdP5ww44Duoe9kV9vy2piBhns++ngAkTqaqHNil9um5AIpWc5IyEFeyHTVXY4coQd9JIjUXmFsx9nhNfhb11Nt+Mf7eqfMRb24qSWo82L/yI7GmzH6cyE+Olt6jKdPs+mrsINc48jIIcMmHWt5e44e+ck1R9kFwVW99Kn5VTjN9K7ryAXhJlkCzhH6dQTJg56nWNPLQPWI6JqtWVFokCqinIlUCTksGC4DwYDjA7LOnwZ3QFYnSFDS6KwZIP6SfEAvBjmLjAVVnuDEJgEbXOF+RsVDPuIWZGVmdjiwRTEMd4SPXTuuahL9vCwbXtOnLZC3iaELm3ZDbujlOUfrcYdL9tbu70n70BGgpG4lFAWDzNmhpO8nAGsl8tRE/fiC2825VW/2fg/94pq4gZPCIwoZVle+84lD1hfVJq8hyILaGJI1Etn96qoTViTUkG/y35cxBWg47AFJoZnGQ+jbu3q9XTlJDW62PZeLMfkFSFCGsGhaHMMtAoOoeO6i6bpxiY93i7UPBDexFzmdqXMrpFLtfPpchH/CmG1whT3AofJs/zKgdvsv2EzOAuhqB/VZqp1yLYER+LWa7URtCx1YhpiNGF9+xXCQkAp0wQDpEUEW57UnIpsNnNvNgTGgVontJCZVQIqYI/Fkv3Cqc1g9fl/manfh0S342epwZNM56WdmGd2o82ul071MttuZtPnMGN8m/hiGUlmfXSS+9L/Ird8Y/P3/s7m+Z+m7i9Th6P0hv3+rFMQv0qn6CZaxB9sZ/83541MPYfSzPVEoCpB4WQWCEWKSPCBQGPQk8BkOtgTQ1yHegBuUlTMUwNXyM9L6DYuXkee0GmIfEhe00xmAy51c5UCX/NT47Lrjdab0ZCVnD5OMnJdLV2DlSupIYGuwshOQQ62ktDrnjJpRUqO+376VLwSeoxSyvfkqoQRHfMZLiUD4KKPxMhDSfMXt8SqTcYN36JYfHLjdZVR1lI+ta9032xcSaqya1Gh73t6jyZ4xGejV0l52Zf+IZ+N2YbYyQrFme9cjQBpNX1rEyXFbbGSydczhTqbGteTp5Al0y8q0Q7/ovJFBhBvbZZNEeFwEtUqgXCDYA9niB/GruXEeTbP4c5xZnfbDY9zXmiYAcZEojMRTZkulmyY5mWigAdKOaQR/d8Pk3Fgv7OZlyyhhKqQAAJTu1Eptuo8jHmRQbqxTZ5dkgCXF5oEijdRbSRxbhwcViqN7fzH+fTXtunTTOnt3exnqeV/l5qT64GItExqnl/0dpselk42Vd2w4VnZUSxk3/9S+sPf3XIC0+l/n7qaZ++t0uiHw2fp9uNd9ssBynl696Pd5P+buvwnu8mM1QCXxcRgImeCQvA88OfqNLwZgXFGA4l9mAPukPDocQK+PYZ30HGRxENo4KVytVKuse5NgSgs8Srp0QA5EZYMXXnyuayIYq2WS9c3nc5wRGE0Q3w4yAxKSx/KZSgl4TWb5p93gpv8aqe9FpSekIfM6zU7a4k9Efqd12sCpkhciZ5z3RqjQBSyIEWdBrxMHUlDr0XuvrAXo5a4u38yaTYe8nnokrvUknRA1MUkyM/odDQdLVM4+UxuRV+5a3GcOWoXVKPsAiFYpfu+2Ddcg7oHFb/EN7BF/Vb2aINxucncbKuV1CHZTMiCxQ4wZVpkYCaNIMlDpXtxKJvEDEr7+vgi/4rjh5i5niABUlcMsmiQSi3w+6XyLP3znbtcBOUbvJfijRpjBPFOcc4rWG3JQAslcTA9f4T0cPSWai0sluesCpRaaqFyXsRnZPOFVIHFgMWavTuV9mkq9dVM4Zsc4JEpXC2ecmbRf5rJdNmXs51UFhfsledwsU3hLLU7cfPAtlZNnzRTdUyNaup3fiu1vZ9enacvf5laP14P/v1M7Tvp3J3U5sVu+J+luz/NXS1YfWO527SyvNT8gmVhRORzbPwymC9InnkTd4MAQSQDNzqMKAa/sAIqUMmzuHNs7iS41WAPTP3lkOynqGRoda0KB+dxgDbzsmdLMjuPxuzxIQE9aSFpVaXfHkgEtCAAA44gzKuJNRVg/YKY5L94RPqUwixml+SchN5EgY9TW/Lu7yDQuMObt+JJqMB7CVPbHndiTrMvwfZ+Jg3RGiUt/6tXNOBlLsV33plIEYnx4jrfAB9Nesly+975a9+LuMaP6AbXk4cpRz06NCEXAQ+8LIPkV5zjOQnjjXqRvt5Dtq4rhxzynp2U06dHuza2ASGh4EmwyHYACSpF72fflKo2lQY32kFxCssFCBkDPxB8VBrA0m1CSaYOfXyOCCpOvuCFmxLnFj0DdjRE98VidBg3Fl5yLV12beH5JNenWRpwTnMcEVuP3W/OH8Jyue1CaSf19mqy+dGPf/Lh91qFYTdVbbO9d1N5I/+Vv0Ve6u1P/qvc/GpzMcktcnM28Bd2hdNs6mF6g1l9p5E+u4+6ls60MuW/xrBZFtil/+5u8vfS03+ym/4DJkpPP56MSCWWmuAWEJqoQCr/DEq/L4Di5RYcaBWBgbRhXMIi0C4mA48Ck201BBXVm9WT00PWDTBNl32IfMv5TETbdofLdK56eES6i81gOOj3+yxSSvHSu9igiphRxIAYDwyJjdcAjxJShNeSEvGOXEzIIwShj/Ew1OFo7F988I1P0J7UHbXHDX/74L7wa1KLz30NfGfQFExKWZh6kjbjudct2J610QfMm6TeuGIp+xPNx6S2fzqG8vq7haJeQew4f/Xil0/7p9jhBnKaIYKPIHRatDx/ADQURSYIK/Auhlk9TbBj/nC7qZoM1HmV+AWrsaFYGE/oOJloxTmDpCVm9/CsgqQgJMRqLCOYn4sGATxmwCqVY33M3V9BHRHtA0NpDkIyVBRdR2lzAJG4fMRi3KJIqufJcpPjfFL0WzyzbKNZpoYz1jqQtzI5GzKrmexRZjnYTB5xTl5z9J3ij0qjcvbebxDbsGu/k/29f3u9bm4//o8yS+aBzGaujZFuZdN3dtkHJMg92DW/msqcOS8SIsJsRTqw2rvZTGc7uUnPnqXIpTshH1AYEnOmJ45B5ogP+C88KYwQW0dQQ+5c86reWcEcnmegA7aFEWEGzKHsWCuVqlVyUO6KlUp6WWLbAG6k8WQ1mQ1H4+vRGDXPqFmr9+Xj8QmEIFmAHD+hR9iLynkFEhOyFeE854/kXzxtAcoL/Hg8gC1aeZR7VJJ82skYVtRKA1+Ut5Wk5L69aDR521+xkXhZLsruq9834L3gi+AwKM/uUC6KRhf2BSVUbv5qaPHAvgSVxFPR6aTjUYHDpVxId8ag5I+SfMYd+mK5MHk0qJwHIGvblw2g0m3OU6nI/Unmfyg4wtFsCtwlykw8Ap/HtKmA0yRD9GONMXmBdcxsndPQPM4aAj5x3KCrYHszb8Dss1SJRCWMOoZMV9iTW+K0ObQTO0QnUGf1LMKRLEXejFbbV1NofZ2+ODlComMHW9lglBpNs+w/o07wBc5qdHGzbJ0eXRbf+q//GbkZP/7uOzf1T36cu/1+/sE3Nu03sl/91vIX/72E+WqVe0kM3iZdT6dOyWV6sqv/uV2G/EUXqVQ/lbrZpm5SqQuM5VT+l6nilQICEBG1OollkRmHV3PeExtimAUIFXRYuMnYWEwXpC5L84g9IzGr4FEGyR4EUxi+Ua6UuMwKy6gzH89G/RFpL6R47NlAv9jV7yPaxA5oDCrnStCFWLWRQGdCCuJXMk8+k05QOHmOkj4BQu3HF1I8an7NDFFmT3BRcUI7tu2zfkaLNpG0y++44r1Ep33NZz4Tz9k3e5G0lFSSXLKzdjcIkuKqs1Gdn+DT65awBYdmx79oLoDwK0js71gwOgdCjOhQJdGDTlV4VWgs6Z41osEgtFHtmQMwKilge8nLEF/ImAugQzc+S/UcF5Y4NHGjK3zEBk9Rpf/9HWC0HkdFB/gCV8BR5CEh7J5VRZyeVAiBbFllggPoFxoHjinUAbw8GbymgWQ6or4MsiACKloNOLbvan4+eNVqDjnVgo6hNUznpKwLLYweQFiZdDlXuKqnGpPL7mze6wx//vPrn7/x/H/2zZt75x+vP/njfPNuik3D77y9e/Mg3R+XLyflyTB3Z52uIYM/yGx/gxjWXfpn+KvQdtKpWmrX2m5f7FbTdPYbmca9XWWxy/4stfllhmNrhsSjupc2d9xqk0ABBsjj8SJzFucI6GRAVhhRAr/DHtVqkaAN9iQwIGiaMInJfH1zOZ5M9FKCJhQbhLVICiIIaS6uXBcJjID5vbiglLyWEMNr6CdYtaS0LdH4XKhLQe48ZD1xU/7ke0wOXuO/r6REtGbLMs2e3HwqrvsW1QUt+itK+rS10K94ReNRJPm9rzuq8woP8v2Ld0ko5qO4w9eoywHYAjftWQw/4QGhxB2ZyjuIlSjnJTtsLTIVn0RQQj0QPzTu2ojakLXzRl/ZF6T7DBUlqVB6lSsClhCdai0evpC1QMsdKrwzU0D0BfKG7kevXLMzmgC2znfqgdeWSH17RlouJ5HgCRpOmCM9H+qYyrOuCrWwK3W3JedUFhGPXkuNqgl4tmEJ94RlyKpOzBa/qJKjDKA/+AgqI3ZDf6pKAp5vlPFxajmcLnIXnTUa9TZ1vcte/Xj0gye/+N5bB9952H/QfHZMxsZSNVu7nT4iBG5Rzm1Sh5y6/TK7OuWo1/TukRjyOQAAorpJREFUIJ1m7ZXliAfpVAP2z+Sebos/JT1MKvMWEM3m/vF2+h/sCi8VDsgPDorhNJvpaFolYW6lMiPvHN4v+B59zpmQrcl4vgg6rU3Xu+7ViGUK48lk7BB7IpkBBAYDeMKQmwFcv/M/uSniElT7m/9Iy8DBvqw1xUtiie9RDnAFmfi0MgXSS8pR3+tyPGGTUT5oxwuGrvMZZfY1J8WiXDy8by6663cpnKI+YnP7p/gadPn63v4py78eaPJpeakkmuSdHsnp/JPUrTfoKZ6Pfkl1+7biGcvEcL0YAR3QRbxc2TKe3sp455pj4zQDNXmJ23KKIT5skXVVTu9CnIEpTQMXutTeJ4TU2wi6EGyQ9N9+yQQhbTQCZQgb4guiLSqlKvGlbI9R0dZ64dkDbLpk221ckxVBkGgVS6oVThFJFCee1kKeI+o4m8J1ryzx2xsWNgmrFmrwF4H4JAMNzyFOI9g04Q+6QwD1J73OR39y8998NP3WWeU3b5ffPawfNpqVfImn8/XDQul2dnKAEzedm2D9pDL3d6lGKtVC4+OPlbBM4RtCJsVi82ZXIi/S308vu5jACgtOD83ni4dHFZMCIVFyRaLIiNCYDRdTdLbJcjqln7AmY0smdImKbnFBfAtt/wl57gRNCLm45VVBmbwSauSSdAa4LR/3kvfgKItzx/p8MEpZ7R6vNmmVFPHZ+Jk0sC/pD2/+quUvaosHuWHroNUiSUd4NJ6m00kzPh4NcNmXBbyQtJRc8yf9S5jTqvyPgGaPrMMJWBBriQRXObdqm4ve8SbwbDOei2rjh01BWrx4Au3Sl32wFbfBvO4G/ecnj0AkCCM+KcBFiH0/ylKZQGU6ZAvqKU7kRAdKwQnYrGs/IvtunyVyr8ZPxyD8fdlt/igT9aiJeSVWM6EWiB4FzGJUmAzJQUghhiW9hntURXQC+YfY/kL8wTa7zMyX5lug33SVrS/FIlWwaMD8lMUupsMsHpA4EX/RKJV+PFp83rv+h4/Sbx2Uv3Rcfe+wer9aPq5NK8Nh4XEqX0+nD/8TPF+Z09N86166Use+IZt7Kn+0yzSxOjTerf5wV//zu3wnlb8iZR5J5XKVVms2nfUGw+FwMhpjvaKYsZDo4AEC/2NYvIsafwqiBD9gPLkL7AOjyjrhFTATCgKS0rziOuW9FPe97uO8RSWBa4WmX5AhYs+SSSG7Yq3cTyqIKgO+UQk/k1f02AdpyHpf1/LFY3FB3DLTEety2Kq36qwh5YBzfzgfTjhQJ+wYaC4cVtGqdSsxo+vJoGiIa7ZgQzZ33Kp++PatO+1yvZxhk9N4Mr/uTTCN+tNFF8DO14SpAlpUxiAhSMShJO90iIaU1jHqoGS0HojY2BSaRhgzIVPccdkVxS3kR3Fqk/QpgFZkdJzODIL1HXt0kEoNEbI1XzaSvAL0yVdrFWrJXdHk03KVrdIFyBncuCpBMAMX+UIGnzhXI3RgH0yaUJkP/ZNOxXRiVTziBM6DeBlZEgPHeNvZGeMask1ojOJIIlSUAVuTH8RKsNke9alSY9tkfr5Yv1yun99s/tFVr5rr3q5m32hV7rfqb9SrZ8VsvfSyWi00KvlapURioC0u11ojValn6u18vZ0uNphhyHbHobCb4r+wLLwqnTZ32U7uT/70J5Ppgr2b3FbMKN2lNMElXIPdRbzuCNWmGJPA9V4AMykCAhMAcDWhVkk5AaswBALW6UtEC4r4EVKPr1FVPEJNNhu3BWv8S+4nFwGwj/LDHvsSlfuexu+ogG9J+ajQN8pQCuCzg/tOu/J7v/mNL795q8LmaALRM4WbyfpVZ/z8vPPRp59dXHUmJDpjX9KeDaJHMRpGF/U6CEAUanzqzlH1X/+9X/sLX79/WMuWCCQ0vDFL9MZ4tpjOlvDAYIKcIcZ+eDMYdfrj3mjKgndvvBiMFyzIoO7jSZSgQhCr2gDDoAKaQZuzSdpNXn4FOlCll4ABpVF7tTm1DWKgARD7uwcOE0Hyg057TYgHxOJbNOt4XrMK33iCHnHFbrhkppFAg8BeMoZmCU2gbYLhE2UjyB4SwWb3AZ61EVvzGZuUoSAk/CzRKqId9ULcUZ5YAEgLILhM5pIRnqTplrNdJoTN0SDhQkUQXyigkMzn6+5qc9Nf/6w/reanJ5XsrWr+sFI+rFaPi4Wj6qJZKdYK+QaZrbOjTPYlKVV4ljS3vLEwDY1zbGYq383X2rmbq4lgsp+OLD6i074FhBQG/hcU8UmP+RVvQZuyRDJU4QIWvEvxKLMvKQK9yPgt7G2LcTFRmZKfXOcKd3znbrzFgxSOp4ImEglDb4gN0elmyShFEWuwZLzZTjRne9FoXNltD+ql73393bNGfnj1fLydN8rFRrP6Vjn/wdvlxcNbww/bN6P5oxf9nz+6/PRFtz9eYEzRclRuv2yHiZv+qRen8ZH87nff/71vv3G3xRklGXxp7HRi65HLTeBRbNJLc08RpYZ5tyDZ33w2Xmy648WLy95Vd3zdm553Jtf9yWi6nqw2BF1CHGgCO2J96LIqEI3zJxQkf2y1aFpgcQPKQlhxk2mEGWF/NQYbA49HvB3P8+H3ZDjqRWAQWmckia5vOV8OmQ88/dG0/GZbch3j2Sy0jYmNuOoVRqSaDj8OMpvlXBHgH5fABtIAwc6ewTxUjJTHKWULEXHDbWSYKh//SXOJcIL+CSJam2N0uVqij0RQjGTF9L/XmMiRgu5erDr67a6zhRnm2cE4mxqUcjmOQ22USgelUrtSahbzrXL+uFk+rJVr+XKFpKQEBabYqW+wCDzM3n7Gw+Bj0AlU9sDhg9+BayFP8+bQjc5b2vHxQ7D5snt2hmvWx//45k1RFCCJhwQfj0tF+zp8IL7aoEAP+WAhOYEP/4dYSx6ImkG4OytixyAgpEg0Gg+Jy6CGvRDSwfFFd9DU09v3HnDQ1fTR8wXbMtiUtyA5QGpZJ5yX7Mml9MFx+b03Wr/51Tvj/lvPzvt/+osnf/rRq+c3i8naCAA6RXd4SRB8pHd3Dytff/M4QyLj0WSVJ/ksx1GxdhuuwXyRaTfmKVAIN7DwudhUJ9t1GUzDGF9/o4n0J50wqGY/A8cmEtvfH41vBmPmh+5w3hmu+qN1b7RgxpiRBYrS0IHgdvpzThY8AhVCxoEfjAoegqoZeLwoIr8ETHmj5/FsgBffKJXFWqfEzS2ojLwm7h0lZA2djWzHOIXYxg774jzcTuc7QqMX68x0mZ6tUp3x9mWfvWtEM+YYOkkp4V6iCZDZiiroGzyRbpCcbsUSPAA6iBPjuHY4g3Ag4uFsLxxHfKFxzE62d7BOjHIFV6DlwdSoS6yYUYDOsryEwTzlfKhCoVZtluuHSByaEBtuNCaBROoaI56dmrNtprfLvmLBYIplje5FSml8R8S0siGnXO5j+wI7GVtACbdfUZp0FXQUoCMgJeatfYGEPpnUeHTvQYtaop4Aum+vSVsW2OMiuezjgbXkQ/S9/m0N/N9PofviXJEXfCopKVu5a0SsB4GpO8SDfviS+vd10cV9v7i4PWtW6+S1nHKMWonEHohbHNyj2a7OgXH9AeL8oFFq1HNnR/Xc4ro8/PRf+ebB73341V++Wv7xxzc/f9a7HhLhYn9wD0Jupcz217/y5mmjPBxwJAkrSjiOR8XCCIQXOSiCzX3QQTpDOm8jXrNk5mQfN9FbNVQB8K5kh5ZBcZz2mEau6hSZc/gllIDvnXkHUxfLrDec4R6/Gi7P+7MXN5PzzpjDDyuFJaPkP+E5nCIBvAmfx4ftdK5ajSYmBSOwoRibihYZLz+ZllA5IDJ0MAidKwZRm+Yju1xyhCOb36mT3HIcurWD+RZzPIwQEMcmVXEPAr8taYkyntdbrJdJ0MLBw3A/zbufDL0mRwwce9slMbws9MtJM4tm3jw9Pl5M5/1ez0VgBkg4kfzrMgPCH02FSoieAHgCBiQJFlMgOKNi+uM/8nTQ+XS8m2AEl/rlMkg9LNdbxXKTg+ML5arpRzNlwvBIK+chf3TdGVjn63o5GSx7XY65XK70wga1fEEhQXxBaPu5UZeoU5S71+AQCkbZkOtRbk+rfBebfEj2UqA0m5Be0O7+Ma/6nEUl9ISi46ZPcQ+64kEp2Cq8CGMnlQpNn1AlQAK+tu0olJB7PBcd9OHooyuYX9x2aaJRypGMCROYdN3zqc7qabl4fHy0Xmw7l5e1Uq5BAsxiYTBOH9Sa5GnlYPKzduXNO3e//v7bn15Of/7o1aMXl5eDSXc8n87mb5w2vvXeHWZS4vlmbrTmj2S9LDNOoHx2ALL9j0CeyEhLHjL2kuMTJO0GL4NJ3CBrrE+WYDGCjPUcqVmDFw5sJV0IG0NYh8zX0pnTu9svxf4VzLU5Casmi+vhcDp9mUp15qvZYDofcBQ0XMRLytcUpjOQ6WzJuaaqK1I/ch2PKoRgdAPGNWxAUsEsGQfhaphBnkGxkU9g20Kl2jhoHeE0X/S6FUg8m2ke1O7ff6Pb6d90R9ss7F0ejNmjkR5POXAIznMVmKN9tTgR36btBfzkGCX7G3QMRlhIrTSaB6PUcH1zA10hIxD4gSzliqTGyIlZdU8fncQNwOzCaoIp1/Vuq+Txj8KyFmHDs1V/Our3uy/hTfOoEJRWrsMGJIopleoFFm4L+DlwwOJVImSTfIy1dIqD0nA9GQ3qi6rRKV2qABnSsP/puY1JaXAh+rbTKDwgmfOdl11NNBYlWULDr4ltT99RlRX62/HFC+r0t9d9g8qDDeM+ro895UeZ5IHkq3U7eNnZB2nUXkRfuCYP2IIr/Ip6QG5D0RJvkIXhACx45/R0QSru9DBHH5bqYNRHOnVG7BipTEZDYhj7rNSTOnwzwRN3Z5oqljiOqPzGQeXwK7e+dLdy058N5pvecFRIsRPl1dWqTjvM3XQPhLGjCZ0XtJH/L5deEZbMzGvUMZlZyXkPqdsN/kwYiIQxsMqUxdFFeizbAwdcLRiMzgE4dbxWZG8UPc5U09nq0fY2Sa92p2TJX63ZYcJ23hV7egeDcQfXkz+Xne7kqruackYWp7g4oYhS0JzduBLgSfFs7y0UOIdogX6Bp4fVXPaWrdESd0XOCHP/LgeEuhuJ2atULCrUywepdIVMKCUy9Rcr5hLNbcbsPySMaMc2enImks1ZepCmIFwjczKFYgnEoNZT5fV1p3PTwzaaTkgooX0B0JTrfpf+PZUL2mbPOhFmqDsgioYJtMD3lM2vWfyis+hiwU88DnmKS0It1wsO95YmBBbAhDhiBQ5EOBuXSJ3NWUuYD7hIMdQYXfr01i2Ndg1ziQcdixfkzgAksnhpycT/6Cp3vMU/zJpk51fwCBupWeIDCP77H74kQkW6t3jnlXyxTbvLM1/oPFRi77kW917X5s/kAh88R48BFlecCqxUtkHS8YnEYBTwriVjXuIKhRkoJzQ/4HhAsmtnSZRPsmJHHvVCf/nheFwrF7fTUVn/eYYdrEcHTTJjHrYqJK0HshypAqygbJIgcAgd6ni/16fter0BXDgFDrTQpqJGAsImdgJgi18FBVnGUIjCDKyPEiJfLmZL5vtnb9SWPhVyqE/ygxOnfYI+gTDCDxnITAD9QW3OGMwV8FmAGp4GdibbpE1qN0/BnLPiRmS7HQ2GXQ4s7c6v+/Pz3uwCQYlWlS2zAGp2DOYlTogpcKRkCl8LAOMQxnyhhoKBMgK7MueTK9oVWuYNDoiEijzdrlZj5woLohg3+TJyHhpFn5yjFZHw1rPflfnTyVQzjWRT6vepRrNufzdo4WnshCAo5ic2ueKeB33BBcRIAwxNYd2+DIwJltyJs/kCZIBNlDgmFiDDc66b8aIfbAtEkVI14hbzQ9AnDEC5IGmgk7ykkPiniKWA7zAy63HQkNKUf+oe9CY6FIQZyg9PxiNRqXaS96kA7IBdGH21QunzUW7ZRHzuK0quUX1Sc3KVGignAvelfOYLDkgqshF7EvVZLIp6KToZ8194ZamaQTMaRu+kqCpmCEwAE6pQKzYpRz5fa1TRVdYef8sJaygAcIHhs8DAvqCfpLPTCfbXdowL00k2nSbsfJW6nJHJXlXQOJM0GSOJqifzMNGIECSyLcfZcWRdAeDAHzCQqzjPJlyiDdFloWN2rrspBKmTKaraEhtsHiX0InTmSgmNy/CESjFNaDmqC/zAFKEqT8g7aU7sGwYuBp2+Eg6wYOHC2QB/C38cCEA622qd87zc1QI+sBy208Ju0Vyv7+qsIdX4Ap172B0OO6P+De/TbnfW6S/Zzz6ebRbUWKoBAg8fypLvgRBJp7JsroRcJrW0Gx/pjQK4AKmRshMUMDyuQpcGwzjrSiWKBtcioKy8pj3qlKIMfGzwNhC8yTUAC+FgIWEYY1Ij7MJYliIBKTA0UQoBaLl8q5E6bB2PUK7QKkmCXij0hoPeYIBsQ6ZrJWMv0BNs47CP+UIIRfxiOiDU2tXmoGt5TAKEQCEVMSuH8R9J5r0gNbtPGfUHr4htn3EvC0wJV/PVmTiRTxTjAmW0yD2pgcGGZ5BLBoSEQQNh+hR0bsloPz7jQXlIuttfCfayDP/3pb2U9GN/hba9a9tUHaUI3lbioGbSioocYILYa+SgqXAMIXLTbTr0bbGcV+tY/7v5pGPoSmqH2rpZzpq1KnVFGvsNdELuedRXPZjrNeGuQ4y/1Za9PrMZmj1tcaQC9I1KQ50c3TNXiJqaxeNJaCimRwU2REBXnXSi09I+0oTZiUAtVnY8nV3GoOOsjVYr+KKY+tm/skbRYB9WBR9FPlMqspUkR9/Yzs1WMBkcQaf09WT5dCFLBp10qazBoDrFFzgENYugtAqQQCQLe+5ygtB2UX6wPNPUXmI/btiSMVlMhyjPo/5g4iLgGHfTBr9TfzwZTpdjchVCg0ZCZt3uEt2HuD1+xzU5fAAoJ8RG51yqxWsEUTrvSgmSSIJ6xDYR8jA0Z9dMpygYMDZIBSggqdlgcWqFwgko0fSYLhDorrDBHmjxjQaTFFpQvcIxeZtGq8XZAP3xaDAaoQGxpExkzoS9xSH7MWpcopaqjW44Oz1G4Z/NFpwvT3/7g76mdS532G4zq5+/ejGfILLYF01OpISk+GCgahRSqcSVIC4mEepmwNSd8IOEF1QaugoMkDin9tTPTQkU1Go1yDM8Ki3Ifa+JPH5Tya+IPa4EwcdTyBocxgA1Go0qVHX4SS/JIkBxLcjQdlbK5jQgq1brbMHR/6gkyi4WM55A/0DrRapTfjSesp0IV8VqPEb6wqZ0erYkdhytiWTfeDnVOD1ly9FQjUkDmHXniwXWc8HJXHnMPUPagTVbS9akCzfHdgwygRHrt7rkeAFWwBHAhTn8qiJRKHKKL4xEu96ercpzlZ0iAp3ctZiQGVLds5kQhY3C2Woh26zmqyVUpjCpXZPihCMmBbLbG9e25ai6+VW6MPTsB8xHKmJ+KKCtYbeipuOBqXJODFkinR0NayF5Fmdebyrb3RGTJVyBcEbVWXq0+qA36XRG1x02cQxGw8lkvBrP0r1xejxfY95yojQSB5mH3YzObrJn6tx6fBZfkEX81xLGaEQvA8oSN/Y322eAs5QFULjP3l/+Net13F80qlQh4VB2x/6ppvpkytTQQAqHQa6mHASSG6LfMsVWE+qs1BrszkQJAkkw5HK9Yn+l+UFWM3Ilst9wMB5PkE/zGZzVOGizZ40pOFUoHh4e14+PbvrXlEXTSh+dHlP1ayqFruiiVB+Sy7mXf/wMRc2ZwZEEVSLbXLdmuoD75HzeLMf4mJ6SC/Y76IAbr198DbmfXEpuwyWSm9o1pAdDwf2sEib5uXhQeoQ57UcaKd4+ahO6QeMkGkPOm18gkyMeHd5AEiOtJ5Ppq1fnFcRsiQNzwIWzMXKIuaFUzC0HvdH580pmBx9VkDYQIsoKcgsIYxVnshyhjL6Zz23qyGXOI9ELyePwHWkD10TNhhkuFvnCCJTsTN900lCFGBJ12V1JnvsB34RDgAh50dCEeXnLmV5bmXZcPuADGtZCKOQgd2YWmhFxxAWkOI1uVy1nXe1nsV//qvl14AmmHyU1+S5jIcqDG7S1i1zdcRheuQLbQYy0y+GSckWGHeJwhalTo5vwED4B/tDjgyygAmgZdQUVeYEkWUzGi35/2OuPB/1p76Z/w3F2o0WPpVqi4tKk8wForHGoKvEcf/AN4ya7ApwCabP/m0E7HXAoE3Mcg9cYN0MWJwbgosJ/AGjAIFGZMMhwOMK0L+WLB+12oVgeEaKDIiSkka1Kx3gaXJdYd8N8Z9mFEH25P5e6f1LfLcfPXp4/etl9dgGhb2aYKRjohpiCZfTM/GzO9LBAB8sxyyvBY8YSl+Z0gHolemY2qZ9pN15comdaksEcXKO4S9kiPh4VljIJD+qo4XZQ/WtS93kv8uYl5wkegOuR9MxjOmScggD9Dh8Gn0AI160+MBbwTKHHq1gsF5H0RQAKFAKKdBbxyV4EKjw8bNMZsk/evnsbvkkO9z45acNLMBZPVBjw0dHi5GR8db4csKBOnlfdkWbMVjdlmzVpODhwas2CACYyyjbDYC0YWGDFTrar9vEpEV3DwWA5HpMsXCp3QGInGXHMY0wJhkbSB+CWzJlOsJK92pXDdAJg22F+tePACPYHQmbo1pahKoemiIEvNB6gGDpfLbLMuauXUpUcFjNrDhvmhzJcTep8vpTypQpHJOGpQVeHWeehvZJ9dmBYJKuwuHSIkot3c7uh7uOcKfKFKZT+M2uV5Vai2OhZ+GGY90htUN6uW9vNXZ0NjmjD2tWM0+tGnaurly/P+6PFZJbqj1dXXRazx/3pkvgOh+Wa5lzXKENxrwnWOsFD+UatjpCChIFhUP7m7Oh40McBMWXsLP86P6zVo3hkSjvDPp2BwT2/MXFIylE1t8ezNLxenF9dg10g1W4cNqqlz+fd+WSIKtxsNe7lPVIVDGFsIAUwYCGtGbmkpnM4ikkip/CO+BFGDOci3qOVBK0gAhIVGQw8yF4kcgWK5SI4pHBSBjwLtSACLvv5Z17iFOpOZLwwxJyzOI2joPATBqXx7dJc8iRMpeFms4UwpCxx2gh6xB1ylm80SqfYW02VjDnYmgRjbMZZIi1oBVlOJXA7JES0BE/zgNRTrdRr7Gzg7M3Uolg8u32L832y69lixAG2nXWvwwRtz8iNhLgt4FBGmWZrIc3k2KVN9Ai6DkEJR8XS4e1brbt3rx49nveucGUAEP4QYAyJsfM/EfByAnOmxAV50TX/xa8IgGGQGOFqUjTqOe+uawhq1zws7jKHwGdeE7KhN+u6I68grmz83Uh/mDLNWXFmf2DVh1MkMHzwspBxBNMiV0RqOKvA49JfbsEkaxPyQ8EED7kiVkSsTRC9T/4T1CS0JvKM4Dko4bJH76M/sASaYAhARkOQR6rcWJdP10cP5++uxljYrJkhwSez5XW3e3XTuXh19eqy02cnJPt8B+MJW4Y5nSaOUcVmR59EkjFLIU8Z6GDQRxk6bp82s2UCMlntxlVaLFVZJB6Px2SoaDSqGs1M8ZUq0YpjTroucngqKwhM98UFa+fT6fnlJeL97PTW0UELu4I1u1a7HbMkE2W2XMZvjL3u1urFrLiq1WgbuQqz4Q7DfkbnFQmgH6IEZ9KmFMpYeWHnqGxBebBIWPzeTn4kOH5NAH6qFfDu0F5zgIhXTeC21hRMpJrODzhOMOAFKHhiiMsfOg5LZAvON4jSLJNwySkVIY0sx+k156yrVBrjid05U4/9JNhs0Wg0bjdxeHAQ1oKu3nS6VA3bUBMBaGEu69gtF4v45sab4cM33iguofBUpVWtcwZbPjfqdSbD3mo+63Vu2MGcmpuuYKZVzelrNWRIu1hlRub76ekRUqZ20Mo7y6FGmw2NaVH6DNC5DAB4lBswk+MFZMhCb3tDMEBEr3/HM8mEG0BlGgTICj/pPmQGYhS91DqJ4eKAd2zJ3UibWt0J2obOMaDRiEgwUy5wXAve/F05r9sKsctFzGgilJj3PWUUmUE8MppVZkUFqeyM4/CYZthiy4SLtcAkyOSAjclWEdxK/KUyNY6ESZNafT9IRkKEUiCTeTOL/b2CDOh3Kb09vLt6l1CmxXg1my/nuJhmg/GUQMAhy3Y3158+uRyPQbzpgIZTE2Bx9rxdYYPYNtVstSar+aDfQyLAobjrUYdYOmAVj/WN4nLHmU54opA3m+W61T6oNmrMkavBEMGHGxp7hcFhyyClcuVqvYWkYokDHwarCRPaQnfCv0eaKeBC5bwatZp7lBPc8Q7MBb2GOp/iS+NaGwscJqQqDrlAEbAm2gWE4o1nxCPI5YLYto6ge7GHahyFWZPG+kcEex93AUQC9SvOyMYV3hsV4Uq50WiieU7GY3U91Nk06uiCtR7Yo1ll7iMohcPEOZnEnRbMHUxrrYNWvV5ndoPQ6SEebDyN9Rq77/B3pxAn9IuZt1E/4rxlUuYUN8t7Z0doqKPxuHF4cO+NO8ynWASMwTyjmHVQDHxWqUmArJKy44mZ3ANrGULuFz/4p7+cDFJLFFMARw81YISfekt4d0JgCBJ8+7wCpBQGSsEeQfoCef9PSRNACp1J6QHliwnpjqcTWLokxq+ANT56pF56IqT5kw3pAgXhDkSmRzKSZseDGZkFMGAyZXbuYlKXcCtB8xKB+xi1HygO33AVIYR1DU3CEqw5sDChUza2m5BIVmUpbIlymq0npo3DF4w5QTcDo8YouYZQyK9yNbKGrg42k9uLMYGw19fXm/7z9984ufve91O56ng0vOlc4anE0mMRbDaeD3rDybJPxpVSg80AuKkY2nK2NU5ZiOH4IB/c9UXEDjnlXk+GJ6enYHyFZYFHIZtp12oQH194HNcdQRi3sW/Z+YLIsA+TWrUKHK+3AxiEERJDAfHjMiFZqdAF4tSbvNBwBKlJlIQS2oVKDzJdSSTmAq2aMC5DYP/TMncSVFqCIjweVM93Jxemep8FsRAxJ7Ih62mUcFhcARyA3Gg1wR/1IqBgAAgKOmuenpEkDNmvc3K9rVdrmgr0ltQam3WtVGoeH8H0zHFQJ5QH4cI07QN8QeXxiFyXHJsCegj7mUC0wBGlc8Smh+nk6KBBnr4+ljR6RbHA+kD7oJXJEPZQKnsCkCm9gE6VLMppw1HoGawCuxKkCP+WstujWpEsN51BN6Y6wEX3NULohsI7fgcUaJ+fUqZs4RCD/iFY4cEsg5ptHXsceE2yDwA6XeyByvQM9PkRj9ETHgg4J9BGxshkiD/oZS6YU0NdZEZjaL5r/SNbVD1gA8xrWII5QV+8iwoUipU7WJvlX+cUDYskfICuO7hs3964gkz4ONoUHFLmuDGoOZ2reCilJgSuWpZ+2YzDqWGL9ejy4md/+st/RoqTXzx9cY7m886Xv/27f/5/Xj19iwGvVlO8yvoOdhxROcOrgcKD4+m6w17bETji+HjYAy5ncY34WY7XmHMWiOyaxQ88nXUfP+mj39caLQDBpApDL6cTiJtxzjdMDP17d984OjlCkyKfCg6Rg2YDbazbHRJ2TqgdgENf0AjG4KAXQcN0TFGFeABU/ACetA6Zcj8oXNSgT4IzVI6YGBK/R2LniUWLhZCiDEhxzndO2UFnDXSXRh36gl7hK3dhqqcUq/U6Qa8Yu/gIoF1sAX0z5A7YbABKp9ur1dyzCW0cHh6Np+P+YIBDF4UeEu8To4Kch4dKpdohQof1Dx0XABb0Mi10er0+hw3udpNx/+riiuYuL67RGQ4a5Qe3Tw8OmHyKx6dnTC8gl8xdgAUvjFka2eMN22wML2NcOU4XlTQxWjDl1l/72jdX0+V/9p/8bRzT+j7kbWDnF2AoUGAbpLeKs2DR1OF5WUN4qN9wFd08zdGMQdUALmYKQaxAoqCFE2GSqKdaKQFcCRypwnvCIFGKS2BRU959rT5JT2F74j7Q6IYT9rtCyZA7nliMUliCfTsASVUZYxp+wGwwVyczAbNfCUkgy2BHgCTVJDqPDynL+oDGyy7LvmCSUGexpDGY0sTbyA8VLAf6sOxf/PQf/Lf/8L/5e0+ePB8Q4IrRl8k9/vjjX/7gD/7cX3t7mwXzVUcnwaUa1d1JO6E9fhtKigY6xhM0Hi5xbZorczHodwE1oMXsZTf6+QUH4g05cobQTyYddnANcFUtltMe3pAt69XLbOaf/OSHNOB6Tj7/9oN7dw+ao8UUYmMfJ+iGxhEN6bPbZ5AykBcnkIDkqwIKcfNvjxI7qZjiRY2UhCKCU4AEXQplV1qX+oEOyFWS4L3D7AhJ7088cSmyd3HwGbvsWXKXDViuQjunPaCMmGK1AuQctdvU2+31+SMYgL5Cc1UMmUr1/Orq8vqaGenunTtfevddBDY72QDHydEhnhnGg2qETDUkbb2mJJ67TqenVNrtbi6uIASwDl0x7dCdZqMCBEDyW/fuVovZs+PWgRzaYKqp40nWBSMjBqR4kwEAioKcw0bJO7NY/OJnP/4v/85/cv78OfvH0B24qDIEDKQ1BIApZvkpLfoHSVPEX0BY7AMqeAB4qTXJOwnh+i4PcA1ZA7V5kpXalAyVIMN3/kSEn3yJhy0WN3hYHsN61pK2Op0W8QjGVvQFvYKL6AzY2OiZDDbhB+gCbKAuQvcABxkVMeO5YhluIBYE8SDlwEWOhg5iXtN95oRCaccf521MBv/sH/zxf/2f/8Pn55f6cxALYIVFyVz2/W98+2/92//n1u13GLOQSDrLO90GPgzClyPyGleTcTkDg1UUcpzeaEeL7s3lYNAdDHvdXgeX/5TT90ZjIspJrkneNbY4zTL5xS6PHxeQaSwZJ5si+BFvMYlYSOeAmKjVG+mTM86QoR/QtW2qzghqe+BlP0OGBUJEKdeT24FNtBuK8AQo5Z/TfD5bKhcPDg7QZJg9qAVUYu3W65xiX2RnNBUwvdAG/E1NgBhIM+keHLZRbG5ubqolTpPF7UbyxilLV1i/J8dHNHJxedXHpJotmBCQ95IXXnI+lquzk8MH9+4g2vADQrGEWzHZ0XX0SOxmfJq4hvApzCdzpkJmiOsbkgvvqITuQwIE46/m0xZ7JvDEp3Mn6EPECRUyzWqZDrdaLeaEGmeQ18lbY0yYPgy9s7gQlo8//uj/8x/9v5m59bwHJQA1tWjB9JoBApagUioP+Q51ClsuCR7oRwYAC1+8FEfOFHhhITMzG4oRiYLnGHOAXT6hHR1JYi/EKa36SuqlQStOuJLAeu0xWIJqQQtfUa7lMeqL+nlKpvFaoFNTgqkgDw8wLTAnEAVUKRd0QOVzfAlvBda45oM05maTfHc0/Ef/6I/+8B/8qNshFBX7lqVFugaPA59MqVb5V/6X/9af/5f+FuF8DjYZFe8xuHjnO13bv+yvnJB88O74fYrJMGYD1SQ5guA/F3dHw+HNzfVwPET4sROVxMo4S1Bi0GJ8hs0MBBjN1iQwhDNLlSoLYSf2ItEhQ8okPyktZqJlQQLAQBAzg6oPHiG7wDWIoFpvoMsowtBzCO9CEqIMQoyxzlL2ZcQZ3aUWpjN4jPT1VGckFMrKbAZJtVoHnFWOaEcr+vDrX717dqriv1qcX14xN+EKePr85XA4C9+O8zKzMsYr6Gy3WmeHB6wTlatlgh0IyYJuKH8EETcaR+0mMhyJ1UEPwnM/n0GZ56/OESaVWhW9M6+XI31xdQHK5zDXaLbG4EEVW5IaYHR8dABscf7AoCfHh4cHdSaNRh028XST5kGbYbJK/yd/+E//q//i75LvkegGzEjWYkqE6hjjrHcySWoI4aPAQMtAWlrnC7JEGIrahE79LrqVp5QU5LzkAxet+Cb3MP1oTkkFCf0kpMC44lENLgpQI7hzWwC1BJVD9NgQ+jRELN5FbGxnbAZCzTGLQ2dcSTphf6km+oAxDH+5IOOc4NROWGsWeVZDVrlCgzmhuwlFCifMH/7pD37w44+JMoFUeBHgj4rOTMEw0LUqhezXvvLlf/1//+8Wz76EsLQxWwwC9/v/5CuYPimacEKUigvxJPdlDAcURdHcdYUyz3suK7oUFuHUk59I9AADoFZhF2tPszyqWelziYgRNvYmUCGAXcRWoYV/wZzlAt7VWkU1sYyuQLx1CZcX5hOGC9B1mYO0Wayvxa42OAQr+eT4lJVtzBEgovqFK/2wjXiGKzo3NzyLjxM+gb6YOojcaFSq1xcXTLDtZhUymCJx792FMBr1OiIdEfzG/bvD8eDl+WVsYZ9lClVmG8TV3ZMTtNjz85fYeTVFF+SHg7xYPzntZbOsqZyenpwdNIlqbB8fPX/+ghXG2Xp11K4Di+5N78XiRaPaxOM8GU9Hw0GmWlmsh9tFZjmeP734FGo+PoKtqmdnp/VGbfv8EqokUuhqtJxkyi8HI9buABUeRbQ/AvmZTcruP8IFmaqQVDmTxfCXjP3HsKQ/6Z0/NRf9PSJVDCCTDWvFyxj7zoE8n7FAxf09TVsa7KhloWRAZFboySmUlhpQaOOFKw/EQcI0zrKBpI/spIRKK+27lImPgsqYitTYnHO0p5VkTmbo0fSPRWF8iiRoUCUA7FA0Uo6pgfkQ/DC984dC8smnT9hPE6p8sKrjUTWkIhytrC1uuk/7n/3JrdM3XRSXlCVaX/Ejvv2P34K2AzRRkKIBPPqy/+1YvGRVqGeckVEpVbeNg9SJZWjCYGlE5GTUj8yFIzAOiSIVAjQKJMYv5KgIcWJdIWMQDyyB8gNBagpoqA9nsnFPeGw83gynG7ozJVptiL8G7TPRzOEvVs8JzZviW9RrzcuFNwNhsFgr7YNDEAMzzKY4NMvdTgdUMjdcLa7u373z4iWEaNwtoQ4EPGFDNRtN5m+mYrzwdLXfvWHJHlWVGaPdbABd3P/I+PF08taDO7dPT+pV1SS0eRz9B80mXbh1fAIO4d+zs1uMBDvk7uktJBTo1HbqEts/GnzpS64nzOY3vX5nMCR5dZ7GV5tavdXDG41U6c1Kk82r/pw5AV0U5VIy2qarjfbBMtPtjxgxsg+jDJqDAnF0cPhn2TkBTkgTplIhxI0ANmwdXY5wC7RBFQBbeoOIAT3kJ2WKt5D2mru0owcMvPANYPoQtMx8Ata4JDuoB9EoQksq4IIflOc7BZyBJRK8Sa+nAioOjdc6Qt5D9/Ql0rBQqf2BPHDj2gZKM1TAZZx+VE0tqBZT1mDHJjcEw7BBv3czmZF/EKFneKwTDsOhS/bHc9ehmCIRuZz1shqkmH4ZNf2Mntrb/4lXsEfQ9RdEn4z3f1RWmFnbr15IvwAKT7Lyh683X6lXDxARQjG0SLwQIfSFpeCL7qrqWBWiC50D25NlVzTrIjmQYpmHvWWLJZDjJpiAKchaQbQZKGU+GXFQbToDLRENgpgfE3a3WUNJh4eHTBStgyohIzT+6ScfMXfWavWDwxZSEQUOjzXLeIvZFH3mwZsPDw9b3W4HW/zFy3NiUpKZCx30/Xffhn8WC/c0Foo1OoqDlmGwPn/UqDVx6uCnYAIkTpC9QpNRq9FkxYyBaH8X86QZQKVh8MPB0Mktg2pLIhOOk22hSvZ6g7DXC6hfTE2PHn9GvmtGdOv23Z9/9Mmry+vJnIR+q9kC/ofSiuZek8bSR0dH2OuwNwonrgmnfkbJkoInQ285Q5Hcx3QV6V/IbENB2qIjEe5WdZbQ/86kgfsRxXGvNckTUK34k0JEq4q/lYJno25oWnqGYsEztkyCHK7t0Q6a+W7vqAJHrV2lDz4XbIZgd2U7EXXmnuM+FUtDwId2UT75aos7gjT5EfTh8yhFrIHpk+Im+bmYfdCkjHBjWcnYZEatMSkQon0qw2yuFIjkqrfwU/Pw5DpdPFZXowO+YlyOzWawRrmiiRK952tcjAHzZrPeSK7GA1/8el3y9d2kpPUwQIbFm8+CemtFF3xdC8BS/mRZk0L2Vht12sGNyBAMCgfQTpxASb6HK1AFBQoK95JgAiTfilgDlHooHr2ZHqIr8xAD5HBklgzIKke71+6CS4+HI1as0NLbzRa+ToTxot54+ew5xsSdW7chAyD68599dH756v79+yTGGLFAvlqz6oHHE0cEGjqWGXOckmjH7lVms+VBq3l6eHBy2GalCApkomKCu+lc41S+7s6Zux48uF9kgxcHwRu84IFttIvfn5haDGW0EjQo4i+4BScTSHd23H73rQedTuejTz5lHeXdh29++YP3r7vDP/iTnwwG8wzeLChSOUcUSpauVauonqzbczb6FuMLhQFosEoCMQC3IAYim6SMKeTFCqjY2JBDhckhotdMpe9CFV4E9gmQ2wdzIvGvoAAx1SJ/6RyNqvYkckvqCsyrA8X/kGIAOsEm8PEVaBfr2qN8QuzJHWuEEKBj5xznDnrKFb1N1KFCZ1kokZaN/+cBHoUnpJ8Q7EbpRdlsiigGKoCJfMVEITFK0PQW+wGva5Noxv4sc3XdrT35iSuclbNdmix26ELQmImyUuv5ZjraLqAWRDDBS+U0jjveDWvlPMBkxNKywLDnds1mkrE6wITmGaI9jeuv78VnXAnBgk8fTRGxA+5RrxtNAlEbtUZ9NJkweEfB9OyynHE1WELglOohPWQWbaPMALjrVx3sXBZ0iQCEYVl7mkB64H65xE3ZbNSh6ZteDw3bCpFFm/XRQbtRrbHI/fOf/oKliqurDrYY4olVtW53QM3nl9eihNUZcg4zxSxXx0dHne71QesOXummWhDBUkz3+cFwdoMWhTKXy3b6Q9w1xPefHB4ft1uoV3hU6cjF9RWxT7iN67UahsrV/GY+nzCu05PTo+MT/lCfkHmsqlxdXRkDkSGqYtaot8ql6i5Tfve9r6GM9fq9F69ezRbYM222zeCexobCySGJYOZ5JiEZkmvM6WAaycByPdOIhtiSgw0xqwl4hItZ0UOhQ7EBFsZhjbZrtlYyWKKzCQYmgwQagrHQTAh42NWd0BmYvvkCrhC9qkzMeEGciJc9JyC6I2e5DMB/ZBmVSyRBMEEFsD34UcY5w8sB0rfUQBnpBukvzcR/rqPUyANUweNBbrwldAevMXVwK2x66Dv8f2y9wXJQUDJaPoI6qQN3CMZClijUbGWyys1vJu3PX1QKv384Pi/fejNTOE4Vmip4y+vt5HI7G7FjIUN221yJrZR0zM7nqtvKUap6nCm3UqU6YRo47+wyI7UbDiHaixnTy695I4jdnw7r9Q0/9z/S3/yt74KHZrOJMo1Kg/xGn4bCURUYP75hNzzD+yILt2MGaUmYB2Yro+MRhN/VzbXr6sUKvgvcM0xphpAzIZhMl3lji3WL+MITSb1XVzfUc3RwcHR0yEX+qAH7FUnMFxJMd65v3nv3HTbY4HUhHAhVEvkf+xjmRONKsMfH/ITdxuMhDAZs0ElYLKNaiA3Tv1mvvPf228h2EvDQa0bDBIEvBnULO4j5hJ6gDIJeFBUIheVekETcEZzZ7XVFYezPoHKmCNZIYPtGvQJPD5jpSGg1GLHg0mdhabHh6PNBf9S56dIuHQDOLNtAnAQvIVjQsPjDJYVGjI2FXgYPEJ1CE6iFOLRBDN85EIpgYISGYfauyShzIVVEEDMDDktPGYqJgskPNiBIDyXKKQIBgJlBS6HIMgr/wK0bBaiA7ui3CCIPocgNiZ65BLIJARJLATwhdUjnoSJRCA6BbjmekdrDYS8qpRkeoz4eJ6O4biKJjzUAXZwkCOo9fXXJlIf7jnFyly6g9FexHFmyZZ2ycUys53TWP6ltv3pW/eCN46M7Z7nmabZ2APeuyRV284zYlHI5hyAuVpoc6E3kRYbApA27lA1AIlRpVz3ItE7S9UNNCLY4GLGns9h+/Ereh+gPIqcTyUsO+eeuCJPcye1bEAQigc1mw+nkoHWAe7HZKkEcOCKP2oe9YZfAOsLv0IY7Nx1IHHolzykxA3h1OB2EdSPomBfZnqBX6ICOoIHgxUfHxMAldAH5PR6PkLI4CvBgIvVbzQaSHbEKzuASKLdYrB2dENVUmS9c2Gq1GpAIpctHLsccHzY/ePdNXA6sDU+mQzQONCUWreBsIvY5KwRxu9qUBqMBdPz85bODWh0jmFEQPXl4dEQiKgQuDNdqtsCg1bKpO5eTpEcjlyBIebNL44OCmYEUR/ThoiUYCTsezsxkUPoIkii1musH97XbEOB4ktGbGDGAw3hgkkO167L2NiLpBH43UpukVnOCnUq6I1kpY42WRfd9LLQrO64FoERJ/lgK/EeZc8mCd/Q0NSgK7zZj7AdNWJh5h95ZynJ+o7Gf8ANaBDMGGxuIPWAC0X+KCofdyhItOor+xzCypVrwHbqPuxkNx4LLYiLhGZAAGhS1QeLwJUzsBnw23CDeQ+fiMbobswiPUz8V8+ETGR1c2gBaPrgV+DM6RgVLRsMDiyyNvIS1NY6PVe5ynMpcpgbTfv3pbFe8xH1O4cWMAPMh+/vZr1MrpY8Pa0ftBsNBjJEpmq0zR83DqtmHMoVGNdtqpxutdKmWgnmK7XSB/LhEbcnh+tiSxvnw9ZrqY8y/+hnX07/zN36P0bOYCry5hwmIOx6VhqC8Ybd70D7A18mUfdg+xAPT6/WQct1ej5G12wc4fKBpBArIg9GhtoODloE06VQHUYpEozRbpkxJs4WwWGNFxEG1hAIRqQcPAJvLy0u8LgT3NWrVd995G05glid8CxL67NFnLBXfv3cbpxMhbrr/6UO/C+02mw30AfUWjEYlLicoz69ubmrNJtYY7mq1vy26+IzAhsP2EajFTIfS2DZGLcxObJqBronOGPYHOK8oDLVxhT/WBxhgQhQQoXpvJt0kWCi2IDF7oIw4uJBxYNjTrME8DRKEFydbujKpg2sGY7DxiJjVTm94ddNDg0IyQvNKUGT9hp1ZZBVncuASr+gkLECRYAAWJZBD3g2nii3otXQ7LiQcJjUKEnMC+yedKPgeNjQ8oI1hBLSco2yMwGlagKp5Fk6JF3Qnb8g3fkOPUJcCLTGNsYcG8ApdJnz84OE/gkrUoKD/PIwNaHjSyJFc5vOL688vulC/LBwmOOhnI0xdIci+z8Na6wTtGuVCyCNDzQ+Ad1GfKahk2sSw5DewJxoRocAeIFO4rRcIOE2p3a6Szx5XC2SpOTtqHR0ekOIkX6/nG84JqZOHufaddIFIByRA8ABj/YLeXytBcSVhBbWi9F/6G/8CvluED/oPpO+66Yaz+kAyO83IdYNg5ujANCL/5ORQiYhOMpmzWa5er7aOD+FzvEt4HJEGO897WiFiy7XaxdU1wcv4Ip2VUmlUYagB+gDUOGGAM8g7PTm6desURzJGApMkaIY2kCIsrtQqNXbkMWBUdvIpMIOCmVsnRv+xfMYUPhlPoBDIrlJA9cpynKruV+giApmo5vrmimUQFnGPDg7VWMU4WXaAL4txJh6jLcBDQBEmL5zB2gVWBNENMCpZgoE39IDprL6A3ex+sUyt0UBjoTl0PJYSWWlT1/Xk3RUyET84eAX4PMt1OIrVSUKTUALZftQfDrrdPv7pbn9yftnvjtiDi2WvkqTTRLOAdgjzUnoqRA21CkaQpYiNRMUCQipRDFwT2yO2SLfIKDwowG3kQU/YD1A/qhEGNCYEXCEboJ2yJJdY3u48SjzbcgPswT8XLZWdMH5Y5wzEF2NHwcJIdLM8EJRLIFWFAwyQrKZJanhI8ZJ/ftV/ckmuK0UJa6WAgHt4K8AgsUCFSrtQaTLHCVvPjyMOHcWYLUaASGHgujMKD4GfsdpGvgFcj3jNY70BE9Ed2AzfKK/MtpjesKevnNm02B/HQgR+6vzBg+98+2u/+TvZWosJh9G8lvx0MHkl7JBc3n/PsdkMEwsJwUImWgpLWyj2DB281Fst4oUQDihHqBMItNGgb5xgLn3r7BjfC2H7kBFRS7ePDw7qdeIXCLfE20MUE973OrMG81al0h/21WwJ8CwW8M7jaYGRyJPBd0IvAG+iXqLbXF9fcvXOe+8A31vHh3Djrl6eTyYoCdAfRNDroOksCbUAY6xqoIdBOxALVIqiAt0QNDpmtW8yub4i2IHNsfmhQS4sXxbQgu7cuU15ljLgMcYLHVMUtYdDFeABVfPVGnMNn6mIRnkQ9gXaBStaK3lCJ1Tl+QkrIU6ZE0AeNyENagborExwBbmDftUot8Ar5Jo7Ojpd35JIMlmsCOYG1EhIgSPv8S+x2s380OkO2ac+I5IzxaYfMlWhSc9pjFYQ+lAIFc2XrDHYT5b+CXOfs/zv2jcBLxwlTiJAYj9omtMNJWvDMrGnOQaYnYLOD8hpMA0bGLLAXdQyPQ+JcoW/H5JG1LmwEOoWOMiw5YpEaoT8L5DwcD7/E/JR6XXVz/sKWVXgKhumEfn8AnTgNMxSBSAsYSzCbEzuOljI/0SDLsabVXq5YKc8lhiV0Lwv/MBIDzYGIKKANuRnLivmbXY/EpsMahRm1JEabVb9xejZYPz8+edDEiHtcg9/+NN/q9V+55vf2ZmqI+oUjfQmVi6YwuRw+VhdLu7k1D23O+J2iJIzKnPuEg9khFVLjA3h2DzeqOFbx905P7tzBrOdn18g6ubrzc2rc9CD7nDJSviD+8SPYYzCAEzSlXpDcU5y12L+wRsPGAt5mljVJCbvs48/e/ri2fd/+7fA6NPnL9qq3YUXrPum0geHTGut4UhvEvKYFBjI0ZOTY7DMEMqVKn0jsINIHrJwQsSkyGD+YcmMKAXAIof0+yCR3mIrA1LseladEdJmLdisXjz7HE5g4EfHx0wOjILRQ+uQNmWgJCYHUtEAd1mkyGK20egqN9DfdlHcYHODw2ylWM4gf6B3lkHYoK3m4ESHzDNo1BN3WIRgrwx0QvS9YY9IJErTermm35jjF0A5IWe0zjTLLj0Yo9cfYFV33Rw4ZzlpOi+PmSUIZdLnSGwsx+4ahEJX7Q6b9TXTWDiZsujBdIfb7YspAnWU1anZYrubwQ8YDzCDf8gzOIH1caZsxJ66OaY2zlZ1qlCrtBkiwo13p07pl6OwnA8kvaA+7WgYXHbwKtzO3nwrh3mArmzBc8Af5RHokTZCub8iDmAHBBAqziN6kZCKW7QN6BEqZE8oC0zsQ8CAJKIm7356VMrFkqXQ8cAJEnnDzTJGtXF5yMFipT5dbl4Ot9dDfMvb7s9Gf/v/97f/1w/frB+eAG9Roo+IKYsPFK3E+0sPQZceacaBCsZET266FecqnRJTSUrAwcCpn33irHsivBcryI5aOEEeBNNPFFOMICbct995CAyYvSfzGUtd11cd4KKs1KWeJZhzNh7BdMgNqA+3zPnFK1ZAWaz65sk3MRWmy/nhQRuxQqQG3n1CWDFJkXms/8K8jJ1eIZCwT0zgvt52Oz0sUZqAKO/fu4c0Bf10Bz8pkAELuJIOWnrvcPRBy/RCPwzDTe+gK8iFHHmIS48x1leTRvWHKqFSko3h9wQwQB1g8TKLBPRqgj6AiIeUQTAjMxoyR6id0DSPguv4cycnXMJYlOvMGAzANGkw/mY6H1EDkeB4eI+OTgxHzdXwCjK7o3dJU5NxtkgKwvStO8hJwlT6z549JsdFrXkGPwwHE/bL9rpEskS6ZHbBrDmajW6QK9DgRSL5QkPmE25hamHiZI6BH1zEDrUhdCqiiOdxpgx7PiE7l+RQOkCXK7jhbIWCmTGYHMwMB/Xj6kYVIAu6cwKpkTkSXi72P2jHsSf/qGuZ2Qs/JgY544bq+OMzvgtNbEASC8yWOPkw8DQqoDpFfWzCKejaBY6AH+Svx+w9XYbb1I2YkC+NGUsAHoAmRh3hPRL3jnXDAqr3s6vrq34PIsRhj/r++//kH3//+9/7rb/610gNCfPZEd8wVegbA3IfHzu5mUSJ5wCbOagN3KBa4qw8OzlG3uEXAXCQAqYrawO5lkowijuYZfWKHSp409HpK4bzF+/du0vijGfPXxDKBuyx0T0nLb27ePWSAGYEMx50IhMQEximD9+8y9z/4uUropKI6mehl5XU27dv3zo7RYMnnBX2Q7FGnUX8AiPEGFM9GiVBaDCrfhv8w9wrFNGt0YsOz87qtQYkDkxh9+Fg3B8u2XrXqJcO2y3sFjykv/joI2ji3r07mFhoN1AykRgEVgBXtBDAs8m4nxpZXcYKMMBT/doKoXuIo1hEoaUzSiTYkSiMYR9eZ4WcCNhGs4U8hj3IZotMAyI8TQwI/K+giFllMGKP9mjabEHybLKpVGpk+mGFA4m1RDXE1MOvEWssKxJHsyutUn3jrQ84Kh0WuHMP4c021jCokYMjwrpGzhKDeWewIHKP/F0IKMaCQGV9gYkBiMEicDv8wFE/8zlJpYE6+hSeLdx0jo+7YVbjyXIJAhaX9DEesGTcSAk/hL5k2AJHC+GDxLaCvqGk8H3qP8KK092EOk64FVvci3g73CCGiQDdBfmDEitX33A+gO1YGodlyeJRyLaPju/dv8OqK3Nf/+oavjc7I9MCwsM0pguEN0sIrK4gCzGsGCOMp0POfDmogdDw/Ga2vOp28RQwiaHaocJN+72Pf/jD3/yd38GCswKpEUuESmEZtOVFestyG15p5lKNQFeCidohxtjl2w0LAg0Qj6eSGS6/0+PJ6ggcANbnixkrKAgibMHsTNsObQRRcHrrlOjTB60HnDGD04OmiCk+zhEYVMPZj60POhazMTGY7cM2kQSPPn3y5oMHB+3W6fEJTANcWEI+OjxCPK9WhJY2KuQpAJWsJIEqZTC7CJro5cT/wBu5zQz5TL4HF+OYkdbmO+EDmHAc8aDXR6Ij+LE0oHvQdv/+GRYvbCPxEjCBCr3esIuAMTKdInq0NCi3JftVmVaJng1rzI0jSgGg4UZa3J3YpKABhyiraVOWtIE7kT/4PVllu3N2hixgEri+voJ/4OptYdsoESqSv5d5Q3MWZkP5LpCri0mGN2Qn/eSorBlNMyz3LOD94uAe7QdmB6zzIlhbL6epwo6IS1zHqRSbN8iiYzoD9AJObCPHqdttO8PegPSmpgedzVEFwWFmV8+wiQ3hL3DW2NEoSyCa2Zo8hlP4BJsCLmFfooIm/qAXDjNF6ptBArvZYxtddkAfgPLUlPAfJXF5MYfANnSbKzBPich7jp6A3JMQOIQu2rP/5QkGR1iu5I1Xv5J/+72H3/nut+48uItQ6nd6L588ffr4s1fPXiyYItjyhQLsjIDOAtAgKBpBchMSiyfZxL0aLkRnYHPA2C7rq7Pph92tmWBucWSq5VUFrEOsxRFJiFuyeISbC+G6BfKorICDrTQIRRaFXABOp9l8xZNmxkntGk1s4jLTPWyHajMds+O2fHZ6SqXI11u3T1geviSCv16LHRUoIQUMBhgAdeHlqwviCFi2unV6cnV+oUa2TZ0cHB18o0FcEDEhyM6LiyvAg4OdyQkzWrs6V0DxZv14vWa0TL44WFM4uzJb1ouu5lckGejjY4QKyYVdvXV/u6hnqi0WA+CHO0cHBGvCCiQGJqKfqBz4cz5vXF5dk9maLaTM3uDn5uIGNe/ohEWZdWQTYoljgvZfqdYxHwBCb9BHN9O6aDahVeZD2BLK7nZ7bz98iAg6ODxGPN9cdVBQCeg4ZHsZzrh8Hr0/NAR4EHSQk6GkhowGhrzPI962MACSh8VmNJ2yuw9YQiFT75AmILBq7YDhgzMWA0IDhHG4ju6OwEKjDo0bfTRfbh4crdYk3yQ8Dj/hjghZ4qxYm2O/J3lqb24IqHXNjlSly0VuMs8sNyTH5eCsbYOWkBkoThDAYopWMp8O2SYCd8gMemDJs6GnAeENP6MOoSwhO9Bx9B2ZPsyFCJACe6AvxfoDzLwprXZEtDBsQxdDzU7oH3UR/Uf1krjgdAaZ+OG3P/jS1z84u3O7VG1AVkwF5LB56713nn/+5MXTZ3gDyHFFpDxdhFgBZfCAx2qojMobXCP3Ryw5CxhEu9ML1M3qx7d/7Vvf+u63N8spS/EIL8DLIzAAIRpOR0bycxVP3Rr7lnAAA+SYZCkDv8BszMWIfqCEuESTBNjVcvXW2S2KseaJMQ5DsIOllC+0kPDl0sur85tro4LZW1U9Orx3+xa8hjTDu3//zmkLRGHk1irNL71Pu4gDQmdhEhVl6Hm+YrsJ+xnx5CPoIOFqrUieMMMcJp26ttFyPuqsx/1nl+ej6+ve1Ut4Xo9LaotsR9qc50vVOum779TbZ+XGca7UMH1GrcKZ4JPdHF2HcaGxV4tlzCvsSAiUpvDoM1XghmEchD2ju6GxQOIIBRSJg4M2Xgh4HnUD2wMDk8W1m06HuFQwwftRC95AfU8fHWdvrq+w6pgqwAHheogMthoRkUolCErmdNf9ylWGhIjFaobyFGxETsxI+Ipqi0kDV+4wi7lTLjUILgHriGM0E6aISLypFoTlDRHplWS5yzkdSLa0JhVy/EsdpjkvXRGj1xR3EpPBFGGPcb286Y3YcX7DUh2K52Qxxv01T8+JFVxV2Ge93ByhCkKjsAXsgj+JBcAFS5wr4plIKsV6N1EeZlVn5xEOKTRrJDRcUeQPT2v8wQmV3O4whQelTG8AI6NEbsNDGJsq6KxZc67pcf23/sKvffjNL7ePWqVKO1cAX1yHsLf37r353pe+PB4OAGmPzCrsabq4YnERfZIVIbxe0Lu7QJyM3c+J3gl9My+z9hUhuZDX7sPvfPiv/mv/ar3VRBGcz1iRWJMpiZ1sPIlyqAlHxyBvIJzP9HLFX4w7ufsP7rLmP5vgX0MdxvvhsZeoTXhBUIfoH6Tw9Nnz09NDkAi753Sn4JRhKiHLQKVezrUevoGTBPc/+2vQoYkIRIH64N23wmUGqnDDgSfwpwWNls8HoZnkZ6cd7FskCgB1qh4PJ53LwfUr3LCr6XAxHkxG3Q0J/AEfcxvrdEyysCipWyEWAoU3HOySXWJLXL8YFjliuVIot4rVdqXVztITNipUa/lqlYxY7LHmwC8mQKgZ904dKi5X8T9mFyvCgeghOsD5K7YfkP+HvUIzzFOuuGiR35KA8oatTeRbNqB8dd1pMrk1aoSOouvjbp1eXV232oy+CRoRD6Vq/qPPPodJbx3frVdcKETjQqfCBAJKeNRDWGUP2seMH0J3aWU1xhomPSjGIrJMLjQqjfVa9A3y0k2VcMRFkfETFQQhjCNKZRjVX293MBQQFL8IyUxhW6zgGJ2u5iy944vMvbVazdhiPulHf1mSG9xgRfRYjiBlDwTO4SCpKRJvR2+rGFRM73IC2zm0oRVW5hZRaxqhNmzRpnAZbFcTDs8wREH3EatvhPQNl7OjJluGXTJGWKOlQ7XojQYhoWtnM+99+OV3P/ygzEai0kEm30DTA6FoL+rpqB71OtteT87OcFwwT6GbTIYsn/QvX57fXF12u92bDmFf5N8Oo19JTtzU5tYheQ+ah8dH77z31u/9td999713ERxMZXAOoyZ6B30QGdRuHUj/ABJXTj51uZ784PLVn3zySfrf/N/+my6XujfawCN0S1xMOENRfs5O2zTCRPTq/JK4SYye4/YB4gWjlkWvBhvjsB1zJQ5rIEoToiFADBc38zWaOrGZoMiQEMMDU0lmK/JTsNEWowctuUVKltR20rvZjIm7fzm4vliMO+n5mJVRVFYISEUQF4MUhOAEkaIXlRj3EWIPg467eGm4yGVkJLBGDeOHzhmUReBtno9YpC+UcbMUqq1suV4/u9M4uYPL3GCFxRy04NpA9cfcJ/bw1cU1wubo6JhtZJhFQxbvdjjLVAbAI6k18L299eBN6qWT9IRtx2CZHiP1cINU6iWyfUAtD++93Wq2jw6OWT3QsN6t2GCDYFe9dMYosJKFoxAA4iNCBGoZY9LQc3wdqB9qrxnkL+o4Yj/r8XCYgN7d/0kwCJcvrsAjDh3q1ahFyVqPVssRvcbrxjrPaj5mgxtihHpQ9uSECVulJmTBxeU6GM1QLW9IezjgoA32wpFzAY2JRA8seDtrMTvo2+LFehwuFDQ03WCuYSWrn/ryU2vyRtaL2Rr7hsmogvxgYXvNfhCGQI7fGtth77x9t33ruNU4fOPWfagIqVoj1tE8jsDAxRwwS+wTDzI+kA0iQT+aHCDG9MFaVrGbTdHUcCRRlqVjPArl+sHtN95iHUoHJGIcnkWx71yi2qEgkR++NyTCrVA/OsRzNyeG7aT1qHf1R//059P+Mv3v/gf/DjMniEQEo13x/eFbb2B4u6g/n+Egwh579vKCCRBllzZp4MHdO6SeU/9jxa5Un+Kv5rCl/oDGYHn267K1nPUvJAlZLnBc4gZjDkdhRRvJIUNGnWm/uxoNui9fzAedDKl11lNQiQp22EBxZ31UcINhZjqAotVIaIoQQThi0KRwB4FtHBox1ZoaCMnKpIe3O+QOUy58h/RDbGJlwU36FvCfYrARAU9QSq7cyNbahdbZtnIw3aDY1A7P7szT+VcdDIw5AfoIb7y0RPsjpMlDAb3CBEyPrPEdH56+efcei4W4dPDcd/s9xAS5BUbj3uMnn9LbP/9bf+HN+6zlObHQQ0QcSyXwKkPAHcA2/ZInl6it4ccOstWDRG8xA2BmkI20h3MgaDQJtbjYxqVLm0pxX5BFCm0EkcBCA2l9ZAMXJRj8ajNdIyD1p6ywYvVW5yrqfljLaLyE7ociCkGjmDA0nBPBOhl2DN6gKmFJ49RDd1qs+pMNJ2W6HDFZEv7HROoRMp5WBG2gs+A2YICxqo7WtMGxqOdpuxzndyQSXsIMzFVYLmuUtlIF9Q3N2+0/ON/mi1KucHTUvn3vLutCt08OYYrbt8j4Wsd4RICi+4IqxoM+zhDla2gnjmhh9sOJBFg4pgkHHfMV/MJQmGOwwYhG4ghvzvNANqFkE0fPOSid/uDFxfWqWFq1q4N06tVN/5NnL54/e7XuzvI4w/+9/+v/CV3FvuGPR0Ncb3B63DnhgL3isN/HQwmohkwlpOUqlhku7dEo7g/oin3jyGuIErkIZUCqRJXix8Q2wOOAjIAH6iSoYJ/+eLAaDzovPx+cv1hPB5AE0GeaR6PD5GLMKOIsPogzUOmWJsDHiLBHYicrcWw0C3+xkblcREfnl93QtOH0b/QLGAAVnL4EMalFWAbpC9nxBekJd0BL4FvYCl6WbXKbbGlnKk2osbbOFofzFYvqpfrBNl+5ID/rhsAn8ocScpS7/8bb7eNbqJAg//bJKRo2cG8dHOJJYbbFywQ+er0OyS3unN1B0qNY43hhTgeniKpKuU6jjIsOOzKOkYyNudD4Xmxr4tEtlDyGATuoiEZX1aSV95R0hxj+N5QiDmRAZDAz6CAPHsD4Ql6i6qEfOniuMnRCGOQcVHg2Im0XZLWGmmAykAU14wHjxC4qR2VGlUTywJPjYYedgwhv0ixgq7DmfHWJErgmiP+GIzNHZJnCp2qC+SVnpLoiYYI4d+QAmg3K0Xi7JoBlR6zP8dkpZhr6xfX5+WYxBbGofPjAnRVJoMvzrNXo5UyfnR6d3UKRad86OXqT6eHs+PZZu90kASYKMPnjUKhAIpsSqwa8QEBkRfAlLjETCAqFYjfzCYYXKzIun+Hk2i5fXV90hqPbD9/rpzb/6Gc//Oj84uIaC7twVD48//nHamD/j//Xf4ilxD4M9g2CaSIcmVvcauj+BY4k0WwYDEeq3exHwG8Yq0WADBmFn5GQS4gNHxFwIvie+QtxROo6rBBcN1hko6vLl599shj05v3r6fCGNQ851fU8sl/tbm6udDzj2XUhgt2zIIrlCTAN35vNAr6nLecd0porRFNIem6D5MOTM7A8m47d58FtZ2EUpoAKP/H1Qh2oNzg/kT/GR0XYLu9eoQDMw0q7QnffHjTBjEtz+eI6lWPVaMuCRLU2Wqy603mldfL+d79fO7xLGiPQdn19M+yPzs7uMEPe3HTo0RFnlEdSOtZMeAzNDWGJb8F1Oj5cdaVlZBbzO5RtSKkDVcYnLxlg/43xwKF7XmVQGge8BArki2ClQBRG3cFsgQryGWKiWKi2Qp/UTrZuWcirPIX7R5eJljIuE2dJomuWGjwcjQGoiUqgJCvTqBymacK/5EIsT+mvWK3RlFiKI0yWXEy40UajSbfH2QJEnizM1bFMrbJl1G2iX44Pq4ftQr2Wv3v7NmoFzilOhb13dojdBj7Z4vfosyfPX5BN5pLzyXmSUQATo1HQVEpVglMG/c7t0/ZXCAB+886tk9ZZu0VqFvR4TglgW5/2dcmUZ0ZLad3Kgax/7Oa91IR4UjdrLHbLfKVwfn0zmef7u9wPXj366eef9ibLwq6cGm6K0HI603n6NP0f/6f/T4gEiscR4Nkb6Osllrgw7jcYE8zFhNDgHwAw+ElUv+LYCCJ2dPXh5+OEKdckyGefI3fCZthfjXoYsmhgZLKcj4ZrkrTMF0zKGMesXokQRZOyjYkYWcdMQgdAgPMQ9hRHiZSRjopFaECFEPU7Qr6AEV9hMGYGhn18+zak0etc0TrF0MvV1HEiGQnjg85rVgQd+JN2/K1YhRyg9KAOvMKQFRfjDmTBZ0IzUpBaByePMiVjxOVLh2fkxS23zvKVJjhN5Ws7Utqd3dl62BZiDtWsxUzMV0bisGxaUpOwrI7ZklBFbBi4Dhx61c7xB9ztHixsh+mDF+UAgYAdwtQWAt2+8iDcbO95jsT+JMfHoqBeGACJJZPwKESVrPzLM0i28OHgaSszVESUohrzJpNOtDuWwuBR4IYLCNWO2liKho0QfKBkMcWe3kw4DZidWbrpWWpgbY1oGKZ5/Kdkh55d3nQ4RI3tSAdtdmSUJpP+q5fPmZzvnt1t1VpoI2TtvTi/JIEuG1fZ0IeJ27saZLOVn/780Z/84Ed4n0lhwvnhWGZadBv2uxbb7cM6p8Rs5pDjwzffRD348vtvffjVD46OW8RDsBaJokj3AON1f3bTHa6GFwSPZ0mmWy+yTMKqyMe/ePTo45vzxep83WfNkANBikt8LGxFrR+cnQ6evUj/+/+Xf4fAZvybcDf6H3lMMSGwb9+4e4vcw64fSQVQ47ZaI4qFsMt5u9mEYcAVBgxIQK/jqIVZ7/r5L3+66F4Mr1+RUwRKDDUO0sK0UUuDNKFjBBM/kXVfUCfYQAXCN4q8YXLgnmEF0L+yH7HJZSQgj68lKmPOIAU6pY8kpD0ylSnIvGV0UneJnKSNxJQJQehIpjo8yhTzpA/4lahV5hlnbNQNa1Ng0qUgSelDyvPdjyA891zgza9SIY1BfBBygcSJnrdVSKHQN09rJ/erR3cymBbVJg5zPfoI1XFfFZG9HQhU/UpYIkbyQVuAhh7gJGKRjFbQ9lyQlRXhHKz/hMLtelCwqzlcRyjLKDzLJEnfNNAZAlo/flVUPpxraCMYdETV4RdHiKFjADy0Jk5RIKYL4cK40dbHNEE92LKsMBNsb4eNrZgzV6AR4RjFg4siykS9W87ccTGDD01NCBkAamJ0eoMrLB1cjZPNrtPtkoCsflwHwGtIj8yeBH/vMmxTfXD3TeBB/NvVNencBtAVW24JqmRCJB68159++uhziINtJz/52S/OX1yNEaPLeZYE0SCK7qa2RGGyQN71WJPM22/ff/jW3QcPzt5/626b2YYMTuns58+viRqZLfuZRn4Q2l7ncviLT88///iSU6Cny8lk2SmyZ2S+ThXrIzxJbN9rHQyvr9L/x3/v/4DCqn6/RP8rs7SOQn/UIH2LUwGQ4yhpvIZo6lAecSysfEH1alocOwyGMcxvLnsXL14++mQ172vkEGOh30B3RMhZFXGlkeLNi0waUhb6AJq9Tj2qBcqBeb0eqntgK8Q1xQ0rgwmkTv7LjIhjqNqFJjyDqGu4X7Olep5ACXKXsSc+Ty51jsqKWBMWpJLwHkiC8DBsNdKCYWfjGR1cT/tXu8WMo3nNUqzuY7eUvxDoF/qIV3BjywoQL4yFrwlCpDeIBzqKtSP74UPLFiMqlVSjh7n6ceXoXqZcX3Oj3iw1jwgHJv84sGBKwWPLWYWwHazGePE6BnAMW4LgtF0VEXszhqaBCG5IJ0giEFzXlAFY6geMeOsn0x7gZlm7XK4XyNQp/PHSuECuh9nZhqbQElEb6TbjySzWRO1elkot+gpVYBvgUYMBmEcjeo0F+nGE+WVhBWfyQQcnMPZPvdmGJgNDm59+9GOEOFtW7927Px6TenGJG2iV3RDCcVw5iEkW/sw3W0cmnARtzCFj1ukJts+zgO3WuMUMnsYmJpsHEw70RtTuQePg6uIlLldmhlfYYdNVt3fz6NPPBosN0aTd2dRoPpToSuWdt958+82zv/q9b3zt3q2f/vQXbFwqtWuPnz77xc8/+/zZi5fXixsOiyEkd947KE3SZDJgmZB5sX2I37/78hXiB/uS1UdS37CshtSvIRcaxTJmOUtTLM4aJm00CEf/mceUw4dSi9EKz+ywO7q5mHSu5iPCUQes2yFikOLwBpQPLhFZil4X7NQFcJzL6ejeYpoDGTiwQPnKXagKbKkLgUucRej4AspTPA3VVQLrQXJ3HgKwUM6VahlynbA7p3ZQqjULlQYbhJiocLRBhegePqN6oP4gmSojeZfxxIF8KFNpGSyn6xGHXHQnvVeL/sVy0odoaFZqkeijpLOfkhiThzdEUcxGzAGQLo5XOIIWcboTiYUvC1phhkmveud4F6bQMapRBfdfe9E6zbWOC83jdKWVLjZS9fau0GDlV19tRKPRT6SFMWL2nzfgQ1OsqXWYr+A0wmwBQ7PekvUNxCQ6H62XxdtJigXWrUEWdAnCxXEgrAyjgNidagLYgsV5I64i7Ia9YbqZQ9Yzy1YqB8ziKKjwCTBkEcjcLizLl7Et1cGYLl2Hv3naXE5JG3bUPiZEplA9ZNsuTLZJNW/dPX6rWr8ZXD16/jGGGpklZ1hOpj+jSgQyDElwWpaEk5vlGKsPbw+BqnOWMYg0KeQJC8DGRVGDGsu1yt07B6RbqeQf3FyS5nD36kU+ffP0WW896vWXJJvboW8bsPBkmbp41Xn62cvf+PBLdBKvHXnGP/7l548/ee5ZBLsy+uN63lkvP8+mhpxLsMoThVVlIWZ8fk4c2Fn7sIXZyQTH/NnEac2BFBlgwXyAO4mdayNWqgnwxciqYNSuxr1nzz/76Q/h1gU5eNfk6xS6EAykJt0TCMlpsky6ajFkC9bm44Umw8SO0ETUlVk5IMIIc9X4foADkSnuMNAQKhA+MVIIPt4hBMgR8ED1Wsw1UvIf1Q5vlVun+WorV6wh7KF4SJVq7ULCUpIOL3C2//L6Z1wBSCn1EOiXJziEqFhsFg9vN+59gLHOYXGr+cQYqc1qOuqu5+TDGm7nQ2J0ZQY5E7uVD/khODdaJbyHXL8u0OnlS1Qp2YcGIWRcgatxdkA2qavVyxzZKpnyis3D+ulZCiu5UM2UDzM1dsQeZ8tQNikP5DYkf4BW2DByt2kYHj3CwphNhsSEI+loCHKJ1NpIFsBLXAJh1cRkoczUg8iBGju2Ff8BDPsT1fMlXSk27935ACZjpZ13lHh06V2eo3c3170emU/xaREod3718vz81Y5Tt4oFkuf1hjcPiIAoV1ucGtBqvVk75DAdKHvCMfab1Pjqoj8Z1goHxHm8PH+FjG43DtgKzGZa8iAzkOWSBB0ECHcXE7NWgbVAUr5arMv3RiWT9yHdG43K2K+75a1Tsuq0mLMPGihv3/zJo4vDB5sfffqic3nBHrEUQX6d9YxTYJ8X+tdDMvdw+h9roONZebyrL6dTI05WmKyDaq57gOWbLk3ICbLLLofjdqV5eFKHGIFq7s7pCeKxxCIqkQ2kw0R4gGmjWzOLm1ed82eT3uWkczMf91dsdZ9OmaERVJAm1K/WCPwgAjcsS86wJht4oBOMBRYp0CRYA2EfMHJCwCc1I+FxLuGL03rGT4LGgR8Ihd7wJXRiGAQ5nIcVW4fVg9Ny6xi/ZL7WzJeaOPZD/VC4qfFD6ZAL03agVwEKFfLSwIUcuc8bf96OT3+q39gbHja+SnIpsjW+TY8YBCL2AA5B1i/G68VwOjTpJ9PFeHC9ZXs7scesStNDdtYjZzV4eZ/A6JAg3KUKyJpQ7KJFW+KebCzP0Bm0iNWm92w6fIkUIDiUnB/YD6naYb7WZmZIlxr5+lGm2k5Xm2s1HHTHeilX3q56xcLMLc7EcpcOCzlyTzDNMlGy2Z/AE8P6mG0BdqOJ1Ya+wQIoAggBwXj1qtEx5DATGUoRoDXb/pbTAWfsZGMJvTfuU2A219eHS4eVuoPmAZL94tUzTD4WoIqnZw8evncyu018Y/vglDK7TQ9T6KpzyQIieZA4JYnVEtbQ0GEgD/BXadXbh8f4grv9jhGfYzSB6vnNiJ0LRJdhxdYwR5CIhQacNiNHEILHs43nwGUDFUxHpDNnRc5T31vF5nH9cDq9ejGstw+ucHugMnDonbupUM5Xz58+LxOIUK8R8MGmEvTAGdsgWLep3z5u3MsMched56zA7Jql20dnVSZmdrlsOBLoste7zr3zxkP8P3hoMEk42TWDn4tg28vzaa/z8vFn80kfgynxWUD6aG9AU0yjxxKUothWihs3z/5/D2TUPco9lgxBvroHOgxxVKpD0hx0AF5RmTFrpT/MCRiGd81WZw7Wbku1RrlxmK82/KtgULLXkefUX8WkgawIcZ7yJ1TMB0zEN3UXr0DSIJ5+IfNojh6GGmDT0j59siNOz/IBjBSym/KhMKDtZIgSzebKB2ioheM1FI7K1CSOnJfaGmFkgGm4nQ1T61kOk3ox2C36GESyB/MYe02QBkhpX6zw0RF2ozt0yFALh/ZVL+EsDhSebDqD9PAZxMkTazId5Kvpcj3NqT6lVrZykC7UAGi9WSX5eNpk/IRcIj1xfRA7hL8VZgAg0Dw55TGmOBDEYXFhspyAI8CVAEZLmcYNfQVHecJyp4uR4UqrIieesvxPzAyhz2ftU+YyhspTD9/6Mv4scr8guIhTAbdEdTGlL6ZkUCD1Xx9Jf+f2Q+IhWHlmtz9L3ydHR5x6TJAfp1R++uTjH/zgJ/hVTtqN1Xr+5vtfzRQbhcZxpXlSq7VQr0gKs1lfsDS6Gt0QfQm2uEYatsyaHJuD1Lq0HHWGk835+fXJ8Unu4PCHL/+gPxtusixos/oQOjLrfchWQucmYzCaJy3Cjrx0i1Jl1mFBs3Ebn8XL3qiy2N6+dfvOvbcI3FgMu31t8Q6pFTBDcqwqEWA8HXduXj7lQIPJ9eXw5ppD300rQP5k7SiJj1YQY9IL1BWCFlpH24Q2oCQUG5CM9Y+rB9IE7mwYxt1Pslmi+lin4lGUHO5CWEQdUyPCHspAUiJDXccDedUWAW3lxgmKPmoQzUBBe3XFRqV02c9tXAp4ehSaj4CDtIK6QyFT4MkKzGxSPGTNwwkveEvq5+EYhgwqD8hGshDdY6zJ/ABxWr92OeTKfj/1QapByStjLcYpbsoC5orNNEOUOeSNqcrkQBDNpLebwx5T/CcpQxIWAIjqXduXzaiSRwEqDQNmXB3OZvF7xipjejzIUCVU7RNMU2SDKK1IPFM93BUbm0oNqKU5/KV+jygK+JuFQXQRgnQIx0DpQA9FQSKUHccVbhN4QCtFPZSYSt0zY+LDOVKO6A/3hTBLy08gB5OeHpEH56YzAB96qItkPGIjAlxdIaqXU4sYMV6H0eiaKMbDw7Nq9ZDt7kY6EcywxSXBOUzINbJNEmGj+xso6gBfb54+/bh967SZP+oNlq1imujJzHbC+Z3kl6rWjre9Lo4lkqziTSD6f00w5/wGRXgw6iBgesvxR49vuuvclKPuKlUifdy4g/XD9tTUqlRSuGTnGzL87VZsILpuNssrzu17+ks8crc5GLVyu5Ivr/qXxH4Mex3VXQwGlthYg3vx43908+JZ7+J8PhywgQqzpAyqS9KWZMpeMEkk4hChe4UlpOIbdiqmoG5nk7XgEsHdQro4nPGIVAkF2Y+arQOULedYOiwSmRxSeY+OC+sQbsIhz+UmRI8O0DD9S5bFbc6lw9Uo7dKMNIBEc4Ch7Hg5yEaa1r6jc9CoZE29kFg8JHf5gsq57nefcRx+8iYFyrk4+andr3QaZqBFP3lGYwSC5wV3mAPCUApzFijUeciwhaiCanGYESAIC+bqLghwRSsG2UG15DkbXm+G57vx1XZ4zbF8BOnTBClNaIDKmfBwHTCxWT76xtRBAS7RL2og8wgmCxPFFkYaXxhZQR4AUrrnsrNKHQ1qV2jnyye5fB21i3AoliANfMI8rbUVW4LFg8z4oD30Lva6pFYkn4L2RNQmu3169Rj0NOttYkyfnl8SWY1zLY8BU8zrzNts2+12pXyIVsXuIao0IJgYMCKjWLz3GG9GizKLWkDcUW4Ood2wU3eCqf5r3/reckY828uLy+tGZdssrJu7+Z3jW9WyQ2SXIfvSgBtHubKJDr8yQhU4juYjj74bvxwtGzD1aLV98dnLzqI8zpYwyIhOw7hRLHO8JrvMWbPi6Lv5jJNvet1Ldn3NN+nzx322o99j/ezoxFDA7jXRf9NBfwODQYGbBfwluJno/sN/49fAJ6TMbxR5qc1d0pp08SfZwAvhrUClgUQ8kxT0UxHqXmze5LpmA3oOo2L9gfVgiuBOhZLgfcoDKYxasiew1geSio12tXHEO84cIhFEqr0BR2IcwuGrAIIsgv24GVwHKeuDhwZDi3EAPkQXLcEr3viQFbgXRBSIj2s8FUygm0iCSIoljzEEfnrbTjB4qVx/FOPi0LjwEjJomwKClqI2uYavhF/hVBIeLIzI4VAdsLQ3cFFMZCi6/c3wAmbYDs7Ty3GO0/WQQJ4RxIu+OrPRIvMnOhIdQVuBDe2nzTkQtT4X5oEWx6IRMMdJBiSu0vRCOUGjNBA/wwGP1VLtlOOkd8UqrgIEP46EdL66y1VgY0IEoEv8ZWEbAGHn2MG4Rz/JhknVKDM0BwYRWQQ3wiVo9dTPsdgMD6QQaIZZgO/NLKwZI1D63ctB5xoZz+ISDoz5GmtgjPnL+JqVTLf3mA0P6dzp2dn9evMIwsXbDonhWuzP+0ggNlIwEfUubxqN9nyXwWG/vH56PXrx959+8vd/NLqzKz48ufP0enGxTF8ttt2Ll2wdZMaCSlDmyRFoYpFc9uXz835/TNwK2xwajYPb99+t1SvjwSVb77f4bNiPz2oHp7KuFoolBAHjBmyMtKaOCpSVfdCX9Mdwsd1En7IalMPWCDZ/wKHMryjq2HauSRGVwOzq5oEscywVudt/GstAZdZ3WBvFYYuk50C1TLlZaekTLDYO8pUGqELSIueC4sEw7TjFQAuSPo2JdqiCOtUFFFZANK4ic8O9DZ0lulDSdMIBEqcEJRV6N6lSyucv3hKpCNnwGCxhkAmgSPgAKFDGfE+SFXIRusNG1/i2DNYZN10zpYcJ8aMTx0IsdG+m6OAhoiCIO7Q/iBUUI9YfPHj1+GH27K0V88Docn3zLDMfhuLk0jWtQcfUSeuMlk/wi3lE96iEiwAZgekiGiVREIAG5Z1DWMHAEpujYnHW0nY12qU76eULYMlEuuEsVIxpLIcCFnZrnS2vOOcds7vQwMQB0niW4ap67ZDvUgC4dm8S8HatnAApiB5AcBdvOBosOxcynkDXJzkyWyCZMs9fPu12XrLgh/vg3VaT2CfOl0TpJ2Qemc7Jq7XGW9juqewpph2ngU2Hw1R+MbwePO2dP051ppvJB0dnD0oHxPG97JynDo5+/uSzxeNPR9Obz9DL5/lBf7eolHsT0vmPKtv1iChMokuAZqlIonoCzy4uXt2cXxDBhzbRPj3EL4ubv5SZja8uOXkMfXLFWsKgx25pZ1lIHwMWqkLCM0y44D/+X/051QyB72JTDBjgOsXLFL7kC+MTUdrACkBSQkDz0D0xiYQuOgNA65CSgcH6Q6BQ84qjzVebp+WDs+rhaa7ayJXq0DT4pQFgqkGrDU1rdIWvRKoELYrd1/+APh33F6V8yRN2XmU96V9ynWehuajLstFNvviUygxkFcQUz4aUh0bQOiLPO5hKKoFioTiKQtw0hNANnS1o0RLSvY4f3f9RrRvyoEx6iKHgXqVEfdm3Dxszk7gLCQ+vubXhFTxfBhPgdJ9cLV98nF/iZWJtC7+Ao8ExRs12Gske0odZCJkEA3CRuZOeAbmkf+xTxncAwKFXZirByX5BHnPTjFVo0lAbQXIMFl9CliQgJLSD2MB0NVOopwutVaao/x+JQtR886BYYXkbW5EQlfAjAX32J4FmtIdxl6RQzCLG7mQIq2cVeTGZdFFAFvM+jjyi31gZze9meNDWu/obb3+PfVMMjfM0JuPOk0/+uFGFv9rj+e7Hz5+e54iYW+W2s/uNXHm4Lo4aP3z2qnjn9Kb7anMzYM1seFL9b//w4/H1+u7pA0INqrhruzc3wx6WJgdWEm7MVmdCcYEnfpf2cbvEqW/wMIGbwAqFjPDXEWGcHNg6YwzM3aAHdDrdAhjpSqpCOcEloN8d6DPbSyWUw7aVDiSfoBtYIcxYPB4igCgFXFXEJkA/BpwxP5DlgF1D1IJY0TPPSjO2x/HdytHdbKXFPIsQ0B9E4+o2IluCTPoDgcp+SXNxUezBDaG6yreSHld8jFadxOAB3h0E16EbHwvGsc9edZROKP6PsfIYzBxDkZRpWnvXa1EGaSDRMCDKhJoTo7cRRKveKr/QqEYCNM1EZSQsGoVtBGdyDXIXlooXBwmbBDMgpv3CKPK1qjo/KzL1s0zt7vTVT1aDj8ppEq5jofJgAnl2H+GTdTrmD2qG67hJx6gPdoVAFVvyYIyUXhEZu2TTGXfhLtQYRATPRid4c7vTnJ3lLI8RoUEs827Xz+7Km8W5pLxNkw8T3+UkW96y0lI/XLHDlvm6ecSJUET7zCl3/my5JBnZnCzzLBchN6C89HpWSS/MzZjDcswuRuwxZMW1N5v17jz4FrE82VydIaGHzG8uD6CrtIlc2UXNVtDWNr8aTNeZ3tN1Z3Qz7X5W2ZRP387VyAf6o09+cdo+efJ5l+3/rGiTuI2lU3bi5BZT+HzY67GG2WVbVb3KPmnIhg2hOJ2ykX2DxthEZeIl1k4mE4hNMPBCGEBFYDPBC0hSv0zlSDAH1ngpWV1MWbJnimYIdgLfIhDYYS6paoI/bQDGATKIOEAZgvTZ4eF+v2KdOY4pFa9lrlhl6QrxTwYd7GhYimZlDaMRqSehDEk4aFoiRLoFGTERB2VDaFyDZJOylBT7yjP6H2qvN4Lw5GM4O2SexIbd4BRjPdJ9cIJ1xgsK5A7Q8CPUJJfS6BUDZBcU1Mw3Jjxu+wjPQfoYf7EzgzvIBqUhkpzdlfrB9ALwLGUxBYgS5zFEAomhucK5ekw9tg38IRlYlC+CzIe82jitN7+/7jTmz39QnLCNFTCY7ZGok+BGR2AvQA3pjEQdl+EevgbQHIIMaf9hEtXU0Itwk2nSweEMRKaA08Vc9BMtFvpHjLEOht2BKoqrqHRQYFixnv1kM36EDbrtllc3h7lKk10fjK2ZHXTxaG0KhE2w5SBXYM5h+UgtIMt+f6JrNmTpKxH6QBDmrbtfP2jfB/SL+RXLC6slZ0T0UZxRnK4716nl5N5BoTbLPXt8frN9smj1VrPCbFd+9fxlfzbKFrYvuoPz69HVboyhhHeWFAD0/LBVx0vOrr9xp4fjgAQLR6eEl65uzi9TyykBUBgtDIHDHMjOtlkgolnwSfzvwlLhCMwllnj3iwABnUgH1k2kCQQa0GHzBEobdA9kkTSU4k+bV5pRdLB2RexN6eSs1GhXGu18gVU9JtgyZ2ViRdEQ/2SmaJGv4EYJCQ0r7+0N+FMQ8yn+JGPwRnFoQrUZfEf/ELVRmT1NrkgDPsijUdwx8SB0wL+oN26pZwWJRNX02vnOPkQtyaP84GEuSkRGqjFL6c/wOhTHqm3MVDwCOdIKxEvTELkNOQ2iCEBwuBR0tPOH2my/GQme8hn7KnNoNpKynrHoHX2AFAF1kKzNQ5iZSuHs1zHnFr/8x6VlBx8H226FCXOrG9zMY8H+Aa5L/ahqyfidy0MgoTIhSeihxM2srD6mEGCNRUZBUVf9CUnGk2IiOsMwATbCi4kFNylKApXTMeZ04t2WuQxbXtkBPNtNXqbGUEb6YLHrPbke9FMZ1rG/8uV8mUc52aCcaR4U0KlKfVbjypW6OZE4yTxPjgXCxF7MlqRDHbLQNB0Rnre7uLq5vO7mZjNck5fb8mc32y7Jvx51ieI6Ob2zXl0+++xyPRuNL4d3T07xv887RMtva/nSatLfLnIE85AF5+G9eyIJAh2NODuYOU2pNCPivo9jahm59UAVRpsaT+B9j3ZwmRCBAgQ4AKmdUdAiFAcCkt5ZAeDHgqiUSzu6g/iqLos3HKujfZyrtepHt7KVJt760IbtjyimHF8kuvglDdKOaoP4t3npPohYfZWfXI2uyAhSv1Wo8MB2EDa/RJgTkQjjZV/2lUm3+9HZz2iBEvGZNOGj8bJLYt8X3yFVqVlKCcjIcFiVEKf12GmpilVbbuBk0co3Rg2CM6UUyetxbxsGxM5GpC6moZJCC9UEBLaFPYjPnUPmoAZDP7jCLjTiKGUs2VXz0ZHjVjTUmeQjR9/c3ZpsP//7LgLQJgRNjcSLYILaH5R0flDcIaGgxigEISUVUvTTsGUBBQBgXWYcIQtuRQHXNMZBY0AAODIyIMAol04qDBVJSD+FAAzFD+thrtuRobA/Hd1Mri5mzx+ff/6893Qw/e1/7V/+1l//K5VivZKtZzNkHtitCgaSmcgBZjD71c4w2M1ktcV6nbBchOH8J589+eE/+8Hb7dOjUv3TF8PPFqOf37Axm224tbPD+uMnj/udYXpCPAcGwGKSw1ZOsaJLUiS0vxr5DggfrON8YQo16SoresAFxTpNeozRgN22aF/ApeAgY3wM3NFIWaBTQKA5OEqvSARiynHzIBO310AxnMUFp3zoEboAW0zZRGuQw6N90rr9Rp5wrjyRj4QfC1ZrVnrYWkKbQeLWlvyPTlCzFEztXE5wIPR5SrKzwxSWMmIGsO0oHVRLOauy4/7zFuiDXqNFiZRv8Z5Ub7M0wbs9Spq3BJf4SUHmKD6pSlsivtK6MKFDwfNRknu2idnimpNPuy8JA8xEnAoXshpmtXYcNdRugAXPpJFACFYsSDpAP+0IkoVOAmSsI7gbUrY/ShooB0d7roIFnM0e3pt83iynbqjfuceK3VCO+wGzE6VUNhPMoBPZoJyCffA6sKuOnlBeURNQhUUAgWjHr8Ck5rQBRu0fwGMSY86gb9wN0AYc9F4wmAAUD9BRshSOhzdPLp4/un78tP/4cn4xX13N1rXj2+9+8J2D6l1MW/IMe5QL9or56lj/I9kpoZE7kp1yWPZZu0aqMjZashA0XK1++vQRGc7eID/IaPP4ZX84W7PaRAwJCRNfXHXY+Yv+lMZ8lY82HBEthBYrdr+QE4rwe8Y/WYxYWWuQ1KDAGRQE8pC0A687GYh16qPZqZGDKkeraAEGgeGEghwrHBDSijvCl2KERbB6j+7LbMtCBsKJT5dpgSkKfaHWKjaO6ke3c+VmtlLDIYhaCTiFsx9WIZLFJ/X7cOCWu3znOsaFBSJDoVTEfS4lT9g9v1ER9QTuFJA8CoFJ1kHk1ifGo8Px488+Ynv80zP4uqqoASbwOV9UrkigkahcKgD//ARocTEpFmzHyjRPMT0kg1Hvw2Ag9wxN0AhEzMMeDoJeF+kbLB/aEcVc9oqUcmqP9kelH6rEqUJwFAl6cuEvwgeUaDJoG2tdJCzkQzgEXpJTnEMn0bnw3CPOoVEsDRRTRkI0N+ijaQDFSrjyxMhTt0Yhev2u9iakIHtQh09J6KGyGsjgkCnsdEER4GFEUKijyDtBxB+TLsYeNUF26/7l4Pzzzqvn44+e3Lwkjf9iNcDGLhTf/to3/vq/+C8//Mq3qXA3Haw4uiBPVkUSEs/7sx7BbhwxMVlOif9hWerZDWclLs8743F/TPbCz19d5g6PftafERD7dL7oJnu/SZ65WHCYw3gxwIVvVBZrhEUWCzlliyXvUp2QxQJLT5Dorlykk5kdc8qQPe+D+XiG1QX6ydfgWgXQdnDSAwNCmPKWCEovxXV+x2j9SRkgjD8BLzUuY+AnquMaUeIHlfZJ5fC02DxJFypMkCq70iGYl7SS6kLAObUGTIPvgg0SUoRo7IZ92bcH8fsgM5HUKvXRC+kSZNhVykVp2Fd3nos+UdCarCcku4RlvUm1PuRXG09q5WGvxX3r339PLjjVKO9Bc6xkBOOFYOSN5tw8kPSSPjEDkhZBldrVDyVHHnUTGW6nsZeIu6f2vS4lAQl/BAeqJ5IX7V/RyvwtF7FqRb5NWAiFno3U2lgEL8AYJA1mv0Pn+qK5vUqvOghi1kyYNAhoUOGRJt0j7wA3HERAlD9msolN6abS3GhjUj+EYHLUQlW+40/OZJcnoJUhuSw04JLXnOJ8RzXsMtf6djvx+GZ2/vnNZx9fPX056U62F8PJxbjPaVlvffDlv/H973/z2x8+uHef/iNxxUghu0xVJlvSg/fG28WL4eV0PMMkXQw7jUrmyWD+/IpsCc3Pnr3qX1zNFpMB66b19B88e3W4Tg8v+8ytLJjlprPcZkdaNVynxFmx3DJfThAKx+1DYIxTf0W2JVxkuyw7kZFEa3T9To8jf5n7oFhijgGu7vkYHrhDS5AyHKq0GAwRlBWXAjxKeYABcPgwXjFC3HBJEBlYLraO6sf3yu2TTLmqg4DJQBTzCjIHhVQtTeCrILOfwonqAW00GyqKv7nKP5vjSTAlffKp0m3hKO8tBYklQQCo4ArPOmsFmyBk97X7BCUgsORWfETDSSW+cyfpiY3xLXmGFmwwHqM31BhiQmEZuhAfUYDrCW/bDNTu4yha1MpP5T0DIAiN8yf3DgNrAGbIAPQYUu169gpMojEaPp9wv3A3UU6cVLGqCXzgnYVj0rGk8bZxePPN5ZPnjz4e3zz+1oNGaTMh9RbRUqYwWc9Y76dNmmaPHnYw27AchzmdzPYPISL/pGG6IveiiKqGhShB0eKENc0AJwYahuHAmz/hZrIPMiNQM8MU7oTg3Fz2XzzpffbLS8LBeov0k06vN59VD1vf+it/+Vu//ue+/WvfYw8XMU4gBqXLlej06lX/kqyOZBVHJky7vVeXLz95/DSz2uDXP27e+fzxq8Wq1l1uXl30pueX2UZxwy6Og3b35dV0NDO1NscxcoAQCc+PDkkLiyuTPZdYlS22TqL0F5lOCSuYz/tdNqaR6HhKCuURSexI7gljs1CdOCP5KiHTMQAr2fgnwuOXowNqQX1Cib+Q4jzji6cilo0pk21t7dP67QeVw9uE7JEUKtJeIPZ5AEEkZUc1fPgFaScXvIah1GIB//GC/ugHBfefiD4UIbsqHUVHeA822BM837ln3bRFLRQNrcmKFXW85AVf4JsL0SNqTPojfb+eRixnJ3wmOrDvJTVRinLUwR0hY6Xa21COd2yYiuON3xANKiVloC1Ly+z8iiFGbwOgVorKjfLjsmAYx7SE7Zt0M3plmz4MK+kCdTES5BL/VzVp3uH9+7dX543pk5+5uMLktxrBScSsoaixqYSD2BBxoUgKLCBpEMWKhSpaoDdqvvSAkFAnfcfA/IYeFcowtBkiC6K3y+BABYxi8sFmuuhdEAN5+enji88+vxpMUv3JqjuZbQulNz74yl/81re+8q0P7z14gxAJQ+oYeZGcakjkm3nnfD7vjblWPexcvWRJOTVfnzSPfjJ/XM3kODBtfH1BRNLz64tLckD1usgYcleuh+P1+LPMkBMNd6QCZ0kMRa3K1hn2tHVvWFdotgjOY2ad829rgDnx/DNAQOTpglxFsrD5GHE+AEDlmDCVtMIx7PhALHTPVQwA0W67+i5Euz/lExHos0FMuJ2Joi63jsqt28X2HfaaYI1xE9BTgFUiSSUeDVKzGh6XgKSIIJoobymL0i1u2G4QmRf5obatbHrdZeuIIlIzMpTrloparcnH7EN0eN9Pb3on2MDRUYl12KE9aSa/9r3jeesMbnAAth4KHBBSZEj9TJvUrkFCPQ6ZLlit6j7/3IuDZEUFR5tx7ope7ZnOkQoK4A0GZDl7Fw5TO6qzQv7wanxCcLYKrymMgZynIbE3m0XMAmkElufP2biqJg8wuOspHpxTOGKHJxKX7EuhvsMewpwuo4TAITQIaTKrhPhABsKHOK+27JKjAVU6GA1agQ1cDUKqMJnBEplpf/r442cf/ezJ4ydX5735YIUyY8x68/j4e7/z9W//5vfvv/VOpVEnyl2WiX6bH50gzEXnavSsP+qxkgw9P/nxDzlOHPpqVVrPr3o/+vmru63DE/L41svPLp5dDbooOavugDEVOPGDpDvL2cNb90lHSbQjGxmIqVuNx0s2u82mxB1z4tJk7t5l8v/vWIZiiBw8jgpEKKtbz1V1+EsIPbAP+EPSC2WQJ73uxRpXgn6AgyBTVEgCQb1BuijSonaXO3rza4XGIT5Njp5UMHACM8+KhkCF2KRJH41aaEiKo1a+QLzQmb1ImqXvEonNBFn7xa6J06ggaMGfPK9OZVm/Wnm8KGt1XLCJKGcx6/Gq15JXjMXxMjTegsfjuRgpZawmIWl+0Fce5YJlkYlk7/ObI5CBKYv8pA3uM2rb5To/WM+yNJ7+4FTuw8rCTyOFUpi84EUioSp1Ix0yuPYprT0lOcMTrBJypnKcmoFsxuxlqVX3vB642WbYGT36QbrXwR3KMDCPSNsIDaMdkX0e9ZT5F0dFLLa4hMsrGAuTgMgGhb/57s3jgGTEPxFQDagjS8kZRvY8FWSGRTzeZHX+8vqjj57/7JfPnr7oY0NiaXPM+eGdW2997avvfOPr999/r3l8wp4aGEXvLxk9VHKI0jUxGz6eq0nnZ69eMkGx8//RLz9FM+HIi85o9vHnz3//T38MoWZXpdsP7z++vLmeTTuXN+vZEicUjmPU5Wa7achmrnZ07zbpVMj1Pe4sOVrdZOWeoOHhNij5iAT21JMBDhcQsGZI8iChx1JbQjtBGmJJHucvsMpvyERKCirhGmTqA1xLaJWKoNOgBQhQguBOrnj4kC2LLICpTQaNxA0fo2Yw7hNRry1EXVGrD/sFwqGc7dow/QErrudLUL4UeMjP4BBtM7kpHhUnFPGdS5SwCnkLFCY/ILHksmQZRG6nfEZ65g9yCHq1E7wcLH2kF0nFdiquyaZ8DemrbKfvepmcf5JRyMTKZZ4N4lVMAj0FD39KHSUzL8rhSHEMAXl+4Z7XGUr14UtwwRBU0Uk6ohkfQGO64FkepJxTeeJygbxmvfXN08JkEEvkzCpZjgyCYcwAi63MKhhiiD0c7Nw3vwPBmGxY4+DaGRBw4sPygIS1atG5JHTddGSkBIAYy1XCCnTSuwVgPHny2ct/+tNHP/3o4vqGxD8sq3EUQ/vhWw/f/8ZX3vn1X2u/+UaaDTdGKaXZGkqeaTyMQIF9gvltjtSx3XH/xaB/Nees2G1zN83W89/68Ot//PGTP/2jn191RqxwjebrUpldq/eIGhhwbNZkuBxNyALFREoaIqTCae1sQ0zPajscs9uqM+re1Ik11NMAZCQhjWCcVqSjZKUF/68LjQIe6MV8K9ECk4Q+/A5w+SExJNQIjkC9v6gswA29CXMphpdkFWUlEeHG03imYTNqDT2C2fH/39OZrTeWXXVc82hNliV5nsvlmjtd6SYJIeHjAm55Aq54IN6CK27yEeADQoCmi4SqrnTNnm1ZsixZ45GO5onff5/qqFz20Tn77GmNe+2119I3WaWlmjCxfPhuMF1VGbDzVzjw+Ru3pEWoARqS0kl5+gY2iWI/awgOJqomCpsluzCZ7xqDkBv0gz6Fnixa9LZw3jzXU0zwBpP0Dk/Eqx3U0g2Nnm96SfV9fou7qhwsh61qGUOn1C3EHDZlRgrLlFagNaLKitZEcqY+I8vAVKbL+A/CHZhQdU+mOqYFkmHmIExjq+FVeUXg9CEyoHIzPWxDcQMDkOIN0y8DZWwbrFwVdLl+U7g5/j46vMuEzKpOIbcJN4yHBbtYOtGCo51IazqEt1ON9ukZuJAdoxwTwq4c/5BJQnz1HbZDwDkOenOaDKs4dnmrMSC9TL11flX+9m3hqNix+oDcs5nLHBzsPXr+5cazZ9HNLbInEJHAR8SxgUUyQ597wvHA2EKII5X9TiNfurnFmolhkhN/rlmw2yFMyRkhnO3Zf705uqgSN5KY2Ohv3rXVDc6xFgvn11d5YsmD/dhgUfVT6SwRouKu4Mg7Pb+94HADZ9Gz8TgaG3xHGIc44+A8B+AJgYx5BwkIEjqWTSGCPgaYjFK4xTeD/QbGhoFSABQWyIWHwgTNlb44H0qK+fIH+AALYA8iYQHVeXWp7iIx2TqYWfO68EzNCGXQB3Qf6KtlAGkYmgGpSEtNcd95F3YjYxaKgUSH6Y9WksBeSGpu0VeVFSvU0LgW8wVXRDmfS/BAj1WB2qF6/sBTwVL+QGbOxoIaVdfokWhcnRBh0hpd5R81mgL8UQMUUr0smkz7UpdZmMpuikYzVrYlnNqxopOfHoVTTVJWISoYsiFa0RliAUYZYOOHrDDOPJolphdLEHoOPZD2yALKTCnyUAYZM1yNgxP3zUoLz7Lzq08fPsy6tZ8/yrnJpyDbIhEtcfaE1vgoSR6bbXBFODpAogaUfZQxOsVRMI3EyB1gQ0B4QR6Mj4Tc0TAyoV8h50S5dte6rdSvK/Vyq19p9Cxx6NiDzdy9g/1nXz5Z2V4LLC4OgjGb7dOePWuD1px9nSeinNP1ElX95vyjVb4b4E4fXW4nNprjeZANX+/IGnjeXBJS7Yb40rYxjjN3zD5b4gSlKJ2e3l2dE6swFUsSWwgIE0VqJZut3d6cnLwnoDUO8kSzUZYrzO+KY6ujY7MuMTWQEsJqFrgQtEDKRIMlYiLCeoDGU4P94rGGz6oET4V9gjTP+QuwdJsiphYVENKKTvQS7AKrPvXAYugFFjHQ0yCr6qKwMAguo2bha6IZYbzqBbEMU1RlTln1hxeEf+KOYp/QFjMqZomNG5zjpqE8h5jQ99CHzPaqlG+6DkYaXOULf50PNzVs9UYT4FyqO2aQ/JLc5EfDNBe8yjfTV0OJUICmi8cOPVAFyo6qB5OVz5n9Wo7pMP9QBGc+CAohaSf7muyLRvoZxmRmH8SWmwND07aSYSAAm+qQIFgqIRXGL44isiOKID5wiFfjTS5fIHrG71G33alXRy3rzavXZNYoXJ+lIp4/+2J/OkAX98bZ6Zm5OYwCDRKukGDaDF1byNp4HnijyAg34SbFWWhHLvsAUMOTpk7yoniMYya9htU6vaoV705P8x8v69etQY3ckf4A4QQ31tefrq4eHN5b29mIZZd8KYKfBhg8RDTtWeH+KIb/+gInV+dWt3V2fn1xeqLkzaQu52T76mK+bUNQxR6btsPz0+OrfAGwkwOBmI+d6zwOOUwpDOv65F0QlWxK9k5SBbJXTtR3JaU6+fAON9J0hkAMir0FZxWr6ZKqoEPaE0w2WBrhQyAEuGs0OkHeQQ3hklCD3QqDFkZaA1uDnirETPDPATs0YAjHoQOhiHRcIAsmQ1jUIqRA0zD8VedI0W8BraEtYTnVmN+mSTFt4ZBqp1t0W8xPlQktYcFCfHVT+oJuggV8gfyE0npNz6UQq4sURrKxQhBNScqbMkJf0x9TjakEVYVHRlFX68Jzg+7mBTDN6ZSwH6TnK9/N8GlROK921f0/fpz3+U1/nfFA7ySBMptbkjNy5ZZSwaFYHVkW0SJMDTT4BoJrcAxeLqCwqy4lg2FMkwT+IDq8tnXZMEERISldjzhVg1Ek5otEmRNpUPAScqFBPf1W/f2LbxrlW2KSf/p4TDDkXCJkNyr3d5fVOOekCKFMjEqd6OW8kZ8YCXAXP8dL5sT94TgWh4jSTKD2w8zCCkpmIjnxglSonpeqpcrtdfk8Xzst2/mWTbbKxVRmfyWRW8sSOH9rZy+zuhnNpQl2isFnhLo9GZH7iCiBCQ7W43FkDayr0uV1/rRZxlN77/5eiPUh4bHHg4uj1y8/3ly0Xa7EEmlduvYwFIiO2LN2ky+5g8MnEYXgjLhlQLILC3G4PJNIRlqcFArFAtiWTpMUN8veMAmPuy1ypjVZZqDtgBlYfhzsALXEgwRWM91MuC4kskUDDmTFYLlLWT1zIC2YgiH8FshFCwYrjLpoWKWkpZ4JUSkKzUsJwJJGSpkpywx2NcAMvaia6QbfALYhG+nrqpl3pKQbaaAuAgNQEXICNXmPQZjWnc5LfIA0VMe0oA3/IMtUifoOO6UxDVVf1TM1y7u6VP/1zeC5Omb6ZJ78UEa31KpuMhQVMuN3WtddM1DRhj7qB72UIV00qmtjkNcToIZMw3+E++j6igqjFTyIJcIV65ATgjopezvETSAGLCRQuPxwcBnAvYdgqki0TrPeurv9p9/+djhzE4DgT3/xU5JH0L2QP5g/OyeOGGkQCp8+RILulahn7evNRJJUg9EMZziI8SMVQjsRAIfJ0mFxnFPChAnCLQCHS85V435Hb/kPjcCGWApLNhC7uXXXuLosXxSaH69rN83eiMPz/gUSy66vZe7tbW08fBDa3knlljk+MgwHOkjj2Wg+6gBUol8S9pLoNXandfbq7O7tqT3qDlPB8Fe72/imTafF48v+efHyovjNh+urjjuwvvf142fxUIBlceXuDupgLUM6F7w14GDm4KtnMc6JFwJizBciUfLVkkoQ0iZrFXm22EFkpdwivk63iwiGF2pyDcYxuwKVZtnhpw5oDQIJ/YGTuWNATSEAR1lzjwsDHKZFV9I6xSERiSAmmCaACz+kfggRhGMCuSKq6gc89pVbTYzWCAKQgceJWJyT7NSqY36qE6VTyEGzn5FR1RlxIh3U4arqE/3UwtrBdopIx5L013pNmGRwTx7aKgyLZWgGx8T/Td9EATQhonIaE96aj26DuLzpjFd/aM+INhVwyEF3zJWhHtWhj1OBedMUNZ0Bg1VY0opuouFQNWqO9tS1kFVvUWzQXxmP6TyaD2Ey6LL0UzrPQCU0JCvI69mv105IFHry/vT04zmR4NtsBVmNr758QGYGIlRWC4VG4firZ5s7mfmTJ4ccheVMCfJQ3EVp8vCNk/8LsZGojM19iE8KZBj9wo+1FH85uqu2iHMg7HezK9SsNQvFSj5fvqv2TkuWPQ9zqD25uJJIxba2c3v313ee3k9tbI+CCRsgeInJNbFwuncRkMMVxfmYNCluHx4FhfPLwqf8IG9tLecy95ZJf9P2dwfTVv+q9OI/Xp9d2uVOv9qcdmfudMBv9/vB2RRuzkl4FHiU/gXiZ3Ux87BqAK+Ilol/kEVM2ha+GQHv3vZmLBQSy78t9Vp13OSAvOLnOKqIZlkfpthAS9JYgBLu6DYA1SKRdxxwO7eEIgI1f354T/RAJaATMOK/eaQ7sGJTl2SCmJ10HoCnPUM0NgzRwo+//ounexuraysrpIGhBHk/+cTjcQqSqY7spSRzTcKu8EsK4pqBsIdHwobABjF00xVRl/CQFjUWMwLDoxHPOLCKLHhFg+E3l/xGHNAtjUG8TQPmRaHoD5XouxmiU5u+8vxzUfNFz8FaY2vS6yIQCvOfD5PE26CymkW4Sl790BAXPOEenWVNYtrkLbP0UhQM6qG4NHsNAkWcYQx7GgdV8V0WJOomWoN70rU6tVI4Er/6ePTm1ZvqwEcqJdSbRCxqtbr562tCly0veO+txx7skLqbQ6wxck/wPqtvtJC4crwSi46cDDhc4Ws3CpK2HsD38JXAIseamC0IVGZ0DNywp9UKucnrxdv6bbVVt0c25nU32sic/ErEyl7ZWd97erB+sJnMZKa+MD40JONJdQfxxewonEJpATXwNCUnaaP9NpSuN2v2h38ppiLLjx4eeEPewsC+bpFzt9wcdo8/EdS+53JH3ZM2qdnWD/bdyTTuTHvZzLRj5SslQkjjkKxos4Mh8T7wZ1LE2NGYRHKEplvKptMJotyEbi6v7m5K6I16Kpg4XFPgEa4IPoKlgGTUGzFhAz/mh/t8k9Rj2g1Ikb3AWdf68IWiwhGO7RuLkakFfUeoaHDB/BWfxvBkZDb1c43qb7ZxVAESPHh0UbksWRg/8GmZl5rUzTYEKUeZeUI5YMYi8gSnj5czRDnF5EDE/CgppmPQSnyJPGKIcvJbxWNRGnVMGKg+pn2aFjbxQ5MMUUybw4RiqwzejEbIpi8GcVWY7guLdWGGrZFquBCPJJLI26ECjR0tQ7SkKrTkFzVSmJaMjAFhxdc1zbAR81AzrVnjlzopSakZ5BlqoepAK+TDMKhTXeYDhWBVl1s/bcG5scqoE+Qd7Fbt2g35+e5u6nbx+PGauz7x3HSCtVrj9OPZ3W2J/cx769FfPD/Y2cgxaWy30V+SO8+x1qPHYPwn2BgWP5YnXCBVIMd2W1IVwGDVwVCi5HBTmzVosXJTaecLJNsejebe3sTdJCJOIJJZyuyvrew/fbD39GFyJecJc8B3hhcRkoLJ6I6tOKNRqKCIp9s5y799f1HstRlsYWHd8s1D65u7T370vD22rgqlN99/OikUCiPLIvLcdIloEASL4pQvQSnXt++dXd8SrSTQ66UieMMqQy6bFBEif3gD6IgsbNbXVkhnmEmFQBWc9kpnJ+eczMI5XD76mkvBSrCU3BWKAiqmVFMJLDAvSJNWEUqYYrqPVigs1YzoTV7jsa6EJgBPygvbNPJM45Zhfn/Uy803wG50HmGgQwkmhpII0QDZ5fubXzzDt5SlG27YHn+IdIJEDJuR4GszSyky53SVVLA/aLaOSTaKCAFcEstKm+LxREkkmkzEl0gepkijwTS5DRJx4sYkSZGVTHJBednLGQIuTmhgnCSm684QJQp1JSSmiHrMPzNKU0aPzOg1aoYtnDRPNU16YB6amTE6NHf14Qb16YIr81V/TN1GANEE2Ka+CKkFGtgN6GfoEFsPBENDgINeq+d6mTRDshbIYIFSiJpC0Kt+q5ZY2br4eFY9fpMKDhOY4Geey+vbP7w8W88mf/4493g3vbNOQlgCVrOrg3GfzEBs/bBEJIcQqUhGABDmRZg59U62YJYeMidBGwTexy2+Um7kC3enl+T1oZRHeRuJeIVQCoa27u0/+errnYN76dWVYDxJLDdWtyR1Z55J8KyVxWySWsgFZ157OHH179r1CgF58sXbcByCOLyzbojtWLEbrtLVycnJd9+9aXeG1dnEYlrG/bVMaDKr++ekNGms7e5YbZtdrfFwWO40AtmUZzxZZFFBfGeOeQ07jXoV26ln1M0txol6dPruPenslHQcCtWeqPCV8QmFBV3gw5yKJBiwYckgmkAv7q+CDqujAJeO8i44oz0DLcFGsFBoEq3y5mSx4KHYFTOs2jVwpyZ58hrOK42Xp0ww3AxHXKlafLSuc/vS7m4myXRxhm1Kno/76SVAQIOYPJhLjv1TnAiPJLalLjKvsuvBgWPsdcT4aXbGdn9kd8r5eumU8M4wK7qIrc7PVgy5gxdSUqjIoRtNp4hTFCGwKzeJeIqUDBMrS65P+N2h50pJk6bEWOSzIxzmF9OhyXLIHyQVLpovGjk/TJGoh4JiH8aO5rxqZkRKDggv/BaX1xNHqQG5WcbqTc2XhCIIrs029EckBtJRXdFyhefcM2IAlkF7+IKadfKAmKF382jq1TcvW8fvF7y9edxP2qqwb/7jw6WH24nt1VSS4H/yXtFkIlqZE4AMZpOBFVdGpbEbcKbJrbR1CBbi9cPySdOCekrUkXrr5vquWKhflxptxWlWw0CN/CKp1ZWf/fRP9n70xdLKajKTZuaokppd/Z7SF7Dmkk7HCXtvd0C8wFGjVCMVWRw3zH6vVm3uLm3Cz8u2XT2aXJ+ffXr//tf//XIeSWCQtEmy7feSNoPEyF27SbwGfCeAhtKmdttkuNK5hSkZLX2sATh5SyKJlmWjEa/nUsRB4eB4s1RsElOu1sQMLFuBjPpmngUiwEov+QBUbfwzHO0ZalYFCoc+TEG+CPsN1mrlLygYUIPl+P0Td1DKvtGZEMcGaQQpDFHCEN4WrnsISUj1TD5fhfkYUqdEIAeYlBUvBRmgUbY+lK6QclASEaHZycEwxKJPe+J4SnjHjJCTTMYhAOID/FhxEooMqhPxnOLwITo6XVmzO7hyjwi+O+j0RlZ31LSrV3fFLuH4wRoshoTNiETpNq5aKXbhFxNkisfbJRWPJKLBJXLgKJ3qPBoO02N8tGkGiuE4BL1lCEDVCEx1Sz8aFddcMUGMQHecwWtS9UX2Y6Stw+QpIWwUmzfTokmXHETxY25AfU2oKuFtzR8zQBF4gSZYVCBbmSRZrz3rWoN+G9F+/P7N1cv/S8y6s8gsmFtL5nJE2FwxW2ZwJDEa0FmxhTjFQqBOG/wmgJ6xqWFgcGGFwcIjilZur/mky2HAAWHtr/KlUhmnTGSsnwwRPeIakph1NbP76NHBl083D/djyYwvzJoBQx6WW+zopMaz6R8prIivhnyZcVakWCmfXZIc1RULezLZu6tCPBzZ21gnFcKLq+Pffzz6dHRauDi32MuLJIkV7iOo0UKMk8fA0j8NTHFxs3tzRdHyo9/ORt1pjygSbLWFmiSylqfqfDGVWFxIYznDQlC9vrLqdZyFYDlR0rkwJH4EHIAAKEAwzatAoyfAgAvJPKExEy1JazBeVKI7lDScSZyLLUn8PxUOiF0QTA9i8dJoxKWk36pmNcOkcwyVw9oYb2WWpQmJBrVLASQkss2UExMVwYGXXh+bQkQ4kBmIePVsWhArI0TiOkViYseOgLc0KCQSOBUTxezD4Gw4JbcO7rq8iPmafZtslNw7GDek3WBRBLUwIsNUSDTX7I+twazRGdQaCIxZtdW2LRd5m1+8es+mDwdn2RkkO9r6ag6LGbldIyF2yn0koVpKpyP4zQa8S4sJsmquk4Z7dYWph5Fq0JpDWoNFyy4pzZKOMiMiCOaVjusfWKsFF//g8xSSFNXWtC6QA5xTkQVDQlGLRObGMA6JbqZEBiIMxcSghNH2Z8Nu4d073o4tr75+8T+Vt6984Ijf9WBrd213WVF6vFGAzyELJp/tMM7t0SUyq3CTsMhkpUcfIPyOG4WBjS2ijejouseq1MhsfXZexIGALJXkKOFoGNEMMUWzwAzn0l/+7CePvn6+cW+fsCcEMvYuRORCJq8BTpthmfC2mi2lzG1b5UazWrnrFSrpvisTTZJgqBh2WaRQIVHXdPrt2dH3ZydHF0XbGt5eFyeucXh10x9Z6leKY/IMhFAt2MkfTGxCivT7VoMlXTidTEQj9XJ1IRgiL6BFEthRn2TpDx/cZ8+4UipUC2W7KeFgFJ7PvEhoKTblcBSD+mbGYTUwHQezRQwwKSEiPyCuwClJzst6JJyGT4P3zBrxHIEdyGXIBLwmp5bgJZOPSvICNQtynDHVetdpX9SBvRUyULw9mT8dZmpEE89QWfA+mhhfKxi0V17X8wkEwB3tfRryoTEWGlojigHiX6htI+pyVAvRhgYCtgkh4Z2GfkFHd9Q1x9yXiyBo8BIPsuQUZsz9ZGK0SG3QmRRITotwJV/vAEIKNmtVi9RzjZbqcHlb3SFUxAWbdeEgSZ9I4xd98viQUDAba0tgfYoMUulFVhoLJHLAjNuzTskNctto9mWaYDULeZOIF2ssFTJ/rDPXMuk//+XPcT0HHEhY5l1TJ+GAuw6SQNtMkJfR+6EPr/FcD2uTEy4Mp3W7k/eftMqFl7/5t8rJ0bjb2d5eOjzAiJbFfMlKVmFm0YJ7Nq3BpFjCMitkuYjG44mVVSgR7UGAxRWA9DrueafWbJabZxdFAvvdtXAXRiMMEPJ8CPYTUmcl8/jJw4dPn6U310iNW67VQR7SssUX0KcUW50stQNclFsoN92m3cSrAC6WDi1sH6Yxq7I25ZjVYDbJVyodq31bLH46urDHLpT5iG8BQz7iX5EG/R1/f0BwncxSdjS0Zqy+I0TnZ+cBLjOLcGCFsFz4ptaJxmPDjva3V3c31tn0O3571K43UJLxe5GbPkhgUMBMqyhAKCHuL/0C5EbTlcYPtgpbNO+CgBHUfDNcVhxJaqsWuET0J0wbftTGeUE4JhHND0gIy+MS8SyWL9sCBmT2omXbUf1OT0B2h7qoi36oMTpJg0JRBDv10Bvf4lKWtYxRADwuAtSRgpg1UkhSX21pdci7wgk6xhB0KhwOz+tG3EiZ5tJ0S+1qUNAiL/GW2qUYtkb2vilEqD76l2JzJOjeCLi/yiVm7iSSng0Dum4PRpxyJqtlvlzvTz2laouzUYR4sjg8isQjS2F98PLlawiPpN1QKe5XrFsy2cz2Svb+xvL2UtQq5X/3+zd37WFrMGvhngVVhcMcUtVSzOV+sLN1E48/fvYggX+jJCk9guPBlAkDyrU4hUQcQ4MYFGaTdFqsZiJot25iQnGkwxu8+vC7T9/8akxupeno+fPDwwebaIJuvJ3Jj0TqrGGbVFbQVq9dJQi2gj/48JDMEjNNdbPw7Y3gl8STxVuyUqyfXVYLVZJGEHfJO56F2UQbYZcLBTf2tx5/+Wj/4T2ZjHQuT3YoNpxwmyH+sjUYTIY2TIh1Vb1tjeVTYLs6/cxiJre7U6tjtywHomHCnhdbzVdHJ9+9/USgG46Pk8IuuJDeX8sRybDdqY3sUYT08LNOPLG49+DH5JA++vA6vbixs7n7/ncvYYxADt+V0tVVq1LicNrjw50t9nfbrePv31j1Bt5QoLlODDB3wjEoW4o/yG4krn6BAsb8CF8R/xWzNJZCXfDQ0ICkr5CS90A2He8JIHl8JDCB6bNAlB4pWAEntcVkCNvAbfgju7lkJ4AAVLkQ1QGrdHpqx57Atgr8j2jYrAF4mZvAGWRQLDja46Xv/u5vCXoIAehdngsXRJ1qUeMyUos+agB0BdQ3gsA0ACWYrrEu+Iz6Gpda16RQmxFnjJjXuYS2qVgfSvOcr5JRBhNF+fzwrlZIzBpBurU45rfSRLH4HuNbPmoPZr2xZ+jyIx+avUHT6uM7kI0H99cSz7bTG8kI0QmMHsuB1KZ8CUz+VlwK7P74cP/+r1/8Ib6SW4tHtzY30O+1WmcpzlImSO5TYm7AU9n5QFUheZGLlKALsRjMm4w4XfKmeIMXL/49/+pf7fZdNLHw+OG9RVKgLC4aIxce0WAn+YLbERID6/yU7Bs+tmVDVAUz5bT5vNvuE5i+XGp2+mNyj9daHDYn8g7HrBi1wiMmlpeefPX04bPDza1NwhRyaozEZwMXm1c+lMq6bZnciViiY0RCxwDDYQV5Y4/nMeoiO4zNwVv7smmldnfz5ZvT64tSrVq4uiG5OkKclOY7B/fpntVqViqlmT2OEcgp4JvgxReM/PIv/+rb3/xzMX+xvneYXlqqXF64uq1Y0Hd1cYXxZy2bXc1m+p1O+eaGwGxo2WA6LF+bh4I0kITnccW1/gnG0ksNy4d9UkAYJoALxPwYvUXYhvOfQRWQkz0dJo4z9sSb9oMs8GeDK0wmOAlHxj4HToKRI2XGhCXyG44sNqsH6osWHtQDp4eQoopY7oUT3tnjwRhjBlAVjbGiEGs3ipJMExh80LnVebAREQ1lwKgNHWjRKNJhDKwhWQWpzyIWHqsl5wKKROt2TM+MkkfQmEiGZhiCQ+D6q2lQzaIylWAquNCaRv3nI99jM5+shlGPETjuaTqlOtk4JgUEm0iDPut74q4Fh/NITwaeeTwcyCQWsFoMqpYaYcno8T5YTZGYCpMU3zlwCqJMZm2yeX58c7a3lpsEYto6QaxqsaTFLu2D/6z5pLu7XFixup367ko2k1ykH8l0olv5OL/9dn1p5N97tLO3xXIJRbE3YLcIDV+nXBgbtjm2ShRXR+YkIvWwPG3DfAZDV7U5PD4vXRbI+ED+qkmXXLaIbIVvIvKuL7O+/PDrp8++fpZbX4EKxRTNVnNnNK8Nx0kSgBEMnMJBD1noMFMSEoSjIizXLBZazXb/7TEOn98dnY8IobC2+vEff2V1FRmQBQPaXnJrfW3rQa87KV0fc74mGY893t7PLa3dXN9UqrckGcTNme1qIjyEwMBudwxV9OxRs9Eb9XLJhezS9rAzfP/dO2LrA3F+wC2dAwLhpJQL3uLJoBQAFowhflgYYBWyGFZHKT0zdMBzhxVS0mA000egdC+O02yIy3WArwZtzCwCJKiE35T1ICfnLCNxM2VWWQgBOxrQE/WBzpDnCenhigQ8LMVJuIXCgtMv/F7hrwyCC8FEhzIGcUlgLEXzIzWHalD/NQA9k4jQEHRDt+gC9VPsMyWprDwDJJg0Ugqqr/KOYO2ouTF0hAjhgsLcw2MEStN4zbSoYr1KeeGcNDFWLKZd6lEhKENHRagYdsNy3EuUGL9PjmisOCms9Tteyf1h9a6mNRDaOi9KnvIXrsoZaxwKsFtpwOg0JHJol+wRCBoi82WI+eMppSEA+kG3GaNQl3CWs3k4lmj3B9FAF2cxckqEvIPNw9WAZyNIpHyva9DtyWWOyDbkmeKoCjYDzFhBUt+hDhOTmfxg0qNaVi9f6uRL7Uq9C+fnPGyPvS2Xe4QbPGdbY7GDR48fP3+6/2CHsHquENE/QIMFkEuKoQ6AASx/pWnlEt5MIknmiGavPpJ1ZowNpsFZ2an7bT7fPT2P9dwnperlyA5UK32OLg4GjDuWTgGt3mBUuy02Kq3FiH8jm7s+O1uNp1gEl+vNH//kz5Yz6V/9w9///uq3MK10NNG4KV6fvI+GfSvJeMgbbzean16/65MUGb8xuqLAuxCAGKiALdCqj/xycFbsUdjAD4wNyAFGUwpeIy2FF7jDm/qIYvBrcrtQeLALaAcEpUsQFOrzTFWrLASD4Yi4nTjuYpZlg1AEwSQ7zRuuD4qwYp5HA+540B2PsOqlMDCgBpa30Cz0YpBaCM2lqIXXfZioaQmDmmjIaCkGs+kpj43sor8idkYouaWR0zGjLms4QmUNGSRThfpH57AnMACqEFmoXowqKPrYv+DZ1KNqJEdYNortc6WCGGDNIxCUb1AHCcbwHWGB5vLZs+B46iWpFUzRtqc9dB3M0oTNgVeit88Jtq7h0BUCxwTmg6BnSmARdpnIZQpomQ9WamzSzabVVotolZNAPIgdJr2cIf8rXh7OuUdoQPUwo6KjOXkgmFF/1L+0ujZs8KhJjrXxsEkCXggFwQjtge9k+ZC8Y51DVFCMbZzhGntKd+3bKl7EzSY+Nx1QaNSfuFAdiBqHPW8xu7x9eO/RF1/s7O1g/cVCrcNYZN5mQwatAOAhISACUkdAmES/6ZKoc0hSI/xRY5llOjyYznDJf3t6/e1//q/rpoIfcwWAh31gQDgUqw1GHPINsIszmcYCEZ81vJ9biQRc93c2Ca6Ty64ur26//fCxclW0y6VyocgxfeUG9Eyy2fTa7gb+eB2SQl6Xhh0y1cAYWI9KbwZZBXsQU7gnuPELZg+OyIYgiIt7I+GFX0I4gduAxqxhndeEIEgS8XWQBlmKEQPOLdMi887U8kdbwKANlXA0Ys5WHmAaKgAplCgBQkEqM4xfdh40Ga0c/K6gh0i94PGEtQE+J5yyBs/EHE23BFn1XHgKxtGz/weaZkz/WVSQvgAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                                                       User:                                                       \n",
+       "\n",
+       "approve                                                                                                            \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[1mUser:\u001b[0m \n", + "\n", + "approve \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ "runtime.start()\n", + "session_id = str(uuid.uuid4())\n", "await runtime.publish_message(\n", " GroupChatMessage(\n", - " body=UserMessage(content=\"Please write a short poem about a dragon with illustration.\", source=\"User\")\n", + " body=UserMessage(\n", + " content=\"Please write a short story about the gingerbread man with photo-realistic illustrations.\",\n", + " source=\"User\",\n", + " )\n", " ),\n", - " DefaultTopicId(),\n", + " TopicId(type=group_chat_topic_type, source=session_id),\n", ")\n", "await runtime.stop_when_idle()" ] @@ -394,13 +1169,31 @@ "metadata": {}, "source": [ "From the output, you can see the writer, illustrator, and editor agents\n", - "taking turns to speak and collaborate to generate a poem with an illustration." + "taking turns to speak and collaborate to generate a picture book, before\n", + "asking for final approval from the user." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Next Steps\n", + "\n", + "This example showcases a simple implementation of the group chat pattern -- \n", + "**it is not meant to be used in real applications.** You can improve the\n", + "speaker selection algorithm. For example, you can avoid using LLM when simple\n", + "rules are sufficient and more reliable: \n", + "you can use a rule that the editor always speaks after the writer.\n", + "\n", + "The [AgentChat API](../../agentchat-user-guide/index.md) provides a high-level\n", + "API for selector group chat. It has more features but mostly shares the same\n", + "design as this implementation." ] } ], "metadata": { "kernelspec": { - "display_name": "autogen_core", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -414,7 +1207,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/groupchat.svg b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/groupchat.svg new file mode 100644 index 000000000000..adc6d7a2a4c8 --- /dev/null +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/groupchat.svg @@ -0,0 +1,3 @@ + + +
2. RequestToSpeak
2. RequestToSpeak
4. RequestToSpeak
4. RequestToSpeak
Group Chat Manager Agent
Group Chat Manag...
3. GroupChatMessage
3. GroupChatMessage
3. GroupChatMessage
3. GroupChatMessage
Writer Agent
Writer Agent
Editor Agent
Editor Agent
User Agent
User Agent
Illustrator Agent
Illustrator Agent \ No newline at end of file From 8895e014a8d4836cb8ebb5dd53c7124c10004bc6 Mon Sep 17 00:00:00 2001 From: Taylor Rockey Date: Fri, 18 Oct 2024 15:19:24 -0700 Subject: [PATCH 003/173] Update README.md for Sematic Router Example (#3846) Added contributors to recognize the other devs who helped build the example Co-authored-by: Eric Zhu --- .../packages/autogen-core/samples/semantic_router/README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/python/packages/autogen-core/samples/semantic_router/README.md b/python/packages/autogen-core/samples/semantic_router/README.md index 6ba8b4c3aa8f..2fbbd7de715d 100644 --- a/python/packages/autogen-core/samples/semantic_router/README.md +++ b/python/packages/autogen-core/samples/semantic_router/README.md @@ -75,3 +75,8 @@ sequenceDiagram User_Proxy_Agent->>Closure_Agent: Confirm session end Closure_Agent->>User: Display session end message ``` +### Contributors + +- Diana Iftimie (@diftimieMSFT) +- Oscar Fimbres (@ofimbres) +- Taylor Rockey (@tarockey) From 2e59a0db3ec42c6b1a357a3f789e98c11cc45a27 Mon Sep 17 00:00:00 2001 From: Eric Zhu Date: Sat, 19 Oct 2024 09:04:25 +0200 Subject: [PATCH 004/173] Use dall-e-3 and better prompt to create character consistency for group chat image generation example (#3847) * Use dall-e-3 and better prompt to create character consistency for group chat image generation example * format --- .../design-patterns/group-chat.ipynb | 769 +++++++++--------- 1 file changed, 389 insertions(+), 380 deletions(-) diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb index 134ea6684df8..14dc6d2e9fef 100644 --- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb @@ -254,24 +254,25 @@ " description=description,\n", " group_chat_topic_type=group_chat_topic_type,\n", " model_client=model_client,\n", - " system_message=\"You are an Illustrator. You use the generate_image tool to create images given user's requirement.\",\n", + " system_message=\"You are an Illustrator. You use the generate_image tool to create images given user's requirement. \"\n", + " \"Make sure the images have consistent characters and style.\",\n", " )\n", " self._image_client = image_client\n", " self._image_gen_tool = FunctionTool(\n", - " self._image_gen,\n", - " name=\"generate_image\",\n", - " description=\"Call this to generate an image given a text description.\",\n", + " self._image_gen, name=\"generate_image\", description=\"Call this to generate an image. \"\n", " )\n", "\n", - " async def _image_gen(self, description: str) -> str:\n", + " async def _image_gen(\n", + " self, character_appearence: str, style_attributes: str, worn_and_carried: str, scenario: str\n", + " ) -> str:\n", + " prompt = f\"Digital painting of a {character_appearence} character with {style_attributes}. Wearing {worn_and_carried}, {scenario}.\"\n", " response = await self._image_client.images.generate(\n", - " prompt=description.strip(), model=\"dall-e-2\", response_format=\"b64_json\", size=\"256x256\"\n", + " prompt=prompt, model=\"dall-e-3\", response_format=\"b64_json\", size=\"1024x1024\"\n", " )\n", " return response.data[0].b64_json # type: ignore\n", "\n", " @message_handler\n", " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None: # type: ignore\n", - " # print(f\"\\n{'-'*80}\\n{self.id.type}:\", flush=True)\n", " Console().print(Markdown(f\"### {self.id.type}: \"))\n", " self._chat_history.append(\n", " UserMessage(content=f\"Transferred to {self.id.type}, adopt the persona immediately.\", source=\"system\")\n", @@ -289,10 +290,10 @@ " images: List[str | Image] = []\n", " for tool_call in completion.content:\n", " arguments = json.loads(tool_call.arguments)\n", - " # print(arguments[\"description\"], flush=True)\n", - " Console().print(Markdown(arguments[\"description\"]))\n", + " Console().print(arguments)\n", " result = await self._image_gen_tool.run_json(arguments, ctx.cancellation_token)\n", " image = Image.from_base64(self._image_gen_tool.return_value_as_string(result))\n", + " image = Image.from_pil(image.image.resize((256, 256)))\n", " display(image.image) # type: ignore\n", " images.append(image)\n", " await self.publish_message(\n", @@ -589,284 +590,143 @@ { "data": { "text/html": [ - "
Title: The Gingerbread Escape                                                                                      \n",
-       "\n",
-       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
-       "In the cozy corner of a quaint, storybook village, nestled between snowy pine trees and bustling with the scent of \n",
-       "cinnamon and cloves, lived an elderly baker named Mrs. Mortimer. Renowned for her confections, she was the heart of\n",
-       "the village, especially during the Christmas season. One frosty afternoon, she decided to bake something special—a \n",
-       "gingerbread man unlike any other.                                                                                  \n",
+       "
Title: The Escape of the Gingerbread Man                                                                           \n",
        "\n",
-       "[Illustration: A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs.  \n",
-       "Mortimer, with her rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused          \n",
-       "determination. Snowflakes gently blanket the world outside her window.]                                            \n",
+       "Illustration 1: A Rustic Kitchen Scene In a quaint little cottage at the edge of an enchanted forest, an elderly   \n",
+       "woman, with flour-dusted hands, carefully shapes gingerbread dough on a wooden counter. The aroma of ginger,       \n",
+       "cinnamon, and cloves wafts through the air as a warm breeze from the open window dances with fluttering curtains.  \n",
+       "The sunlight gently permeates the cozy kitchen, casting a golden hue over the flour-dusted surfaces and the rolling\n",
+       "pin. Heartfelt trinkets and rustic decorations adorn the shelves - signs of a lived-in, lovingly nurtured home.    \n",
        "\n",
-       "As if infused with magic, the moment the gingerbread man emerged from the oven, he sprang to life. His eyes, two   \n",
-       "shiny raisins, twinkled with mischief. His mouth, a curve of icing sugar, grinned widely. Before Mrs. Mortimer     \n",
-       "could reach him, he leaped off the baking sheet and dashed out the door.                                           \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Story:                                                                                                             \n",
        "\n",
-       "[Illustration: The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind \n",
-       "him, Mrs. Mortimer's surprised expression captures the moment of unexpected enchantment.]                          \n",
+       "Once there was an old woman who lived alone in a charming cottage, her days filled with the joyful art of baking.  \n",
+       "One sunny afternoon, she decided to make a special gingerbread man to keep her company. As she shaped him tenderly \n",
+       "and placed him in the oven, she couldn't help but smile at the delight he might bring.                             \n",
        "\n",
-       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, his voice carrying through\n",
-       "the snowy village. Mrs. Mortimer, despite her age, gave chase, her laughter echoing through the streets.           \n",
+       "But to her astonishment, once she opened the oven door to check on her creation, the gingerbread man leapt out,    \n",
+       "suddenly alive. His eyes were bright as beads, and his smile cheeky and wide. \"Run, run, as fast as you can! You   \n",
+       "can't catch me, I'm the Gingerbread Man!\" he laughed, darting towards the door.                                    \n",
        "\n",
-       "Down the cobblestone path he sprinted, encountering a group of children building snowmen. Their eyes widened in    \n",
-       "amazement at the cookie on the run. \"Catch him!\" one shouted, but like a gust of winter wind, he was gone before   \n",
-       "they could even stretch their fingers.                                                                             \n",
+       "The old woman, chuckling at the unexpected mischief, gave chase, but her footsteps were slow with the weight of    \n",
+       "age. The Gingerbread Man raced out of the door and into the sunny afternoon.                                       \n",
        "\n",
-       "[Illustration: A lively winter scene featuring children wearing colorful scarves and mittens as they pause from    \n",
-       "their snow-play to gape at the gingerbread man sprinting past.]                                                    \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Illustration 2: A Frolic Through the Meadow The Gingerbread Man darts through a vibrant meadow, his arms swinging  \n",
+       "joyously by his sides. Behind him trails the old woman, her apron flapping in the wind as she gently tries to catch\n",
+       "up. Wildflowers of every color bloom vividly under the radiant sky, painting the scene with shades of nature's     \n",
+       "brilliance. Birds flit through the sky and a stream babbles nearby, oblivious to the chase taking place below.     \n",
        "\n",
-       "Next, the gingerbread man sped past a farmer tending to his flock. \"Stop, little man!\" called the farmer, shaking  \n",
-       "his shovel in surprise. But the gingerbread man only chuckled, his tiny feet kicking up delicate swirls of snow,   \n",
-       "leaving the man and animals staring in wonder.                                                                     \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Continuing his sprint, the Gingerbread Man encountered a cow grazing peacefully. Intrigued, the cow trotted        \n",
+       "forward. \"Stop, Gingerbread Man! I wish to eat you!\" she called, but the Gingerbread Man only twirled in a teasing \n",
+       "jig, flashing his icing smile before darting off again.                                                            \n",
        "\n",
-       "[Illustration: A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking    \n",
-       "towards the gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.]  \n",
+       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, leaving the cow in his    \n",
+       "spicy wake.                                                                                                        \n",
        "\n",
-       "Onward he ran until he reached the edge of the village, where the river flowed, its icy surface glistening under   \n",
-       "the pale winter sun. A sly fox, watching from the riverbank, licked his lips and called out, \"Need help crossing,  \n",
-       "dear gingerbread man?\"                                                                                             \n",
+       "As he zoomed across the meadow, he spied a cautious horse in a nearby paddock, who neighed, \"Oh! You look          \n",
+       "delicious! I want to eat you!\" But the Gingerbread Man only laughed, his feet barely touching the earth. The horse \n",
+       "joined the trail, hooves pounding, but even he couldn't match the Gingerbread Man's pace.                          \n",
        "\n",
-       "Unaware of the fox's intentions, the gingerbread man hesitated, uncertainty flickering in his chocolatey eyes.     \n",
-       "Seeing the baker and villagers in the distance, he nodded, \"Yes, I need to be across!\"                             \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Illustration 3: A Bridge Over a Sparkling River Arriving at a wooden bridge across a shimmering river, the         \n",
+       "Gingerbread Man pauses momentarily, his silhouette against the glistening water. Sunlight sparkles off the water's \n",
+       "soft ripples casting reflections that dance like small constellations. A sly fox emerges from the shadows of a     \n",
+       "blooming willow on the riverbank, his eyes alight with cunning and curiosity.                                      \n",
        "\n",
-       "\"Hop onto my back,\" the fox offered, with a cunning smile.                                                         \n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "The Gingerbread Man bounded onto the bridge and skirted past a sly, watching fox. \"Foolish Gingerbread Man,\" the   \n",
+       "fox mused aloud, \"you might have outrun them all, but you can't possibly swim across that river.\"                  \n",
        "\n",
-       "As they crossed, the waters rose higher. \"Climb to my shoulders,\" the fox suggested. Then as the water's icy       \n",
-       "fingers reached again, \"Onto my nose, dear fellow.\"                                                                \n",
+       "Pausing, the Gingerbread Man considered this dilemma. But the fox, oh so clever, offered a dangerous solution.     \n",
+       "\"Climb on my back, and I'll carry you across safely,\" he suggested with a sly smile.                               \n",
        "\n",
-       "[Illustration: A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the      \n",
-       "gingerbread man precariously poised on his nose, steam rising subtly from the flowing water.]                      \n",
+       "Gingerbread thought himself smarter than that but hesitated, fearing the water or being pursued by the tired,      \n",
+       "hungry crowd now gathering. \"Promise you won't eat me?\" he ventured.                                               \n",
        "\n",
-       "And just when the gingerbread man thought he had outwitted everyone, with a snap of jaws quicker than a winter's   \n",
-       "breeze, he found his adventure coming to an end. The sly fox had outsmarted him after all.                         \n",
+       "\"Of course,\" the fox reassured, a gleam in his eyes that the others pondered from a distance.                      \n",
        "\n",
-       "Back in her kitchen, Mrs. Mortimer sighed with a warm, knowing smile as she dusted flour from her hands. As she    \n",
-       "began rolling out the dough once more, her heart was full. The gingerbread man's short-lived escape was a story for\n",
-       "her village to savor, right alongside her next batch of gingerbread cookies.                                       \n",
+       "As they crossed the river, the gingerbread man confident on his ride, the old woman, cow, and horse hoped for his  \n",
+       "safety. Yet, nearing the middle, the crafty fox tilted his chin and swiftly snapped, swallowing the gingerbread man\n",
+       "whole.                                                                                                             \n",
        "\n",
-       "[Illustration: Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting,   \n",
-       "daylight fading outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while \n",
-       "crumbs of the day's adventures seem to linger, cherished in memory.]                                               \n",
+       "Bewildered but awed by the clever twist they had witnessed, the old woman hung her head while the cow and horse    \n",
+       "ambled away, pondering the fate of the boisterous Gingerbread Man.                                                 \n",
        "\n",
-       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
-       "And so, the tale of the gingerbread man remained a cherished story, whispered through generations, each retelling  \n",
-       "sweeter than the last cookie from Mrs. Mortimer’s oven.                                                            \n",
+       "The fox, licking his lips, ambled along the river, savoring his victory, leaving an air of mystery hovering above  \n",
+       "the shimmering waters, where the memory of the Gingerbread Man's spirited run lingered long after.                 \n",
        "
\n"
       ],
       "text/plain": [
-       "Title: \u001b[1mThe Gingerbread Escape\u001b[0m                                                                                      \n",
-       "\n",
-       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
-       "In the cozy corner of a quaint, storybook village, nestled between snowy pine trees and bustling with the scent of \n",
-       "cinnamon and cloves, lived an elderly baker named Mrs. Mortimer. Renowned for her confections, she was the heart of\n",
-       "the village, especially during the Christmas season. One frosty afternoon, she decided to bake something special—a \n",
-       "gingerbread man unlike any other.                                                                                  \n",
+       "\u001b[1mTitle: The Escape of the Gingerbread Man\u001b[0m                                                                           \n",
        "\n",
-       "\u001b[1m[Illustration: A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. \u001b[0m \n",
-       "\u001b[1mMortimer, with her rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused \u001b[0m         \n",
-       "\u001b[1mdetermination. Snowflakes gently blanket the world outside her window.]\u001b[0m                                            \n",
+       "\u001b[1mIllustration 1: A Rustic Kitchen Scene\u001b[0m In a quaint little cottage at the edge of an enchanted forest, an elderly   \n",
+       "woman, with flour-dusted hands, carefully shapes gingerbread dough on a wooden counter. The aroma of ginger,       \n",
+       "cinnamon, and cloves wafts through the air as a warm breeze from the open window dances with fluttering curtains.  \n",
+       "The sunlight gently permeates the cozy kitchen, casting a golden hue over the flour-dusted surfaces and the rolling\n",
+       "pin. Heartfelt trinkets and rustic decorations adorn the shelves - signs of a lived-in, lovingly nurtured home.    \n",
        "\n",
-       "As if infused with magic, the moment the gingerbread man emerged from the oven, he sprang to life. His eyes, two   \n",
-       "shiny raisins, twinkled with mischief. His mouth, a curve of icing sugar, grinned widely. Before Mrs. Mortimer     \n",
-       "could reach him, he leaped off the baking sheet and dashed out the door.                                           \n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mStory:\u001b[0m                                                                                                             \n",
        "\n",
-       "\u001b[1m[Illustration: The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind \u001b[0m\n",
-       "\u001b[1mhim, Mrs. Mortimer's surprised expression captures the moment of unexpected enchantment.]\u001b[0m                          \n",
+       "Once there was an old woman who lived alone in a charming cottage, her days filled with the joyful art of baking.  \n",
+       "One sunny afternoon, she decided to make a special gingerbread man to keep her company. As she shaped him tenderly \n",
+       "and placed him in the oven, she couldn't help but smile at the delight he might bring.                             \n",
        "\n",
-       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, his voice carrying through\n",
-       "the snowy village. Mrs. Mortimer, despite her age, gave chase, her laughter echoing through the streets.           \n",
+       "But to her astonishment, once she opened the oven door to check on her creation, the gingerbread man leapt out,    \n",
+       "suddenly alive. His eyes were bright as beads, and his smile cheeky and wide. \"Run, run, as fast as you can! You   \n",
+       "can't catch me, I'm the Gingerbread Man!\" he laughed, darting towards the door.                                    \n",
        "\n",
-       "Down the cobblestone path he sprinted, encountering a group of children building snowmen. Their eyes widened in    \n",
-       "amazement at the cookie on the run. \"Catch him!\" one shouted, but like a gust of winter wind, he was gone before   \n",
-       "they could even stretch their fingers.                                                                             \n",
+       "The old woman, chuckling at the unexpected mischief, gave chase, but her footsteps were slow with the weight of    \n",
+       "age. The Gingerbread Man raced out of the door and into the sunny afternoon.                                       \n",
        "\n",
-       "\u001b[1m[Illustration: A lively winter scene featuring children wearing colorful scarves and mittens as they pause from \u001b[0m   \n",
-       "\u001b[1mtheir snow-play to gape at the gingerbread man sprinting past.]\u001b[0m                                                    \n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mIllustration 2: A Frolic Through the Meadow\u001b[0m The Gingerbread Man darts through a vibrant meadow, his arms swinging  \n",
+       "joyously by his sides. Behind him trails the old woman, her apron flapping in the wind as she gently tries to catch\n",
+       "up. Wildflowers of every color bloom vividly under the radiant sky, painting the scene with shades of nature's     \n",
+       "brilliance. Birds flit through the sky and a stream babbles nearby, oblivious to the chase taking place below.     \n",
        "\n",
-       "Next, the gingerbread man sped past a farmer tending to his flock. \"Stop, little man!\" called the farmer, shaking  \n",
-       "his shovel in surprise. But the gingerbread man only chuckled, his tiny feet kicking up delicate swirls of snow,   \n",
-       "leaving the man and animals staring in wonder.                                                                     \n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "Continuing his sprint, the Gingerbread Man encountered a cow grazing peacefully. Intrigued, the cow trotted        \n",
+       "forward. \"Stop, Gingerbread Man! I wish to eat you!\" she called, but the Gingerbread Man only twirled in a teasing \n",
+       "jig, flashing his icing smile before darting off again.                                                            \n",
        "\n",
-       "\u001b[1m[Illustration: A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking \u001b[0m   \n",
-       "\u001b[1mtowards the gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.]\u001b[0m  \n",
+       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, leaving the cow in his    \n",
+       "spicy wake.                                                                                                        \n",
        "\n",
-       "Onward he ran until he reached the edge of the village, where the river flowed, its icy surface glistening under   \n",
-       "the pale winter sun. A sly fox, watching from the riverbank, licked his lips and called out, \"Need help crossing,  \n",
-       "dear gingerbread man?\"                                                                                             \n",
+       "As he zoomed across the meadow, he spied a cautious horse in a nearby paddock, who neighed, \"Oh! You look          \n",
+       "delicious! I want to eat you!\" But the Gingerbread Man only laughed, his feet barely touching the earth. The horse \n",
+       "joined the trail, hooves pounding, but even he couldn't match the Gingerbread Man's pace.                          \n",
        "\n",
-       "Unaware of the fox's intentions, the gingerbread man hesitated, uncertainty flickering in his chocolatey eyes.     \n",
-       "Seeing the baker and villagers in the distance, he nodded, \"Yes, I need to be across!\"                             \n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mIllustration 3: A Bridge Over a Sparkling River\u001b[0m Arriving at a wooden bridge across a shimmering river, the         \n",
+       "Gingerbread Man pauses momentarily, his silhouette against the glistening water. Sunlight sparkles off the water's \n",
+       "soft ripples casting reflections that dance like small constellations. A sly fox emerges from the shadows of a     \n",
+       "blooming willow on the riverbank, his eyes alight with cunning and curiosity.                                      \n",
        "\n",
-       "\"Hop onto my back,\" the fox offered, with a cunning smile.                                                         \n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "The Gingerbread Man bounded onto the bridge and skirted past a sly, watching fox. \"Foolish Gingerbread Man,\" the   \n",
+       "fox mused aloud, \"you might have outrun them all, but you can't possibly swim across that river.\"                  \n",
        "\n",
-       "As they crossed, the waters rose higher. \"Climb to my shoulders,\" the fox suggested. Then as the water's icy       \n",
-       "fingers reached again, \"Onto my nose, dear fellow.\"                                                                \n",
+       "Pausing, the Gingerbread Man considered this dilemma. But the fox, oh so clever, offered a dangerous solution.     \n",
+       "\"Climb on my back, and I'll carry you across safely,\" he suggested with a sly smile.                               \n",
        "\n",
-       "\u001b[1m[Illustration: A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the \u001b[0m     \n",
-       "\u001b[1mgingerbread man precariously poised on his nose, steam rising subtly from the flowing water.]\u001b[0m                      \n",
+       "Gingerbread thought himself smarter than that but hesitated, fearing the water or being pursued by the tired,      \n",
+       "hungry crowd now gathering. \"Promise you won't eat me?\" he ventured.                                               \n",
        "\n",
-       "And just when the gingerbread man thought he had outwitted everyone, with a snap of jaws quicker than a winter's   \n",
-       "breeze, he found his adventure coming to an end. The sly fox had outsmarted him after all.                         \n",
+       "\"Of course,\" the fox reassured, a gleam in his eyes that the others pondered from a distance.                      \n",
        "\n",
-       "Back in her kitchen, Mrs. Mortimer sighed with a warm, knowing smile as she dusted flour from her hands. As she    \n",
-       "began rolling out the dough once more, her heart was full. The gingerbread man's short-lived escape was a story for\n",
-       "her village to savor, right alongside her next batch of gingerbread cookies.                                       \n",
+       "As they crossed the river, the gingerbread man confident on his ride, the old woman, cow, and horse hoped for his  \n",
+       "safety. Yet, nearing the middle, the crafty fox tilted his chin and swiftly snapped, swallowing the gingerbread man\n",
+       "whole.                                                                                                             \n",
        "\n",
-       "\u001b[1m[Illustration: Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, \u001b[0m  \n",
-       "\u001b[1mdaylight fading outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while \u001b[0m\n",
-       "\u001b[1mcrumbs of the day's adventures seem to linger, cherished in memory.]\u001b[0m                                               \n",
+       "Bewildered but awed by the clever twist they had witnessed, the old woman hung her head while the cow and horse    \n",
+       "ambled away, pondering the fate of the boisterous Gingerbread Man.                                                 \n",
        "\n",
-       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
-       "And so, the tale of the gingerbread man remained a cherished story, whispered through generations, each retelling  \n",
-       "sweeter than the last cookie from Mrs. Mortimer’s oven.                                                            \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
                                                   Illustrator:                                                    \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "                                                   \u001b[1mIllustrator:\u001b[0m                                                    \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. Mortimer, with  \n",
-       "rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused determination. Snowflakes   \n",
-       "gently blanket the world outside her window.                                                                       \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. Mrs. Mortimer, with  \n",
-       "rosy cheeks and spectacles perched on her nose, is seen rolling out dough with focused determination. Snowflakes   \n",
-       "gently blanket the world outside her window.                                                                       \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAEAAElEQVR4AWz9CbRtW3rXh+29zz779O295/bd67uqV0+vOpVKKqnUIEAWioWFQIAEDgaDEAKPkeEMpyN24oRkxB7O8CCDEAMOTkKIA7YhEAkZCVVJJZWqeapXr17f3f7e0/f92fn9/t/a575iZJ2z15przm9+3fxm36z2tdHeSavf6nTa/dbJyUmvOzwyMjI2Ojo61mu1WkdHx92hob29vaODw+O+gEPdLp6tk34f+HZrf38fV7vT7g51Dw8OcHu1+h282m0g+/0TXtstXrm3wckPiOHe8KXLF+/euXt4eAja+BKoq3kDbbsNKK/6tztEmZyanJ6eho+Dvf319fWdnV1Cgr+AvHOFUOLx0qADbeMDA52h9pUrF0dGe+12Z2d7d3l5ZW93H/+TRIVThJPrRBkganjE9/TCXUA64LbVHxsfOzM/t7i4pJbUQ+jCfi58AOIKU96CvI36Ll65jKxLDx8eHRx1hjrD3eFuF913ccNub2RsenZuenZ2uNcbHu6RCkPd4XaHZwDaHS7QykKrPdQhYAi/Ia7hYYJQJXciEWBSQFcdCZ30ippV0AmJHE/TWv7aWkW/+R0fH+PmftTmcXC0vb21u72zTzJs7ezubJ4gsoFHR4dHxyfHh4c4DjEAyBwdH8/Ozp5bWPjw5s293V1Ig/Lk2B+3MAQ5+ZKjVh+xcJ09dx6utzY2D/b3Dw4PwF1MKaS8efEgQkdLwREcUS8CXr16ZWR8fPnh0nBv5PEnn/jg3ff3d3Z3d7YfbG9MLZwdnpq+f/tO9wjDNsIJFovOrly8NNwd2t7eOdg9ADn4Do9OhiBHgvBCPul0piaG5+fnSZy7Dx8ur6wcY+WoqX98EvuBxcgRw5W3CIQpyDFBsCr7s7Mz+wcHaAgZ5FvWpTeQUOvHA9CkkK7pmempqWkUerh/uLW1tbuzm0jIbSiX8VVhBIoWxCBafSTME6h4oneE4RXH0dEJ9IRqMIFDaNWZOIklm4nf3As8TEq1A6TiiVMIHiKRPHfNMwHiKKwlIVgV8eTw4HB4eNgw+aXYsADoYLLdYWx9bGJiYmqKsgmD7pEBesPaMu74EIsXzR2Dx8yHu5JtiPcpuU4waz1KpQ0DEoGZ6Au7Bkq6ueknW0QTKnZ6hLH2zQLH/aPj/e3t7c3NvZ293e1NTOpgd5eMQgm4sbm5u7dHJgCPgrbNjZauJycTE2Nr66vLK0uRLWnW6EEwdQQxYsnnSadfGbU/Pj62u7lpLjw6RodJJmBjHhCwmCpCQ+H32ERA2e1Wtz00OTG5tr5B/pme7nzwznv7e/uIhAEbzzLfMrqLzKLTjwKlTRrcvXtnY3Mr/vgSZGDzi68JMtQlRY4PKQO2o9vI0O+TAMY5OYYJKJESHTRhsaFKSbLRkd7ExCRKHR0fW9/YaHe7iIbOQ0BJIlqEID68KonFF5iplo5PjrT7Vp+ahyKyLJI0QhajBoHmwwt8VzLCSd4oFEmGIjAyOjJC0djqUDKhj8mJCSoi6MiArDRlE1IltcK9mvAnT1E6eDUT9Q17xJLw2PgIOqAAazKGyASi3FY5xoegrCkeblHgGTvpdGZmpg8ODtFdjHt0bHJycmp6dGJ8dHR8fGKii8zUAKkZSITA4DO8t0fpqJrJyMdHh53jY2uAIRMYeVRH5YfiW6/8aQelcw2fC/PGdGOG3KwOyzehlOzU1ZQ+B9vrG9sbG5T9ezvbh/u7VFE721tb65t7+/ukdChWgkodHqIv3YpP2Q9xmMI7nOmPwzJUl0y3u4L228hF+2NnZ4cYxJdrJfENXRNJWw5WPPGqN4RCv6MTo8BtbWyAnPZL/5DyjsgdTJdYpQBwdZtoYa/X0zAODg4QW05FzRW+uEnd2+HJMRgPhw+oTzDecATFSN4+ohDEHKanps+ePYsDNnc2t5aXl/sUWaMjpB+JQ/mgwY1PjA33wHR4sA9mrMMKJoqhkJscHx/GxGmuaDF9KkFQ7e7sUFpPjI915mZpBMCnZV5s62D/QO33qYSxaltlMS/QYbF92w09Gm+HlIdkHtje3dmjBkrK9yep1IaHVXwXc+piCNS4yEVc/pvMFfGTPNGKYVKDaziJqixdEBkrGp2cMInDOrZNS2Z3f5/2ANJoD1oXSYDJanAgpl3XHe7t7e12Ohg48EMjo6NU3yMTk+SB3uhod2S03e2RaUiY437H2KQR/8dH/eM2P5sR1OFQzCXXXnCYqq0SMhYEddNW+ik0eaDH3CngSdsYUt8mHJ6EUeocm+Yk1Nbm5sbK6v7u7t7m1g6F/c7WuXPz0N3c2LBGNT9jUFpCxNR6rDd4ESk300XOecMdVRCF9zCIn3lyuNseHRsjxfcPdoGhpUDbpGA1RzSvIBYioFHzRC4KRRcyrRblLJZMdbS/bwMeczCOrUFC4VEY/rtFWDyU3y1o23iEmP5yFRIGexUwGCh9Rns9hAtfyYgyWKUd7fvehSuXaXIur61t7uxsbu9s7u/REjxOhpFweEgMGYcONo76oE7B3O10xiNQ9/BwcmyMJiPlyyEZwLRQuRQ8pBgikVy0gi9eODc01FlcWkwZAusARjkKEr21W72R3sLCGRoDa/Yc9lL0KRrKRCrNNr+Zmamxs3MUcGur64gOBIZU1Zdv6kXToaqEOnX61NTU8Mjwyso6XSSQoV5uoMWSyNhlPRcuLszOTb77/ocHu+RhZfcyAXwhFuZOO3nh3Hmadffv3iMIVfSw/+npsamdyb19qExOwyV1SNdar01hQmUE57DfHR4dO2kNRWQ9xKjcchGOzXRQqrSToIYY8vLnJTto1vLfLOmdCyfhZoOT/YP9tZWVzfUNsgGNmK21tYOdncODPdL73Pl5Gmazc3OFhmwDOug1+YGSjpyTziFWThOASow+Ag1iNa8imiJBvdLDpN4i8w93x0ZGMX84IPXRhnLRLLI7oSVzoWllUCq1oNSmCe8mwdjY6PTMzM7uHu17uqFEpOKRptmRMpC4GJK6oOgqWxcNIb30vGxPGfyRHFCYgRZe9aIdOjnl9h0qYGh3oLN9ePTqu+9s7e6pDUosbRyt+xcEzQ1PfH1J9UFj/ODkYPvgAGSdra0hyuN2a3JkBDJdbELTJ4Z/2rgPAFtti/uTbquPlkk4vcQXCOB0A9ymgEzl2qJAODg8MqKAKBOFiCUedGFH8aKxuLm5bdQUUnIvzXgYyVfe9vZ2JqfGIX7v3j1qHWFkq67ASKO9cHaOpsnO1o4weItNf34mJeXCyRE5fGFhgbRPfAlESpKMrEYNQv1EzdAzA2BBveoE+2ZlQZ3eMU0LM3FET9KFesMRqpcjfJOdedH606HV0jH7E3uuR4cpZBDbkpsif3d7G4u3D7q3t7W+vrm2tre9fXi4jwWhUehsbW5jU/Qk9yhoVYJqtgdvgdIdordCwTrVoY8MP+MTZOop+jMEAmb+s7ynOzlkntMyLdeIic7HJ6dsa3fao1OTUYcZ2y4/ZZXqN8eY2bRc8wimhkCpA4doLlKQIszZcwuBsZFqzFabgmnv3u0oSx1XEwgUqos73EyOT2xtb4M7ilSZOCrVuAtoVtIrSlWv2iaJ0MbW27SfDo4OTlCRMQUxLvfoywQuvHVXh0XgNLeZT4iLPrDK/Z09BGWwptdpD2MOZmOYD+pYdrksInBBZYC+HIWeEAIAUXWNTfPWptGFomWszEXzsDYQJzFKASWyr6KJ4NqR7hM1oe1YyIQBI57SFK3FnGMEMTdRPQqVBPD+zHKOB+CkkEJ6VWvKkrCmt0betTfMk4Sl94ILf0d1zDPE0p5kSvHCilKFgre8KGukIMQinwx5gOVitv6nTHRgT1YZctnGtDc397cx3d21leXVpaXjgz2CYDKNiYjS7i89eCCdpEVJFKXKEoRHevSIZH7vYB9FPWw/3NneVsOdIYQkiYnJEAS4tEiTXfuiTMOf1DnoO87RpIO8yx3ooMibiSe4gpMxiMIFXTREv6GU0q02NS9W2yYWLRzARCaS9DANNap1Cpo8c/bs0urK/uGB2EIzwYqpTMqvjsdHbQBs7O0BctCijDuhyj8GSRQujeYX1DIZr8J16v4o6gAC1IAUP4hHvmr19076Q2G31+70yLjUhgOGKKgobyK7RLhOiehACMU3wdC4WcV3maHxicM86ivOhkka5gglTK4kNTiFUx/BL/VONJbmVmAqiJDgKTb6LdgTxIgoOHgJL3T4hTppT4jOtPFkStLwSpbVymlPcmlLWL8uvONvq0u4go49FL9BIMOnfxqvHNimp7w/tFFP0+3kWBQt+hX40gM/Otinjbm9vbF5uLOH3S8vLh4d7LVPKI4cyiu82FIksRmjwE2ZEINUvUlEmgPWLEe0wgHbPTygLZtyUdmMrgFzefdfoWXePxsOAsQnNEUqhL0dQYza/OyKBQbPTpuhceIBZd4gSoMwEFAcGj6mUzE+xjtGQad0hPqKbhzFyQjN+nabBueZ+fnFlWUKCetoaxZwYDoyC0psyK4YTZSJif3V5f2jmL5hchzGSgThw2S9Vl6Vaa0BWWQxMp7qNREGovhSzOMDNFmLDtph63ifarHVHqEkSa0nvMiCLXdvwXL6pMTTyHKFiLyewsQh49a/cIZ4pWBAw26eulCnmWbwHonhqzxMLv4HMXQjWRqK6UvY8kroAAMQpBBvkKUMw8B9LRRCmgH4UdYzNk056qgaSZWC3xCzQXQX0AY5D8xSLk22RmZ5pCrCIC32DyiPnaKh52DZe2Tzx/xwsEe5v7m6vL62vLKzvnZ8sA84jRNaJL0uhgdNW43gJ/ORZfcOKFPhEq5PupTYXFHlEf3yaKXTP+7RkKXwkk/KghZFJJMFtGwsiamDSZEMEyIuWPSzYiA5bbUGwko2ZQMDLKDFJmtI/YThQWKDFlNMewUqxGWQAIqM3Xd6w8wnaGewSgUHSwdkd2sXFKNycHU/86lPOorScdgV0uhlfGTsmaeevri5ySAvxQQxSEIKIkoOigyTpdOllX/39u0Ha6tbaeaDSJzB6M0k1S+XZPIaI82b0FwFqQLrvfFCiZFLkI9cRgEFeYDqmim3kU6LPADfFJAWlFLMDSgxD7BDG3zo+dgGYpNICSyyBSgP7RajtBlTIrVMikdoBhwC8wgxnug1yIteyUWs0wsUmJYNZrkzPEgLUCiJkF6q0TaJyJViIIhtYjOAXT/+MHgLKzwyymluJQamM0BObAeXJIPEiMwoiKU6qX50MtzfHerbuGWctN234cFwHjX33s7u4sPN9fXt3jGjC/udg5OLw+3ehfZwp7e5d/zmra3Z8c7Hn7s4OtZ3ego76R/D1e7h0NdfXV7fPGI4+dr5sfm57gidFGzxpP9g6eCde9TZJ+dnRy/Mjwy3j4d6dAMO1jbaK1tHe0f92an21OjJtUszve7Q+7fWltdhlc5O6/z57tWFYUbpPri3s7rTOW5158Zb185NjnU7uwf9N25u7RxgiCdPPzZ7/swYxu2EG92Pw8MPbu8snJt5+qmpe/e23nx7fbh/ND85Nj/PZOsUqLd3dhgl3j/qfePbK6tbjtyYnmiIDPDg3n0ctjWpTKuRQPOrO0QJgj9jgoxpYxQoFuvvjPRIypXt7Tv3FunTJasmLctSPpryRPAyzZPueUupcJpaeCX1jRwsgdFPjwRpyd8VGs6pRmGPIVhGVegbHLY6E84SjNiUtco1l2pWTWStD5shd+uw/aC1SfHEWgVtVEGLeTEBTiSKNzICarIx6kiXTFh8ijQR4jDXGQAAqguxhAudCy8o0n/Fm4JUiKAKEiHyFkbMnpalcCImn4SrKo3d1o7Gnva02cE8L0zguDk2auLhEC9pfuSEyerKCtNAjOE4onB8fGly+/zMao/y3CYDfhjyAUXx3Y2db7z6/tZB64vfe/Glj12khDs8pAd80D/e+3Bx/61b67PTvReemhzu7VNiyxhxW631rZO7d7sbW4dT40Mvf3x+YuwQa+Y62D+cm+neWd3f3m1NT51cu9y/fGmWdgbzN7/39cXNg85h52R8svOFT59/7rGJVqf79s2pf/Xlm/Q6Z2faP/z955+4Pn6w2//S7979xutb+/3DF5+b+cHPniP62ubJ2j99+8HSUW/o5LMvTV27PHJAch8w+HEI3MTY6IXzIy99YvzelZGtg/3pzvHUWOfpZ+bPn5/Y3t7d2jKVj45G33hnfXk7bSuaZ+Q5MsA7771LoNrmsjnHW5wmT1wmA51Qc8Ju/3jr8GgXMyP/NIGJWO44m8g8RNRYu2l0GiXG3cAmIgmS8KZw1QI0ltxkKC8VoZzBDHdU4PvH/XfvPXzm2pVnXnjuaM+5AkYswiBFkeWzLe92m2F1hITy+JWreFnXAcqV0WvYQ0ay/fj4KEjPn184c2aeMpbcxKyn9TKFJf0QG81kMSpTtHfMWBvD1eTUswtzx0yoWxArWwRVMOyU+uTixfMTo6OXLp6nmEcWrDfVsJIISxQgM/Y3NDM11LkKy7b5KXXGWJTCeAaToaPjTNBQPfUYJaYHDDi9uxT8qplmp4PlDF+ODDPo0t/f29tY33j48MHdW7e2Ntdp0U9PTM1OTp0fOZqdAWaodTJMZsnAi41eWg60wBicPOzvT03T/uvvH9IqotnfHlm3JIKfM2do8PZYfcF0IgC0tY/63ffvHr95c294uI85njs7TTcdeaiozqwc/Na31vcO+ucWhj/+4rmrV84yZH1w2P3g9vqdlW2o0dZ++rmFi/PD/XZvaPzo3Q8W79zbvXZt4tnnL05MtE8Ohq5d3Xvn1s7KzsmZud7cLH3p3kn/EH1Q+SA6CmHJyf7mHsSmZ6cO1rY6Qyujo2bzo3774dLO6MzwQfeIQm90ZHh8bOTcwjzR11Y2LUVSqTLmwMwMtZnDoIhou8ikSII0ph3Dj/8hxj/R2z3pr23us+ChgJvejGk+sNQAiwdEePvXof4bH+k5P9rpwPTu3i4zWaQxqUUHjCYphQ1mah09iFn4GrSx/kcktBYubKwcPjcP9r7+9jtvDA8/huEyc9QbaQ2TihalFIQQc3qBDED7udvZ2tzaP6AxSbuC4owBdDSAzXjBDaOfqUAIx1CVZJgB+REsz7ld8gwtCnOV9BOF1k2/f/78OfgyF9klbf54Q4NQYXaRRsnFcxfINFQZpB9rZ6gP4Nxi3Yj2QiE/Nsas15hdMkY8M8/bZpR/Ynpicpp54LGx8eERClnX9lDQMgigDiDPyhkwTTiUFKI2zKjnLpw/PzM1sb+9+eH775Ifjo7MPt3ecdfqnFrguG3zHvWw8Ii6kMqOmqw9MkYlj10cHw45vdYdZo7SAr83yiqxNm3lVETEYpB6eHTcaXrH5FsHPRQ1NuJgztExKUC2ZIDq/PnJmZkJOjAa7tDxeVpK9w93H+5FVe2x6XMHx/2Jo/XpqdH7D3fnz06OjNLEQ89DU9PYzDBjlsOjNMSGGazpQp25yvSSRsaG4HNmqMMEHbMKQyMjU3PD5y5OWjG2aOhaOJBTqaGHez5JWZoyYxPDh3BqIvWpFYePx7BQM4B65Crz97XJAaqWEZhOZ5fh3vUtTBSDMayJYBSupEPjThApYyFBSfCpzzz/7//VP33hwoyDeCxoGRunaqXphBy0Lvb3WAt0tLbOsov2Bx/efvhw9cH9pXfe/eD9D+4+XCTB7LQVve8iKs0BuXKH462jo9dv3x1rd6bRN6ZGJotEMEtLgSKTovSJJx+7d+/BysqaXFd3XUxaNj5mWIVrBLIswytZ4czc7JNPPv7eBx/SqLD5JEhTMelKNMior9KJPjJAImDJwNKbwp6YEzhzdu7Nt99H/DDQRIWOyZUCilRkhc/w6Cg5Z3RicubMwtz8/PTMzszcHOPorP7B+s2dIQQdLmbB19bWrRk67aX7D+/dvQMymnqri4sriw+WHt6nnfCw0704deH5J6aBp/4nNjmJeoCZ9LFxBpda7T1GLdETvUfmm6k36ZE4MwUkpQQ1D7ZgjTpEu5FGsyZe+kHQE5YHoC96ZEg1ROmGFmGS6PC2e9KaJIiuwtn50cmRLRugfRZKMnNPM5aiijYskalx0Z62QbUs8qEOmk76dPv0R1z7NNJubZNumfdG1v7o5OjOzv7dW/cnR0cmRsjHGDpziIwXH2e4mJ66/fy9w32qM6bFaBwgGWyTJWKrfdYalCLhWFUqVlKOtCQ1WRC32z+h1+IAhvZUQLGWxjYrVu7lDD7gKGFffOHJH/7hz9AZV2TVRnwHBGI0jqCJzsIan5d5QzU0YO7ee/jGm+//3tde+9Vf/e3337/PhCC0GbIc0H5E65HLMJmki8eM2ES7PUayYdcqkrSkiX1wwtpPEwm6iafEGn3afZFIzvUlzXGSrDWWQiIxKggsCzGcRBso4ZQfHOimqRnFyEthYICC6WpGSFh0yApKm15i5jJpcxOyQpJY2IBdjQ4lGAMtVGA1Uk/+qeJanrC+QbKBBR+4AiW1xMP791555ev3b9+em5k5e/bM4t27S4sP6RBIsH/EuMZQ92xvlCJec+JnDh2iuD0YtorrT0xQ2XUZQEEnGjIVBavFoNFm7h8IRKAJZ5lAcpgFAHBBRn+oN3t4RPvIoToaiUSgxD3cOt7cOFpZ2Z6amZqZHt/f2xodbvUYO8b8W1Rm7YPdVYZqkIVuA0h3t/cO9o5YqbO7e/hgZXtr51BrxpDN2JiNgzQ0NJlz39tPY3JoaP/owGn79W3WybLK5aQ/wnzc2Cis7lNpq6pWl/b60NDY3sHunVvr2zskXzKwWkcAxbN45YpKNYakB3ViZ5dFTlRoSSy1MEh4oYEzSq6gKmf5ckcXn/3si3/2F346TUZKDeowjUQAyApR8aFXJiGC4VZ/dGR0euraM09f/8mf+KG/8ot/8rXXPvjSb33jd77y+6/8/pub28w5GN9bYSqEA79CyfwFRkFPZzziSVUakiHxKOKKdMjKOuGFUQFx5SWEcJ4W6RhESq7UG7w0MSUNpgLnBWzBWAoCI5zQCjuyc+K8G+EkIqWSuaCgzYFgM7fKCwgJN6250TO2t+HgpbNV5mSykOV3EioYCKVvAqNksw8+fP/2nVu7G+ud4yNGTjZWV5ikFaUJ0tpZObj11gHNaRKAagTGpXHSWl3bI8PRqtrZPNpeo43MOOnR7vbR9t7x2hJG1N7e6r/16vrx4S719+jYKMbdG6UdP7K+fATjLHT47S8/pKXzuc9fR1Ly6s4uNUub6Y87d3bG+kdTUyc0RbY3T/Y2jjpHlL6tzZ3j3a3+zhB5vbW8ut/f721h8SvtB+/vzs+OPVzZ/sara9urR+fnJjt7Q0t3WHNBATK0u757QAe03X7/vZX5cRaFsMKNWYvjudHpzuHQ2sP9xZOD199fuzA3t/fw/tbJ4a0OLe7RSnTWki7ep99CIjAC1qSY1pBUMS2ifW3TOons2Orv2Nz/LqtHlY1HrETN6qDJRYXboZbcpeNj/eWY3dz09IWFadq2Q52RGKo2Y8lisuVKXF2NmcGXDXfTisKn0794Yf7C+bkvfvF7dncOvvI7r/7dv/uPfvPL31jdoDMCnjLs4BogrCfI9hmzYv1cqz1D49UJjNDkCQGQ81agAylkIUxw1yH9SEYEeetjWzYvVJIQsfkCq/fEJ47xgqlx8CA3ohGAmc4TIAqIEnwJ3aIFS0UgMNAlG5gPYvzmgqoDGMS0bhKhwVQ8NiM06I2N9ZWVpYPdHUaHz8xMk5IYciQXM5rduL/1a//oNQRTqoZNMxJFxgrsDbVf+cqDe6+soH9QUqvQ4ds3X/Q3lg9+/Z+8nrlWmeZnGdZurTt02Tne7996c3VpqHP79aXoy4H57R1bafdvUpjv3v3wjeGRLmMAx1vHixsYbX95ef8f/4O3J/qMsLdZkchsaveg88HvLy++sUwfZ+m4vbLbn2MMd2vjN2+v/xY1FaPJrf4Ss3bUOa32N77y4ObvLdEro2xBodQo/PG/dtxeOm7NddvTjPO22h+219qtD6N1buQWWlfUbiSJui5DdG6FhjgEGl/U0W6x/tq+j6knqELnRY+68qrhS5reydAPffGTn/rkS//J/+HvMumtujtD779/i2b9uXNTjcmDhcvMER68GzeejdtURYVASTHI9elPTfZ+9Idf/vz3vfjbX3nlb/3t/+dv/MYrO4wyJ5KVbmEOem8JoI50Gp2FloxgARE3XJlbFc33UMchtUG8SBuMsg2onGRYht6ZvOOB0qUzuBrkvp5iKjEG73jnIqk0aV4rTvwVWGbyEt55AxIjtAZgKZkDBZT/9FmtPExwFIfg8AGMczW5lh8+ZJKLIcyxYVf1kmNK85HNGw0ajJLcY3aAoCmsSCQj0z0MFbMOeO2QWdtGCdY1TLHkDV1pOypERjOHntd2n87BCCv4XfWGSm3f2kM4pghrd8B72FrZ2gEUpl16yYJkhxPaSw+OtpxwL+kpMJG2v3nQ2m4P3Wm3Z2lVWQRQWwBCPZOWsrET5bi9d0hLzXQDJdpAb1SL+1ReQNJmbto5cipDPOheAEvJbA/ZBqjqPDnO4kL7IGlht1uH7Q69DDZH5V3sEgD/wFkeSS0DGbG4dH7+z/zCT//sz/3o1772Ohglxl+/dfPmnbffef/jH79u1PjhyeUt+E6VCQH4S5guCfoClO5G4zRpxod/5Ic/89L3PP1f/v1/8jf/5v/74cN1LCH6GOANjkQhrkGZFT+ZZnEliiCdafQSZUA9rtDhFnuI/TVY5DmMEGJzOavSwlOysJlIJmVT0FzFvcQf+RkQij6jet4Mf+Q9cCqu5mbm1qZdpUPzhssKwIFO1gUyomI9CWAg8BNmZ2t7bW2N5giLbBwilWcvYAo79zBZIuHGHw/vyQ2svaFoIPmwkFPR9DItAdJ4cDUlFq8wIBvyHM/ISOXUeMCBnRXtzgvflLmWeWRiV5HQ7EpGFn9wS8qJNmK4ucqSHRzQqfi8CRYBjGM5lDwsQHzDFEDyo59cN5cy6GnyA0uQ4xAMlzFEyiS4GmeGa3OLWRMaXGILgoqmmygNDrD7Du6Z6ZGf/Ikv/Nu/8NOf/NRz9LHYOYni0af679iX29oZtNqDTRbqEkFQnuIqCeRQzDAQEIlGu6rTCK3+/Oz0X/6LP/fySx//T/7Tv/evvvz7DBUZI4CGB8oouv3tt/ob/ZNphxiwGy77T8JhiwWjlnFWLoyKZE4ulEU3LhKl4Ske4giW5o1QRMGHS1MppxBxReXSlD8VxARbCDaShpi2oZRcVc6nF4B9Y+DM5jIfj4PKljXgmgljJOSn1AuE7GzvsFWFLRo27cGijTGyRINXklWugDgcyseANQ0MiDx8mhkE4iEYFidL8fEWJzJRmsppspGJTttEOrmMx4uJQAh38oSW7mUmCJw84qcvLotvvIsXOMdPDyPhKPrwFpwqLuGiehQoKv9PA4kqRTwrhPjmR99yUbmi5+61x64yS8wyiaWN7ffX1y0ySwNmvwIexIgM8kWbpzd07cqZn/sTf/CX/vLPTTJe23GZB+PQxAWB5o/YmZNqyCuUySv2hqeGQWv0AZNGjHYFkhz/YSLp44uFOMuZWj/4hZeu3/gf/2f/+X/1f/9//MrOFlVkAStZKfiUDK+wta2sDlpjMlmWoqKII5nosZSlhyS5DCzaUKUcpYJ3OIJ6t0IMDAKVKmeRj9BKnVKWEOYGici8i/b6Q8Osxzqmn5JoSkok2Awen5odmdV/dMP+w92dw7FxrN+Zz2PG1GjM2q0IW7QxjtA8mz9s8Z/0GY9ngZdjSIwIz8y6ARcSJBlNL5s3MgoJqFbSGJpXOZdNLrOiT/jArYs4YTHsac0luqwTHRHtLRbegAcnialf9CuYyBUTJIXMNzHiL8nEL+sPbHADahT54A/1NXkvqOTrI1dEUcDgleUB+0ZGlyFVEdz8g5F2x5i8aLcfrm+/8eHNLaYlQquh3EBKqq6Uh23U+/nv+9gv/uKf/MEf+J6JUboigGeZ9e5ek4iUHNgp8Wx24KeE8qQopzyrRDz2dw9WVlYfPFjcZMKaicGRHtsCp2em2L/CQoxQboTUrURc1Nf9x26c+1/+z//SY9eu/m//xt/ZYjYc3yb9wuwjzahY+gPrTtCMvvTix1gjQJOCcLijac1aRUxLw+x0acJR2qIpcGXlcY9WRFLWYbhrVy+cOzdHm4KhHRghEe2OskErpXEgLbpJI9tmqWDSArGsxkH2npmeYCPRtauXPUzAjj4zXWx2oDEKdTImBo8cLnGzBcPUCTNDjAP2RpkQnmT60zk5xhrcDo+41GUHrUNQw0sth1o4Oz/HTKDbJJ3uutjrMZIKJDiPWcd/5yZ5JqmJ3+kVgylLMZESkhQjk6mJ5or6AeBVwdONQGuD4AooA9AiklTcBcgtZiRdzEHtDaKm1WQaiSl05aIJJXb5+6zIjY8MN8SJqwzeDAR1dC8683CgqplnPR4BqJVcT8MoKTA7h0fffufd9d09cAwIy0yhA4CLmwTo7gy3f+SHX/4P//ovv/DsdVIOH/E75+of5axvsmAtzWIBkZjdeco/j9iTXOK4c+fuV3/3G1je2YWzZ+YXsBpSf2Nr+9XXvoMBfPpTL1+/djXVbHEeWmKUGcxldmr8T/3cH751++7f+y//iTvGUtmCOfxyk7aplWS/t7b67ffef+L8BaZLGDmBJ7p4GNzY+PjFmRl6x2urq8zM0X0EOTG5m9wmF9AnbC/KbBpFKy2QDIfTtRju0jZZX6WR5doaRGawtDSmJcOjHcKs2bQ5oXUx0UGRQTaQr9STtGwYwh/tjdLOISfAfcpUswC0KanYMrq1sQ4wUyj40h1lY5hMonZFaXQOn7QH2e/DUgimmRg4TPsoM26wcngwRwTTAEalkhe4KM+QLX3pBWAxaAxew1YTt9xwDxziaW2iNJLoicGfivceH31DRxjAldyQU6wJjpfBiURwYW0w6C1L0hUdCOstLwVU+EgH84D+QocXbyGtr/xWUL+7eXD87Xfff8hSI4M/yq/wdUUgX9mb+qd/7g/9lb/8J5+4cYGUSfEevARSGJRpJw6JwTwgxZVWFOJyLKIm5Zjief311zl+4lOfevnixQuuNCjtObh78sxTj9+99+Brv/eNB/cffM/3fIxJmIYVeZKipKyi22fnp375l/40g4D/17//z9i/YefJK4I0rEFYTTAK9p0Pbt26eWfE0j9MSbLPDuMXX3iB5tG3X3t9Z89hbNi0EVfihCt9cGjhrm4oYXujvWeffoJzMW6+f5ssAkosFrxGTASJiCmesixDGGwq43Clxq0nr165/PD+ImcRGN1009dRagp7ZKOa6I3Ozs+zM5fG8pT15Ig5IV0ARzNYc3/gQQ2cqrK5tkKpj+mDGzQQ8I/V463WbFWovnrBaD2iBt2KmKf+FT/8FFMJbyLLpb5OXyhkg0k/sw+JbKjS8a+rwex7nBUiFsKNLcbkaR9AGbcuUjTtIuECpTcI8cylfgucdGlggm+AoZ4BE7Wv/GSJxXCvvv3eB/cfOtGrPz55lG5wClREO4/duPCLf+mP/dGf/uFz89Px4ibrlI+p/dWD/lzQMIu1WcAlCm2+6FljYADs9v/yl36b+f5PvPTi1OS4k3yNrhSeZsfIzMTczJM0Fb76u7/327/11c99/tPkJVlLjhZnyHCjSLx+5dxf/1/8Igty/sb/7u/QFVR3ChFt1S3s4ssw3Y5Fv/tphIibnbira2sciMTZNhah5BXCUpDHxQsxNHD+6VPWtDie5AMw7GztUtQahQvz9Ao9wVNF6lALTfLFFWQBZpLBhlAPJPRlg0B/+aPxwl4f1hAMHw8fHW8Mdccm1sYmp1ggx65I8NGOg4GyFfimacdpMfvMqjp/gyKbPAemBqbRGx7NBWeNjNBM6ulTgXLt5StEBuZWAMqiZ2MfRqUi4J5YjcNkL6/cvTUmEn/eC4vgoZOCgzTFQ0WYEgNywWxGQ2IJyTZMJGZc+vBWeUDemksEgSKY/CGKYtoSG1qN9Z9CJ+JpbCtxfkPtT778xP/p//jv/7k/+1ML81ORSzwxImWivGEPUarviop24IpfSMsA/77HNvvf+tarnHXx0vd8YnpqkgIydbgFB2CyhyOlLJvCv//zn9vd3X/jO++a0gQq6+DWiKy2JkY6f+HP/fSf+Nk/QKPBYrrocgdZWDBSrJi1bOxfoz0OOYKafybYmWZSAA2niEAtHIkDrkLXkMYBpGV7SDX0lLFxBgWQEeb0IQ8RMyENJmKFRUH9oSK11NxpVDLARolOw2Z7nb36q6t7u3t6iij/RhMth4XR7MHf7gZI5S6YJdsQ+6iTyF7CoFqHKbi8J3LiG2iw/AzKHuH5Ra+kCRbCBQ/Sq4tAGeNWOqyE00fxglLQYGjuvofdYIkaJOwlrrpM1/zr04RWulSEAiUgnGiYBVcPuZKBXKApbTM5DIn8B/iRFEGDcNTAFy/P/8/+J3/h+7/vpdEaYRZ8wMMA4RhHnLiysrlK1poWCHDBywoLKpeWFl966YWpqXFtUj8xSrrNSsm9D27eYUgj9PujY8PMr7399jscwxFZxcMv/8b0XSX2Jye6v/SLP/+JFx93pUBwGTK41FDAybRMfGa2QnpQoSDnrCmsH7f/A4WD2VjB3tDhRSQyktAqH4SCg5BoRr0HZH0GhbE+4nnqHuhG0bmETbI1sOkfU7zQTaAnwHFgmyvLSxyJl8kvO+L8ybRllC0ibT+UROR1SqheuYfxwZvBFrv6loKMEaYCEpniKlqifWRFwIbjRC0Xd8ysoV76FXdd9Q6d8qnY3E+ZFHWDcUBZrQzEIKhYxUMUiZfb6Vv5lVJOxWgk83HqN5Cjsv2Aw4/KDn702m5fujD7H/9Hv/xDP/g9btVPQpu15AqqmC93u2usvxV/2EmQrJBOBqszRypytZaWV1n3u7BwFjBgZAouIhxol5bXaJO88gpVBItQZe/subnLly+89+6HAAU9KOsfkw1BBgwN6jz5+MX/1X/41x67ft7BRjHjKXoub6GGg+UBtf8cPyo4Vk3SVKu2bAPJw6uoIXSjQdEEEWE+DbdLwKMJyRxocalnoD6i4kEk/fmXQVRsx4EC2CF4rmJYDYd5s0DGF+jUckzOLmeTrK+vebSRvd+0ByJ8ES28ogkBxyLCZO7l7fsAzJTxXfr6ykhem/e8wcbAbIQXIOYn+wN3HEbWHgpjUJyKU1gH2HkDD5jkOsiCNa8VPWSM/eiyTY2HtwE/hScgyiGAOHMvWjh9E70/ruLdV9qn1nuGB6oceYun79eunf3bf+uv/1s/9UMcxWffDQ3gbVEjIUtP4ZWZrGJSloL0pGFz4gr1Blee3miq7s/MzDD2Ukkswwpk1NU1+oE7WXMvvyFDeP+ZZ5/khKHU+qU3CXDxMvg3Om3fH/j8S//un/+ZEfaJOVoikoEsj8SjI0JHwQUJJYzDkR3OHWoSJZhza1KhoRNkIW9ggw6JcEXnPg2W8cG/UPLQgPNaCV9ekjc9bEwxhqRCRYcmyZmkJkrRiUNL7tNKY4x2b49T2RjnSSMIX1tzUT61gANR/g3IQ1v8RUUmZMB33Wpc3PVuYRZ5o1DDG/WFScG5gBfhKZYwq5YTE2TKUhQUxwIqlJqRCVEUe+WbaEXfqKFhdNEUM6HJu0ADzKdsig6aQlfkkiUIvTWM1TvWgYP/ptsix9LM0shg8hbY0Md+2pfOzf6N//iv/uAXXsygki31+w8W7997wIAgR8li35zb99yzT83Pz8oEyEqbqCO0ALAlkzIBXsgjJCMtbdqxNGwGbMtE/WiDvPfuB1tbewvnzly9fIlSmWFBpgUwgtmZOYcIj9hKlBwL96ZLRMgd/NDBm6nPP/Gzf/i3v/L7/+0/+RI9QZOrhBL6VDw6smxx7LD1AixkYoc2B+234BUa7MFp4zgxKzpSQBsokHMR07EVwnzPM9YgcAEFVcUtGDwCm1ghA0r+sZcySnpAzHN4iQ9yIMLeWSPAAbGHe5xWwnE9U9NTsIF8DLOSWMyuZX1neEh5JHXewivlAWvBkwqSCtLoHUYak8bfbiyx5EsgXiJQlCggfoWCp9hNA5hMFB1GBcL4eRjc+PiuL/EDXzqVdsU2phBhICwDHPENT7RANLewHYxGCTeGFLtFPuYQTDAmu+EFZySJlxx7xEoihA8CRUOB0p6dHvv3/tqf+pEvfpJRcwa9d7b23nnnHUYk5ufPXOy52IoscufOnV/5lV/95MsvPf3Mk9bH2p8yybvMu08P2h8hXnqwxSqQtEhC+UAMJoIef/zGt197c35udnd39+6dW6xoPztyhmBo0UGlIezoR6QZaD3ih2ldhvXn5yb+5M/9xJe//LXFVVZz46lSRVIqENg+AMu8hrQpOwysuuEmWEIbpERJ9GZgX8kUptgFHVbFZio2lESMoD+1GbVQBJt7GEjyChNP7uiMvapsDNndZT6BGMUAs2sDnILCOO0sMqrLZJjv3SEDbPT7C8wHIi/tPVZkjY+NXbl6ZWp0ZG9nyw0jqd+xaatl1+qygfygde8uGSkII2elQbQvDZthPgdaEKbIR31hrlHQIxDkqoJecYEPHksO30qRCpx8ou6kGfED4K0gEy/xK6L+iQWmcARm/2NfSZbAhWooJ1gFN9olGHE0yuKsoSO1JGsTKd1WEYeN3EAx1uv+5b/0x/6H//YfYRgaPJwm+OYbb7zwsRcoY+iRUd5gi8w1fvyFZ55+8sbvffUb45ziNcNmLMuiU0ZAxgxrCrbkd1JCS1YGFjjaXRNYOaMEa/nZ2annn3uaE9fWNrZpJs2fmY/s3JzpjEKizbAryxW17KbcquXki1/45J/+U3/4b/6tf8x4iSQa4YAIKZpnRO50bty4OsFxy4y6jg6dv3imNzpEc5tlwGRmaipTyyNDuBCaEUfp204IxyghnfjjycnR8+fPoHUXI7BdZlAGhLkkdUO0YnpKaUaNMVxNEzBEYw/H3Cwz4FPGyh9pXOV4jg6xUGJnGeDOA4+O9A85knmLBeh2A+gN0Dji9MLVVcbW+sxyH+4xFSA91rG62ZcpYzaGHM2dGoF0i1Q9T1Mh+hloUr0pLLk0Ks69lMi7DApxCi3G+CJWCIQBPGPD0m7Iqsm86mHaNL8EE3SKVw+N3Qd5KhR9oxbWz0F14hrb93rmpVDqFLJ+lnBqBEjJc4k2NUD5CA7jnYmx3i/94s/8pb/4M5zAB/ju7tFr33rj+Ree5rSwvY1djngHjtNRKfzQPkb84osvvvadN5+fewrryaL50JBl8eVHl0GaecFupu7e+ZAFjBzPLzfC+ZSdVmt+brrVmmldwp8cEkaZPGKMj+LfXXmAKoUa1l2vj9z1Pjo29Of//M9867V3f+1fulpOKLHHASeUo33mvw93Dg7Guj1MfG19DaQw7xKC4+Nej3ZXMwHFTgCYwP5pJrnXMv1O8JFH0CB3jizkHHpwa2dNIkCMIrjRMbxmiMmKhKbN9NQETUg28mXgtbo5VAJYqsc1oFDH91lUS2YjGi/7mdB1YpFFKF1YZ3fhyM7h0Pj0zPy8C7yjETrKWzs0jrYO6SRsrbvSKzKTQNCAISbCZliIDHCUWCpRj6UVtUPgR6+BinmSFpanBSG2JCYOizbfK0VAVdiSQjpNJ0o2IsYVL3RTUKLB3zsemmfz1qCRcGASzRwAgOMbpl9wAliGU5CFOBIV2gFVwGXaEMgI7A0UZABZw6NBRY35Uz/1hb/ySz87Mz2KNwnxW1/+2pkz05PT7F44np2eotgCloULRGf2kSOWWKiyubX94P4iM6PapvIl9SFiIQe4fhDnj+DLlxa+/a1vffDhnaeffqzUH+rAVEUR+HSbtIfofHV1jUki6p+SV11GhAhV8Lnrnyri5OTi+TM/9AMv/8avv0LjBo2FOuCS8kYtdNJ/74PbD7KsqFFPaIlYyQNJ25o5amqqfmtudvq5p5/Y2Ni+efuOJjm4GsjIic0O0IeWAgdPqFKKg2ThE88vLi+/9dYHmTaRkzClKHnxphi5oT+Wf05Pj07NekQ0Z21yPM5hNsEf7m8OtWfIlMxDciQmkcm33d6ILVbOzXYhvckP3jR6NOFoQUIKKFlD6eJoDK4YkhecmklCVWZSJY1AArPEVM5MHrrpAKKn8BrjMl5dwWb6kaZUcelegIwLjNKDGewkrMUHZEFc6gIzwPhJIi96yIbhBYOPjgapLnUthFEFGjwNyk8FFLySxSs1AE7fHBP8npee+J/+B//O7MwEbleJHlIcjn38xecx+32LRtu7yIVAVSkfdDhIz6NS64h9lSEHpiGiYyT1Ljv58Zienrh67eq3v/3GlUvn2ahum8FQ4hjZq5DosNlDvLfefOfcuTNhMAAhEaF4jUQCl7MEtKD44hc/+3/+2//th7dXBpQHcQfATAgwU83wVkWucgV6oAhH5mO2+KkXcjvbltgevbu7urxm99pL3oD2r6gPJJCpAgkcb5Xc1BJbWzvvvneLaqcQRPAgKnM0hcCiDqmHLl2avHhh9vLVGda2uR328GRzmxrB5UUz84dnZ/cwcz5gAtoR+hIXxqZHTvZ2hjdHjxgtZfLACoT+hInAyapYouZMuuA8Za9Yhr1GvRSBgGvggWoA4cfBAAd2lNZAWbT4SEbAaTsLX71pX5Ij08FSC+DGzpKS9L6IlAzlVzBMYEJMe/KCKSo6kDNGp7dcaWnJQPi4GZTIBApmYHFCkCwLq1MmxXwqJDGUCZT2U2Ey5imzGbwHPqk4PzvxH/z7/871axzyQcYG3rMM1tdXONp+fJw1tu6P1vzN93IA0Ojo1PbWGoqZm5tjGVk2vEsM0oCV7nXLjP5wwPXCx569e+/+u+/dff7ZJzj1Hm/xJpZsK6B+XBB68GD1O99544/81B8Ujf5CSECAANV7nEY1hLqn8/xzj/3RP/pj/9l//g+zLgag8CRWLqFd94CiQhmEMFjoJNRQkRFJiRZv/MNEmW/YDKtClYA6Qop7I0TSt3B7wOGQ9ipIlUKB59XENoKoZIOlozO9l1++NDfHhlKpA37c4xMLrC+kodoZHtkf7ayfdPYPj4fZajU3dnR+Zu7kaIouy+H+BVdQc/yLU2j+016jPTVyzFk/jmajVVNYnLTlWpwON8HBrnzdg1GRpDxBwGGs2itrP06OmbHnzDAsgLhWdJ5+4krYS202vJ4Q5EqVpAkAtLnG++0J9luhL5ZWeTGuFaVSqXHcN00ydq4jhkriUrmUhOQ9N3OftLaPWt2xnNSJqao7s17PAylaHJ0/0WlPOPiroqBADmGhOXBjnaGj7tBEp8/qGuZnYLZCbYhwuEm/f46PgLFXcXn7/rurRqVrJHWe/U5vpP1Lf/mP/9iPflbrb4x1iNH6hYX5r3/j9z/+8WdmpiejOVmGXcoV1i4uPlz8zmtvPPX0kzSgkYZ/rQIImQLc0fbgR3p9tSWOH50c++IXf+A3fv23+XDG5z//SU9hO035kI7xqJXd/YPf/NJvf+Yznzl7ZlZ+waHUkIj0ct9c+saEfPLPy8kJ2wb+5t/8B5zrKlbjcukCEZxUDz0+YbkYT5B8Bj5FnXE1I/cUuGovhY2ecgQY/yF/il6PhkECmnBQAUZShJeKrIexAKkKSKTCkT/8wIDhLDq0UOaf8pOUxYVwrMJkeQRb07FGWULZjPMwxceOgWFP6uxPgIiCmE1/qfoVCAV5V0FRSfgOr+gfzuQkfkJAELrAV1GbYSiDExXc9FEcTnAzI2MjTdzkEE554CM17CynTeyArsNV8Kis5I3t/UMOh5qlr6nJ6FmFASiTwp0rbG/YP1iY4ngTwpr/4lnFEMv6Ih4mEvjrDV/frU2UUl5LJIIRl7XKCyjruL3ZG2q9uwo5fK2aiA7OH/+xz/2FP/8zHKgiP3jBF8V8pzU6PjI7eu7hgxWGZWgQ03klORCZY12WV9comx9/4hrDKbR2GIzj6KXWBrsCoqZ2m7PMoOKbyOIrZoWam5n6w3/4h7/61W/+w3/4T19++cUnnrrG4v/UzzBOKYT1tpcWN7785a9eu3b1Yx973DpVkZQlSsGNjy8+8yaRvOJJb5WEeez6xbnZqQeLDBo2WipY4VM+0FW05OFdVGExGM1ADarmYUHKp19YDg4nNrDDiMDGjuLDhKi9iN9kHl4GXFMspYAM0MCQBqQQRJo+xHiyuXXwxptLn/0sE9vCE0JyyBhsajLuXeAotPYJVYTDxBxYx4+0oeFDy0hHqvEwE5RahahEn7uUyjClyx8pg4+Mq1bMu2Dja/ODoCRklCMfHQgBbqEgqtDSnGjeMD9iaWFJrKgEar2t/tTR0ISUPHA2nXiECSGoANjvT7PnZ5JYHM6oJVjsgpjOja0fooAUwQaXZKULE4welHji8Ut7mHdxSqi1gYzBFq6mrPR4dHVBQ/N/9O/92emZ0RRueIiAC25Ys/Dqt94eZwniJO3ReYe94f3w8M7dB69957Unnrjx2GNXoy+P4GKcRHRcMNVmpfG49SG7sYMtOg67iNTpj44Of/8PfPr6jcuvvPKd177zFq18tptwMDXza8zbvPrqG6+//p2PfezpF196BnVWE1TkoAp3Sq0k3OM5CIk9OpdE7/XShfNXr156sLhFWiJLOAt8uMSD+jkqKjUV6yW6MjR4JYP+T/Z395iYI9WSAxQwBWpwiVpWRBGcPKu1aghectpnc4v0TFXKPvkxcYssr+HQGyYBupP2w4c7+3sc1+NwnOjzr1kLwZdD9lv8t2iAeKFoe8OiIdDRpAZR4CFEQImkOIkiY3gnRuMRTKGEdRtaEukto0VKv+AoeRW4AgAybbV/T9Fj/wJtPg20gnM/RZHxCb8RWhKBEZ5BpNX7UtqUx7SDYr5mAALlrBi3mAkwMhOHbEL80mpGgrH75JlAOZtilVTSy4h9AM67Y/nAyy8/ZV+jKBdK6HQ6Fy6cYc/wt7/19m99+asMtT3x5NNsc+FDetjBU0/eePbZZ8ipYbbFJ0wYxFxc2mLOVpnZr3TA2n6IQUVu64I7QqMSy5Rr1y5evXqRBULf/tZ3vvmNb5M1OfeR/U/jkyP/xr/xI2QH+K+ujqxBKRyqExzgFHNC6qYPUMqMzbLKjVFXa3L0Is0w4S2vKUhsSyJ3oWkQBkmAG3yJIRsp7ghuSFYeKOn0iyEUi3KB7AHUygmmX0ujoPEjvATIk8BBQBMDpo53to6Xl/doiII37FRYopqOjHZyui1ook7yI1IgWV6DkRcN1ZxKCOGnvIVXlSjKQSb0BTb45zIgcoYyL1YpiCGfeuUXKJx6VmxXLlESx4MCnkhKTkw6xbFR38Si2ePGPw0hydkkkaje4QJ2oznDvCBkDUcVTGz5kWbghTSr0WqyvFVOMNMEs+0VMaxwQspNS2KXIiV26zOfeu4Xfv4nPaGOBAYUsyQYFoFJjrh69dzFC2eYZLl9++bdu/fXV/vPPv/stcuXsTJaqgCH4TbfzKK6uHVndX1zEx+EZ90/iEoXYTMyiN58GRZkFgtcmJ/7oR/6PviipQEDTBaxygxopFLs+sWp5sCuynmEUSno9jIkcXSTC3LYpR4JCMggWLTahmIjp2kks4kuwkqCxAQmOvMkKa4oFEAjhGaSM2xKQT/xlS9ogks5mcqgfWtwLvwDy0shU1DpaqeGMMS5tUF0dCk3JnkZlCAognPjdrqdtDn7VAUcSEMLFuNgkzRFKZnePzBhNsYXO6R0hFITPOABfoXIa2lB0HgO4gDS9FXEEX0FifoyYQDWojHC2B0vIS4OWZC+lUPFlRTFoSpNdEu6yBUmImCIiyR8B82Aaellh5zjCmio2DY5cxE97Fmoy5YYPBidxhqg/MW/3z2/MPPLf/Xnz5zhNEEUJ6VIASeyx4PSkx8ne830pqZmnn3+Y89ZJMsyoWU/Wg2IiciZEnYTjYpHZ3trOx0ouWqSQkZKXJkIjygApz05GGUPVBE2RmIZJv684QOY7/iKq2TzHhrxbSABDCiUi1vjNdFEbhzCLlw899j58370YIeTcW3pIw6zVBEuBETAz7VPDMVfuXyRbY3Yop1AsUiYokXrtPYnS3OXtAN1NZFLb9T55lG+r8xZ9VOTDJAQL6IoEBmVtPcBEs8YH3akiAmvqYnJoSGSBgpwUNREXIKQlpI84cPaNsEDEWHrFq3jq83yZySlbsDEBiK1KL7BjWAgw1oB5m540UwjQWhoeLeCF3e6KQETTiKxCgZLzLKijNlIzXhFViXVRQQIowrDUJ6cJdBYXElg9Um5yltZe55C51eIEKURVNQyH5QygztzoOgjCjKg1WWg8Md+5LPhGKyBMqLYwqg2mle9SN0EIJ2+KoqwcM2TfXlbW3xBjQFroeBra3sXmRQLFZQkwWqoWbABFBp0YJJUUAd5SBjySFEFGX0Imldv5WroDuJhl3xwcjx7fMGuPE2EhnPLH7fC0FplyI0uPgM99r7b7Qvn5vnMq/sMWVxgIlt9czAJ6x3OnT3jq6mOWlUZViheS2gqf9sJlEx8P29ubpJPiCwvr0EW8Tkcm/RjqODKpUtwQpeJi0lfJrlBQuOULwmwIgj3+OSERVqns7+/w15ntulzjoTJnLYCAFyM9lhmSPbAtVV1VidshSXslCyEfMxkJJfAm/JXcUt0oiWXRhPJHZhT9INQjb4tmaK0KkKJwl/yBrEqPQFWOSQwcQOMA3a0EwtlA2CTUj+4cUlFQwOB3DeXqB1kLa7Qi4KJERj/tA7jxUmcRgXgprQhIE0dssYRXz0UqskhaqMuNSZKQCm+45dU6/6ZP/vTLjALe4pnoGatugtQD1wf4TbOkkiMTWymeC9evXL+1u110evbZ3t76CJCsoq+DR5IwK8SiyE0vCeed22rYMX0XVeiGNN/uDSdKh6g4kh0U0NfZlIhYEiFcm+gdFCG33q4tHZ/CWYwfGMkrSYnxj/32dmHDx5+5/U3teiIqcgJFVmDFI/G/kMt5EPr7Pzspz714jvvvnv/wQrIvRi75KBBT4aLjdhCdS6CrEUgCDGOcnNEAPMq7G9cXV1luLw7Mv/Y4/NkT8suTFyCCs1Pr/b+xBSHDLZ3t2gRsQKXtUAM1w6tr6zzzpf1NjbpSXP4E5QYJ1EAcjSiOlYuZ/jQlkgrK2uN8OQAfmoyDvlTI45ua5LJsdxZJELOc32eI/mmLMxXEpT9uFlc6/FLSgzC+j2SXOoK4tZ0poJAXtCPvbkGlizLecLwKV9JMjjNsCMexIivHHORLjBFaTM0Mj41e44hmM2VB7tby6CoFbqwgLZI5CqVQpCxkWGPJy+LoRh65pmrg5ZMDEDMNTDYpKWq0gL0hwXD44hLo9JT02jNzU8/9dS13/6d18OgJB4+XDKc4AAGiYGltNgw4mNMAYpRndIAY5lb8RGQhgPlVwRDxCZgYcAVhxQbP6bnCDRGc0+CVajD5xyGV6YPH/jKDegY88FSCWXhNF4N9gFuqQa9HAZvQYS4lPiTMXpBLAj3BI7wB1p6OPKOgz0JAyyF1jsD667wpExz5T+nJLO67mToG1+/8+q37zEND1pZCk+MydJLhttOb+LFT84wTfne24v7fIeIPkb/hA/LLz942D4+PHvuDAfC01iTWC4dijhQN56miBrlSXOaLMfXVlDAnfvL2Sdqi06bpl821Ol1acvRTMNceU1bn1BPQjdfsGDP5Xp8yA+AztD29tbDxU1qtVIAOiUvAGw9ELrmLDLfUGdqaoKPNDN3d//+w+QWZzomp6cee/LpNgtA6H/eurm5tg4e1YYWVCJ0Pevp45/69LOf/qH7dxe/9fr7H757kwIgOcsqiE+tc8Yiy6wgUVUeRcPiJuVGLsZqrQ8adchk2dVAVwVlinqR1OUYPAyAm0p8NrP3urNzZwHTz4vNX5sqttABW/iE55f0D3Xp6ggDha5oStFI3kDTcJr3BlfsEGQQq0wWvKeMEpePuAzCAWt4aGIHI4UNzQuxe5WQdCHdiGUxVgaOtUhK9ReYbFayxqNBmLCgKQ1wKr1zqfGJohLdm5w0uAiNRyIDxSxvr8eOiwM+ajU8StDhfn+b9SZ8GG0gAQ4jRcmc8L28tPjYk0/wMY3NA77eRr7gkBYOk3MoFP4p9UlwiCUlZAbb4a4VhXSDVexkGVmjbCUDOIYXGV2NiILMMsnLG+nHF/uFIiIa34rFrMJ5UxzRvr65xdnlqdYaLcj44Eq1YQVKrMmJfb4Qs7q2+WBxh1HEEGvdeOLMwtUX+VzC6vLyu+88vH/nNlFDSusyS5rLunyAvDc2s7Vzb3nZzUJMf0tBOJhGAh2JpYRkv6OsaUB0hCMjlsFGP8oOZGOxRvzoFRym1UevwqwPRyjz7fgOWxnFFRg6i2pYfJXcRq4geaqr8SF1wGXBIEBYSJEswZifQjTxB/gl0qAzxGjRZpzC888Z82oLuOCM4QVWH9nCFkxlIhYOA2k71yiKbn6hLGzx5r1h5ZR84yAk6DTC1TW+IF+nVGhIXCCqqL5UjNwRm2fjgfm0O3w9ZGubzXGcd885wDKYmA2KAEc+1oa2OquLD4kzMzNruWsac6cWMVa1ohn54N2qnTaIrOBOdvgI2aJPILxSuwgFNS9iqADHyiqmuhqopWTiTZyCMhfHxxg80JYP21rzRNBCAd9GlLEGsVSVhq9nX75yhYUejOkQSKLIRr7rSCW6x0Ygv9cR5hNfUjb/4crE2tnZ5ksIGUI0PWXedpeak1Y8UAW9aD7+wT6QoJcJyzgZLxPDQ6HDsZwlJnddg+uj7oGf9Kiaj4/eeuud7GcngERsM+THzgECtcC6ABRW2v5OL/xCLzLCHi+wQY6I9RbsI5DTaANHg8soYBJ38aSg0guD4CSBmltihmTFbVjUJ75acGlCQ5OBSsPiPbHLM06SwViJ6qP0bxwoN3C4QZn8pk9+hdWYdYEEciQppg/fZENWYEC/1JB8ErVISFkI4xREssrm9u74lCemeGiWLY2kP9bo932Bju3GfCGpONGEzxDGx38BGsw215sg+te6B7DyzhVPtcY/bjRQSrCBo6f7xMEWzIYSBZoqU3M4LW6g6MURY3zmkO/IG2ZOFZK+PTuhAcjpqA6pi5e4PAOhihjHAHObD7kyoaXVCQY1fKUZrvXLv2ISe3DZiwiId83EMCDJJQxr6ZCi9Z4X4fUv7rh9eAmVf5bNkcbicIgatj2wNaFlyYMyP1IHS+IXjsaZHBwzFpNsFFPyHuM+jWd4XXoZHFYihDpqqKkluUs+GMQwQuKEUomQvBZieh75OR3VoDi5O6qp5k36EgosBnsLcQD1kjZPPqJHF7zRod427mPKBgcocMY5vYxMINkPYKFVppxWFI5UHkS0PKPDwKeUSCD2qY7TZJ6djdBFRGaMb0zii0WfkGpEEjsmJUiugqGclHT0k6SK7kQTDFUGfLQkqMgB4KYJYODhPcIk2RIVRFKWD67A6RAvnxTY4cN1rCKCKVhiwc4IU6kbi/399cOt5ZODLcbM0k4wpQe0QOJ+JYa8NjfWWZxPYstYUVB2ACET8FJGNCID+dFJhxZvFCVEzD4okp0Ks5iSOywyaOqmf+wBDDyN5gUt2l/snQ82z4PAQe5kYF1m5cFfIhHrNFLxkZDCVHqVpVD1aVT1lkiFTF+5CAd1T7u2YAw1NrBtipbk7fg9ujUiBI7GG9+x1T7NKySRJ3W2GYShKUEDqiKZiKoTaTQO4CKNVCJYmBNIxjA3BbePZQYwIgLoSCjaTZzEVZ+RrSEEDOB8E8/GD51m85vxvIwuCUB8xZk6hbOK19fWr167MTN3ZvmBAw/MObB/lXqAUQ8uVohmwL6EgGMRBY9oKol5qE11ykGoflgOlaQNgZ/Q/Bfd0OaFpz9Y4iHXcqUwYLEdZueYgR1BDAhkEwW3FxEN5YkVolIaEczfjw+3pia6fH11vLvz4INvPLw5jCoWpo/nOCGYJU620OjV0EpUx+iHworPe29trR0cWG2CsfiULV+Lgdztn1SRZEJyufr1gGx3dEAFpA2QmiZWpSrYZJuXglY3eVWMsJ7XEu54amb8+uMXHSIHzAgany5Vgl+VKUl8PCVf6MOZL2IN72Ll1xAf0KxX3hg2IGlFGZgIojuIQik3uTjpXLt+LXoAgPAIwDNxuCtthw/KPjk3Meo0eqRi9z2j57DNwMbzzz/lhkPW1mNBcCAdqWIZ8EBPkXqu8UGV9KeRCUebDRIce9EaHx9naSSEQlDsEVM0yTchWF5hiqicgwgZtoNyaq9fG/E6TQDclKyZdYpA5FD3WGLi+9S0/Zm5+YUL5xktAWR6avroYBf5aBsQhXJShZgKsgEhGEV2GTOxnDPxYlCRBRscgNzpzM/PITUDQY7royfUo2UYiQeCs12O/AUiHTkyFZzR0wkeOBB/fWODQlqzo3dshlVBZDHoRyeWtgwb0Wne3d3e31lfmB2amRyeHGeBMwD7R9uLFh399iQrnsY0pSjTns7JyTALq/la/Sil14mHupLtGfOAYYkoa0SVkIUIbCMIVfIO+Xo3xNH2L/3y/5qvAoD0uedY8DzBIBFDEKiAsaTpyclgabFWh2/V0ipdWV1lQAp0HMC6vc3xDWeRcGlxhQ4KdcfK6tprr38Y2yYeOmqtrW989WtvfPrTn6AoYVgD5bB3jCUVHIQ7MzfDCWd+fC5De+wKZ9SPtUN1dDOCoJQwQycWloZpTfHNZ5Cw4PRTn/6kY+hu9mDFH9mBJDEhKT9MrtRYX/vaKzdv3v3gw6V/8Wu/p7mhBJUXK/ORyyTQE2Q0eGx2t09YQqefa4wdFAR7d3SIT3TiGfPV/soCeKI30hVO7aOltFRjYtS8qNLPX1jgq8OkA7B2KrioczEkSJuEVjWci8j8GvA5ntocBTaOHXj6macyMU1yVhs0aYa6qjDPQD72R7Ke8GXvqdmjg0M+Snr2wgVO3uXrSFNjPVYKYXHTE9NEAQn6hzNkaooo5PBLjPYjMEczhoJBRSsH7OLFi4iDn4Pn7P5ntT09UQHM+vBMWoKDxEc5bFnG6EFBeNLFU685zJpoUOckKGokgvKVA9aBcvGmREQBO/nlaG/5zPSx34F1MmugR4nJtkmSGATxKl+sc2GIk/x/sruzvsY2COx2bm4eWdSyDyGb9IJvhbI9zzHx7fX1JAF7CyYn9viMhQ0MB2glW3zZrYGMhswwKgvd2C1Ow4ZXMAJC4VcDXnR0Tdb8pCqucEy2Zen/+NjUNF/JdB892NASeBhpRl+M83EOnPo2lGFHl/MCA2ZTgAuzVWYmX1C+SUU+o8x7/LFr7EPD9LEeKi4Th5PNj48ZcWMe2hJrqEOu3t452NvhQ9pilr3mAmOpRkHxH+u0vu+ZJxfv3l9Z2yJEflS3YEL6w/abyKonbmHiunzpwtUrV7796nc4WlRu5dmYSqLbsocrkSopHYPgKqR8AvvxJ5+4c+u2zc+Kb0SVPDE1iYDIgx6456L29xxcckTKXL4AMMMubQYOJ+bO9iZnOEWYb2Q8uH1ne42iapMMoOyWuDRHkwEavv3g9dWrV6nb7ty9hx80M/BlLpVLZGiktllI8mFuZgBsPQZAscPyeI1nb+/e/QeYRuUesk2ExdQoGSydSF36gZZmbFOweCKlafEQ6hUiJ7NTlN1M4m6xWUbFRAOqEWbK3qOxukWTjfKjYWYeJqfnL21snTx4sL69xen2ioApQc0oplmiasy6dodat9gFnmqBbIqCVRBAjvYWqPDsBMLblDzcO6Z8HmCCdgokppDsgKM7bqrLON40XzkjQj4Ss+kZb6KKLEIldPBmlEhM7IY6j7hkuLxoCuOQBh8F/da33zZ75rWxGYIrwTQ5+e72HIKQlVO0xFZM+U1UbiIkgh+hNTdVmH4GeEczQMswf0qZXyRxIkZ2oMXAC2KbWvzlLpnCkWJfp4iigxpM1Ycfw/0UBhgWZ6wTrGdiAr20stIAVUCTOqJRpqCnYuRrCg+Xli+MT3Jm9OER3452v9na1jZdMmeGPfGlmFeCRAa3GcCz5vb2qJNF+Ig78AYqrJS7eecBJhUqB4zw0lSgHuBCdDRhcC5AoFRZQnNEpBSJUUluIhENYLMz1LKU+iC2kaaC1R7/wYVXIQ37YYF3fXErDz2Aw82V+2+1hkanR3sbK+trmxpmRE14g0gsouLEYbcLNW/dvV2G6itlVWkBB70qieoSc8AFXlF98Q+/yQxhpcFJNNCXIGpFNNINzUcUxKp/LnQVd1FpXkRaZiQxU49nyAt7KlbiAEegPwISzLx2qiqKgVPQUDyVBFghAcP6qU6KFZnHrxFdBQAUkYNGNoqiPPCj3QU0lWcDZO1XohpKHKMnLMzhpyylRF5ooFPp037dkPOEFlPBUWKJj8iIX+jEQL4ydbEd8i2HTGysrvI9GFYa0byYPXtmb9/Rw52tTdqqIA0jRgvrUq9aiHJS5OEG+GIgXOApTf4S+9G9SX0yfColgGPhAfAmV9EFSOWSK2hF+N0XPYfOwplJ2iwjQ/sZVQBUuxdnQSdRi2mcoAvbDV8JTDFerqPd4c7h1csTI8sHD5c4qplBVMuaRq6yW3XogOQpJ/RgGmKKkYCkOQW/GicQbgaKiFMf4ZIe4qGYDIBaVMYB77oD1VixQQCGhbAtZ4EPINGjWyDAEA5RSoICFuBCBRZTB0uvGDKYGGErvR3raSjl8BK0xrgupOr/1Awa2kT17JOwKznhoBsOwnF5RhaBFHYgo47ow8XbjaoUKzQELAYbcBnw8lVV1JsYyYFRjP6qVzMwXBfwJajw8ZMSEORcRpmc56OFtL22srM5P3/+PONWw8MzpLKZZ6i9sUqPwszA1ZCPK/1E9COzIR2IU5ioU/hBnFMM5Qg0YapC/hpBCQz7RgxaJUlFCaQJjDhiBI4m7aVzHIKPjLUoRJRpfWHkIvU9knoXsZajb6ObAkglb3FVLDBytXduge/ETt5/sG3XJIoysgBiBEk6eWGI2duz82NoMPU/aGxiohRKFaIyLbdBv3N/n1CGGmjQ8U97mw0xdg2Hhxk9Wl5epfBk/wqlIEXC7duLnJWvTUgJFXReeP6xs/OTdn23mdU8qPY9/WAKWTAq/dEhpRg80IRgHJeOgJqrAbiggShPZhXKvwZ9SWBWTTlEAa00WUs+ZGSTwtBwe2S0ffHCwvzszM1bD27fXlKBJXKU4ltpI+MR6JRxMDCdJs8AgDgRJqZIOpRg+gUjd1ggZeot6dCgxh0S0USIBjmgRaQCPTyPng0DcUWmiUXUAUYTr2ALXym3POEHz5wWt7W+fu/WzaFe98r1G8xFolFrX7g7Ptyyg8iKpwEesfFm6axKeRNLQ0TB4+czTBRZAOD7FAgw0ovYEKK1T7IGaSINIihnSUU0PJMl4iGeyfHu9DSq86O6yGSNVow1ovnCpYTwUWzyVnVK8BktY2K2QiQhYUy4095dmB/t90fvP6yvQRRDQAOkTLpSbAPf/dKv/T2Gt7BFcGFbDFzQp6mdXI8//sTG5ub6On2pQ1Zizc9OMcY04cUGJca52Nuxzxdc4I64BGF7/8Xf/cd/6//yj/Y9rUONwNQv/5U/9W/+5PfRe3aEZ5evcdHc5XvjdPbJQfaM4Mbt5sfHTPozBERHm+5aolYKsK54kpX6SM5y4uoJ8kVEiDJwsrS4tra+KcbjQ5LBnjUDr60+xxaNTYxcu3Jldmbyv/h7/93/5n//d0itjyQfGimFqRrKXpLHxcMap/4+A+1LQMOPnnioZwK4jEcXqWZnTKIE4Yd/4QGGFOQtmCqkouNZdBDdfqpJUjejmkzBL0YvX0Eb//jFIvCxb+v3qWj6rzx8gA4ZDLx09Sq+E9OTU9uz+3s74N/ZXE8f5RECyMV8KVwGhaOMldwKAEk7NUU3xPGNXMqEk1CIo3Mq22rpAgU8UZtGgbwXgmBRV6Hmd5dbZ+cpRs2WEgmkSKN2YmXsgArMJo8v0aIAHDImASNEsc5duc+FiJVLwCXG3XPzvaPD0cUVF1DVf5GBA2e7xAtkq3v98QUAotiGmaeevrK6unH79t0rV8/2ehfM6PJPRPmnsuageuoMxKc2mHz8op39YUemsaA/8Ac/x+e6+Hp9cQhLExOMWw6NMKg73pubcTN0WuagM9sGszeip+aLz0BpIIlUkV4GLNVknUuR8eHHnZ/e6AkW8UqHgjAZnuAjlkIkHrcG+eCVMiALfSFkoKDabNGIZhJFrN99Ne8OSloMYgRglpc8cIoujOlhgNiL04/gIsQV+yKJcBWUtJWTwlBCGjeJdsoIo4pZ32w5SEuDT6tv7rz12uujYxMz82epHGdmZ7Y2N1gWx7A1xU9V/cUkqEkIUnNAMNwV+7nLvtThXfOANjIgAFd8dDA2ResA8yvJDNLbqEbEu7Sgl0iMrggU/0NOkyQ1CSJRE6YOAFOdQUrZFIQExgyJn9FACrzmnTSGmAcHx4BCn6iSax/SFmLn0vom2azBYyrAQiVHULsFM1FhlTgmAsRnZ+cfPlx2axeLcW3dalfgpEMZWR38FjhTd4yBqAHJ0u9gDtg8x+VdesmfAEfE8lbDTTcMiLIaGcDfe3OpFY1YCHgTVQOglyiEJSxRYMHdIIlNqxONEAOy6ErgxNTr9BpoZdx5ImtRkgaS+VCjQIW+nsQL4ngHg7YRbJBk6oB5kvbKOlAFFoZNhga29N8EisQ/g6POsJpqz0Ig4hSjgZCxhlrQfYSXvHOjlchg9ImrVw9oC3343gcfm55laqk1P89YDTUAybPbWTviG1AeZQIGR5YZ9iIZHalsLvlrdGpC8CJswBt1BwAfzdPJr9rC5uqj07iNcAioJLBuIg4yrglB65+1n0St7fAJLSKkGnM+8EX/ANG1bePLRwo1qddy8Taj3p7fas5JjiKN6eepVeBNGSuNXvfw4vkx8gA7cysFCCIs1OKgBqAsj6xyBkIelBxvv/WeAuWSuGiVmlkNnli8IQQM8bVDu9G+ICdL03OarqInLjdZcohEh56NOBiajHopYS4w+KY//JJD8hpcyQYgkk68i2diGhv/MBDcoApeyy200t/e5tvHEGsqMikVnNidATo375Fe169cYWpPrVOxO1yNGvgTlMSlhGZlK1MZKJrTCPErVUN+cmKMEpZG18PFFYoSiq4U6BRSR4hAxCIIZMQBnxfRSSP4Bjnj+ilQmgIRkkk/BVFpvuAVt7FxqyJscHikx/EBQDMbkFk8QkyD3a2NpcX7l65cg8K5+YVee2hlcXHkzNndtVVWVQJE2T86NsphfsfHI08/+QQ8KKTdGQfOLV+dYbQUJptIG8Fi9CalizRRqJ1AZtzow0xNTlnKRDBYswBnAAa2MCff7b+lzJYGTU30Nzay3upvAyNV5hkUkHEEWrGpUBQ8qRhJwQADgvAs2yDPk40sbckCZhJRGUtLkDSXijrhI8Dnz00sLpMmAJhFRM3/bubvwQO476iAn2nuyZL0BJ559ikUIBosRwciixtGgeShX12BglWu4WH2H8JZ+t+8KyCXqjRWzBomeQEPdBOam2Bhn4chqi7BEmI4A9oNA4bLcB6hatRgE1P0IC2LFkyfY2gBTo4SrkCAjo7NGZOTY2idbHA8Q1/RJYeIEJ5QBqmJDXRJZrrxhDKR53GOkKX0SW1JgXWwuzc2OvKiu6VNfXoFGASd+1KqxuFEaXd9Y9OZb04+Y79VZlVZ6sN4/OzU5MzE1O5FTl0hB8qkJqoC1FNEhc+07mIZEAYsFsCye78zsnBuQVGdV3IEg2GgDqj39ybHJsd7TBQOjU+MH21tOhm9uQkM1+4ePSm6UsaABDj1999gGJidmWK0w2xPWass4au0Kk+yuF1zLtqIGQDG5YwHPHQ6fP5wZmp6Y2tzf59dXk0WotrpDrFhJWtUJU4MR6tIAuoxDUWemL00Sf2pB57aig5SppRiqUZZzNnX8k542lGkqn/iBFjQozk+xjIxv3sw7MJk3k9ONvZ3GTkOo54MJw9V5CA5jcXR0Ylz588uL22cWZgaHmYW0FmDGLAZlWhBrUM6slYkeR3UXAkT0EkKqMJbMnnoBEWss2KKsVFcE0/MBcU9maVgTIRogmCedfmE0GlUkGoMyqXRtDc3GQiP/Q9gggIf47GmZGdt8x5fHKLebTPVf0Sh5+qxFP4pkoYWFs6zNIMN/swpdzs9mtNgoGGNmYeFIs240yh5ReMibnICUwRJG9RyQmE5unB2lZPCojISDYInrB1stRcXl5NeSKIw2rpbNXWDLPUtFtH03PB0wxXlJfMHnc762hpDCzt77MFAPCX0SV196/aFK8tXrz8+NzvP0pal1ZWtvb2ljc2lO3cY0kjmD+/Rc+PKQ/uCeYeGseH2Bx/eZD2emA3gT65KnzLYeMbPEHUKpOIPtc8tnJ0Yn/zww1vk/EjjjZD5meHzCy6xNtNQmWj1ZN4Yv8liJkyVUTZtLSQzEouqUyQSEWw0SI4lCHuSp2pKQR0bCDew0+7vMjK8vna0y7IhyoB+i6/rhHnNhpSWaduB8O3EOwXAMR8c/+rXX19cHnmRb84xJczeKNhrDtGC0EBWxIns3mJWfP2F6k42DbEggSQ8SSM0oyIj8Ys0ybyaLH4IIWSuj2BOQHkmWkOz4jyK4nv5AWWCEQ9xtjZ3T30LtboqLwqOTmudNUzsi3d0wXxSxRexfW1xcv/I5OQ0Tbv79+8zGFVtFVGbUCk8dVsLyzEZ3l6pF4gsmgSUlU+9+DEaGG+9/YF+8alosoSHcZXLMiOPeAVjFFtIwMmfdW+7ffnyRfYN339wnwwgqlhe3WDreG1ja29/eHyK/YSUxJPUMLv747OzvZXlHSZKgz1Ei15zb+jJjwU8WHOwU4GnlBEiSiIGJB+lV/EfBoERtdUCxQR1CHgUWlXIoDPVKcllWjqqLoZiLDzZ07bPqs+mPOVMQ6Zu2YpJNlDHGvzg4hXDdNuNvCQ2pMQXRcaHTNahxWP9Kj1C3aESfojAOdr48OZUEUywI4F0cmyr1b97b+mZZ25wFBrlImw6V1qW1YhZ4ohzwI+r0kUN4eYB81XZyXgD5pNgEzawxQ2epxAFgEfEqDcUHhnhEzgF5mYJYsSGYBDGG5wA9bd29m/fYaAWp3BeIBEBl9EZaFMj1sW8Nf5adjFImUILxk4Bqy35BjvnoULQAl6Ekg2+IB+Ioye+KVmKqGKgQBOZIoZaQYhcpy6t35fGo3HW2yPejUMTPMnLzdFPrInwpDnQoMbJgxvTwyyImtzdZqsqx6uwKrPHCVtTU3xeidZ+6VYCxXcwl4ZhNG+AUD6UhouTECg1SSV/gMq1/Iey77ywJY2KzxFeFJbYAoVzRkq0mUADCRUvaYLDQiO9W7pSRCRZKt6J20ponQtK0SMNKkoYRqms5ZGCskcDUUd8vAHJcA3V8yaLHtLdYLCkUTcZgK8ycmj9/vHu1uYWBQX1Kkrl/LKJ8dGNNYq87W5njKRHs3yd3FQky1p3iViKmoJuMSowxiFvBHIR4CkpsdZGS0bE/5QB37n0ErzhXZ2BWrlEkxCckTMPA4zSmGxwAOohALGlitjfWN9dW98q+g3JQTSfphNLnjCHKC90wBJsuYvLq/pwEao8KrG9B96nKVORZMGXcFIdG0dLqT2MnChFPZElYUz9C7nPR28DT8IaZ4LJk/qE28qPxFEhUTcIafLSzmduhakB+qlTU0xHbo6MT1C6HR9knFodf5e4EIjEPsj5SdtT8qccyvAgms7TqzRnZHu0Nuvhxv9AyJ1y0agzwFc6G2VSeERiAKiIae25epHjYUbZza7yWa9PTmfNIwWJOJRTFNiC74gRU4Gy9ETVXHHZvBkd67ZWyQD4E119F54uB2ZsbOzMzc9ODzG05OeBOOIWLHT41tc3aMUyrUjtCZ+c+cNoCdHpVNkiEo3UwV65ANUDbOmZPxnjX45TvUhT7mSgQIxKZO/86gYSHbynJSUoZh2vBqKgG7+K2yA4RVHoyI+Li2yn3mhwB608CN5QZRlcXk9Tl5CBdsIFr9juzu6uJfpAtTiJP8ARtyQRrOQxpqlSEeKfOsYhVi4pDJgQT12RP0gLeYAMKpAq9Ab4WYl4yOEfaROALNgA/WjJhOHwyRg+LUzjgfnBidFxOg+jExPkgX06ZmEjlEsUcCi6l+KlKC6PKKyydxIriTEQOhGMU44giOiWlLzFf0Ah6rEaxCgIkEyIOraY+IH2Rj+ApOFTXbRvmHPFi6+A2zlgZC3dAblU7qhHOyMLFI4ialpoaFwqJ12pCtErVwK76Oze3cX33781f2aOdYXURGOj3ZEhF3mzvtezDfk2Y7ohtMFggNawwwR9voZkB85UUl8KxIPFDr42rOgnu2Eyt1NIghTBhzeRRJo4E2JAORoAmS4gHbCAeIKc+jYYCg/BvK+sUvNviiCXIpMHgzjO9iiTACeppHwnIxNLU4tTxmjIsmaYvQoILQjUYue4HYf76KW+m7/oJWESkx4tqS6bTOzgQkKFxTsYYheBLoQDAuUVFT/ykgKX56agW+YgWZASj8KHdEEtzTZss6uG9ed8V3hyanpifIIvDdMK2tzcQKxIA9ipQIloPFHRoSzzlL4EgEMfA8ZDbYChxCnmy4/i3+oO7aU9BXRieqdAUQXidACUWPihmEHRDZmkgpYD7fRXmRzgHGBjZOb3lBKJ9UiXBBvOPQKYuySnZ7rLaSwFBsKmkJDdsfHeEXvQesO3bt1/de3t6amZCxfmn3v+Bst1qGT5PN7ZMzPmJYa0iYVSJB6kscCYCj5efPruzp27KkPpiONg4hjH8pgm8ZKkZqSE9dcoAlx4Gox3U7hDT2uNXz0KZhB3EGOgy8DwwjN6oWVDBlij4V78BrdaySVH6NxjYWiUk++pjuWrudKWUlCkYQTPVeyRfRA7agC2Ue9pKpyqR4t1S5MVIE1ORicYUjKZjcLVICJi4dChJwAKIEg8eI1TMEQbxOeF/RidIbZubbswpIClJ5YggTJjsfvZasSuCc/3HhtfH+qOTk6xaITWuTSai4hEk5Is5N8mkPV8fBtWeDQAxitWkVMeY2nhURA2s9P1ZIaUpS6WKqrdZIFP0oZsgYxEd9RQcsaLIzzgFJR8YqmRYFIp9Ym6ITBqJNcAlKoKH2IWk96jjnAYMrjMc8UimIAuKPy7IyNd5gfZI3Tt6pX1tTfQFBvZ4ZmxM9hk5DoTDvQ+OtcmLuazdnJerRqfRYE744k7O2trG0oZKyeQEoCFENYYShjbNMqpjeKrRPyaR97VgtmgAiQhjEIWFE48FKHyTeDip6suNEwou5b+9YrRqF5yzIUsqZJNkcElZvEHgGbD8Ai1sYal+UXSBmAQIcz4Ak0xikotiMPkLy/La15NN1gTvTI1XGgkFY9nLn0qtGGlEBKGw9zk8e9DqgCUxvVPa5SadzGy9Ip9dnwtZozZuj3mIqjLmTqgGmfVUMUASsjCYQYiqk0UINFhyA14NIKkQs54RYVXE0tfmFFBpgH5vzvMd89hwTBazs6fav2HljgYtp+OQe8p76IPOYe2mIW07rXDIEOOwaT4qMBKnGRQd7OAArpSBmU48SGavPtUlkpjIcVfcF2+/Uj7/+CQEUO28DJ2O3Xt+kW6HaSW26yO+itraxfOXYBtxkIobJhgV+8lI8scrKe8IMesO/XygAUJwiGAtpjUZKRKvaGCcuFXIYY1Px0GGsNgvePWb+AvQOMbEIFQa+6JxBsjOJub7jgLZHQRbEEHRhN9YnyMTzSxpO4UG5YTEQD16YKBmBvD0Y4+qMkGQHZMMYUHBHcV+QCInbtWKBQAnE64tcPixBPWqNLsYn4aookrvSSfsYDEkziYCzWwxMRm2wlORKt1OlNB+coMNB9t4F0zSqaCITDozNDzxDTXJB1JNnTSq2WT0PTU5OFwd+Hswg4nvLknk2oS6wWDScmKRrp5zPeDhiftgrn5eTobqQnAzFoY+9YIDH6TXoOWpmyrJZ4KPjw0zNqQqelpmL9+43pxZQag/eNeewamV5Td5pBjPsPHfb9TjqaIjHrJLRz3e2I/h/4mAxV0Emx7q0y65m7pTGOk1BYNSRgm/H0kG6g7kOI53O3NznJGoMXOBjtoNjfxxZ9OBmOXTKN0Njd22RZM8U/luLq2s7G+s7qydnh4+alrVzkf4ezCLJgpDRGUeGZk5GTvqeoDj2QYTHHK0OD4YD3opDuUkdDKpwaUkMDwYsIZAYTedCYYMFNUiPKKYoQwPxVoyS2G7wIJFpHDIk24zQQDId2kT8MbEKTX5YsXz8/N3Lp9e3V5lWGuqclJFo45LGRym64jHDrS789MTT315ONM7oK9ylywMQRJMSlqJp7c18tQgfISM2xiXa6DYsU+grDuYHll5dLF89euXsI42O3FVKtRaRhl3yP2Q7mDLDiI7iumwTptajHKuJOTEaoiSx+bJXywzRpgqMVXRfon8579CTRkYI4/IiTvTUw6m8t3e1ixgj2z72ZqYuJoeOjk/MIWH+ShhmRho30E19TBPEtz+Wrg9NgYS9fZ/L25iYDUflQFajNcsamVb84nnyE5s3I5Cxz2xkb5UvdllMDcHN1F1MTBplkFvO8ochaPAA8SvkS7cKbPqSdQ5Axu2jl0OGsijFKEAsfCntE5Tybo7+wdjoAOLzYf1/kDFr+mJTdlDc6kOq5UIFYksXT0W1WDW/gZn2QNiwBYsAZLbHIaW+fchH3Y5+uFs3Oz8LG9s7u6usV3PLd29t5++90zc5MgYWwUeJZIoEYzurFtogHPsBqFLRTRggdTcok+d5qhnpugHcRyLS7kWk0MTB9UIhuIwEuFCKm/bwVCiPEqA+AZ6fQhHM9BeSAu/lQ6G4OlrOUPrD+h3LBuz8hwlO2IbbWzM7NgYcyQCRMPQfCiJ+fRBOurq4L3aY9SltL7dH8mXMCnRZPZpM1CbkYMmvyAeiCOb7CwkpyVFA8ePEQVTI6Stju7O+9/cDN78TCC5BYsPuUxeUnOmkuJKD4gBP8YIlt++eIT32Ggc58UddMTpsGmU0YspBmNlbpQzxgV3PQMhR9nTFzgq3XTbY4rZmj7wb3Fpft3kcFDBHJY74DZ/sTY6JVL3dv37m7v7hHWIIQnVTiACnuVaAbEf7W9xkZ+Bls/+PBWwZpoal3bSNFb2Qb7Ppnl+AUKdlpcZvs0dVJrQQA/5sephIacCGCu42jv8IRPUptDbE8MVAM7pnH9N5ghRnzu1bcOtAygpLX1vdUNF3TwvhOdC0oNwHIiSGK6nGM6PTs9MzU3MjK8t/eQk25pBVFfMxA0Ozdl2ca+B79fcdw54fBKCjqthH0uHAxR2wmoMS2ZWAzDQK7YYaCf76UxqusKGXySA/TPFQ51BRb4xtiB0iz0j2mfRiBJKJnYkUCQgaooZJqkb1ARZjZqnayvbQiXHw8TMDqQOWO26SXv7myxJhLzIvdurW9ubGxUZsaesE727z/95JPY6d2bt3b27G6SYFJONgSDgkoOHyg2eMNdQzW0ALR9xJTi1MTY9u7O6uomGJqgsJKYYW7AbeXbAIUI64uOj/hYIDXV9iIt081katuZoQ7xsBKk+BCdnru1SJtx9Kog4BODc5SdugZ++Q/JRkcoHR8bslQJj6xf1gA7RV9i5pUYBsoJSwz292dnZ4ETJzYf1nGqjYpv64Yyv82Xb8ZHyes0h+ySQowlRzRHYrjMTmrBFj4Mhta3SU03i1EbgGW+sRAbcI/06EgD+EsB3FPmyQYHq25tsxlLtwVMo1ml6jJVQhFFAXbt2rXFpSXKMNbwM2syMz21teExB9SPVEAsdHE7C4qBYLIjVQENKSDvP7jJMSeMojLWBp+WYSg4XKAb6lZqGErMWKTqjjZ08CvVNO7v9lHiR+ECE5NVL/cfLl67xn4f30XVKBeT5L3BadVAeIcOTDX1ih11gqupFnFwEvJw7+jgaGtvg8qN4p+JkISLCGw2cmmOZwEP53SygV0MUTH+Jmau4kT/5C9TWa9c8ZF8bAsqVPcMXJpqp+wQ1sQEhYRFjJePAap4ISPVwOrKBqlW8uJNG2LAS8rbkMY/XPFEIHMI9LA23kqreLpmsdgLRZu2ZVsyHi7EEnT64AS/ds2VkBAJlwWegSPYxr9giAFdk4hL6MTmbWPzYG6eM6Y9/oSinVKVXAeBERpmTdyMn1nD5T3xccJAvSMFcmONYcq0D+GBJgZUtalWh48m1+FMcqMY0aqY+nSkjkZ6ozT/7t5bxFxnZ6YpyPcerm1v0X8/5LyxyckR1jDOzE7ubG1Tx4mPEQg6TCNjNEo5LWJ6ehbJbEbS1KEZWcrIHROmSe0KM4dEbdHiXUzAWF4VoHwN9Ip33DJvBaaPYa3W+sbWztYWBwrR1lYRFTPxGrcRDfHRoV1XW8JNZ+hE5ABWehyf8AWAA+ze4/iai5IRcQBC1VYwHtfjhczqDR+RJ37zxCO+HyFteLwbSN+lTiKR5dLyMiUCknvDdHgAmIswriAmeY0d66RET81RVtaAFmyBh0ecmkp6GBo+eZmGtO1fmMRwHJYLRPCXURcu8qe9EqIMNCbvslIUg3mgBkOSLlVyY8aJaJpFGYXSyFx5afS3u3+yvd2fns5UsX1F2jvkARaQO2MFkgHFUnfpPX7gsV0W65c0niJGsUSq/yhNT5lo088ZWqPx4zsa4RnkxtOvu7y8/uD+Et8mYefh2bPn799b9KyL/SN6WFxYAFSYR6Tw8Cgrjrtn7+xJnyWInD5BKAdYsS6c3MIRMaKHI7TcXCYtuULBsnBDmqfldDBHUbHvNGeUBX9pxvDjNBIe3E9O7t29u/Rw8czZc27LDJVIkRgqw4jxgROGsdsMWwGGP7CN/hqN6QWjB5w7nHOdGqJVfCXOAJCozounrWysBhcRgrSeeQlDiBpGHvnEm1cQgp6MxOiNubEYJTmSEyoSYJprJVRQV6ol9zrQRPYEP+mInpWWFx9eYRhnMHoPpATtRJKIqBBhWZ+LctApoqABG6UAS1RNYyW2ZLvdnfZelRgJMVAIL5O1kdpX05sw8gCbI8eG2fzXJpeewqd4E4exjKoT4ivrB8xKc44DLDim22LutU/VyGm+DnHZEimSeTTp0lgCRWlNCwermPnH+gOlAaKSiob32ga7beFXecN78ZI7TSDOdZudmbEFzDExzJvsHd2994DWP/vcO8sb6MuOb4/JMkcjtrZ2Hz5YBPm5c+dsGnkSKOVFlzrdzcHuVzMXhhJMmRNYTMH6UF7I3LKQ7Iu/dZevePrkhV/DZFy6y68JcgBum05tOkbUKgOAAb0gUk6jw4PNBb4X8RELAaEXYXWJgZSChUbXEhwEnjoNhTSqeBT2CEgX1MqA8gIBo1TqPSIWD9KVxKat3IQ2hOURn2IszIuyIceDlwa1dsbAFGUTCzUHfo+IlxyPGlREZVjK7dc9jjhA2UfMVpLMtGSzika8Jb0ak6BpQKXHkKs+//+vhrEmhtHgAHapZOgNpqGVDSEiqGwuniZWUEJze4tZpv78DEarwdLBxeQdSPRA7CPOJiXXUhbgr1lnrB/eKATpMMijrFavwK6alapMRFGhBAlKjcOjoeXVfbpBA7KlVmOHab6zfHSysbE1enhy6/Zbjz/x2JWLFxnAXVlZ3d6msGcnxM7+DJvKjkZY5HPkrig2N6y5Y/jepUsXOBqMouT+/Qd8HIl1Skirep1ijD5UIc07vzShIqpetMCxoIGDyhCRJmpXLA0wmaRqCj24zCY0HNNDZRR8a2OLAVlGcZAwmgjO0kpQmDSUMh4bASsENPKHLUlwlRd2EOMFj5ESkhtOoZ3SR7dyEKYfAZy6SlZetUOjyVNh+26UhFMMU7gWnVAYUPRJMsrbI5PRL1zUM7Aj3R47fZeXVlmnUqFAoSLuuaCuwIocdDZWx8b5YAy2ubW9Z4uUpi1nA1bRP4h2+kRSIIhqbGuIU8ynIKDWMxnVpwGpoRzTYVw4UgdiECqEMgyQGci469ISG4l6Y6Mqy4LTj7mn700ohn7gMYRaf6OYGFDkCjo5JJB49S+Yuo8OQWiJO7S4RPFvCRczkAGJ1RWlOTLKgNru6npvmOGfHqOAJDVnejKgv7G+kcqot7O9Ozk+xi5hyp6V5dUzZ+fPnJljZhFzHx1rMwC8vr42OzsNeo6AjJSmgHriH4VSVoUB/GLcJhAOCIVbfOG1cob8eyVbRF/1rgclF0cdUvbfvX2X6UyKtdBQPOlF5ZHe6BTsFNoktd7KXCZZYHqVnmLVBcL9VDc4gGyUDzQDxcVHYHCegsYYNFPDgZQXbk3/QY/BpUGhK22kOjAJCFXJDUQoNwgbHoK0mNUHTuxskbllJYJLLcxGuCaaAmAa2P8Qp7Qzv0F5wVG7FmDHdOXZvW1c8nWDQvWhImxKHxrisbrkANMu6pAlLqUv6r5EI+UJNeYCmY6wh5GwMB93XuMKOltB/d2D/sPFw8sXR3vD1BhuN6fhbakFXy45xySsHIq6Sg0jsAcjVA40J/FJf8VX9R96ElfZjPz0l1fd4hfi3BMMlHh4VcfdBw9s9GOjZzlLZXSYcdCNDWYGSG9LPg5sp2pZXV2n3N3c3B2eG+NToTdv3mHbAGORYKQ/ytEpZ87MMN4GTRiXYznwxkUXgTpBUiqJMDIm5sktmYFcYD4wMMGC8BoPHQOx0MrJMl8c6/cZsD97dgEIF8iWIEZVOdJO3WIsvlQOYQagCgf3sCRckaMNLZt5K2WYKfRA01S8cplAqlc8Ahw+AU5S8JIroukSr5IGFAy+CywWgEDCkDGCWyI07OifiMUXdwFtOxogKrwsWP3iNJcJ67bxtAwKvwhk+JGAaTUwyTHEESl8cXx0rDc5OUrL8ZDPN2SiE60D7sB0U4xDJNyDiU4Ih8X3RkAiDwA0ZGRIjgAwwEu54qNC6FC6jcTtsKm+8aswoxgcy9URLady4QjX1sOlw0vnaafZMZFzJOXsaMtvmRSHfzIhxlAmPXLhV95FoRgFgleG4rvLKxhlJq2o7oigBRjfuKAU0Kw+jBHTdr92/fLIKDMAe6srK1RAkxOTbNXjA+4XLs6zYWB9bZuWzP27D2lSXrzAWSn0B7Yp7yE1MzWzuc62AZOFwgnkUIiUMpT0NgNokgijuStYrJVHXnMTmKDyiMwBLJ7tM/j1hMMjtiaura5N0udmdWrqcck0P8Vq2lp9PrLC7kVqgGKmYQrYSj54gef56SkG3hz0Nl/W2ILlF0W1XVXXkXPQfpe954yP0bpFCYz2ioTD35lcJXt7pD3SKBgRQY6MPKELJxpR/lALE+fMy2J29OBRY0bmPYHdtq9S6yb90S1Rajk9lu8kqCmGAglhDnX+zNmzF7d2piamzPC5fPKjwMx5BajfZv/Y2NTc/NT8PBNn58+fYbJ4ZnLscHe8e7zfOZzgjJSsh5NVaUEEDQ11mHadmZmmx8BiIWp4hEmR4sw0xkgDPKo2h3JBER7KTaOUYpEhRL5ssNfZJ++hCeoqsm84V8TEEKXFXmKioK29/vZ+b3qCOQF3U2GmFufmetE3Kq0SH0r1rvUmP0VqFG8ML0mAg9UVm9scysvJPWhOP7rlcAAYoeQJtj4KzmpIxO91R88uzO3v7dPgge07dx+w146ZGpoZe3v319e3UQUpTQOJA64vXjrPNoXlxRUOB763+vDM2TMr66uM3tK4JFHBFibELfpWn63X6DE84CEPUQSiqQ8YTgqWcvSpV5nDfKigZdmL8v6IMYJjvhTHcXTLU7Mc3j4FkQEeokquEOZJBuDs1xiraavmhA9ZXdZOQ9cuX2CunzSOt3NVEu20OGoen5qipxfDdMfHXniBONSNLAwRFXrLOjkzDmZLollcQSZCNpSqg8ELoVZiZdBPPP4Y8eEE47J2sZNNTdWmfsBBxmNVFfAlOsGBdKEDDhr0vZGxM9S5MzNkW20pYtkLZJNx9KEdU0FPzXQ4o6Db5YvFDBkwos0RcRMj3VGijgwdHk7bq486YCESOfWNHEhNI/zcwhkY8MgnRTshiAKekQA+y521La4Vo66i0CacWSum5xgsYR79hReeRx/EYeAEeLiTz6wkoCPO6WdE1/wthV0gg9WNsrricMOqhY/dU6gpvHksN5MmL5XEalbtNSW4jOsTNcUf2+4dHE8O98avXnUBf0p7IYShjObrl8uL62uroqEGoJmAXWMonJ6ACtFU7J514/soAjEYGJ2jkJ+Zxj0xOU2rojM0vvhwlVMQL148x3ohtMfn8SidWUkyPu7GcJrppni0a6/rmJOvq9OF3LksAaDeFNa6vOLjPVF9xJ/byQkjrSzspQQCOaUyqsRRajI2giqicflPddPf26etkaUZeEJPDYR6EHPDpmJDfT6whYrhnHEMpIbL/eGcsm08kwrrSlT3+BVdsgrYqQPPnzu/tbXByjZsFz5JcvTM5WCFFRRO+CNfxYLDqsogxMtiAADMGIO6evkKq8dv3r69sbVFWKwIDggsXSiaZk4XovEEKoUhw3aOdDqfDZ4eJ2NNH8wcdrojB73R0Y3tPT4htvLw4erDexMjQ1cuLDB/f/PD2x4ZpO5seKi0/Klzf5bPyGjeUJrWyFjvqaceZ+/UrQ/vIRqhKIQAGv1UjOFKKyUS3sQKQgXnAhq10KZ48snH79+5R5loxmjM1kjgQb8jwyfUstNTdKPTuDUZJS1EsRdnYcajIVHhagL4YY7EXt9g+cF6u72JohANzdfSBGiwOIrxYMZyLDaU4KTLhyjYtE/isXdobm52cqo+F0APfZW+L6Brq5uo++qVS6xzojy4+cHD+701esHYASOk9DNRPWXhIas2SGOEsUBoWIZxin+mWuOlGIhkaoe2iecVAdVc3INbBeBrZmFlLD3gXb6Jcwh+gpaXV2CGtZDWlKVmza1Qae38sTsH6qLnKj3yMuANTtjfSyuH5uIHd+6QRCQgdq61waRpxwNaj6KQrPJffAYjiy0vXbpCO+vm7XswCdWPJP2jFJJ4w4dPE7WInPpCut3Z3tqk5U4TC1VLVVyn0UQNlBnSXqy2B7tGc2i1SxuFL8eTidkFzxaq4/YQazjJ0nR8dzc5GXFtY3lpc2N1t33C+XwOJ/g5t0YzZk3xhXsllLSUKSBQqtxC7JBRBQp4CggTMEo3xMFhninyZDYKihf5ImDgsqRvj7Ow75AeY7pApREi5hJRa2+vvbUNwND8fG90nGxJJoGphBkuGR6qAYynqW4Gw6i6LOlcXz3Cll2YRlw00+aMVDgnTcs0UJJf1MGW5FSU9FuGuyz2WllaZuErY3QU/EBTl0GE6p6uLSMHc7OXWTN34cK5jQ1gmf86mZgaIUNz7N5wd2x4dIwkc5UrxFKkNMza2mmxgOJg78hxZZThT81KGQGUwV/cDUPxC4hgAZR9SzyEIamdWDikSQbnPUvc5OXCx32AC9JsBmC4mzFZkeSKKutNtdooBAHjkpRYTMTroy2gzrqHAd4riqiNxRUYbcb0SeMePxMmV7GdtwZZHqSEmI0ePL5WQBOvVhmRi/QVtwBJahO8+QtxItg15p+Lma4UOsDiOcRg3ug4+x4dbqJZu7e7xZFGW2ur25ur1F8MbcSq1L2lI3jCA/eBvnUUY48YxeVhDQwpcpSv/NWlA6KnHshs1FIF3dhAGe6YDkVvalIZCL5ThSmTqGxzDq1u9FmOOT3dnZtjswoRSSV1GUbBbFUMweKa76XQvNjZ6W9sICU1MAkCACT8A4zMioaKQ3XaatGd6x3uMQNqRUUGeHD/HtNxTzz3LIsZHy4tUWjOzvLlD1cyA882+bNn5zhWiXXFbCmihUPLk61F5Ir7mw8wecYlqPXhRg1RHMRUI7cC4ef8mpNWFAYRMnKWtEiWWA1kg6N5E6RqikBpq0FgDYNlU19RV1Lhq5lC7VPtA4knjmQA7CkA3AB7lFrgR0FkAIPBqcYUITETQ9vjXS+jNtzjWUgCTBBM0PoladFDsGi5QQQqEUTt4DaaBX1Q6iowXETwQkLXrpGlH1VrxBYMzoMzgHAbu7dX6uphVkU7LMTKZTrZDvkPe3z3EAua+dj8/s7W7ubG9vo6kzhmV9gGSRiDZEkW1PWmT3PJWDwbtRAxndpBLHHIF5fqU/GJGWdFLcYFkCZp6CesdeIVRQ7iFKkKoq454nNbVAVHExOdycnuqB0ZwMHmkeC0nhijp83Cidd7+xTQTFyABxLyEn5Ok846GZuM9iu5Txi6QFNaQtjoXr58iQYMMcfHR86fO4e9TtGX5/Mh9jgPRnpdNpKylp1FnpkNZSSDM9PXySQUNCQ5RbsJRnyMX3vixktd8OFGSpuMZctyUnQtfQOkjuLkVi4FLR89Uk4Tx55hluJhT1Mcc0PjxxMkRRfgoM1rocUXWaysFbWugdDNa7FiOkLSf3ERZk6Iuzws5qNYHvrjNjUai6Sc8BtvGCDaICwYxCKsCPQxAjHMnwFJagaPiPMmbti1sDDAClPh8bUloRjSLttHcs0+SW6lnjYonVA2K/UcsyLND/lkPEd3HfLVuTXOQdH6bYrDTNCGMdkqEsWoJE+vgsBr4IcHPFiWN3AljAKItyIqjPLWW0muOBYTfNWKrvC5c2cpahldBBQhMJjw9AiL2hAbxRxrRvpra7Sx+Yowh+kyktth0b7Hh5tAECF6sKvhRmWJW3KKRNpRXkpFen2cQ5EKU47Nlsx3oC6KLlU6MU5ZbxR4mhgbuXz5/NYma9xNjOmZSXTHjkcLn06b4RU2D+QwXAc3yNx2WzLEH1WUlmWSFi3jfcgKXpjLXwgQ5nsYbh5GTfkdfVYIPuVrW0cvCxLLHKsUKCM5OOpe2AFPDDteicybFPU0pC58eEXWGnBOiCZWMDpyqYzTyzqRF2WQewRGcvOlKxmt7wtLwUe806g6irr3wa90EFyi5ufYCi139CnzCgYwLb+kjwtPUD5wPCz0uZhZtlDi4LkecYF2Gyj9M8yflVt7O/ScmJ93YXEYT/ujSDV604Lsl8mhxLjp0rIqBSK0RRvNRVjCV6UBFgnNBo+KiER2zsSeMUMKrmlutxk/nJmbZoxwdHL8xvkzHFW2tfsd0o6RlT32Rmxt2UkFi2hRKg95k43go4BHGxBhAIx10+Ru4Exy4Cp56qGP83BEUlrUZhGJg5+YcdAiirVDIzEZBXJakWZSh14U8ekIpl3IpubjY9o8q2sbfJwYC+6MeyiQdQPfAvTUaL4jfYSEgEFEY1QdFILs3lCYcA5R+yDUACWbnISdcuiGwbA3YFQArnqNFhQWD2o8E1Fgh18YJ2Ggr8vHG0+RlMOoUjMuMvIfonEJEfRG4kdWIhl0n3onOLpRQ3ib+y18eW3Q4cJIKcys+d3wwI4nGz92ziUdOPKnCnEAz+QsEqIUHdFECk/AAG+5annokD+JRonjMh+sHABTxeJDYxInb3R/sH7+Hfnhn01b5BB6O6z6Rx7aUQdHmD62xZk2Lhku9kxZcw/GVN3YkIdl2CyJ5SgKCJvRXzwMhmeLm+Q/FRMR5F/YsAl+ZUJkbZ92wzPPPocTC4HPsYkxFhROz81yoG9vevepoaHlxUWmUUbGx2F+d5MvGlE2WyRjwfQFRBx1Bp/agUsY547oISmpsCF9tcGy/p5Tuljz+CTDoHwkkzPhd+kIoZRkBtMBHxCbNJGNFYIO02LORFO9aFmsLcb+KdR6dov3WO3T7y+QH7R4Gl/2ziVJmYAKTCHvpo5ovaSkfbRbDFlKjUZQvMN1JPsopBAoOV7cTJKgGaAiPr0OyWV2hAFpZ/JN7Eo64hf6pN8gspLAgXIWZtIPyFPMcruxtzc5Or3AoNbhIfCURJToKYQtiDVjrdXBFbDgH8PVKiGNrhkGRcsUK+fOnIU9CEXyKqmJyoVWJV8c4iIikJEwpVjyIZ11yJ2dn2GQgumkw1GX+iEbSjZdwJHzlollU99MAkOw1GAAKS+izaAfyUmGGBsd7o96yCn/cp7UIQrfPMGLRiSKAEc4CVc2bzQ8yEGU4oaUJk2Z7iOb0U5mEQCZlK0iojSGie4gMRfwnQ6bRmaYpzu3MDM/NzI6xkeL4ZTJeKjTSvRzVam/ifnUx57HkDbW1lcXFxdv3VlbXKI0QgOMcBDKWLOMpCQlLiU5A9RJ8NbcmbOqFHJJehxKYVphm9aQZHc8GCFBajUvkizS9IRPG09MXC7t7sQiNB6mi9cKAy8RBRUqGQa3zTdMMYFWh+0Xfs9UOho5xQ3kyLgmQjhITyz2DhIIciFBEOaoOapOzciLh0Fpj0oQncS7WjaJXKAqGGKagcqmC2BkMl57yK8IuylWoxgUr2oMOMnr8j9ak2FfuJoiWri8i5rPiJK6Vy9dQqkaVafLaqjIxwl5h0w3gNfCCTmJzgalITZwO8/O4C5pRlrYBep2Hr9xXV5MmMgHWVVnLg0/LMOkLUt9ZbahnqRQTJkgL+qDcp3icHScOSKsleE4tAtDUEVMxrs4UAJATpcG1NROaYUNoRl3fVE0OkNCD0IfT/jje9cjPeb1GfK30o+RKDcGj2nQxJ2ahFXQSJ042hM706VILY8ny4bws0dBatEkOyHn7ODAlNEYq8JQDoyAcoemOh8bf+GFa088znQp7kKKUFBDgEYPLTaTEDiwk6GhC5cuw/nq4tJ7b7754Vtvs77VhMkiHJ406pjvI1fzHUvqV+LSgoc/9IBbnpOKEEEcZOL4G3YvN+0ZzjrhNG9OqbLJU8WNluB+YMqGWLixaQJtc3q4w2lyi9j+TDGxj47JMY1MUhIdsy2GQCBRChHIcKSRd6oCzMe1ENZNtik0wyQtVuj0MIkE22ANevJkEy5s9K9McSq/EppWXN55Z8MaZznhiih9jqwjI3AoPu3eZJCoJIwLHVGIyPZWlHjkZzCDTRbClpilBqndQz/NvdvftWKlCchKh4MDxGTNArl6dnqKPZNLK6vJAB7RDgyxYARbC5eKhF7VbhoycqicEgAnqx74ZDzTBZRtDMlvbTJ8tUO/qA6YcXgAjZFGWAYjHR630WJ3b8xeJaewo7DpXrl8iXmut9/9gNSEcckRzRYtRYlFPxUR29nkQSZbnPRBnnx4n/1zKyAHPixGE1UNKgoSmAdwgVKW3Z81xAE5kObbalUei5yfuq8kEhCW4E21djozCwuf+4EfeOK55/gQEIAmSdJZAoUUCm4kN2VUTgL0iRXN82VvRjVm5175yu/c/uAmC5ZKlbQ4Zmbn6F/duX2HuTPVajqKsjhpsAcbSzDARjjqIHNyFAXtQnY2M3dEPNRkrHSmYJh5ODFFGppAOB3AQL6GWyRTNNmHmnhd57yfVT76ttqukMOfG/oiC7gQnHMHRi1ywl0UDTqOS6AIkUYkl4uSzldlUSZp8SJHsgX+WJpugXhQtpmHwiHwNG0J2t3hzCIOdDTXfeQqPEa27saKRSIJOZc8P58h3KaT89bausITQTiDSVkyNscvI9vyyvIHN+9GOWIWLJfIAl6Mn5YpehNQcGSk0dEb16+wVJaUuHP3PquYHPU4wYAsckI2d9BZoODNq/qgl2EdItc+qIEpcqmKaElrj6SYLXnPBkczlP4WPCkfSkw6wayrdwTCdnNKJTSRzJOFpANBYNct/qDhrvRcK6sr2BPFAiWuioreZErBeFE40dLdo5SZm/2pn/m3Ll2/ThcAVpi9Sssl+GJFYj9NgualkMm61RxjaFNTjz/7NOeX/s6v/ct3X3+DeowYVEHuXDg4YLoJC66kEZdsyCe8YJrhiLnBnPluMvNpBCbsdhnPYUE1zTjNhshGQVMuz2pKYOShBhATSHOAR/jSu8kLlV9NEO23Uhpxmgvi6ibdgE52Aw91VvhMUMmrtsTEyurJMdeJlDnCCRptNA39kAxoc5MYpOJfbICJfGW9TZC5Q01z9gaLwhRLSH2NlitRdVFXkwPi13AD8Vg/IIHCBNPu14ya2ECarpZkfAeNLEzrMyjCVhNPPnCWSoLJUiK8iCY+RpIYhcAQhri6wgqmZQqaCsaEdQnpZTlso5WSyWOVDTKVFJl/ChraXHxnsGnkUGFQVWEUzOWiFngNtqY2RGvCww21BJjgoXQWdkFX+sdbt1ee3ACLrYQ6SIUUzJsqjhu4/AtP6+CTn/30mfN8nsMy1ZpIaOALu8lo/EolBMH2kDQyIxRQhFHckA3YsXPh6pXPfvEHGe+++fa7SERkDBbVWWA0yQM4mJurarKwCHHlVZOAugOlSkw4SiEj/16IBCbQKQSUqcoYQIuaU3rgmUuAoNKjgguFFApVIKQnHE/iIRdD78ZtLnPr8vIaB+wiIYu+yZQM4TOdVgUzccxXdYkqVzy4IXURo7DhKI9iw0SVnN2QtdVVGmP0zFIQDNiCP1mRGQ9C+9fqh4aIPOef9HCjIEiN5x88NEBQ5AwRZgZTDMpbREy8wOmjt4/yKCEKtZ4FG+VQ+Jp4Zl78wa0q8dDYATOOo6osBOZScVGNksBexss1c88x4Qwz7vxTQMcyQihYvIFXbF4qIizmnRcYqnK+8a9QAZVazRLL4Q0atzj0kGfB4g7WxoMWwNCTzz770mc/zZeShFGyUr08BEqsxBy8DPwzhU3aAG9ersyKKoaHLt64/vkf+1GEu/vhh+ZnIQbWLyp+zdUgBgAi8dZHi2IcycFMCwgw4xOFNPDEhh87FOVqdzmkCQR4yH4oNK54Jf/gLXzi5G6Qft7iD3bJMFjnJ0/EXZfNJLqWaUS5wIUTpzc2GQejYUBfKl1ZhsX83kkhR19hVAw4gon1pJzxvRuEkdSePoPBbea0d3a2qKwZcKgAOSJSxEERNDLJA4l4eouCTt9S0qsRSwWvYp1XdUL9YJGWEM0jVh4IbzGnilIJgHuQg8puoh+/pcmSDTSlkmRQCRMjGMrAQM+lCTEMQiGp1lSuvoITwfLOtg4Lj2wQ2maFYq5T9fmmryQqKq9iiG9CfVO1XGWjMgBQwBQ8NpBwYwldMeLWH7aJ0m5RYH/mB75vZm6O9MXjxGP6NaRTGHUY4CAItcoZRC5h8UMsG2aOdxGdHTGXH3/se7/4hd/4//zztaXlAIowAjVsi78RSKU2eIEJkESpakDGoIATz4BKPzwoUFgIQgLo4laNZD4RlcRK7IpphIYYjwpu3lWIf/ybz4DHUhgZKNxG5zJL8KcVDgq7NvNG/BMFu6eM5iw+Dpugt+qhfO6+j5wgVHmg5nCrdWQJ1TCgUTpG4Zx2t8s61tHRsQEvoWlEIB36hXQKAFgDbUQpeUAhHVMoQlAS43x06aaFaqOczjHuGCDFYrIDz1NgChtkgYqRDYjLxpWpQzcWxJgInQrkoxSw5DYoP1NN5flP+mPWco6907wRMRymR2IyURPSImaQny5bk18lKYYYwXfxT7TmPY/iFme4DFqcMiHhU1nKxz5gySdAFDWASHSJzi2c/dwXvv/Gk09SxshF8MhL/rg1pKwY8JOJihteBaJop55hUwd5x25KTJA7ef/ak09+6vu/7/e+9Ft0MdWfCgFAFGE5mPTJu94Ji+bBBBeoyxZcczXSJEKJa4liIBkAG5K9gokuGkb1EyRgDfvKgU+Sr8KxfRokthdh3ZHHxhKMSiRnAd0FazwvUSa3hONoZ3v3gH+8sVcGm8kOnk/JWX4ZhacMZuYicRM/li0LwUh+o3PR2F+DMlRtP4X6CA28Ik6cRgqYiATyQvu6ilI1UoAikEuUVCNdoR4ipxCCFDRkRFZXo5+kFp5RMotStyeOmDBgnc44PcR817CsQn4GNGWPP1pB5BbmsvRPfO7kMIzfDECDmLqv4nCXcNRZ9jHgAjSWa9pYWYFu8SUCNKML/PQXh/6BCWbHNfLh9ApshErc0KTp3/v497z0+HNPDzHoSWwg1HZDpHlKRDqK2hQDAdCvGQyVdYeYSYK0dwWzI0FZ+OwnXoT7lfv3uztuSKAxAwHAT8mABULeIU0To8KU0FRzBNz+tYtICBEyQeUweyYFiIwsdvIA8i+XqIJv4BG+jRrfxhIAagB1gTKFbLyCJTe5YdQ4px0JIyfQkSevPHOLP4eUHBzR5mbFLI17vyo3woA0Ke62BAyS2BWvEowlqBxlxfY9jp+mJEGYgAkiISOQoyJdUSM9k9yNrECDiEEICm7HI83K3NSUF6x7d62ocAPiElHpJbX+KTWCiwogxtnIqbzMTk6xjGR6covxuHRbgYFqowOwBGHwg1kyQRUO4oQxGKEcyZcXsP6mZJO56CMyQQv2S0E+aWFatiF+YxzBxQ2eEhOHf5KMr3cvwmk5YLK+SEH0DZwPa7lLly8987Hnx6enCIvKUvHRBLLVSbbT6nxiZBUXaa3IwmQSwWZPUoz6MLTgxVyBZmx2tvsjk+OXHr/h7Mn+XvYJMR5EEYAykmEsB4mXS57gw39++CO3jYlejwXLfB3CNI2W87BGtS+epTtkN2Y0LJ7LIhtR5VqPqCiKgGxBhJSB/FWIoF7lQ5NBfriIjzgdUo5WOvORhS4qNcxmQ6IGi28f8UwoK2/5d65LRIIBoqYjqORcMMOElAuZK02DeEA9QmMFclb8FBIwmW7xBl2nvTA3T+edEZYM4NEwczSS/vrZ+TlAyb98YItIJI/FKtoTQ/iFIfUZ1Qe5CRJe7eUzPdLvT85MLpw5S5LQ7ZmemKDrQ4aGnQEg4LgZUeT7k/SFMmZlMwBSkKmCvM3aZj5ewhT1jSuXGRg5baGU0kJZES3sUErqEPZsw+zCwhlPQ/GA0fQHUZhPSlmHMHUGmykBkCZLQmG/jE62GUALQlWlaTeSdVga+fGXXjp/+TKSS1VJ1IODKkZAIyxSKw2paBRhoEpzyY1RqgPgHJFNu0gRbyeDKbZZbWDNPHP2LAUTk220i2kDs/mETqTIQtDinbKe8S4zm6MijEPBv3NTbBThUy/t1vXHr/ttzyRTzCG9q+GRD5ceLt+5HRuggKYAlSc5ACgujQ4uvSlI8/IRTgX/aHiAVBQ5D2gvMZmnKYpo2Ngi0UOzy93YIvZKbEMaiIQN3qJdS7eMt5YYqpWs5fJHdlDlmEQVn1SIpksM0NEBKd0XfaIzkZi0FliS7daVK5fHOIygUgXalmMmAxfmMs81d0a6piQsmnUgJbMDDIgpz9bRdmzIIpghaUay0FFJzmJx4dhjj12P+I7SmYouT9BAqOL293fIACPDI1ggf6iEINxW4swxssiTRbnt8eEhJ2QkTVKTFRgGBU+kADgScPedRhOTR3atzvTkCINKEazT1VkM1gGjMXllKS9EwYGbT0YQb3pm2s1MjqM7muKMD8rstK9cu/7CJ1+igo7VSzx6tBfLOTVMBKAgpuvhx6Uy5HbnXt3xbhMBUs5+WIpb3LjkQcVCWI3GNhCZVh6aZ96jc/YMLqR+98239ncPiEbyTbEof2ycL98wRseh2GCjtOfLRVQRTDXCBRkA4cjrEKMapJwMdpWKgBQzpl/UBkFXEMEDYfkzXRVIsZqb0BVagpbETQSVJiQA/LcZ8Tht7osHpTEbyxyZpXjggtQIXoJE6zq0Hv3qlpBy0hRCNob/1B5g/Cij6Vpg+u2Oawf6h5iqU/SZbZRZL1ExEaBmo3te9UWYXPVgzffq+jqbB2maM6yo1kKlrFCjyiXKDAoRSgqRrxiDsvc+OsKUO5+BYOOnKVgkPOoVxMa29opQvNRkKFObWJXJj/0NDfGNa/bs0uV5/70P+JZFhvchblwQmh5IO9K9cuMGBcmt9z9gib/mwpWcrDRaRUljSmllpK5HsGAn45zfCjIsB7ZJ63MXz5Lz+OSr6661Q9PFqo04JSRzcCm2LGJ67nOgdiQjDDG9eu0G09o3nnpibIbGT/QkG4rHHwUv0z00n9yFd8Ln4F2Nc9hydUM1WMjukjMDmOhh0hZ/7WZQVRQwmCrkrQFt1h9xBNj4OGtd7966t765TURCF86duX5jkqS6d+cuaQUG0oHsyik+DI2AXzKsUed73FR8JqjqKH/w02TeYuFgFEaITEf0eAyso7QftSpftJ2bbrnkWQGWpulpmV7tY1SGLptuWmyFHRpMNZD9w4aRkmcSXXJNBihsCS2YRyHdoSm4JMfTNXRMxpV9VRoNOyTonkyQH3f2j8bHaHBxYJYMhmtO+aMGkGX9ZLyuSmzdjEfdunuvu89pIZQTAUlBjjAgCRqcxjasShIsiKKlO0Rj4JlnnwHDBx9+iFUDTRygFR8hovN4SDYZVyyVHIHQ8obXSL6RibEeM68uS6kAMAAZojhY13/7zh1MyhatOSeok7NkCpRRH5ilU4GeIHS8yS4pU8cAALGJ6Vm+mz7OwDKjZ7IlcEKF4MINfF2GkZo8gBybmXnx7Ln5hfm58+c0Q21RRqDsxsGjvcuPX7x48ey9B2tLqwxbHzDsxRJ5GjlYLRUWeEFm0qeSLNLExXy5qsLF9glN7QRNeHMlEmXEYYvGmPyDCfEZTq8CghrQmo1E3N9fYwcNi9KhkW4IlSq2QSUs9eYqQR1EN/pARLoLZSJw2Sg8YRLTUVRxqOnyGvjjl0IoBVJg6XSCLbyLP3maypSCR6Uau/mrKB8hEdy+W6FYUUlZNqMxDxQZGRvHq8GS3FYkgXFvNw/PVjhhWoxkRhHFMX0h2ak0xQEDXgLzJnpFoEziXkED6h+xA/UCcBKlYgPMoUTbOywDO5AubREZD2CkEExMMFIi510nF4/G6qgIOGNiZndqb5jzEnP2FuGJwh3gYhPX7tb2PvYBRv8eYS2UVha4SoJkAVPTakQxGwu368dx9jvUCzJRwDoqtpzxJnAhlRG3eZi9ODGc3eJT0+OTrj3R6Aqpe2DdKnz90tTLH5+fmhi6emHhg9uj79xc3dpxmppCnT+a5VZ54YeYkEme5V1PUbkUhxEDESfL2bvDQVza0Nts+jILwacqIagyDpjoA5BtQEIxhCTE4B6cqMpvnNVg8ECTohAm6seTf/sA1tKKrdwplOUwL2pHtQS00UvjRXjU6z1eysWHXTn1HSYGFud+Wca/XUE5wKJZS6yiwa6U8DC1eCtLJDiXhNWbV9OdFZAr+CqeZSL1KytGD0/WNnboc1M8Uw9VuyvYo3KR1SVJRY5PkEW3oEjyBEiNDKCNHpZx6I0aZduEcFFCY5fRWbA2CPAImbJ3scWqeYYB320Ks2D9eIIvswRAOqFS7xHUADI3ZPP6iDNdlRnCH2BiloUBgcaLdjh+/Egd2mZWC8YVsUwVaWM1fsWCwSLzhxETmxI9eRI/jUjLo+y/NPGFzz09xYQqn4QbPXnhienJsZGv/P4tlmKyWJHImnHHdXK1SVWfoNVUk/2AgAdHhKoEN7SY6zMuTi+ERqNe4QWrpmFjj4NvxrisTfaJKM9iAaeFkW07mSQLEOJqC80G7ikf6dgQmov+FT2Gj2ijvBOpASkEvISl5lYIGvblIDnHc6TJttGYEZCTYVY6grLAhaXKoxi9NbjMLThB9ijIXJI8kUXDhBGVP6UzIDGaKHji5Z9M2cOjw2WLnAShbj1lJqrWFgUjmEcJHjXhp8IKUwMwABrgFiSx4Jww4tEWMxP4ovYHtAImGWMSmPeKGyOOV24mmDW1eamRCv9I0iA7xdqoS2wQKj7Cse+N7MaVxY9eMbZAEERpTJ5FjUIInRiDaA2tkqWBiGj4sA2Qo29sVdPYY7DP7YjYJTn3e19+bIq5+FgXgL3O8Y1LfATk/DffWmSUf1gNaaZgsEljXZBxbTqjLiBqinwiUpFmHMz0KLWRfPS1xienSFMAZJe/kxbLgflaA4jopBPFQj3mA8ipYDiIIK5HJbI+rrm1zwNp08LzrhpV8IjqHmkw+tBOceQmCxXcKFxfPUuRHO5OBuC9UNkH4JACehmst3FkjFTjXlF5xKFpk/q+xAM94jQzxFfDABtQBTAI9UmM8q1Gd1Dr28gBV3b7ZIYrsvgMu/oU37rwMxaOSNMEJY6eCfrITQ+zEQgoh7J0USg0LXECPhKjkk0KjSvIQxuP4LBTiEUiZkP9o/EhAVjptFHsKXaR+hKPkiYYwsqpP/FpPuQPIpgvtyi18BgjeOI4RdUIUwqBvrX69s7m1iYNKD5VNgogYQzTv/TcpXOzo6hBwZq0p7zvP311vH8yvbLN6m6OEqOteMRGDv78IAwyEXnApiUmqc2QV7dDO55+KdtZMoYsBBY1NTPlfDNDRgpFbUBOsQ5T/fXhTZ6Mlbnw0XI/VqZUNtasLqzz8G/0CLlkPHmoJtBHkqyUgr+hZhAdjaePQXisL1DxLW/gMwqUhMoNQbJRm8lacQ1gE5tbvAx5ZN8NPcNILsOMhonk8onkFaW8Ejtgg4w0oOXol+MYkWWQNhouAMjmVZyiPdYeNwMD4TEhAyhjFHjiDG4ktn9qvC740ZFbwdd7WYVi4EqqF+ZiA9FJnlQBySXhKVyCQ8ACxiBLDigM0quIGJDQpsgLAwKnKuaWMaIwByoaIfSlQGJTuzguAqecyyNMhNsUDZJjPp6TyVZXmdPjaCB2ULCqEQwLc+PPPL4w1MJqqxXtuBKRwDDea3/8sdnj/vBhq7e0uX/7Pp8188uLnP8Zy7JNTwIBT1yUwJOijoYKLXzahZh0lQnkvTMLZ688+cSD929S6sNKze7RJGPDgCKYCp7MTveXuDJuyx+H3XRE4Ys8paISFLRcpzq0CTSQvRIPMB3+5WocpSyDwBYbkripcdoowdcmkOFB5dImvq0EiWY9glz5lytYYLLeGj8eIjdLCIdigIdbiZAK8edmRkhwbrrNLNyNxysSgh4VctSFzDQ86VQqX33Ki29YielARB/6KkOcARe0LqEIQLFApLQ5YTUGNTujQMRPWjSgJkRVCTGO5ih34hAgSEhpKqS9VRxxxR6HtKU0AAYzMPhF7gDy4gIjIxpmIc1AJxe9Unxwwg81MDbB0ivVp3hECqyTEKhHZQWrozQSzRW3pItT2eDbPCsrr7/yzb2drfn5703LG1T961fPToyPcNqv/Dnm4cwGMnCjRGY4HtsabR2PL4ycX7iwtXt8++7K+x8sbbIJnhI5S8OJJmONxrVjRgUYymPoEImiDU+DHJ2YmJmbPV7mowFt1j4yCDjExy+HexR64FLVdDPYEEwt4TSmH/9lOJaSjeUCIFf62AwJTe0h/4PLpRAyoA7lPS4ecYS1ChBL9KHGcp0GovFBXPfUJTkaNLizvGfYjnuwNvcSWkVJXNy5Gise+MmzDRue6cFEjmQDcRkYtJQkjTtP3ezUp9/jOFqSpDiWKeWUYl15Z8UFQ4O9/R67RU+DQUJyYkW0FzAj4iFYlakxM83L0a2TQ6bS+fYjRwUbniwAfvtBCG+6JFr1i5La0c/AkqExzMEzY4yUXTh/jsMN6d7JH+ThsHJUam54Cfd2mhEq8Vil0YMAL1VHAoIRYOKQdKrh+NAlMW3XC6bfS/plO2t3+PEbN8gC1gHRuMSUXCPWORiqp+RJ9yT6pfdI8WZTiHPTyPMUdYcz0+Ovvf7eO+/d4tQrunrY3sXzC5fOcZgy2yVNItBmq0Cf3vD8RGf6yYXZ6bFvfOvOxgaLzJEFQ9ScWNFLQ4WMSo5RPzTlSwGMtqXFA64ex6KsOUHNx16tJZxXIWE4Tt2CCFXDtrtOJsYoj/je236+EE0Z3GWfWmYMSQ+bSZ3O7tZ6f3ujMp1CqWsFf3T5AgdRRwUhSmqNxktQnOFyyNEFnXBO0ogpieyDT2L5edveYCA3cIml8UdKEgFWkhSkY2EFmwglQgBg2rgVJcExesv4Qd6w1ISX+AQ8eYaSgf2r+XCTHNUFWMPawAce+STg1fl56PAJEKXgwlKEFBYLoWRlJo6K2pRRbZa9AolE3JcunSc5092Ot3OfpIfMUzpgsjgCrd3TByWUWOJCKDg/PuEAq8mpaVKOOlOsEdwOZ9rrM7NTJC2fGaYBQ5MWJHRH/aRfVoLgkZpPfzgjP3BnSyeHeHMCDx1O1pPLAZdaQi3aPv/Ra8pCzZSwpA6513p7BMtw/GKkM8LE69QUp2PzBUi2j8yd9XgElyr2+3yuj3Njn3v2ybGJyZW1rQ8/vPPKt77zqlOS3bmp8e/91HNTo1jpMC0bpEUhDDiem5+8fuXMh7eWYIpRH8ZjUCbKgGukR142iGHY6Cnq9whrOH7+Ex9fvHf//FPXUdq7r7y2dPcBDgdkHdtB914kE/LTXrp87QpnEK2vs4iYbUR+HxPhpA80g2DsWjk5sOrNRU4ujZuaSf7ovpKnQFRcYYgOEcVywztQKs5gTZNXhiAVFDf3XKiRSiYLXhvMqpmkaOLpbH6NQ3OOUzoFS2c9rsoMAvhaDR64SFjMzBBoGWJSo1NVD0AEkiHZlHg8fCEVVz7Mgc/GRSgm70kwN5QNc1IYZcbDh4u0eqWZY5wtauypMe2cnn1yC1zgD1EiUu5yZAtfztzY2mQ/MUPUxQ/xw5VT9EQKX4yimgHc8xmWUnwnLUAEUATi8DLmnN9//wMliwDyUgo2ZQXVCBqxZK/HhOfwCNuLOfZyfWWNVoJdTSMHQVwowSRM7GipXGKamZ4m97ELnBpm7tzCHL07SvuzZ5xnHGrfuf1B62Tv85//xLUbC3fv3uUkNYrva9euMBHJeqBpDmBvtf/lv/rm3/mv/ps/9CPfRwnIIh7OaLzEkpPJmXfeW7rzYIvldJMjrFDau32PaTMX/1CNsYvTwiJjOzJhDcWbOrtw7fLlJ67zce0v/fN/wfG6HCGmOHz+KpYN88n43sjtTCIwP8O3VAimVqHwMjtFUNTLYg2OSVK3kd1C51QJUYC6EbEvBRe9xqOURxJHje4YjDdlj9UIsTB2E4b/xKUahnuyNPPdeGhDhZenl2DctWXieIt3BXk3Tb0qJwSOW0XAgXZOK40mA+ibKM4p5ltX4STWoczE5QaTPuWztb65GdOJf/RCqmPNyNIbHuVzsQy6cTRqg9UYEa4QieKRvkLKcJZIzM/NceIG38dukIueKySJE9/yMpYcgVHZAIG34jBG4KGcEzRm2CZMYRZqBcNdI0lcIzfvxPePQNoqxKKHDX7yAA2EwsBWWWiGo8SCfsNewyDTQ3zdSrb4wtLUxJUnnjh/8SIn3IyPje7vbm+sLe1srIx2X2JY55XX3vmVf/GvfuzHfvT61RsPH9y/cnH+8ks3+IDZ9376hd/5en/h4jk2gjLDTTvyW995+/bi9q/+6u8sLa597Omrf+0v/ezU/OjM2Pxb7y+t7TA428vCHVuhFO2kHdQtxGhxDbvJhF3Pb33rtd/79S8xlRtVNZqHcdVgpaouMDkqDWpe09AakRkDxltN+pRc5iuHgZqLYVDWJ9YLsRs1mEjqM1foNK9RbHmfAuBn05eosMCYT5rdYuBiVAt7ZGoWQwXAm/UGd/99xsEjb4HKrQGo8ATHRxS8WaDiSNlAqheUeYGUNk94E8zWqsuDNK5YNg+Z0EK8ohWVx0V2ETsFS6LjABkLBqb5Ekfgg9hKgCvRBReVHOiJ20sQRh44DcrvKVjkmI/tkyRYCCFP3xpf0HhFOwMOY8k0VugachQk5x6yLdgw/8xCEpR1WfAPFEHDqwrKC5Wg8oe8YywOAVYSCFGRop/vYoliEbrYN0ZD0xAiG+trVGWdM3w44uHO9iZVFv60w9mqND4x3xqaeLi8fff+8vlzcw6+tHvvvvPG/dv3vvwbv/Pff/mVP/YzP/65Fx/f3mn941/5mi30/tFIt/WtV9+YmhrlkNdOb+IcBzOPTrHec53t70euKsLwOfrAYoseNkvsaLsfHt17872hfZecVIqqr5LBBEQZaoLdVnyWgNNROAZRRkpfDkc0aQfKKMNkIn/Ajq12dQmuwidiLxWrhlVkA6JHAQ6gEyQVE4EhKjRm+0EfTdRVhFSCOKTvvYxXNKL15tW4UwKGHNZd/gIENMBGAAM8O/zE2HE8CDLFExSGCqrfYgMyquENbpprkNo+4+26Ig4lx8BPWtNTLIHkOBkW3jUXqg/zjbwRfoAyhq/kCgu2hkKeYs/ROrxBHqjQUwcNYRjWuyLpV+w0mPDIJQ0YMG8DoUWcyhI3spX2B4iUX00w3UXNrBKBa1qoRMeyrGofXbKAPgEKD8YOlcKL39rS0iH9DY8En2YNEQetHO1vcWgMn87hnOIvfP7ly1cu372/+sbr729vrl2/MnNyfGN58+B3v/bqz//xn7hyYX54fJqDEWDpwdLG17/5OsUCq9n+3b/wC+2T/Ve+/f6v/+pX7t67/4UvfObnf/6Ptluzi8t7dx+ytvCIQ8pZ6YN++IdduPYb6TfvkLNlHW5L56aSDOsnNM0q5wgQKbI7csHVKI6us7WCknFxx1Jp4iabgK7xN6Cu0nV5gxwH/6Ul3wJXyTmIEOPHX2j96MZBiBptsIzBWITwqAsYAYO58Y4lO4TDe6VbGTdAA0scxB5kgMibYg0jRkUkfEOCdXhw7J/sFu8SxA2SMics/sD1JPrv7zJgoooIkxF05N5tC2bsDkfsRP8oRL2LVWqF3IDoW2BXCp0SHYQ3HonaMGV8ETaX6AstRKW5u8enAW1NBg7MTXMR12luqAhNVFlFIBdCUiHLeTq+2oIL59UfOMou5MEMEv7UlOUX/WjyicT7bT4kfvOtd648/SSQHDR4/caN/v52r3844kL99vzsxP2l0a2N9RvXLl6/+j1PP3GBMcbf/PI3Ll5cuHBukiV5zz956Z/92u/sH77M+KYLNo+OpyenZmemxntTk9NnRodO3nzznZFeh6YDzZxL50bOzZ5Zvrvy7odZTGQZ7qQzRx7d/eDDpXv3Yj6lHUSgHDSlIoj6UxaMIg2nqAKD17zrT22pZLyaC5VSA9AHUB3cuLzxi94HPgkwsIpSwvgLoLdotyGeITlLnQYhXR964Y39m5hRPcFENBGahKhcLVZ9Yni6U4PoZzEvX4OwxqE9GMN80UQ2LvUyLBhIu5I9ZXIYCmFcOQY8w2VTOjiaDgHabOy7IpyCAgQE06+iDR3N2cYjMHCN3QV24H6EGRgQpzUlUhHKP55yCgIuPRtHIQhEvMtfOv74ZyVsENYiP5gQiTRSdgEFej14KmtK/UwFJKUDqJnQPo6qQjbIRU8MGeM90oSqIyrpllvo4HP35s3x2ZnL166xFmLmwvzM6NzJziZnHF28cuZg/3hrbesiHWUGOHt842PvO6+9+8577/78H/9JELPQ89zZab5t9e3v3Hzi2vm/+As/9U9/5Te+73OfHmW9xPHRV778JVaDT00OfeyFp9A40JzsxrjPTH97cn9/fHiald8MaFpAnfTf/c4bR6x2ltmBrYd7ZSyN4WKRhoMTTlEzQmT7TTlVEHFMEiFNEXBopw5m1Eg5AaaACaVG0IY6aVSVSHGrIxOgAQ/II6gMXbnQqIJBZMfLXgGK1y8q5p4o3JEZfBKVpt7cfI3bFMEhmF5xJ0DPhGnvAvOjwDv11MtXz/HLvEQ0YBQvGPnIDZXRSHPCyK+JpMDA5tUqa+pYxocZMy/fjHpadqj+4FazYBRdGJRJLzUNOwyhADfOdwQFtw1T9JMGYikl6cs0B8N5juZbyRVAoSrEjCrSeT3DKCTt1USlpMlWU4b1qnnrwmP6u4yTchYiS8QnJ8fhf2/okHk6DlAiC2FwnL+2u8MhRXwCPltgojhF4KoUVwbfzPlITk3jRitGiA/fefW1na2dlz//WUY/2cCw1z988HDxqaPHGbedmZpgGnZ6aoyvznzj99958603/8hP/NDCLCcVmHswuj/ykz/yT/6/v3np0sInXrz+1NM/y7Y4ipKvfP217vDY3Tv3Xnj+mU9+z3OtE/b7H3JSX5tz3feHeguXZ05G+Mr7IufkdYfW6DgvPmRsipYYxm11rRGrbBilt+JCiCF26QyPT7Ioj80JzJe5LpN+mJ8lpE6ojQFpT3JocJ9vZHCR+oyWlZajcW6N/k2YSqMmXX0IybMxZo1aq2oA6DVa51oC6RPz77dIJ+ZMBBPWIrBBknfHk3BkJDcGMggX3mRqCPg0gqgb33oM/A0uhYuBS2wnfbbSlr0LHdkCiBNoE51Unpufe/bceZhXk5SpuWKInqpCIXL92mXmg0SJPdC/1JYdTY/0DjRAjhlHIpPVbYAWL0eHly9dABkYGYoO77qhQgaDtlU1zQUMJHM6cGQJTXu8OIgmozDkMrPM8gnb6UlIcBFRNtIoYqaI8X5wMp7BeQKUxHDA6LYFZ7vNlOr4JfrxqsFYLnB2EZsXMd2dw0i5lXbwWVNQduacjmGGjyw0bR/a7drbWlu6e/vi2en2yez07Pzu7vqdew8Wzp09O8/ZOkPLy+uvv/nu/Pz0n/szf5TB/tbhnlmTDNBvsVroD/34F371V7/y1FPXr16/vLy/++1vf33v4OQnf+JHbt98Z3561A9p8b9/2NnlW12Hu62pictX7713c35uhs0afuZmff3M3OzC3Bz6kRlNT10ilhmA8iDTH7CeOYT+1WvX4F2hXFVhGsBJLFMTurm6fPf175B+GAUZ2Kq67APVxKm6UrsSUkH/GgiCGWQgzGAI/GEZDP/ilTBtIFmADoBTDUVAywRAZnQ0vmltM9/UEAnGRxC48PGdh+OvuvkrV/OuWAOUhKUktVPLtLh8VJaV31hCouNdekFHfJMHy1BTUapAOlueEipUNK1h0B8InRZzwJJklmOSU2bbrbW11Sz8G6YUVOlDHb7iyHkWrL+HLKzQMSEVYN70O+mwVbc3NMz8Mf0EfKBgGWUQyPIglpf9GdmPpsNziy8zUK7fuXN3h69qsThMMCCsDLAFGYdr4rjPE/sgx1jPm++wDx3mQF4Yq+WzEzjI58hCpoA/8djvR4XHY5PjvEbkFLmdoY2lpS/9i9/g28NPP/v0+YvzKys7M7MoYnhpZYma/id+/HO0aDjXly2AByeeIN+o/mT/6sXJn/ypH/rq19749X/5TbYWXL589caNi4yWPnH90sn+zsn2Piubhzgy5mjo4fbOerczPT7Kvjqo7h9v7x9u3/rwvbt37sxMz5DV0AcajjmYnL7G8kgkslt00JzGiZQ5961DQjBvqFC5NrY389RSGSPTTYGkA2SN8srbkPy8C642hDmFzlc2DCSdKE+x9ZSUhcuqh1IGjYvHqEQW0GxjK913ftWUFUXeUnDgTWUiLEnJU2ABuPnMLZ5FPFETUO8u+hWMUT95xzG4l6ve4l5dXetzZKd5CNj60+QGLnyTAaIay/sWhUrGB/3y4cRjTz2B6d788C6lKZJQuMpyv3Xl6tUVvjC+sVasNeSDFP0xxcYA681bfqpRtokS3YZnYVFxw2nzaFRPELXRjevXt+ka+yVj0yKKVKP0IyNuxdUZAPxliQcpoUNbceUZmZqlAJcuXmTwBG7JgSQZUSg5WTITg4muLcvwNi4O0PzuV37v2vUr/+Yf+4Of+MSTZ84wuTt3crQ31D5m0zI5iRlYlhkf2ZojMU1s1mZMT47++B/4PDs6URHp0vXwF5Yr+CXW1QeL+2ubTFy+ubT0r159be7CjWsb91974zUMZ219+WBr77VXvrm/cbC+vIYtRR/eLCyk4D+Q2H519Zn9CJMWB+cvLPClgju3b3MqMfyrgE5rc7AEg6jub1A7KEZdqTh1c3pLXaO/FhHSYgGM90QpSKNRd3IMwRxblvfXLfbwokxz9t5sarTCbAJY2qdLKadSDercgvX0VapG8Kbyk2t40c8rDgIqNwmUn+0Lu84p+dK4LvBHd4WIlUsaSBEWCTHzAyC9pLRJUgAaILPqoap3lE5cTy6ihLFYiohoguuDDz6EiSS+6LjK+MAAAmFduMaMVGP5BSRPuKDSlFaJecosDuhzmdjR6mmqJH48hYFTJJLb3It/6YovdQwtImiwGIGMy66WPc7ftlwkJjxXPGG5ZKZUlVTP8g1GTna297/8G1/9qZ/60dk5hoP6bC23BWkv9vh4d6s72XW+1g+vKDdCMzxPJ2VmZrbVGaEJfriz7hpYtdyfOn9ubH5+aWvnm2/8/v2TnbWV92+t3jzY4yB5PpvQWn24vLuxyxHkfBHPSYmGK9gyPWJc0QtkaCxy0hZFgVUEi7VGyAPUebwaCUqooH4qxh+CiCd6EsZ2MSAixwXeoBY4LkG8GoJ2Cg2SDxOYgu3s/PzM2gb9P/FwUbGSEwmtlEDnVlVBaAM8xT+QohEIXB/5hZdEDRGgXP4oQGC1WhxqMbR8l2beIm8qnwAnQgjjEp5f/E6fwasfYVFA4w5AgWpUKMdGf1qYdRRyn3ZONK4eHnHCi+yJsBE4wbxCwGYLbYdcsJJoPtRIwBvPAUQU3EAzvUjDCVsTNRyVVKJI6gmVlzga0rGTwpmsIQ91gYAarF7VnSLwJoYAhCNeRaT0g1i0kU7eevPDr/72t37sxz/ZZlcVIKqfynFkb+nh5ms32+O96WvXOpNjx64DyPj07pbNNpd5Uk+SPcRJ+XgwPPzNDz74+ptv3FlbHZlgAS9BXBYgVEqLt+/xmSIu8ws0BizCCRaEEkWjpzwnr/pwiRS77Q4OxtW0x2gDGQgla6SniCReXiKfVCKroLG+tLHUq2mPV+nl9F7aqLtxORaF+fYiJF6UawdLPqO6YCe2VEM5Oah6HHJFOCH2iY1bBI3T8GygOyp8hmsD+lQn9Za7KkhWV2Cmg4z+CFYmg7jwy7k+dhrKWbBgGnCQkjIvTeKrSXjQFmybEc8+rpggV8+8AAJEc9NHMYQxNgphWQFtc1LoEaXwUCgKuO5hcRCfLrXbB44wtMigPAFT0BAMT0il+oxl+IAzPVCfnv4JRVCEr5Ll1E7Cq0iUMyiLg2KPKLRk2CP29//eP3ji8YvPPX8FSwEa46ZmYwf38Ov32Qi8+e7i1A++3Jml4V5nHkHk8NEKKpHTTm698sab/+i3f5MmP4bCH8tp6IXwXQqaZ3SPps7OtTq3SVUJRBfFOM6GmRS+CmTx6hKYjG741Yp0rMwBQpqqVlI6uAdZWlRqIZjLd3CXnOITzT9vwSF06bdwoM8okuAq7IGsOIjLAIV4UmdLQ8j8x1d3IfbZhALrm/0Zb1y+6ZsrrgT6SkFB/qlX+3eE0umjl8dDJw4pecn1wEJLA40SwJ+/gVwFbgTkja2QTnkpL+6Nf3rbyT6xsKgWyMG/+Inpa5NWqsC2ECxyukEd4xFtQkYx4TVFe1Rk7DAPngTxwI+BGzhAMrkpLn3qCpfiKWxYD6VAQHwMrkQLrvBG5qfhT1qZswfwip1rwDmvMUD8G+wW4K03X3/vP/rr/+kbr77PHl3pynC/e2Gu89Lj+xMjw+fmWsxFVts88VSk2vby7ge4+996/11OPEUqtNTrt0f6bCDmiJ3OOAdkjnQuPHd18tKsuDEjY5nu5mNin2LGHdYJNMkFlhfwUFtSF0BXv5RYSFq5lfgglAnBvZpH4xbHqWcFcR+or1FDYL2Z0oy6Z1yVeKU4x0YNVOzC4BuXLMqnFHCWTLrxzS1uALR7jbgB0sID/ShPkBCB0T/DG9p9zJ9BQPtDRS5kP3KDAPFsQXklgBIdR1Io5AwvxaUWk27i+MTaDK5RUcULisITHTU4y1v+FdRLNKyzs5epyUkxsEKSSpJvLqmHmwIRkjBsFT5dmCky/7wZYsziTATyFHyyGqCAFojQuSz/U2DyRnH4qI8pVlnK5YtR5CYc44K37Je4e/v+P/6v/9l7b922KwkQIRQ/n3iy9z/4/t5nnuuPMNNU6UfSSbxIhykNcXVr+87qMpYZe2iPUQ3QEydgqMOsJOeAd8aGnvi+J2evz4ueK0QIB4/UcsGaQYxEs5abJYCWibEHJvKlVApQFDXqW8NGMoD+XgPOIqpQgEtCh/ekRVQhZFCoFy5fEsqMhAkTHSWM4+zSGhcJsU7/dQJViMCcGL7qKZRYk6h5JaS0pyNIJFoXIZUn8mggSQIGYFme7Zh7sBJQkjTShCF8QES2SWIXvYGsqLjhOgVGaVxP/cODagYNcx36nqKXM4Bkp1EaQEYBhhsSeiixDSeS3QoKb4MFkCH+5MrYZnMeKsgXLkW1YGOKjdVqBAmvnxWLMR4pCh+EV28Aulg+/2FDSYmDPwqinGWl3Rj7sEg8RSpVQ1GwHKeS5qSvagSEMUWLT457fP6l53fa/X/0K7/2+99574jRTyOkNGa7eeYhwWM04tJEEaVu1cBG1MPjb7715vreLptSh4/bnE/W5rO6boTw0Ea+i8QipP2Tg6mr08//6EvjrK3goCDmlVhjT9k2NuY9i1Q5XInzI1x6704G5gRZze63IygmaGdysp6JoTpMMgfHo1D4cB0EKpM/GEu6hj11WjCECi3jxTpvAys1RvxFYeVGW4txz0IVPH0mMRC1Mq1EgrVRRwN3StUY0gARNMskpPaIXhiNJeob8kYJTMOv6RqeQeCaWHOAWHkVHgZ0aTA8TI2J0dHzE5McjUXLmnkhNKWN5URiQIVjEUEGN6slqX3QQQvySdaKnvSnpqbOzM1l00zsFXqeTMZ2ktHMyzqwqMqDlhvV09joGGuQFs4s8Ep5F2HkigKEwUkqhmrEuRmE5QQsCIWklllCsdya76fPkgH4FjCN6EbkyEjlAHVIlBxwr2JK3Fif7nQd0RuSsP1khl3nbfLAGJyQtRCNP8dDy02VIxf6pnXBGABLpIZGxibmzndmL0zNPjEPJyvj7f/u67+ztLX68rNPz81Mojb1DmfJ1GSVNFFkRezUO0fHS+urt5aWv/7uW5jliEfzHXdYyNnqHJAbRnu7Ryd77pTg+ESOc+sNz7c+8WMfv/Pq7cO147EhF5WiECTlp/ZgOPMYJDWycxoxoZyciTysRbj++GOIogEE9vbq6oN33zaWGQB9lIE0ofGOTQ1s3ogIINsJRDAj5acPv+Dlvra8zgp4/BRcMT3wmdjCAiMGdRI7rodOXIASULYZjEGZKEFWRAQkFLTGkXZz6UEKGR79hgqQWCFJlZInAaWsASsicB9d79zZM9QCRDf3wq5qlSLprtGlkVTsmyVUvDkahkEOPJvebly7NuBL3rgoe2TKwRKm2ARLg0eKoMSnP9Gfm52FCkRBmxQybwTSnEf6UdptrK8TpnLgSNHJLZQyNmrZqkWDE89TOyC94U5sTgaPzExNUZpub+2ywjV6JyNC3s9aFhXuMLSxRVEraeSqWTEm2rb4vCTNDwovjgoeH1/kS6bRDHcSkTL44uPnzzx9bn9sf7d9zLE//Y5fL/vd2+89ONi+PjP/4uOPz06Mo0CzT6UMkptC5oC1lY27DxdfvXvz3eWlzb09ds53/ZzXMQdK7nQ564/BPj7wRYnE6I+TtYrdPh6d6117/ML6ze2RLusdYNeFvNbdUEDpWVHCkz1lZKY99gS3u4hPaG/UGT11SBKzyrSzhhQmcNUAiW2q4QOaJL2vUXqSKymKVz1NCYC1gbpsv+lz0ueczY2NDQ1UED031rfwpwRLLLk0xAtCXCECdPNi2hmmh+lNuHhOSWsYTaSULCBDn2Ydc0BhKWwZqPQYT2sAMUlX6r7hPEWLHyvRt/Z2KH5rwBjJQpYPg0+zupxSnOLDgpm4os34HGmrmRU6slhcyTNEpvnFMi/I3L51l5WMGCikYw12OSBNHoIj7ym6qvRC9DLfKKH9xJOP89249957z2MMvZQ13CtM8zeQJgWhWYGdwpiyp3l2u88++eT66vrtO/fS2Ip6QANlTZnX6JgXoqlGqOuLjI9dv7G4tMLXyAHn6yXnFhaWFpcsnNWb6mOV6cKT5ycXJnYO9thxxexXe+9oemJyr390f3f7rfc//Nabb376hY89dfXKjNPJKYK0v87eydF7t29/7duv3Vlloxrt4/bwYb9HCZBWz2G3tdttHbNSjnPysp/JskZOO0z/dfZaax8sLt/jw69wa26FYRtZbH+hfQffx8fs2bly/SqZ9u7tO9sbDE/HYAi2kCBhKeb663tbkcNb92vffJPUAhGNJU6IoEFF7sdmYpisbnDMrXQNReZ195k0ceGAc0wmCumuxvobm5ybsf3ee3dSIVvdpMvdfuXVd1gIRZoAyZwLvqYPa2ww2P6xtCBOQ4X9oIdHnI/J9CYz3haflU5pE0AGGJpuxEoiWQyz+YZZNje8ORBJ8cGgr3M64ACGz03TInz97dsUr/LilUrGpx5Br2QwgLncu3cfbwgJmp92fGOERbyrS0s9Fi4Mdbf9WKfZDMhchRnogUfhlku+eOWu2pW1daBTBIr1EYkGw+kD0WLhUaeGjLYxAyVUNBUNYXRassC4epd/L20gAOTUoTbbi/EjV1MyMmHMhjLhhFfAiOeOEQwykXNLdEvSXGQY6JpX3VfQ32O9BrBVOMmAu+V/90tfO5ptTT8+G+ZORoeGJ0fGWGp05+49prCW9rY//K3fvDox/ZnnX5ienGQjwe7+/vLO5q2lxbtry/Ru6a9qxFRu2tgRBQ0zpsd8Dpki5qjFBnsGU1Mrqgt57ndWb61uPtw5ZsCId3oatI8qK9DJSc1JSxVmNN0TPiLKmjdWj5oYtg4wkhKYsVGH5rlMkO5P/ORf0RHDwjRZokLvKmPM9rT2Ed1DNYxQGQgaeFHVGtuCzyDUir7QMenOsG70Wkl28n/7r//7/9d/8xvwVL7qNClnvYhZE4C1ygA1VTQJK6LGRweBlbnNwlEE+QUcDPIw48CyR7IoIioMS3dc2mVhR0TyMxkefezs0KoBoGYQ1Udwo5miARV4U3HSU0f68yMp1tbW/SB2mpUUE8JUgEoG6CPAvkmm4lLUsB2M9kkqPjuLRD29xBGO1VHimEd0nUJJgHYvlgFF/yRldQFUaTbwhVKvcmHVKGF9bcPvemTmiNyjXEGtcOAtIfQyUrwkEUYihf7ImoIv6UbalPF/RH0OsVP8EAAg9jfqBvru2u42lkeq0W4hcZYPDv7577+ySR26uzc8zkkmNFsYL+WL8H4PCgCtmJN0IcUKUUYGbCy6NpaS8bDT39jZhisbMfw297cfbrJVCaORGZJMBlUGErqhD5dokJBsJRIKTxVj6UmW0J55s4Pus7m6mztZi4KP+ue+Q0s+KhLi1FyinUr2eIs22UjrQaWAWlVp1UmoUPAG67tONAY4cHieprXJUTbQUDeBwqfpEoYq6Y1Ur0ZWLK7N3HMbRE8C4tPfpXZt0pSwhjrRTP/Ty1ip5YJQDdaFP7pgKSXbCXpDB9s7JLMqbMBkv5CLINI0mjIgXikaKDLIt9pSfB9ZT0EVtrjLg3SxDSJuK1hqRdJMBedPb+kNmISl8tKnCIcLhg6dYNhnFyUlmlEFMNaAoPn8FE9QlrbDBZDpC7FColQFAI0No+cX21AshjfHJsYVSrZax3TqDw9XtzZolMx2xzjFf3VpjSVsHQYZRsc6U+N0nKnzWcmEkDTcTQoIcbw9burX/19j/xls6Zbe92E7nrP3Pjl0zn1znHsn54ABQIIgCIqQaZgsQlSVGSSTMvmFDqLL+mCXbbFKdpXLsmiXRZuWYRXLqSyBBAkSIInhAJgAzGDmxrmh7+18uvvkvJN/v/969+kG7A9+zz5vWOtZT1rPyilVN/JTCj3zMHItd55wtsjxcEAjYXRvt79Ow1i7C8GiDTN3qj40F+DPvLLsrjU09kmWYPIvrCeDUhVEi1JHXJJIiVdlkCttWM6Kd/VI1sN7hBcu0IYInmSu+E3QTsDibWpTp6KCkaLUgn2CkK8JcxIOmhLtBaOoE34CFUZFWPExIWg2OnmveJsEhHYBnjBZ/M2bUbUHyfjiFSI8Md+5mR4bWmwREEuMlBNP/Cvw6kVD8FX0IUQAcjvTs0i5tLmTMBWQgslxghbrFwRHqj004DwrjQZr5q4HARSKHKFR8XCCtTjqCmGqkVhA+JYuvxKvKsgQFeXJhzBGDs7KUMp2X/l3umgkwz1BAaYbx8UCKfUtXrHUjb0dKFIOXF49s8n2DLUB6YDOSgyZqYmDo8MRg7sdJj8PsGs2ikAzGiMpaapFLVR3Ls4da9D7OWD3EnLxbr3Rq3eWmANzZmZxv/3GWzfo+KJIto6IQilO4MJSwR2TSDm0cUmJ9CtQvqAp83tEIv6ie2OEcCQxJIko5DJOCFVifNKSQHQafG4yXhu7p5J1aKo2wvOHjlKgBF9wG7JRo8wipXEQaoV74o/6EIqOcieDaERWdSRu3p+4jLrDADdjAIfiFWNGtgLuAw+1lkoOgeMk4+ayFEFGIPB2g4jGwsT0XBle0PPlMwowTius5TtfE4vAgLA+5uPSNU6dlUwrKq+IVgHUQMVFePej/Gx8myX4AxheZCqiVCFKgMAn4ShQiAeKVbAHHI/FBmleiiDJE6HBgcilPAv+ynoFIvzCwvzS0gLVNmoVIDfioj1uesuJTBV3w8TZe6g4mGPz0piyLkG9xVAFOW+GxtwefrR29eL8sJ05UQSh1jdoHG3s3j6+92B7o7bQpRmG9U81mrSV6ZDucV4Tx2d4Etwx/bic/TKgNUHvJ+M1GJwy0jhxAi/FH/Wi1fr0ufbsqdkZFrYOl4cXVld7U+3v/eCtA0YHlD3Mwo06JtrlERMny08CoN6BA5z6Z2HMP4LwGLCXI25erT/z85+nx5d6G8lGyDFb7M8sLbL4psdOMOiAvT0ePFjPseykSHozRnTeMVLBhXmBk966CxdOP/PMdZoH739493/29/7z23cepU+Geljt3/sr/9YrL1+jD2F7mzX/+8yM2NhkvxwaRUes2UFkIgnx0Sh7i9EaIvnuH+yTLIk/+tfpgMOOPAmJLaaxwqanrlPVZ6MSIoCcm4THzvWU148ePlpaWlxeWkSVzE6jRQ6D27uH/+TXf/fug61KXuU21lVVIpsPfmglDroJ4cNaLAf10bhhBRP5E+qlSRID0V/dC+s9hmEQHPxM04Vt3lB54gZnciJjDEiBTPmCGwdiMGUJWTnpKSLbwercBK6ToQqGUEx2JaQIQWMdVP6sCnDGGTUACwKvQkVGY/mhVdEOnUoqU1Shgp6TrcgxqicvgDS5V6gJVCh99AfvT03XnvrsM+xIOE1s05lzMFqcmtvY3mYvXKb0hGFmyx4xSkVHx4D5nRx0SVzP9xgLRAFEbtO+rzrb+Jg/YqbD0WJ7+tT0zFyt7UZcqNHMY0THzuJc53OfeolV77//g7ePaH0Qjs5r04JNB3gmj5lbWKAxwnYeqoJQYdbxPSC5KCXUePQXKVr/4H//H6FfamLUGgGggcscdwbULA5iFXTd7B8cmXRULEGd4w9GcjgSPBznIgt2FOWVV5761V/9tbu3183qa3TUtP/yv/NnX37hEnl2Yl4kTLulOwUrxr6R16IjIywgBMblPzSY2m02DAS5LMOtscVlzHERD+TsREOoWzbBBUBGbwROtU4WNjf23nn7o3sPtyKxsRs81YuWrhbp7py9euki9UgusNhVPLJeRN5X73RZ/TTuH3GwCjPLSfaIGsJgirVZ9sASN+LITivE4Ggmlm+B68qlS/TB29MfjgXiD2DbeyVKik2qWAWw16W81ObmiIqZK5ev3L53l64I9Wv3RUQJZGy4kpkwlow4SaGxtbM9zTrzdotDjdhlATeRV+rJQ9ss6tCdD1sdtBrpP7D5Uedsq1Z/iFWxrxlT9rNZZ+BMabHsHP7w9Ozpl2bOoC/4uLOxfvfe2mhx6Qiz7mDxHBUGPueBIi2dMmzrMsXeht1pdnrBruwWpW/QucojWgHkqlPD+kqre7m3NN+YNmEkNuXSbMuym61mP/PJF9lo9533b2L1FE0IixxEGTLgMsPZlUyXAlUuTTTt5cpAM0ueI2WAKRddn9ROqPAwqpLz7R4bierB4lqN6YUpiiBtn2CmgRJDppB0csBZ8g6MUIYpN/OAALk72sRNKytS1GpzCzPzi7OK5J9YxV3xU+uyiAcFaU/FkbQtflOC7RuVj6jkbhWnhIwLCCTrJ4TFTcYxHHPUZFmcgH+IlGivor/iGy2ykZvmbh+/JpUUNaIfZ9QeznGyEKomzhhV8fRs9Q4yeSpWK4fEYoNEi6CbdHCTSxwdYzgUYfXGjMwHFpuYCGquZi8z2R6KAy1nLs3MkvgtW5lRYEHdX19fx/Ps6dMkIKRDBQgH74pqbHDZ1IMoGZD4KFFREa5aB9MxBysrK5yvh1B6TkTD3xzDi+4T14KKw1HhzAwgQxwOL1+6iN0zkEJfltlf9iQNaYNBg3W3L7341Cdeuc4pczJVq58+N39xfvW9zQeDUZ/NEzFt9NglM2i3Bh5B1eeF3rFBw20LKFRtWoxqTP6ZOhotNrtznD1GXyobj4qeapBRKIuJpRJ7aHp+vvPVL3+SKQ87+0MSJr33yXwRHe4ajANgbDOzs1efuo5miALkBENiwAqLqrt9+8MH94v8jgQnIyx3jR48KgpXqAeqKvtOuLGrSjjr1wJFnVnUnV5IMgN+uTTiKqIKtspdOvlLaBngCiBE5LGyflwr/LFJvQIa8IQoOgpY9QrehIGARoAiT4JUwXhUfMjE5sbWm54mS5RGcmS3rtiYn5+9fPXSvftrd+/dB7VSMTLKm/Ymm1pwyhoYV/u18eVLl6h8v/vBh2TYQmiytk1CjhQAkIQL8YQyC0hG12A197NPP/3RjZusXUqUgxAEEdhctAQSViVwz8ULmSuV0pWVBTo+tne2UzM1wgEqqudeSjZcsXIYSPImjSgC5bmOdc6fZMfMEeMnbKb08a27YCD7wotkACnKZYmiW+/20LzwwrUXnrtMWQFn8sQClFrt1Mzs/f2t+ztbpGCOnmB7RpuPtG7r485Up8/edoPsEkIaGNWmGSA9Hq00Oqc79Fhh94oLkxJSSPu7NUScc/FVcsvV5bmvfflTv/Wt37/7YL3XnSVCHA7K4pPtnS3C8AmKWDsZhNuKIajLU8VLdYuj1yUAOtNHdfkWUjJgJCGZf14RMm9+F70GxwkANkMkUVDHFAJq27sAK1CECU6JxNQKlJzoVNJ7oceXQLKIAgoR5ZETFfTYv+AooSTBr1hZkoF1uWLWBa6ChmDgAkuri3ENtkwTsYyGrkv1XH1DDk1tDS/+SiCGabyUqHBCGH1xYh068A5GWOEJO9zIJ6ikyRYwwhm64jQn6tlTb38KUQVGe/S4Alxiyc/gfxzW8BgD7jJMKHbu39ndvXPnPs4ElRuJlIvvginO4vJ7EpocMwORDKEwNOlAqGv8LeZrDlx6iZIAIiE+KCiff+biT33j891uMVrJiZMZULXa86fOz8x07x1uszEvu+Jga2zPwFbmHJrHjGfqDJ1aozNqzrbmlprTbA7H7o0qBwyFI+3A7FcJwifEfZMP3WAFU5jrtZ65cub2zbv3NrYo2+wHtRAuTXZaF+Iq0gJ/OL+PjGyTmoy5vnl8IJpgNAFIi0vZRF5oOWQct4l3YPQWPBr0XlExYOl+4czKbMmfwGSR8EUIvgqegtN7pNV9wqiEgZ0Ah6tYv2EDPQE1bzBHTizKtLAGLw/uovEiAbC5fJBWkhX+CzjvhZxDIxFGDvSDiXha/xJT8Sw0Qq2YtySKp46UNcxNcT6lbJ8kpNBS4QXae76CJ7cCmloVHU/KVdgK6shl4CIRbrwjjCErFThUhDctP9QNYEg9ESS8qZ1KK0DIdhUxiXWUCDKdHcosdlIRiOy+Sw2q9fHqqcWf+5NfW1zqRZSTGzDSnmk0r88vn1tcWj/cf8hCS4ZjyRQODsf7/VZ/wIrBM92FbqPVdRoPSEOTkCYNsVdMhsMQnUheANUVzqi68cz1S5ube9/5/lsHDKgJpXj8oz3xqJ38UVaz41CpC0lI1wlSZpfKdi7plw9tEFnhTUR5FJCTiME9ETAJnCe8EfdknFIoPnQehiDlII5iErc4Df7EValBBqwzTLwr5yAR2uzO6DtBJTbz4njq54sQ3plnwpRMqqiKI2ZdvRWhhLWRFqfHYcVRTNDWbWF4AnQi14SSGMulYJIkG7TQUUPxkLBXUARdgXtSAamWlDNR4vmkyk1J0Vvw+w4ukEkgJLhBW/SFoO/QqfgRVUFRghBap6IBP4KQQsqREN3DZwHSsxARmURotK4szfzcz37l/PnVKC+MENDLsKJmOHZYnx41F9rzl9qzbngyGty5v8a0yIXe0kyjt8i5x3S0F9qJ0YKdckC9x4Pb5PIbliNc9cCLNEqh8uorT21u7/zojY8wPVil2qYS+Bk+qLwTIenU4lVMEdO72Gj0lAAnKgmhEl6J1RYQRbg8DFFdoOAqIaIq2hw0dibe1ZPvinHRhnDlE9S6VEh4AByskgrpCWieJy6qyegqV7SYuMt3gvqG7DV2lZ2wHYl1xyEPKUOwNOXjpF/FArkK5JhfVCxLSxAxviVYcJRPCCEhg0G5jIZIHORFgYaJikFZqZrwRS0BAzG5d5AXdn3lX7yBLOCGLerCLxyImDoXtS7iuXBWQkpHsiJJxGd4RCeu6NlyD6jYuLDpTAN96pqxOulDxmyCYrdRv37t/C/+6a9fPH86tE23hQmlEoFfcGyt0z8Pi+81WrPNqcb88sfbd9h19eHBIV0F9H0yVaTEWImVhE9zqbAGXZGDSNylelNZr7lpqaDUerPTn/vsK/QpvvuTO3YTmGEVqctDFPZYwEzQBVv1ERenQ0cGcctPBDBYpFF5vBRGda3wJFbiHG51Na3Y/YPFuCGmXFDysFM7E+DE5Z/igLkg8VHh8zVyhnehjRW8dU4wUPzxq4I9cS7w5bNIQsTSr7O4OAfCmHU8QewfqItYdm8rhWTt4PNBSOKiUd/d22dyK9+yY8DABU25gUKn4k/w9NsWOQOvHsQ3CQJgqOlgwBMdpmsNL/xLhXgSIkoI/ok6wqJ4YIeHDFNnoQJPk7/SIh5gziWcl+A8/K8eJS3rjRSQLTOrSbxFKCtVCVtwItnzz13+xV/4xumVee00DRuCqZLCRIEOdsNaIye8Y2mk7Q6jRd0Ofcj7B2yZd0CXI1uycMmWdMLX42jSTPAg9sUdX9IAdX2+6LKDOK4F/+LizFe/8jqTKG/ffEQ3YXHUVy79ggF+VE0hx6BuUlHBr69AceJDgtAK6kpRoqg8hC6u2kJA+eSlgklI9Mg4BU7CZv8Mug4jw0SOQHubxFDlEIuHkyi0iBxyCXwSqOLg8XfeDFPYLh7yFfyawfLi/IRxJDvRW/J9POiHTmgyrVgeIWywAkf/H9VUBjzUZCER9fNJRkM7K33QpjHsnryHYQP3Q282aEZSD7RfUa9yKyCaik5gCBJdwRm+6IOHPTHTn1Bm+orVS364AuezBOCBlyahUBgZxS/whVXNLlpQEwqYq5haEBhxvuCp0lH/6qnVFn3ioLAkgSbBLMrQCEhfeO7KL/3iN9nos1BIcOlylceESKhVHzIneWfqN2Z7MyKv1e8/eEilnRmj+DxRZdGoCkIeEwvFoSC0WLWQ5HLiYj4DDcpTq4t/6k986YUXr2SCsjYJBodNuAwj2kytokuwcItAuHlPv28Qeask8imAF0+UU3koj1D6Fze9dCz4HIgmUvXNP0mW49RFwadgT1x/7LMinvgFqvI1nKgLhjwKtrjl5vcfwxXx1KYZMuOYAiSYgPLBR24aASNd3Wurq1RLcaUzAQ+MFzPsMgrV7T791HUPSnG3GaKA0gLLyPhikrdoqH7GUGkBc6Ytyea5Z59hFgPR5ICaAFgAaKHLvbpiWbE9/YEcdjl3iFUEZ1Zm52fgi5ijPiWEkag9GJGZUk6tLNmhwwVFFBr6jtp5KsciRBlAIEhRCpCaDrHkJdriRSp35CDjBpg8o10cKHh4yNJCD0cyKXl4u5oD83PPXvmzP/9TK8szIjBrHTMsh9TKpE69T6w3L3xE4cXHe3rVyIRBzox6ZgT0pqcGbbtE1aCBQSSqhEzC5MPPyklVBI8JwN4e7UyRbHnWVlbmvv61T+Fz48YDp+4ZYUIDgEUy5wBZHZVqtxkJbo5K75b40gYI4YqySCUsZV8KTz5C/8TPXFGw4mCgBCC+nJ8cj6QbZqVXqqkQJogRSoDcBJ5Qs/l7Qqs4V/ATYo/TUYWvYiABq3dQqE2jgnmynlBU8UfcF46VsWRPnhg1ZB0Cg4+cyEyFjUWnTktxEHPM3F44Y4Y4PGF/VLUx9SycFLPmU2fWzQLrUvf2dsFM76HTwp3fYWbcGrUwX3lRVi9Esn7slHR6BKOzWBHjBsCzbS22N92ZZ0CK+gyfoCIZMOsY5MGCehmJI693mmdJEhgiJRUZHnE9OzuP/R+yuCdVBchp/ok6ULEPVlJTdBmGVIdljn/096+sLDsc3GieO3+uUOn1pi6dX/3Uay8szLO1CeJaZQAjeOrs55uGO3SNv1xaPoxGUhn2X60THUlWOdayUbu/dv/s6VO0YpnLgl8ARBES3n0p+ipIInxwkZlgw8Oak4fSxVJ51Zi587UvvT7d/NHmDtvdM5iG/dElo9WjIiKC+fPgZeLN6O7t8SPXLXKlG7TiWrZhxaswktdIo7O5SOVXICrvuJUIJi1OEoYo0NRwd9cBlCJiFSAkvEXu4hjMcUluUCg9CV/YMFDl+kdAcMPcZUJvGa3AmNFgRTO6jPmDXnG1fuMKofb7x+u7W0caTePA4VvyFtqL1jMTwizYjDN3Gah0lNit1a5fv7owP3733XfJ2Apt8MpmcnHhBYwlyHLhqxKX5BSEwWkIfYmyM2dW2UHtgw8+JMlBjZJczFoVPPpn7LN6kXptalEkAE4RRd9bWxtMImVraDYlpSpHUcYoBxMx2KSeeYqIwDAZ/CsMpKIXasbEGt3/p0+fZp05Bcij9UekZNwpV155/vnPfOZlNhFVaU9wrzKYi5WwhbfCfpWrqGPw48bFm/TgnpKqvb8LE6Hd2N9nN8UGE66E4D9XeYmCCBI8OPHDKUUSGmHTuA7HJk2TdMk/EpP6j9mk8atfe+2D9++srTODnbkUHMLnoqKNzU04QF2OcaACJ8PBmEQykMGzkLI0j5yhPyFbREA0XIveKn4Kx97jxYMYsS01uTCdrS0GWTMqGbgJTlGBMFozf9BCFDbkpV4kNgxvZjvF87GzXn/0iiaUZIIsgZgaFSdChlCihXe+y2UUsfsA03MpKui48GCeEzFNUwCbagrLhJG9ChcP9KkdU2WgwkfeGL8JTPWsaEXnQaXciopiJgGEwZF5tZ3upUtX7ty5e3B4jAv0quBSdjNDDIEJgXzwx6/gUsx64+6dO6Sfs+fO3rvHvuIHWAe5JcZKVlQJDNVIAjIlkybpdkw+1e3Osv/0zvbOw7WHRBzTXJ7+5Auf+uRLtFcB8g+C/pI3UHIeHTFDUcioSP/gUzKhymcaFGP6qQbsVnLc37PtRMUjB5hXQ0aVDARR2yAjaCEWoqEZSTUYQNA5dt0esVoi/VYAJ1jCzc9Nv/zStTffYR3oBjX83Z0dInabvV/toXHCHBi22QRSe+OPmqDM8queeE94LzwUMYCvwASNgJXHySP5JQSmuyVBq2auqldUrXDJqhSkn0+QKfEJxpIshdPfq8JTzEAuqiuc6n/ikBcAcCk0fIxokjrBp0D5qF51mJgWsVKceUpBMgV/6JmfhckSuHAEZCoP2D7zpheXlmgxpHdb/ZRLLMFTiaP7xA+vpH8ME9/CV8gGbbN1xHxGvfDh5kwII7+6jA2R6x1Xz25xFIwPsn2G/8iaSZmOSbvHbQCLECpYPN7jHHv2jYm6zCDY3t4hIF6rK/Nf/PxrbD9hDUdqhXMhIU7FbPeA1cAD6mknXIlRQHgt8HKp1XL0ztFxMXdSI7xRHaLYMeq9CtgJBQJUHsXJzwJYUTKDQlb4pEIozce+wrammKZx6ezZeRduUqRTTjC6x+rBPpVDGKGaSpVSJcCoZXCFHhcduUdFxnp18VKcHn8/4VW9yoTaoUKckBVTKb0rQRSUGPJLJUm5BK6wVy6QM8ufsFhAKt6qjyceCasvoVV/sBd/uGFpInNMlMR/L58V2eqbWY3TXeq+xErRh4wZ609cJQR3Yic1XjQNOazN3gYbWI25hVnmYKntRLnChhdeeFM1YUOm4hGn4hlC0Rp+QBO5VFoMbSgo4YdPCQqapAVB44h73cPhEhBj91QVohlo0g0QIZ7wBi1YdM/PypUw8SIwVkXlanau86d//uvnzrtrS6Eqmlx+lxWw7Gm1xRpFe9FEZ+1MSVEcGqLvXgXVavSCcDYSaJjozqxb+UulUusldToVlEu2RJEPvvzzKnzGT5cAMN6C2bMOBkT29JhPFCGqgO7O1njlpWsry91R/8jOMU4Y8YKwV/gCm5IYzVHxhDokJJRfhZUv5ZOfP3apTzwLf8IIFLkNgh9TrDymWHRQKaoELujKU4wClrDBP6FUkBnYK0zkWRwmUMGuKQRpQHkNT/Ei4zGVS01mE0cFqjIjSvSSa2biagUKeCjKNVEkQlvFfvkTfzBaI5cT8zNWkBHDc7PJMQtDFZi0K355VCRkorIuqcU9imAXECouCVpCaUfFlL2HbpQcIHB7mR3CqcaBYXmMSjBKtWCXAldwFVpxF0AqVA9svxlNIHjttReeffYqLWO8AvFEiEyh45vViQ8ebqA64AkVOmLPi2aNmjq93sXrV89evjy7MOcxO/U6B4SRwI7299kZMqarUSYUhEpwMXgFkRkN3nyiq4iSL2SkZFPoYtXFqxJVHbG8pP7qK08vr3ThFwxVShFHqIgFIWjtheNQy6thdeIqbPGiLT++Soh868xn8fWOOshKK+j0FexzOma+n7C8P4JOREorC7nCACRD1aATj4L2hL8TKgn1+CuqK6hkbW6eKSuWjCKSDPIXjIVz7uQDjOJ5Eht3QQLJLTx7q4LwYv5uz5odvvzcqtY5ZAQhOjG83kyn66ToCWQxLqUpeioRWbE8cayYD4SFkDx5M0yhnscEvHAofxWIAeHaz4BrfMVwAvD4dkJI7PmQVAROGg7k/Hz3c5/7RIxfiomYic74itkeD4ZrDx+w+AHD8jDcCh8oC2KOK+qev3b9s1/72mtf+NLzr396em6JDBs1zM0yCMZSmUZOune9AfUuuZaSd/+12HKVZ6JPXsIrFTAOIKgs2mKENGAuxTUJJhfjWq/b+vrXPz+/ME3U6pUMwgReVsUIzO7QleLyKIntBMsTCE8UXLk9hiEMxP02kqJMXhQWFrQXWcktEsiaUw8qBHwBF7rCeYlmcsX7MShZVBWwgAZ8Ahsahi28+iJD1GwENhqLeJB5HFofGirMWJyapg8To7aIDEAFVAUqHVziSDcMnNC7hLF6fBBi5mhbzujk+KoRp5jQPUL/b2l6mkGGdlgI/6JWKv+rK0J7q+IDFuR+4lv4L58CPRk0oI45YPRw688FN+SRmFIhURggkDyExIR0UmacEoz4Gr/88tNnVhdTjwt5QSVIWERhf/NNjw7fZyb+udMrjP1Zoa8irdCpL6yuvPj6yzNMQkHGRv/UmVNf/Oaf/ODttz/64N1urcmpIeQc7mDDpGWtfRIhil9oyVX+8ZtIW0gAwoFUnuvJ0DUdsUC5EJj9VMr8omCIZvEYD+dmpz79yRducjg9w1GI5M0xyBP9ZRygGCCkJFswiLd6JUhUVjziPvGZsCmXorc/hJVE5BEVLocAYTwxGeTBFXAFCWqCVuF5PomZD5XgZdgnWPLzsccEojjiUehVLNDk4jvwJViFMk6VjPQVwqT5uSZUakzUDs3tE7V0KJrdm++DLnk/xmalhwnAOQCKQWPquAawa64+xQykTpcarhOkWW6HZpDF8iX/hUW15AVF8g0UC3JaIsvLSzjNzM7ssSEXRmyvCd7IkAB2NljJLlkeoYgoWGH1LbYW4VU4fXF0vOhVp/uvVbpToUXGpKN8Fq2rYv6KSYB2bmb6tVeft4dd7gAkiH80Huk8IY/gHZO/fP5sb8b9CQMkD/IlZtlkHnWPXYmPdwzNVKX+9lTn1Iuf+dzVF1+/e/OD/rd+687HH/QHdNXuLszPySJMJBdFSgIX1mIdvhc1KT9foWdjvb/PcAgOVMFcDlkdJaqa1a48yD6BVlfnX3312W//3o8xRksvGhBM0a7EK5PhKtMyyMQEjTA+cxUGqnfdVRlEkLoCCnMJzuz5I3fhg5CSWKt0WUO4KvxERxASRW6PCZVICTKplTlqKrfQ1sNQBswD58rLF8nkU6BABR6LjbBFkXo9EUp5IUAutjq/sMThJWgy4pG794d9DcuLiLZeh/1SwaO3hCYmw0aYAhaL5TFutbSwNNOdoTiGDJkxZo47OyzRB5dZyq66wiu5MkknyUr5HUvii5YSRTqGDC26rQDj6LnZmS61C4oeRIA0AMAbw9G/d9oKCJNidoGjymrj06dWQEcSvHz5Iq3Po2POV9W4ASbzTq2B9I2MJgBTKhKCUWGH3R6byzafe/baxYunjWONwYv0SSEPD6wTR2q+geeTexCLXFiQJoiODjK7JCjB4Zn1cQ/ILObmL82//JlL1577yZs/+oPf+zfra8xgG7KDGJo0HqTFPW8GFaeRX/iIt+mElb6N+sONPdakLS3McMYwgwkUvMyQC0sGEkuCh4fRC89e3dxmoxwwN9itef/D0Z29bUY00UUpAaQ2uRIWGSGksh9TD0AlUwEuvMVpEtop+OxWqZbC+pidN/EzifstX48xxqU4666nwpew0UVhQq9yqfLqlSfJK/nGxE/TqLT+mKlqwlURBGJFJLnjLdAuRHYrHeoq64+2GUZnmHaOTs1ZN8RkESNrczF0OtGwZqZwkaSZLzAzM8/umUxvpDbMj8F2C+XpNv0S1D9YP8XK563NHaKEjkKS8sqpVQ926Y9IP1qQmS7O1ThxEVnZ6rWtTcXAwohPTCk9HWYiwGOhpBQ4wVk9ejeXIWnQf48jGwsQkP28MGyKKga2kkgCNmVuxHZvyKKhJOUxaEChQwoTwuCcF3aaOVB+lijxIe2qz16oSmuFegV1Eq16k2apA7O7M0FhxARoTI2OUiA0urOLr37myy+8+qn33vyDD978g0Ns0QLNuRURKMSDN1zJyskVa2HNSZtBEnY8wJ0h6shq1V6NqVvpcXFP4ULDY/r82ZU337l5mNaKi2eiQSCTAIBV1YYhJiTNB6w/ljYYddNuAlaIFHK+60pwFsCyH0EkJnoBZppefLhZQoq7oCiuhdNCMy7iqVR88l1eoqUof0JNAeNX3aId3lGDPsaFS7ypG6QGcQKqd+WblzFjRrtUPlpNdsOkg5p9+Tpu7FrfseZIRtP2ECQWurLQEfaN0+ajjW3Ml3XeWBLlw9LK6tw8mwlMp2OPvT3GDAzzDp393T0iZ25hjg0HWLTF7hUhb9VXJuUqb3mdvMG4AlQKN15r1KkuXrz46NHG+samUaO3GNRpngVXPnCaGIKvwsE0dmnEFmCegLA3MKvXKTTaLUobdmd76bnzpcQQT+GmYJKYIXU2Iv2Mky4FUoaUCOfS/DClSZ0HW9VPzzFFBM8ErU11ui++/vkr1576yRt/+PF7b9aOD0o/G8gqgYJ4QkQ3WZCE68sc3vZ8WHbAdfdcCiQSckwLoEK1CiHF2vjc6eW3fnJzy1EOt/CKFYKLJZF4o84nqMIfAiqbIZXGd66YqS+SKHYcVvUyrvhAlUwhE6QKw3JQt7dOkOophnJJSBL4Vi+6K2Hl//gVZ6uvBVPx/eN3vQ1YyBQUoHduZrNFt4E0pJRwvGoMcUmPHv3ZSfA0WhxIAo7M3YzJWbt04JEhI5QqixXZ9SHvKMqKjb1y1DysXtAa0NYchydDpVShNLB+Y1chmZT9RSdcyIv/sFysQo5UnVjzkNm82/NdCo24hHvZVzG5B5FhEkCnXKKvrtSXEiacQ7XOthNMf2OzBtq1FFBLfHc7VX0cPMJVUanJg8t/2Qud4FWaIC3azEf604ZkDPhoSjTJp1j/uEKd0QSCuIQCFZteLZ5+9QtfO3fpytt/8HubD+4w0F3hmyAVSjoRMgT5pKIIK+StmYvR73JIc8OjkVO4UWGTw4QK/3KALxv8PNrY2AFHBu9EiHyZ6yveRAFUQVz9Iz9MJkKKTQWxEJEfAuCNinQKiETv3LljsEoAF5LzStlkZ0nCRJOFPTFWpEO3+tTRa0JWXHKi3rjyaTCVUwjpFFZ4SRzJWsBHrFtFNSRE2RZJcIiHy3Dc7chExVY64JO6stbPdAMLZUJo/vUjR6aiD7GEHGmibNBEe6/PKghaEA3mwlEksBSZI+IpaN3+EooSDS2JgyTGpLTyJA8KIyd+5fJD5yKl7/pRtXDkKDIkSMFUhQm2oJs4TNAFm/RidqIqKKgCYS8koeMjB86Q1KqOhAUshHizaiHXBDJOEh6b1Db9lFX5m1z1/f0++7dxWhz6w/jZV6TZOcvRRwVUebkqeSmapk5fenrx1Jl3f/DdD9/58fCYM7UofYscoakSJrglLgLu7NbjmLd7wg54ktVShtOvWfCfMKYk7uVs+UexQazQtaCEKuPxVAg+w9KEEASMErEVVOVevPNexD/hDFim3I052slKf5GRJ0P04C2mKg1Zr4LnyXdUHcQnyPKVm/6Bf0zft2ggnD3hGZ7x46mX9b+xe+iSMaiwgr28lPcJGRJALFoQRk+RgkJVI0AoVaVvOmRkueRFZOYULHREYPSgcbqZ+4vYR0QSorynVcAn9aXpTq9MDk3NGAqFf/kxBvJZZFTdEUcvX9SML5iBUvmaZoP+vvo7CSO8sDzLm94JbNgYL+AIU4XTG1EBRl5Brdt5vhAA9lqBrPCXTm1xGjBXCBVKhtdPzOUVz8HRaGt9V1UxUjC90upcrNdn9JbB6mFmE8F0pVbTXXjps1//1Fd+tt2bUySxFYSpnxhIFy5eGQdgxgNZgb1bNfaz6NsTSk+CXdiEFUHFkMIYEOWz0yvNn9L0ryBs4J9ccCFkRVYLK9yeAJy8yAP4n7gbTN7IKReX5qgBxM8bdYOgDOMT14Ig9xMqfj1JsMAk7iqWJg+xVKmCF8OchFPwCpGRHhzoA4jcKww48KsI+CidKQhgP6bJhgyDLrYEpItmxHZmh8VWxF8ucBiHlhjgwoLKeBCJzcRDnJL10axoU9dl5Mc6lZXWbMr3mLiMqAHulWPhSsq5VFthnU/g8NBOeTWEzBDeMHEqYbxH9Im5xVkueTGvTmg/xW5juOBMSrB5iI8M8EQbBXkVOJi8CfXkBb3HDtT1xo8ebo3qvfr0qUbn0rg+j2mExwoo0GGlME6D0/6w6QvXXvj0l3+mt3Da3lOu8HFCJ5yBQb1j0LjDHuc7UefE8AiPcwGuoggygHv3omBneZYZlQNhhRN6gXgJKkJGpSc01VShRuATJnwRvlxV4DipNarLDAPhFwnFQC+JJoUoYAnKE6lO0OTF2wk6ghsiTnhU5DUWPzRSUXk92XFQACv8EA2APYzOv+U6ofMExoqQXZO0pVyxwXIKDFot2UVDJk8nS3AWRnJ35MvxNazcmoBxYl8MyR2btznGKlgKh/agw3Y4rBQjhtiaD7SsKNCoCKIY3gj8WL+F5bB3Qk0AwbAqLEtOSnREA4HSW7cTpRBErN6jM6s55TMuupfLHtuSlwjcoJvr0aP1c+cXDS2DoBdBxVZcqq+g07+KXGH8Ci+o/sH9zY3N+vnVSwzIkrLIKNS0cSqySp8FSZmrSL+R6Bpnrzy7sHjqnR9/9+b7bw37h7S8kq0nGEyJH2Fo+NYWZ6Z6HUrhMVtpkK+jedNAfGWmcBPWuXHmtocVkdCCD16UmwY0/yIFGuIT/vyYXNJ8fIn58ZfvCRy2Iv54c30jSq/g6F5MmHBepHgifHmNOtBMUkhFQSoFe9RVqb1yDe7CtpQDadU4v+Ck97tSNT05HvUA6ce8q6UTXnAmbuhLZjLbFh2I6MIMBoNm1+FsQ0zd26LV8gEKIZTcHxyUFUy08sll7YlpWGQD5kjMEuW0+sGQ1sC51SX2wX/vvffDqjm4NS2TzROGKd/KYgxWUvEpd1FsvPg0vgoAiQFg2E12YDZOKT+9sLBEfxFA9DitP3qUZrdwE1SiK7h4IZFTZBHK5gwsDod3795/6cVr7BYSbRVFFR4MJOGQm7AlQCpQ8oCnRu7Ftsr9P/j+j1YuvDTdYdsj0q4ear1khpAGmeybUaFZETp/jq9GZ3H1tS/9zMWnnv/w7R+tffzB8dFuYKUjMbvlms88dY4dBPfophuwdSz9vS5gRZ8SL1xIMZ+a/Gh9Y3tv/5D1eiwRGNMJNNFBuqUAi0DwIk/BETzwJzrcJv8nfuUlsFhXJYfAzCkXmaIaWo4RixdxPHElaMFd4IHOnzyUq7yASTBRAoBYQSTN4sY97AniJS01JTaGYLa3OeCIIg+fgiAvABUGhHFch5FXau3s60Y1hXyEHnfOyiFVwD9GTLdD6o6EcmCJsTEqOHxQ1WcrNQSldrOyzFS4HnPqOVWLgoSakEeYUC8ddGc6U3u7OySVWebKzTpjyk5rjI6ogSl59d3otdvfQtp+pRRcioMzJ5FxAvlo2OtMHx+xGEQJ1Tq+JDXTo1WumZm582fPYw4HBweUUcw5q86woJXCnKXkpUW/JSCU4KLd7fQ6nb0DNoelEttiL9vpnktt7A6SPbU6UVc0EP3ibBTIGvq35aQgXOzTNhhxWNbdhxsfvffGsy99kj4YIOOdG6HqWOEhIxrotkkR6UlfmCJdZxzKxiiEuyKunL+0cur03Rvn3/7Bd9cfPEA74ufXcLNkhu2ops73Zpi/zWA8MUKmY+zAQBKjaiv8yGPjww9uoTCmKg/YmtHdMsMqVAv78i2HsVnf1Y+2Vt6Ltfnhv0F05woW1cCrD77n5mfF4gf03bW9QiMQ1yRo9RUMlfNJ1qdfoaJ3oppg0WHiHM+KRKFZARssAfMshBoHBzneB6fCpyEqVgusJOpsjTo9v7BAfkjXPhTJF5eWljLyP7Rha/3SGibu0GbqBA4Y6TQ70GKXdnM7UMpxMnR6siSC9KBpowD6lAb9o6MDYpqNi1vOuyaeTFeQdVtCq61i1oBMi4pL8qBno7DHYnkm9puN2MvaYFTOoymjCwKmJqw2UoMjTTYYpx5kCAKmz549SxisHOunKOYJUROZxHgzICHp+Tl//rynAfWPf/LBzfnFmVdeebbmIe1Ym5UKYAXOZazy6g0LyTsKjb8udKCxAIXdvz1VafyTN3/49LMvkSHYvzk6AhO5x4iZ0Yfrw/1HdE6jueERG9O2s/08muxQWteHx/Q5yFudzX0ZbK+SosRKrEJuVGPiFQQ5QkEZHO/ET/UVZuWzeqsdHtBAa54/ewGxkXF/OFjbsz8UfCdtAGNBJy/F4UHMBEeFtlgNLgEsMBVkQpVwdfapfPyZNgABYEZdScEHl8L4pRME81DkuBeyJX+r6Al2AlfAZaUgnWARZ2iYOwrPA3sQbOIlKa0nF0B2zqIrtn/uH+zvrW9ssHEkeTAhyN2ZWI9RkLucOrW6tcUWfENOPiXw4bHTPWKOcxQdRDsrAR4+3CBJLC6zqhc/GhL2/DO4Q/bEAmO2C2cjYrqgGT8mMcUmKSAsmkgGxEppckQDWico5ubnaTlQbjxYe4ScFhAxviSZKqIRAxNNQQLLiaJsF07SIPrSIMnkjqwiJ5UyNEGWhI2SxoAG4ebm5raNSBM27ZaHm7u/+a+/Ry/Wc89eojHftJKclmUxLNWGvlIjVMklzzJ+UQ4bPdDpl8FxO2fQ+Qfv/eTerRtnL11FZ3QlAEZVfH9/q9U47DaHbG1Om9FWKWvs630qYdOdKwycDPv3GyOAGZBZOti6v7uxboyJD4Zl2qV34QcGiE5zFN+0Bv6Ai2finJbZqH7v/hZLL1mzREFD4l/n5KV7d4oN2Guqug2lcL6X9kqxknxLVgivUIlGKkMKVT0qDLu7O84OrrBSX3Cmx+O0JEL8eOQSiR9xxsVamLKC1a/ibEz5RdA4G6ZcxfIrHDgVD7jFQ8bIccgRqXALrvICU0EFuRgpj+2DICKY7+VGQGbGAFXxzPF988PhugmAaQ47shcNkwC2dnZXVlYZ/KL3nwo388OItYW6FSSN0u5US+ZGm3P43CKJFjlTIRCLHIlJU/QLmTk7dwhaJT+NhOGQaOaIBDZO2NjeRPgTdiNmwFSVfBbBlVewuIgBHXgVANNrvc5wNVvWbu9y9pl9vwlZwgHu7glIRnr8tV//V4PBF194/hqbClBciSNo8UWlyIVsOME2ycm99cnTPSGpEiQRJygVvx/94HvLqywGAC0nRLJX/C65OwbRZN9cdpEkAVOU0qds3r/bP16j+klqhRd6DIgZx23L5gBCQdlCqRLY/I2sBrFIArAjP9wUq4pBMp7xvfs7P37ro70Dp/oCg8J3tumijXrII+ByIl1xBAMOxvHJty9+4c4DYvEqbvoZCwEX05nTK+Y+k2r3xsYW1WAPWJA5wmvMwAcXLhNc8VMgLkUQIn1heqh3HcpfQEUgN+IB3i+vE74rFJx5tk/Ji3PBGzRFtAQlCKTQK7k+eS0IUTJAaaSJkAtUTMwUYVjTU4iKcyKA2jYpBwPoDKbYjh07p9FMxpyWAMHNsIg8TA6JGFrOkILDBQRxy//wr2yqJvQiGAUEn5Iq8pcqeaWzCBqv8AgYDPIXfvFUrAQUI35s0o8hu0gyU32KCgSfKENxSLe2l2q1ze39/+rX/uWtW/e/+PnXF+fZcNyWP5dYEz1wTvuG6R5U1ZRCFYKAn7SFTB7EPOkP33v7+RefWlrtMhGEkShqdK2pnueH08zCIqFG2qdxMqYJOzXsP6rXevUB85yddUftkT5+qm6kBSaxgZm2FbgdvqXL0WG8iIoMKic1u8ik0CaY0fr64W9/+4d31zasJWGWqGlkbAoQdmntWwlQDWQfRkLeK7XgFHMXaWT3AeSJwYFGRWuCBuXO/krLKUMC2ait3d+gWtz2ZGNcxB71iNAg+Q96qSuHANSI5UUHLt8LYPnSIw5hFZDqG7cSSjwVqVqd+kMhXAX24+Sq2AkOY41yXNyhWBwRjYTBDD+aXESGajIjkTSQwFBBIsTB3j4tXzjhrJ3e7AFT48jljB+PMLEThJibm5unuYfdsHqXXDSNYNgMs3Kk7gtzRXIIgCHD/iVvqyQVSoVXwL4orwhOZAuu4qOvb9FmybxNULgisW+8cuGi2slOjSEmGhwPfvc7P/zww1tPP3X59Jll5y2nkGRqCXuOOKQqXvVgYGmDLjRAkQ+fLHzZ3f3u7/7OS69fW1zuHh/udJntusAg+eigP2xxBmGD2REuXaDWwMSI8Wi/wT411Fo8obx1cHS4dv+RnUTOZSA1lWFHZ91rHqQQF0fKAaUKLmZeEYbUQNnKouVvffuHN28/AJbeUnIcXoAxZ5VndUKzCQxW6Qw5qaroV1z0jZchImvxCkTsFc3JwMTXyVXUXEsBS9DNrR0q1nNzbskC+YQObd8qOriSfPlU97qmO0zCwVwChZgKNtYUX87401ewvCpJPESDC9/bOxzum68qUHASqAQUoz8Q4k+BXryDx1BkG2yPNTPd26hvCGawYjaJ75xFRy6IF+0w7lZoGBWeGhJfRGT2nYuCid+Ms5KSBjQK7Xkyfchk6Itb4ZRZN9lTH7a/5U5PYRTfAPkQ1ouP4hTXOBQnnPXQOcZBNiNCrR73oDRalZ1vvLCbcAA400Pqdx9s3l3bJADpn+ocnWFf+vJnLlxYFV94KVow2RQsaZWLjl/hq9FYu7t27uIKvZZUBvd2t6fbs+yTuNcftKfr0wPW7NoHRAui1l6ojVg4Rv1kn532a4OpB3c2Htx5NN3qDNPVDElUKtMlt0evDoxAhvwE49GE8KU0p9Kxu3f4ne/++L0P79LFbaUNnxiLeuFd7pXBrSXAYMmvm1GYS/bjIoHKGuLhu0DS1WBLAGirUv5p89kgxz0acMYS278IpmMFrWcq5tTe4Ab2RMd/9IgXaZxOMfkJrWIWIEzECRt85lnukVTjSB4HmERRcRQK4/H9+/fefPMdBZ6QDxIQFBzlRY2UPkey5wqDRCQz0+1dOHPeZnHkLkRKsKAlRqjRYNJk1hSn2oM9Dm6QKia6ti15rRLGj8Zmq82QJJeW6LwJpJiwXYiqSi+BjBYoF90WKSJK/HMrfBX5dIigJzDFRSXKjvpymYVX9JXIj8oKF5lRLHlhEs+qzgqQnTNWVUo1w3gAKpxZR+ATIZCoxILyxM+b6a324N4mxwLRCUkOsb27sbTU4eQ1oFgTQxcsG1k06RVtc5rMLCdpjGqbw+EemQOqCi/owfX9IFUnslSeycg1/RL71u/pfuOQio8+vveHP/7JvbUtNtAyuRQzi1SRFoGqi9JHYzPePPfAoiUUACt6Mllx0VqrQuRBfBN7AqeqhbQJibR1utLdmOmIxqJ6ITekeWQGz9AUgrgsAzapawxZMpKpV3QUglSDIOk4xtfkcL4O1g9ntIaMiaJwlYFKI0e0TzD2p+kfPxjWDpKSVHsYNEPCenYP9g4PjiEpkngEQcFQIA0CSsp0WCpOUbDGghdIEO3ATsmgFm3MJlGNllAg/R4SIKapBUmWk/VcTIOkOFle0w4wkEZCUc4biQRV0EgA2tRVLDGqL1Fhq8G4tOkmKcLIDU95NOHnq3CBS3wCpJ0IrtsTVyBLEQ8sXhATFzfQ808ez8skQ9QHZ+92igRctCNWHOCMUEpsSP9y5VGcJq6qxFZqc33tISe5rJ5Z6E6xQIJllbuLS6cZmeBYqMHRHln04e7W8cHu1OqFRpPzwRbpF6qNDubOzHbmpo8ecnY1pIthyopchYRxkT4hmGHUZGf34PadtQ9v3P7o1n0GYLUlMx9AuXKLQggLCtFQBfpbf/s/pmxaXlmklkt7BuMsoFRtQUDhzuwJGjwMN7C0yeTv6XHt1dWVpeVlNpSkT2Nre5NDJZkBURaDv/32rWx7GiVzmPXuwX/29/+fV6+cpxGzu4vkx6yG3uWUvJwnzsFzVATghWKD8bzFpQXOtPoLf+Evnz27ICVYQYV4JxWiAuOq4pw0V2Rq/da/fOd3f+9fE3esMsUc0RN2g5Gw/oTO74frO2iLQIotLiO/XJULmuCt7PTUZmUjKqAGKhSOoNva2aGfh4uD3bCBICCBWejBHv0alAGlhoClMyJANpnyjdqt6QE3cFk1Yne2TMygkGSOOHZhlcLNzc0PYIs7pYJNhzT1OCOVSURUezk7jLUEIIEQ+VUUUNKA3CiF5UhyichSorYYSQAiDOHVQ7IqlCdfpWxXp6yJm6JbxsKb2RokWpI9/IG7UhXxkIuY0oc4i/j6AgKgnBOVqlg34w31AGx3QGPUH929eR9XjiwbNmpT7cNmY51hu/b0jMNhx4f0FU/X+uPd+7UO2462EZWjt6lGzi/MbD86sIoA/0ZdHhYJmAM3c1IqE+xpxMLfN9587+79RzRPmIOaQfzCc2I3bBHGv5hAGK23/uGv/kaiX3GAwTfgCoViVW9F1pAJPtEJTBSGXFxn3k9qI5QTTrENiXgjCf0Xv/rrlSbFriTewCbGyVXRcaRpefXqX/iLvwyEoRRdA1KhbDcPRs1LZpMdErzxj/7vv/Gr/5dfBZpR8UQrdGHS8EDZ9DcskNzhDLL+861ICUCvAgNMdFBcu3Rp3WpT9wAAgdpJREFUZ3+PlYSatvFHdNMCpruicf7s2X7/kMqlWGBDAczOmXpADgEtJhSYSjLvliPcNBhswpuFAOvAjKnpxoDev+aQdfOUHbAHEqLSChJvAbdYnGZhl1NIaZOQWp577llIpOSkrDdHC+f2eiTxFFvAFOjbdPCBUJiFj5iJERU1g7PDSV296eXVRQRnhClKUEvuimQtzjYJOIFPMo6U6gthFISSDL5gtYoP+E/1ATHlPt0DUhPab8mir/SlDA5qazcfba5tsZq+N7PLWWTXn7pQb7PhbnNve48T2ZpH/WZ/d3w0rHfnG03Ohrf4nZ2fHY7vEVHoXHvLCzbgpz2wLLc4vnlr7fadhw/Xt+jrbHdmmlPEfZE5EZ3+BjgqSkM002+xCNrWRIr5QCxCwVRuvisrDYoY3B+xWWM/XtyJBzhz5A4sSg+XwSc6eeY/UR1nDAhXqOD2xKWfF0b8r3/7d375l/+bVO7pAFGJ2XqECFWG6GBCGbt2ktNHNz4krjXmggFyhTyEycKH1jxOKE48dQq4NwAZv2H5Clt4Y33Yj37U35jJZ4ZHU8TeBuyHQFhpsWvTlQtuprBDzAJmydApJwxivyqNmBbFpY1J803wUf3OMarDLtvCIgtRiFzc2UUXilgeaW+fgfq4RSKX+Ukv0Yb0SEkZQSUS3uibIrXQ9JjmhLk2UxhIn46smS+aOWolkZNgJTcgGjQaj2TGRUiLJpXKGJaGQiFXZu/iLjWDe6kS/smW9w+uspBGfsgeogtVRZTk3+hXO8VBto1mo0aX/v7xYO9oFzT1DTakvnDlGqU0fWw7R/UbP37/wc37n3jxJdYjdE+dOWovUuahxn1HCAmfvC1tXxjjDzkZR2HUZmPr4NH28fTs0tmZRSQ2Kao+pTecESerkHfYET9Og7vX/HhvE3dSL71AxTaBTRLJDTgSQgwkN8Mpg4+8+5r35PTAavRqS3QELCaaMJPk4MdJsILHRAkaEfMXADn+zu99j3WDy6sL6LJSLYMlbNwJiAqWigRDhyoatSyyMKSOc8WBQFyB4cZbPqUTWn6VC3z8bt6+xUay2ik2EtVBg4yfmQdnzl/Y2tzuHzI2SQacnZ/ZEE5DEaDTZUdB93YGLY2a3mxvygae5yvCkFvSZnI1iyodJ+Id8z0e7O7sM8UaX/Pt1HywYFzoMsa4UYLSRdjwbT5bXnCXlFe5q6RVqrCLCx/e+Ajj0NnASlxUWkHLYFEDjBsr4LEPt9FgZTNmQm3ZYEBV+KNRpz5xaVclc+MN0TBtsqbsdZXaIlFpO6cKSwDzjaRbMZLww724IYRDq4Vlbx02pliJ35me6g83dz5658bN1bNPnVuZHbGepje/d0RyO+QwgZgz5ZniaNbMtBs45ExMMvvq4Ghw46N3MQATI61p+pQoyXil1xRycGmRaI7Ghk3kF7QuWuvZvjbayJJIuYvUilFZ2ETFYVw78qoUWB4nd7RaxY4wQhpL5S1xwbtX5QRbE6TlGdvHrfqq3bp9+x//41//lb/8FyXLn+HInESV2jkIRM4fct66dfvevbuJHGnIfcXshKKQhtD3sfUXV50JYlV9SOU3NYewE3Bq7rUmU2Q4Knz/EIunXgDy0aFn3oLTCLZXhwVADVYnETWsgKYFwe4QFCO0lOSFBEOdwWTFnhzkttBgm1imq3GCoicxggk7BxMYzbGSKZglT5J64cTEHaUqdv4iKODWlk0uhMi4rCaWNKKTkMqMTNa0jGRcJyrC8+gYR+EDoZ7EDr7YA98aEZcq1KKbjenuTLPN7pdwhMSkGYKTN5EjC2ofYAoGbDDJxqRDdmxOZrlIwcKguUGIz/trG8vnr3Tml+tT4+NRk66S737/O9/48tc6C4fbt9++fffemLP1dt2p12qv3Q2jA1p1x8eoc8HFm67eZJ3jo/sP+mzoCIvwp9mjM++mVbio4rK2fGp1Zm7u0dqDzZ1thIQjfCgB1JOamtx8qS5lUiGi9Kkqy1VeVFeu6lF5hoMEChGTxxMAeX3iu5CoHMRLKfz3/t7/6vSZ01/+0hcWFmdRO7gYGkF3xi3ZjqqkVn30a7/26//5P/g/3UVTUjYaJTSJ3+pjwlRgjMm4AxZN+W1nv9mXHuFVU4leWCI41eG0i+3dbTQLYazKTMgigsF8lgqoY/YWpwm5s7NDBDBsyS481K/JjeAoMWIGSJcXBuQWKUyAs0Pd06WDzFQBci7RysGJWuWVK2JFuvJNQHmPJVcuLMM3+fBldGJgk1fg1GlJ+qZgwuGAsJpGZEYGXEKU/B7DZH3WVLPTZXOjmdnedK/b5jR1hwGY5TTdef65S3NzjGQdjQYH5uV1B/mhGFMjZ2+l28yZdMyOyJxAaBuD5M1sTWvZFsFpbt//6P1bH9++/txzZ86evXD56Z+89S5zCd94+0efaDfZKuLo0cfolk0eyZgoYykYyYNgdWl+fjo7jwRNjXcqyow7FbEdyFZgBUTEIie88Wl/Dt0QB0fs1mT8qq6yLYpffoCx0md5AFIMpriL9//Pq4AmllIJSzAjLJj+GK0nifoOL3fu3f9rf/Vv/G/+0//kz/zin8ZJXjF9XviXWaeR/at//dt/42/+7ewhDiFxTvK8CZO6lffYQ/UhCT009eLtCYnaYoW+wka2h2LQL7kaBuqf7R3HVeTCUp4a85DeLbK3/YN90qeNdDZQGfQxBKYK0LAEJQmYkgLkyRrZdWVMHoZl7e4xY3/XGi4lG2VKBC9sFaajK0gpeeFJTUyux296asPgqfIaA6izsInseMZbp4iMLEDknx6amR5N+Q7bAV04v3L+wqnFxS5Dv2fOrtChzWxGzrmm9k6+ZJVIAvwwb7LOWVkjibstDxVC2wjaNxfWNpxm1gXfR0fs0M8+MY319V0rgWbn1CRtou9tPiQ7e/t7D+8urTAd9cLp0/3Dffq9PrzxHvpkChD8JorsLZul34BeAfQUEiXmkJAZzsQQaU0lKLEKggMknEira4E3nlVLxEi55qZ2ceBmMC8cStDyErf/X7eJ9+RpyErvBbygyzswXAWtMuk1cZuEL+7GlawcMIf1eGDeLIfmXGScaRVY3yE809ZpuQoKtqR0tVWQVrRKkjtho5A/gQi/GfzrkbXb6UAwHIsaCjeSIopp3OJDFQMlk7UT0zCFn9pjUXYsfkTR7MRdF6oyvEKWRSzUPGUdKP+p/XDfPzokBzq1sqJU5vn5Y+jfMqMBiE0z5eF6MkJ8h1ix6+hvokHETiQqu10MABZJgqEEAKXgJl3mkrFRxvJK7/z5+evXT12/fvbSpaXlpd78AhYGDNicIzwe79eaxxyogsGylLA25hx50CK4SDLEwVgNc57oTJodHu9Rx3JpENIM6fWiLl47PtxrNadJ7exN4/lpjUM6ktc3Bw+3901KowE7f60sM3u2Ptxdv/3e5sxU46jmmge2EiBVUcNBLHIPM47oWW2xy0C0oDxegjElfWd3Mk4VNSkGfkmKAKkDMfjD9s1RvARhUEaVRbt8q6TqyleML2+xBxQNLg3lcfLyTcOTiDiDoMRWoSw+acQn4fmCFy8xncDGqbjrBVL73QQle+Y/1i8RnFAF7uiFBmNcvBXaeROvL8XXN1gMvbyGV/XBEC3bnc1NT++nWCzUn7gDYC8mIemIxD3MiIkfLcjUDFqstsa4d7a3sA3yfCtJ5FTOfyQi0wBUOWaQFAfF5NlCS/7sIPLBhS9ITQSp4IXXMAJJFZzrsTh8Pta8EVtBxB2kJURBYIrCkmrLC60XXjj38itnX3rhwrlzC7NMtTd70aJVJxOSCaeBMAMUzZMQOi0SwTFyMXWZ6gf2ToZAwuaVCp6zDDEoRl4xcdaAHh3t4dCe6rGcgcyh2eq2O126igd7D5D+8rnG5TPdraOp7/2of+/eITWRevPoPIvwY95aJZx0GH2yGoZKE2GV1DBlZEENxmzpq1BFpoimY7fbYeIpH2QmlMtRlwUAQdBuoARGsdpD+ROx2mEzITCp10q3xodXVGfM8DJxEygWXJwSolCwbJwEE7oKzQu4oQ1o8qBg5iNIk5VMGCouBkjYMAUtZZAHdJNW8OQTG2PkFnSKG8oRlg+pJWAUIEBhxofx5fSeOnkGm2HBFoOf8+TvRNdjRAkQNtC4K3sx8xbdPlQcRaWBZqSKHZDSOGMfz1nOJtId0Sjf7Q7HoAeau0V9dizLWI7v9GJOOUrgbEib35YqcAIc2I1ChcbJwoQsVvFDOJquZC3ajmZUDf8Kl/8qfsViBBnvjdrp072vfeX6V7587crV1XbLVWCRgxDEP4SdxscvdPDyhRhrNuf1bWzZ5GqyUxjssTkAdaHjemsRNTJ3HwIsRBsOHlLDa3dXyK+P9h5yzE53+bmj3YdHB8xomGp2l2EYSvXj/eXp4WsvLH3v8M6de2QalOnGsXwqBTkasZzPiKFC/IokecFmGKMjDQBcLsoHFojFRCK/FjARXaQKYyXUmQ6eFGZAFRN0jAOcCn17CHCaIDUicTBj8BloHik+QBeUFNJGDjGm6Y05lIzqlGnMVOViEM8RZL5eop+wfPgd2uLSlC3NyGDBA8oQ1X4LczDDBD4NOCtLcNREkogjUavbbF1dWnYWIUbDqDc2ag28wVw8jBaW7LcBnUtd2RfL9pN9l2zc0miy/HHLRS8UIEYCxkrnGZThrjBpzZadOp2boSmzYhAsc7MzJht7D8l1qDBM7e7uTTWnkIpu+Zlejyyf0WdqSAgFdjrdHItPH5yqoiudufP9AZkW9R1q2NtbvW22jbN7g5RjyaE1ZgwT3ggadtj32L4KNaOWKDTUSxWB6pP5qlDRepJTAoojUGqXLQp+6pvP/Kmfe/76pRU6aRsYK+pmzHXMkWEsvDJmRB505AN8c2gSG84SuH60gUpJpYN6b9S70uqs1obMK2FE+94U1Z79OwzDwEtjtEsn9fFwn6Fkl8rRA1xvD3ZuttocBTA7ZksAT5VkmSVB2NN2fXWp/olXzm3s3EqhAqdG+STBS39iAhFDX120RJSSuEeAWAvhzFA8mwfDiOlMHnwAW10kZTBYyXSUxp8K8qq3ugV/NIFDPAjrG7cKaajas01Vbmp6ZYWpTNNEGvHNfBX0CXkKS3JTa8VUe1n84/5zxKaxW+IjDJkUIaGHvGG1mB2llnkYoLwy8u9u7qiWw2YyO0X4pBbjnSqopuXVbU1dWzlNdZU0SHisa3Z5Ab9juixxMv65SIdMSXBhhdHO3IgjaqItzmtYPXsaF/oXCBt9uukxzMAbUUyvvH35zEaGxXZrfn7ein6m+ojb/BM+xxx6TvnLAaPssEZPxfr6Jj350HWZK8elYf5YfaY6YZ10pZCqQN9lWVmtztLGc+fOznlUBLhtHSqXdo7Zq33oGmlEkv3tGirBzVgA1SZk1RxqTP3Drtinrj0dUWxAHPWP0Dtbunzj6+d/6ZdeZfP3Rhtb7NE/RQprt7sqebhd62+Y8UCZFfy1DtNVVe+Q/tkBqhkwoYuon1qZmjm3R35Rn233pojQ5tyV0d7N2vADk9OYrp71ZmuZIvn4YKM9Pc+uSO3pheHBBn1Jg/Eh3WjjQ7KJDksyx4cbTfbhbTavv/jce3dG9z7awiCKsRlbZo8l1vgokWwUliuxqTMckr9YKVZ41FDjPBvGEsgBij504m9yEVPpkmbTvvbq6dOo7Igcemu9oG2dWlhO5gwn9vGFboyT0h9rddJbncmrQNMShx5gWEahRH8l0dnv7505O/2p1y+dPc/Bhndv3jy6v7bfac7tbG4PjqkdmpdYaSOsgxNhrdlk2g9JaG+XngGmhWl0oW4WnixuVGs36C7XUXEUHJlMbLxRYrMTbadjhy6TvnNeAl3QT59b+ei9D7YebUQ2FBBlkQv2Zq5fu/bRhzc2NxEb82CZwhqeKDtFpLO7oEu5QfJ1XsNoWA47YvSKxGkScLso1YIuIU0q5VIm6+uk9UNLns40o1Fsb85gFtEjeYzCzv4RZQEZhzrk4Ij2NImKBEn0zXF4Q69notzP+JfJVjpYOeM5NDHYy4+BG2IaBVGbgqLeqDKiGV0UF0QJhR48sk012VuZNd/sUSRfuVr/c7/42lSLZWoro8YcFWSYcaOaqZlh7YgEORzskD2DoN5aaDSYikyiwT77pIFxf9+KLUFas62ps42jveP9h8e75ALU3WbG+3eojI/by7wPDj+ueQjvbOaSHbZbs9T+a83N/uHDIUVBbXV6dnF/515zvOPs8Dom0Tjcvnn9QvPBLYZWUv5YClVxHKNWe4l5JU5sKqlpAMnVAPDJBfgajRcX5y5dvki8ohwrR1ZczbYAL5kVs1RQCxHEb3l1eWvg6mR/VBwuXbhImlCpBkY/dkNgquiEnb3nFxfpu2WaGljJ4Xi3zeDZBFMAD91o6PDFV2f+7C+9dPoUmcfwlU89ddRvv/3O1v/71956dH/vwZ0HroMqtMqjkqL+2quv7+/t/eS9d8GnKYabvAqNDCzVnp2bS5aGs5kdFFUDnME4WwPM9XaP9klDporRaHHhFJUwV6PbmjRRE0zLUXO8O69Gu4nN44KEmCVosXjEoB/vaEzHtrjR42zqOWxsf2jR4QVKLlHJJU8KUpsHpAFLCcpGxjR73fmF+b39Y87FkRSABqPoRZou4JQDewf7RAQxcf/hI7wOmK/Kzrv2wVKaN+3t9nA7KlQzy8vLt2/dUTNmdVzJBHiIOMkXH76qb3Ujd7IHcRPuq6+83Gz0m3VyR1qzCktOz1pEnpi9YeGeGUG2VTqk5To2SqUQq2x18YPvMfMjmf2w/Q5FGouy0A0WX9v5oHl8mwKbA9JaJC1UdPzIStNwbjRmn5Ld2nCqRjKo9VvNBRbB0Nht1w76h3eZLM8yd0piZnqeW62fP0vGCivadETSCByQ9pmbQkeR6p93dRr1G8i4skYwpKTd3twgQ5ydn8OXDYkAJ3ZIBLygEU4pgwLmijmg3x0PIBQ1WFo/eOsPqxqALpKFBlrBgsDwzExveWWFIZ6PP/qITmtO2sP6ejOz165eZ7y2NbX353/59W988+nONPs5ckgbsT3oNoaf+ETvuPbM/+Hvb4GviCY5L3DnkrSVlnibyCcAusezvnLm9IWL5wOgrMhDXQcK5L7ogeLqzLkzK2dOre3uuyNjzBMTD3ap8GbvDUGIWG2a6tOALfdpoNJ5SvWA/HVh1gog+xdwSChEsT8Pui5tF0iK012xzIBVvdV07E5I/+Sz9IN2ezM0Gdh4aXZmgeoYU06Y52YShM/cCAEaNssCAUyS4Cg6+YGC1JquH2zJdAsJdF9jRIEXiRXVQIqLuy5FpXzCvDzonLdI6XuSBT2GSwtTLMMdUpUbs4syy1+Zns1wHmo/atQPRsebFKZu2dmkDr0yGDxojNabzTn67xvNOfiifogA1Pun6OJEgU2mZx/VD9bqg21w9VlPO9w63ltjGcRhf530Mj17vn+0VRvu9A8eTs9dHBxuDK3zHDLDKU396VH9qN5cqDfmSSSt+sH8jJsasthG4WA7AkL2JEmrYksIfKMK4QpkeaChpGIGle/ea093LhGp7fb62iOLV3JxymVswLX+duw64x211sY77GkwQURZDJViN0EKMVudxg2msLG5cerUaSYvs3swJUSJfGo+Wzsbi6vDX/l3v/z66yut5r4tCC8eMc7G6KXnF5ZmWx9BbnJFQHw1JK0JRoq9hpcipLBm0Y4rfvEbX7505TIBcJMdSqvUUPW0LlG7eOniL/23/vzf/1/8LxnPh1vsAlAkVHbeqfab5Svd3v7O/Ts3Ty/0nrp4ijo1lS3yLHrqUY+4hzXnGdmJ3dja2t3e5YzFPtUCSi6gLHqK0YnKvaNRJ6hteTh6kIRCF0mvtzfagVVaxtZWbPjaF0TKLaFRjcxwkQDYG4K63/FRJl84wKkq0Ik5sYi9J/2pJZGoA1U0+SfmeT9xyBu+XnrBKfsITbXOnpnDCMDWHh2Ojh/yzl5rWZhLTeSQphpH2YybsxBgwjs5HpuMOFOBFvVge8SxLs1ZZhJOdbv9gz3q8RRvo9HukNpRbQaOmW9O4dA83jwe7TRYzUiSOGBgi+W8TQ7H6O+tEY8td5ChC5WBfE7pItfp1tpLran2kCXqo/7c3NT6hnlRzEGRYhzwrkARYuIQwSp5ydSL7OrFf+qXDtSoXP0Ci/rsKyf2GaajrcobvgmnnVQXRvWE9VeOE5qCMQuAbHB7ZxubUftp5mIf9ebOX//3v/DCi3P092AFoJSuRBNZo9pcb/TlL19944e3XPfxONpkIpFHBppJMiVlKwjhjXQEoB7bXZh/6ROfYM31EStoWdrAAltMz6VtWgPzDrBdJiB88Rtf/y/+d//Hnbv3rbbRakxjH5MGF9DKK2tmqzPd6bNLvePjQxsw8bBxQ1oiJK0a9GaHfb1PN37XmYM7Tr8nkcTUgVcsrdR5PXb/4SI5UeRIGBqy9O3YaMn8fup9mQgBJnMg2LAIQnvO5qAEGFCogvDwwMoPHAoXzUnUUVXQRylVfKJfKZYrbvmMeNFu5cUDQAPXa5xYcPGS55xCYTA6mG5SrNiBqEWQlQ2PYG149Mh2gdMUuqh21JhpUjDTezbaajBZiQGBZoejgBkEqJGRMyjMFN3pxfrM0/3d243RNnPAx3VW+S46h3p4iDIpQDtzy+3eueH+TQYKxvSTUqUxU2K+3fR078r07KXdnZvUO+kZUn1yHIZzz63EGh7qHFFwjPjFVooz7pZz+OA33XUw2E2GcEnHI5mTkSQ6XsBg80liSTzkaglo2FLAgA7Yk5+gcpbRH8yFPMoPXfRYXG79O//uZ158cSGD5CWTF7mcyliu8dHXfurCSy+fmaCqnCvEQfakF8FIEgZu1s9fu/q3/sP/wVf+xJ98tLnDDN9Wi8NXaN5Rn8M0OYKlRr306GjE+SznLl7+K3/7P7j+0gsYY2wIBooUtbm5OSwVDfPf7XWWl+ZJNRgfA+zMueRHrEjRbiu4QRFkBYPZXnthtrOzt12aB1YAvIoBi5mGEAgwZwoC0JtChoPDAxa4MguO019o/qpr2QAfeTmJBieAsJC0NiCJXzaPoDpqNZAkBauoDuMMKWMDJ4LAoFqRfhgpN5hKhKmvJ9wnr3kylE7+wQwq2eBUd4qdR/XBFtXa9tSCJaCNJfMTxnGn2nTyQoO+FfrfmKnNrO8p6iqM55JOauzmwNK2qflDihH5bR/s3hoNHlr5mDnfXDjfmjvtpHpq/Asv1hZfHU5dohdwcLRFFof2TflW/dojalm1xZ3tm43hOsPE5AOMEVNCImGuwr5GZLRoSOUXTwArFeBfQDAYQ0KCTho702OlBRf6Qvm0UtGhJawtK76MCF+KzQYPHUJFh+CSg4qm+SysoCCTDO1F8cKT9jL+lb/0ydc/OV+rc36ErAgn24UvFGGeR3G3sFD72jef/tGP7jpxOFceYsGXdGXlAnel8IHHVLf3zV/4hb/01/7KlWeeOTg+AiN8QJv+DWihfDhh8wx6k6Ijtlpo/8K//d/46te+8S9/7R//5j/7dVCQqVAPpMslcmpP8MKq9tnuNDMO6cGQrkJhdYUuJErWYiuOrgNaG24BMdXe33ZH6HD3+KZGtFow46lK4cRj8EYjWsQz81Y5WM7CFFJFcuSe8WOKWejVOYfJzi6kJh1S+007gJVQJCSrTIwwlfooebS976QHN2kEOuqJyeNhHhcHnKGd97zmjZuqUZ1bG3u//e33/9wvPNdp7eByQGNg+hL7Z/aPHrRRhQpna8clB4BHW+wYRP2xNma/oFFv/tw+3WXO6HYu03CwxyYlzdZKZ+Zqf+/eaHTYYgwYNVBcdBeP9jZJpmgZwRqHa9PNqeP9ex1Gysiw6swbZd8H5qAxpYKhglF3qjekI2lvqzGi5dV8+PBgukOuBC/WAGNACuu/BhhpJ2LpgvDlDxiBBEPzbL9Nd/TBwbbqsvpvLKmnPMlMAAxedYm7ntWVTkWdAhBH3lWgdkp2bK98srTwo6S12hs/+GhvjxoRM1rt4iw2QlgNSWKGtrtyPHruhZXFpZmCloDlRf7sIcS4Ch2c0xvR7f6lv/Hv/Z3/yX905bnnmDDDdjPIQ/OFygyYMQ6rHKUmBLiZi810IGZXVv/Mr/yl/+A//LsXL1/Hckng9MnQzgRvWEFB9IJBlnzK0VaCanT8qdTq4p0kkcy4zf4l1OlJaycXxCyiAo1smD45C7Mdh8cMELsxDs0ka0HuMmvnEvihBQyZPmdP0M9ELkRO5OaDMGaubI0KYDDjUUCIPKBADyEEBUR51auUdSxvheXCuh6VGAFSZtWLOffH/+Kfv/W737+9fUCTmhZBrzU9w+qERmtu2OwNW51Gd+l4xEmmjGfTRcucn2k6ONi47XDrY3soaBkpwR5DZiQSkvre3gMWK7ZmLrGZP1tesKfP4GBztP1+++B2bbQ/NXumdnR//Oh7U4f3aD8gZKt3ikRCNEwtXG/3LoHzcPc+iYfOCRZQvPn23qNNigb7fDRWLgWJPH4adcWxiFeMVgB/5WatgXcGAc6cXsULm7KKJxLVIFreRcOXTSsNM5mXmHHXiAouAuUS3+QCgO5OvjGpE3eQ/Ovfvvt//gc/oO/bJCqZXAl3csML86aHm/nbhAVmIqTg/Nvfih3ab+1OqOwx+1f/9t/6lb/+13tzCwynklPSs0iCZc0xp2mSndN1CHDJcTErzUKMGEiD2bqMz1174YW/+Ff/yquf/Sy1B+KNCkcSD72fVAaOPO1LUQlTFI4mfFdc0mNUhjfvu/sHjzZ3GcR1U38sVTB1xE1Ryxc4FEIMeprB2zLhU7Rq2rLDGlB+BnVgWpNCNBI/H+ohaKJevkqSniwrI4wJwO4m/fgHXuVNPp58mbyTTIsoMlWv3bu7+f/4r976rd/bvvmgydG648NHbI5cZyYz8xqGzOFpN1qzg6O1UX9r3F+rjzao8DCJjQ5whgjaZP/D42aN/J1UAy/M2lk0UlvU+6fhrDXcru/faI53B/2NASXDOiO7/cbsio3gOvXyFQpqekpb3Yuj9gpt3+VTV5myYPVpePjg4cH7H2165o5SkitJwI/c8qX8qkc1R2xIC62jWQE3TcAH2Qgz+WASzVI6A2bRz1UFSXFNRp6qKFHAS3y90RRkArfkQ8xgSRRUiUMfGpbCHPo5jc0GK9CN3/qtjz/9+atf+sIpaKlxPPhV9AhjHk9W+8F7G2wBBreyG57k2loKK7DdPohqA3Xni1ev/s3/3t/5qZ//OfYwNbekdzl7ZpQSiwoNqEkJJAmYoqOLmhAWbjMXdK6xIqk4N235wsX/7v/o7zLT5s3vfo+5xpS/lGBgPDjo33+w1Tu33KVYp2tnYu8IregTyZNmxyzLmJ1fnGpNnT9/7uzpU6Q9pbEEMHdRdwmuKmLcmCgqJ7kgETcqf0srC71Zyj1LZ0SP9FBhyAxEJaIhmbqNWjIvsDj03SE29EQ2Vcq9q9euUT6Ah7E2RC71NtMPcZkt5czzTGXuQ4GrCSapTTJJhR++s/YPb/3G77186We+/slXr41PL29OzZ0f09c52mmN+kzNpkeSmqRyDfZAY+Eh47QbaU7SikVwmaOvk9oLmSwNw/Z0bzhYrvc3a33OKm0cj46nGB1ruZUP5sKutW32OTzcGh1u9OYuMPY8Hu4e7tw/qnGaNTrb7R8N3v9wh/nSWJ5Cx/x5Gps8JpcGlR+qK2lAnfMWXZZQRhlxOKpdvHh2+ofvwTUKaHemKJGNMiGRxctgxpwGCHz5AB2DhdesyhKXZvP04jF/VzXSUASamgCwiwsYBPXi5uzsPL0oTvUdDO7d2nfig0avRYmft3CcO1sAT914//C5514yYcCIJbtmRMaPoVy+cuXBg7WZufmnr175H//H//NnX32FfBq0FBkQimmacDlzkmoDkelArf30xwwkwcO+E8epcbCfMEQVz4ZKq7Z69tzf/rv/w3/4v/3P/s0//83pTGNzcgWFzGi4cTjaPR5Nteo94oexhCjSFKRRqh/67nePhgdD+kwGN29+pDA4oxazGC8eyAc+3lpT7HU+Y5sBk7P3KQrQjuCowdA8oPQF2XqhCLV9ZmSDD13LKmUX6TmqQzNglBOqDSZaJyW7esN9qp2nxG+qucA0JGbJp1hzPQ1erRZDWpQsI7oBQRdVII6Mmp74p/xokHnRT3/4r377zc2Hq3/ymy8sum3B/VYL09+w6k4Pw/T88JCqTp/zjIwpNmemjwh0rmFAHhpODG08pONSvjYM1Zpa7LPNIbUjzNrS7YD6Xa3eG9Z7ZIl0qsbQavub77ERIrWs3hQD/IxCsKdc78atB2triMYhBugmCb9SX7Ggyk1tFZGAE1KGqktly2CaD4g8unzlwksvPruxzwjP8Nz5s2Zbpi7zLG3beZPqhQyR+4P9/Uc3PiwoYh3UDxmDpCOAAUPOuM1CBNDTdGbHvxsfckJBZk2NakcsP/EcbJA70mOz6eSquFMeUBPTFPIPH2DP5Uwa4l1x9NTiaixOI2Knu92f/6U/99TLL7L8YXNjw6VV7TbLpqh6OceVvZ1Llwsmow3WmI4mM03meJky4ZB0SbqHHCZEfQj56UL9M7/853/nW99+7623zbxKDmwatEWxcmZ1eW7qysI0WRpseBmcH9Nfah/cfXD/wbbt01KG6S3T0taCtdEwYvNDY80EQNbaYaz0L9mUTQgEYRD9YO9gl4nqDnmRmMlfLAOAsQeJi8FVZsu5FJjtRNMh0uJ8nR6lI40UYm6fBTM720QeRJ66dvXR2sO1h+zyl0QjYxi3W3FB0SRuN26KflMkadZMZHF5+s/925/75tdfnOkwBssUKUCIvePm8NisElMnF693qYpQqhPKyYPMUHMcyGRPykZu0iCA46NtTiW1cwMQ6kaD/lRnmS784dG2rODO0pkGUiySHPr9XTapwfbotWNXbbw7s6c63XlWcHz8wc57H4CfSdDmhsDYB6AQiQjVDBNpt6ptle4V9wDlTQmLN+B6s25pbq6zvsvGw+NH6xtsukPclFo08VUyXyjCPLkDNizHxmq9dfPmTZuDttmI2sbZM2eYMMO+PSkSrIOCUXWgZVUGed6JffLmi4UvOMCWwhEI5V+OnHHFDjmHN29+jAEQspJEaMfNFpYWl0+tvPSpT5EAqAWx7xBGgx8JACOznuaslWOSLLUvjAAu1I01HTNgJrSAEJ4pjIApasAMmJpIUjt98dJ/+2/+jf/p3/nvH27vgKcomKg7ssE6XD13ebi/Rp9fCQVOtWlDr7a+zSAH7TcJ+a9P3vOBKeACK0jInTlI1OWY04b10Aje2dpGUQJyIhxb+czO7e3trq8/SukAAYupYCZ0ftwYblO3Y9rN7j9ar3OKCa0QmsK2GNzpn/GIEbOwnO8ULRfW5IOYYJ0KxCxhYjUV30YF5tvtNf7sv/Xaz/3cC12WK/QPjEAqKdYSGHml9UmapMJCKlwYtWacBmcGvzAcbtQHm0hk+UHkE2+s+59btWF2sGntyCSAKVCXdmr0iDlYzFuius/cUirhwwPWAxCKJD6uZ1lcbW9zY+34+OGoN7px4+5P3mehE/MxLfHyqzTrF6/lCz0hgmI8thoFRngDVa965l24GseBTm1vb6EZJpjRC3doqsJ0K3skDFae2KnBN0ESqtY6Yn5v0hJicaH3xcWlze0tNZXhDalFsxQnvqrw1rkLnZdfpd1N1iET6kSEkYEn8EjfGrzw4uqPf3yXLt8R048SaYUDspetrc2XPvXaX/rv/Pvzy8ubW5v0PlL5BwENXOoGtGvNg1E0RXisijRAisIusA1KMtx5K6Q08chGUWcPDxu5DQef/sqXPvPlL33r1/9ZYRt/1EF34/ra/Y87radOc05LUd9E2XY0MS0i299O5PSpchGy6L58Gk2KitaHo9VTqwvLy8ccDT/eUmwpmXGUl0JDnZGhYnO8oAcyUkLzz8zJFicUsabDuod6ImXb7UbM2feQJp1lBz3ZolJMVVj4iDlAEkmKqzFRXqH/zZ969qe/enmKnKizPBg+YAkvs2CZssfQIq0wSFDet7urIzYiNy0x3X+93Z4ZH1LAHkKxNb1Alj8esmqizQae4G11VhiTOe7v0YxmkAsBSUPN6d64MccwAy3d9ni/2d+iutdoshcyhRDtPE4emck47WBvb70zVZuZaR1sUr+i/kOGa1YajUTBSiX/kSG3KBrZ4qrKCQXQk/+GUeej06eW2FOGfQBpYxAvVaQJXdIA1RUTANjTrYkHaDGJoIOAlxql/trljqJJAt7z4wXzzzuBBp/+wsXTZ53eKPGEBEBwQ0y+a8ef+ey5U6emOxTAxrh+/nLjXIYv/8xPX33mGc49t9lb+v7qLBs/wKBZiEtSRCrN3QMu6cdssHM/vYrwhl2AR3OApTSk5AIUspy5wSPmHNZf/9znJYrA5Fuhq8XRnbdDPmFyJFSsSssCzlYlzkoQmYrClUfFRc5kIbwTOJJQUb93/z7ZM1lwQYh1F7xmOCaDII9rSlrWBFP0M7IxTbJZWF5iwh/TOM2SsHhs38pXhPMuTknb8GAAK4uk4qhHmCggBJFZgoAlPK4stH/+Z56baZNwNjmfZqq32po5V2+vHPadCcLS8HGz1+jM2xVFtZeeROZLN5gOTSHE8M4xaYqZPa3p882pVeZ5THfnm1NzjfZMnynq3dODGhXm0pvVPhrSyLjcmH26OffM9MLLTrZrjKh8mA/ZMmeybr8zf3rc7s7MzV5+6tznP3/x6sWu6QmpTLnwjZLMrv2IzAqlLEgVJQgcz9yKeicOgAgOhlOnlhbZRYvqa6rbMdvEukainfBLvqI5iEmVWY/3RRzeyS6tewRWjRZ7kJcKQO2eOtP55s88Q4Gqm1B5PvmqMLgPrj8990u//Or5i6xdoUDEyeDlfvn6U5/8whfvP0grIacSoRDinzMaUB+GTsWGRq5Hl3OsEN0UaUey6ATmOAALNkUWEwZY2eBfxhl3ZCI69ajGS5/8BI1sdeiv3HwXhodiB0PFvv0FAav0jWfkLlo3hH/+8q8Dbx6RzVAA8S0zGr18BZH1C6nIZ9FkkIiFxYZTp86eXVpdJQqwJc0pAwqUASVGC8vyJ3sULI7JFH6hVDEip+DU2X8hpU6gp66vnj3DjGh0MqDcY3kuzbZ+f9953bWpzszZ6c6SqW64X++vH+3eHB7dbzBw0Gcy8yJZM5NghgcPx6zzGmzSqX94sEMt6xBrprE7Zq97hn47Vi4aM+3pFcYjWSzEMoH9g816m05Scigmy3ByEYjom2KiYX2K0qM71+0uzc21PvXJC+fPMeGEFkK1MEVNyr3RqXTRcKUy5SkOajsf1SOyG0h/Z++2zp89hZBGY8m8UZN6THjuYMQ6oiyxRmM2RALgA8RkzIxQk1cZqHBV3ib3Tq/95//CZ65cmQvdivbE02fBFraoCRx96rNnXvvM2ZXT85V0ioeKGj/zi7/APn2MEti7lNEezD1Jz7yZIwwwZtoAu3u71NsfPnzIshOSQUmciAp1MksASAlpBxsUEtaZaArQx9E/Xj51+vyVy6FbMRje4MpWPFw8duVVTaiiRMCJEBMY2daQi0p4JLwoSoRBmWoMtI1AblQPGI+jOwsIYbnjYeEQ1HW6tmgfmxRJ9iw6d8SszFUs8VGCFFgCuu6WjmBQlWiqOA/uvAvJP6DwhDpZaUNbCSzTU/Mt1m0db6CY/vHD/sFdZ40Ndg62b7YYAD7eqvU37Y1iBLi/OThggxlGrpeZQT0c7Nf6nOZy2BgdO/BOtYfWCNPgGfOeOjXVuUCVaNDfGuxvHGz/sD56xJyCZu3IBgZFHBNfp841O+fa3fN0WNCFaIPuYNcZR04eP3zqaU519OAF1ZMrovKmg6lgorV4mqEUvfhZZNWFDyDz4308Wl1dJAtPyimRFZCEsKQgiFj4IY/BuNypuLx5TzaDkMCIPFcgDQMADP/iL33i6984QzepybtkVlYngqMgCn4QKMZ4vDjffP7F+Q/eXX20ts9uCEBKsdV66sUX9o8O6McMY9R5pre2t6jaM5SLAVMt5s7SEYzVaiKYsXj2RdIIasz9cG9d002DTQEwo8EhJ2AyUma6hTSWRz8S0xleeOXln/zoR/KiLMoEVwQntehi3VHHIi01EOFKcz3yF/eEJXApw0SjCGKy/0IrI/Wxfq3DNvac6eCKMJoxZOowT6ItxalFA0Ex9uy1zzlFlkSp5uFBnY6yF4TqTTjbA2axvKf+g6sVRb90goPixaMKEgedwxwdELjTOKJo6R9t0lx2visl1Igo2BkONjjfeHhAoYIJUrCgQJqCTHohsdSmW3NMYkPZ1OtY3+Mg/PE6Bci4QVFMR++D4/1dVgU0a3P9/ib9VURRiwmhyrBRH3Io7RF5zLh+v9maZ4EoE0KP9h6wDTQNj6P+Hsc7Dg52l5bGC/NT9F9INFdlkOo2IiBoIi3SVO+IWqyRu2oyegA3KoKFWhALdJosUVND+CZygr6KsyqM9c3YIQmg6JPPYHNZILXNGK8BC95o3Ur6q69c/umfvjrfI3rsWC2ogUnuKTh8JQL1EqNd3qNXXjh3+8Px++883Hy0LdP1GlP5L12/wjuJzRg6YP8MtpMaLq4skuVzbAL93IwJEIfk8ZwCSDqhtwd4jh9cXVkGLzPSyHG5eNdu7J5gtiOvKsaCgBY67WYaD/GGaOEMxsiQaGPIfMTzEcOn3ONn+0LlFF3jF45PoP1S5eCno4Mz8+aXFukI6VBTm7FR1Nzdxp9RZCaVWdWfm0nkMF+IuZU2aRiCpf8UBsCAUcFVkg8TNKQOXS6KatiIJIR2xxQzG7PBMA35aF8AHIqAvgKsA1FlaqqxGJfuecyc+W00f+cZlyV2Gcly7A61wSBLeU2T5CQEpfZVHx6sH9c2mKlGjDSmFtsLV4926d3awstjfkgYRw/g4+AA5ARSzUxHGR0/qo22a4NdJlDARJMessO7zVk6s2eOsf4Rvd5nDhhxY1opDWtVOmQu9O5eVgIocpELgcxM+VbH5VKsaCWxDGzlY1U2tlaiSKDa8tIccyI+uHGPL3AWO+clBEJDVPbyqqogKhyojpDTn1iqaId06ZPFtKZ6za/89DOnl807iGhgSoIMzhKiIEkkVA5QZcfZxs/+7KXbH63/8994hwOf4Od59kAlvzRbotHSp9Zuz/D0NEMQHLpIdGMoXPW+s2sK4+T97FM23t1lF2B2cqa/nMYO1YZUoOzyVTJ+SJUAWBP6WT29SianRRUlK5FWQvlAtqsAfEQT6HWqM8Whv2zcbvvbGhVNd32LKKWYK58QYf0XVn7mwjl2k7r0zPUzF8+Reru9Hl2CkjZzd8I/iyr3d/eo5NPW31rf3Nvd23i0cbC7T3W6zIpgyThz7mkzgo/eRAqCgz3mlhKCMViYdnYVQ4DENiUgxQh98jqbUoxAOPSaMAp7zjOs1R6t053EqHnyJnona40Ddg/sLFH/ONq+hY4wDmoliO70884pnv39+6RYkiGpgh6cMbUgpszt7AynWEm82CFTZ5LP4UaNTqQGbWWmhlOfocavMTHl3qlLZkOulyBTY9L60d7d6YWn6u3FxnBjb/tje2fY9Hm43XTtFHu+d/p9ZvgWO4y5ovJo2xSNQ/Vh/ae4EBtGb2AJxoW1aoS4mXJctXvh/KkbN++xBgYP+lrNcDBX8xi1lGwwVPgWndMICI86lYI6BTnb0eEBY/qeGYeRQwOtUw1pt59+8fyly90Zsn8Cy4f3P3JpLuUqTzljtSg6mp3rf/pT5/75P32LINRtnnruWU6O6THvtjdNZR1KlNYUPpg7gxSswKQVi3kx9EnPDyVDqe1gVVSQOFsBqZjt/GhjnYAkAOZPEGGAsS4/hltR553RqNNnzhwdH2A9cKYotTEnmzogSG/IhN3IWWPG6FPXLnPCbSrkDDo7uYAwaM9eyHTIUhChElxIhK986hMvfOaln/rZb1y4fJlM3WqQSU0lRDFGEMGhIiWUTd27PyQN7HoY5c7W1vajtY21tQdbGxs7O7use1hfW3NJ8j47grH0yryZOR4r3d4iK80W5m93Z9/5+OMHbKyQNjaYo25HvMiHSbDFFixG6rV337976876tetU9pgrNsOsvdrBPSbdsfylM3/p6PDRkPo9qxbZwwce2xxIcdCYnhuy0Kg94wwI50Rg5hRrMyTWLl1AfUrddWv5TOwka6BztLPYb3SpPNEjjWyjwS4lYgoylM2YAKNAe8c7HzNc3e8zGkMJ16PtT7M7VmEhRDmv4aoZpYnatBnjBbumqYabH0nffuhXdFsBxc1byRbqtatXzzMcljVuZCB2qyQJkMEaPyCgHvhgd2/95o2CufXi8y+LN60xYgy8ZK4sg4y38UZOTH7E7NXeTItTQF3XLA9hIzFwwoMpjD+9KmbFHEfcLl6ZW1qe4YRWBkE6vRlntlCtT5c5mSU1Zqhj6kQkppwfdsiK8iFlBVUG066RbLpkohuVSzhk6AAlUt/B0fKE2r/bjqfLHC7ds98Wgi3THDlBIifmmKcAg8pmtQ7WCsPjaeZ6dNkimrkDFPYdBndd2kt+DiRZSmZAULmnpUtrhAPeOnOzV5+9dumZi2SCbLBS0Dgmp26MPDEb1tYvX1xsBdSdmT99diGewNgnwQ73m5s7t2/e+cF3/+D3fvvfvP+T92kszXe7y73ZZ06fvjy/yEa7S6tLz66efenytTs7mx88uLs/OGY+CVGqQtiyk/0XHD3gD8Qx6cbojbe3Ll1m8zVMvDNmbsLwDgIf9Lemplen6MqcXiXOnQRBKh+R1TPjjRghd1qkC+jo8C7jE+x00jjcrI/oJ90a9VnBTA8pY1hdtcY2WP2D6flTLK9h8wjH74fHjO66gn9Em40RG1LIkkn1cIf00ps5z2okTIljuWkjH1C1JYlxqZ+Sr1u+wWH0prYSQUYiQJidTzVrbOBg0CDgq5i2zqPR0vwMowHrW5tA8El1RsunskkVVDyWU7ug01F02IWpkMYa+druHhNszIYZ17x37w6ZERjI89ginM0MdncPTy0/W1m4vD9xgUmC3vIAe2VXPOI8Wlxqc+Amyw3J3K2yaE8cy+7YJImBiyo9iY0opZMHy9OszSEc7UcZrCKHHxoDZPp7e3ts9MCycVIO02DQBsCUY6RUq0K80Q/UnmJOKTMp1tbWiGDVjDvjo9TXr51VZBm0JsEDL/U9ONp8uP7erfssXqI+wqaftDRUMl4KmCo6gpEkMGU0NtX46cZPs/sJAjKRBBgYVVyexluljMQcWHTyjzfvIjVd1OozvcZMb/bixRe+8MWX//Jf++U333z3X/2zf/nWt743u3N0ZXGFHSOoAR0fHiI1W+L3jsdfuP78w93t3/rh7zO4aGs7eZxKDuVg9+3urfvM5PrqVxj7Ohz1yadtFqCq4wE7s59mZRYDXmzXAzPj43Vmwo3Jm+vH46MHrO1iDbGjtRj0/l1K/+ODI4pxOj052ZXdr6a7zPK4z0rjwea71KinGixxJIg7laWA72I2tfFu/4AJF04UYmMVLKk+3B4drpMDMRdkf6cz7KdyiwKip6KZ6sPYiKs2bPIo0Vd8KzmTDQuVyFGRqn7E8Vydqdb9uzeIr6STEndAAZskw6TYkiEZC/XW2z95Ax/MEWnpX2fOK+259c1H9+7fi82oM865o0ygLuppD5bxZmoGV88hnVdbdYWRxLnMxTcCuDekOyKbyTCXc8ia+pdXlq1ssAZ7agp7Jhsj56f4X19fZzCORMIcSLIWE0Oz4SLawQC7x+IPD9i0nB7rNpvEgxB1gwEWUnpYs0lWkpmYJIyILoMQHw+W5ma77MjmxB+ZhUnVUN5H/TNLc1C5t75F5WyPrDm7YAQOGNALx8QYMJG1bHI2/KN18jPqCtTNGRRLq0wzU9c+ga4UNNGT5IwpvSrVpeVnNxDVLCaCvPaJp1997bmDv/4r73z7Bzd+8zujjR2Mjx6AqWZ7vtfYPTjYXHtweml1uTv30cYDOspoUWgm4RKiPoOZlf7/13/0B/NzvddfXczcOUDo8CH3sblhplDvqrT+I05vJ5tndJYVkyz1qlMgUBoz6cuxB9qt+wwrNukaojoA/JCJiP3xYAvzoPmSniwEZyLQDAMCtOo9Xh4/+UDJrMNvzy0909+9z6ByXNlepLW+TsUcY7JEznVi8H6lioWGYmYljsgF1RrkKAscY4y4JRSvaludmv5qZ04tx6Ma7ZqoWTCxl1RQPqgZMGkCCFb5ipIJTVpkOQJWkDABVTsw2NN+2h0bXTwnIq4ncBM+6QInff2XpQLBm6cJYZfU+IkrNgW6cvkK9ROWidKhycxKikSKndm53hS7CjPcS3h7Mzmxq8/RY+T2gGHlZHg0sqBLE2I0pdhoBng0Qp2dMiQ8OUHINjS80sKWI+DYEK528fTK9YvnmOeeOmMEkDUBwjLdObUrp5dXFmbvb7IuwP0CEpGVoEXsBCCSTRHU5qmMseSScoBih7obdAFQRQVOSRLclMCPKyirGPO7pJSJZ6K6NuzOTb/8tc/srj1a+50/pIlMK4QCEfEvnj3NybN7e1vXzp29tfVAvkn4ZkumN/OsSvU4jNfWDv7X/+lv//Q3rn/9m1dOnWMfmcVWcwZlUHtpNVhI3WOKypjtsWqLzS5jqNvYOtUdjmXBBunCNbO2CmHqoouTar8DHYNtK0torDnX6s4cHtyrM2e0OYe+iRpXEcAIi4ynT7F3Akz0ektYJW1ix6Dq0/uHjXv3xnt7FJvpRpfbotfkFxN9Q7BIon5ORONdZSlwVJlEEXk1X/6TO3NqhvVW3tVBNES69Yur0DNWREUVqFD31f9Us4tCEzDRZNZnvFoPs9CWoWDyYfhg0hFqJRr04J0cU1d/pnVi0Jkuo9HNW7c+x8xNcw/W0rLXEmM09Oe0jyg0nVzcYupvi8m5LRZ2WbM/btPRzxFGLQ5ImJ2ZoxJFpxApFVWYLcOWWZXtYNa108PIfFITwGjI+XY0YDDrlfnZy+dWzizOEavkaSpKHtVCyUYikzdGKOe67ZnuKk3P92t3H2wxXCX/AS+3YsFaHTU6mrPdHo0Kt/RyeT2tEQwE8nQvIj4Y+Xn54FN2gyDK0mCTUlQjyTL6osaKXLQYp1/80mfufueNOkvPIAac9eva6vwc09/mxlRNewdp+ZTAzmsp+hYl2KhE1trd1vbx+L2Pd85duDw43B/W91gR1u6cZr7DENt1eVyHCjCW0vIQ03GzPWf31HiPjDyWpqoQjK4iOKcqzYoyckSYHTE0xor46aXMtENuttk6JgWQ8dMgZgKFdUWUwJ7827fHHI3Ub25tT9++C/auVpx2a9FMMbNKEzgZJWZaPE0lSp4QRT4VZXRUEae3CkB04eq106tLdKhx/A52AZUKLEFCrgASHCkQpiCDntiTjVPiGhFiC+KAoP80GUURbuLnRxAILhMkTRxyIcTJZYxwIviUTUzIcqwLRQFtXGo4jGRR1eaMSfMZDig/OGK/QfRNg6Tb6jL/mpYIlk1NlEMFmREPb/iSBiiU6HvBVEibVvqplFO1QeNN1wpTMMDP8GD/9EKHTP3U8rwDbE5ogsdKkXmfSBDTMQGrNtb71c7MTi0+f+2je+vv37p/yES9iQaLwMjBNOZH99fv3rl/6uxpVFXCUleg1mVlkWLTBqZpwexHfeWCS0Grq9KYlTY4MwK5kpPS1dianpu9tb/z/tvvbmxvrs7Pf/KpZ5edYlBfmZ/f3RksLc4er28WvIpU4hBGJcB+eJ3XP3v96ed6Tz9/8fnnXqbe0xhushcQfXpj1rk3mcraa9Y6jKePxhvj4ezUzHlOKjpikQDrxYx7tsFq0cEZK6CPC5zyZw94ndUOqJoDzbZo6RoBwyPGLSEMGCtSJEExAk/pnKgd7RJwfa/5B28cjhtLM+3a7DStMjBPpkJoFKEjDQSSjLE0KakfqyZGYhQSS6gYLfLvw0v3MR10rM3uHR5uww5u4MJfheNXnhPt40OG+PiKTYtM+hXaBJE3/iakRJT4Fp3IA+5NiGipQBdvoHghy6Cj3YKAuB55HB2my4mMVBswX3NMhhDZJ4DpE2V+BI7smpTcHSuf7tCz6xleHNYCPkyL6oZlAvdmk0UCtN2pIdDtTgpBO1R+Wsd7S+3hp1+4Oo2uaPWa5Is6ZFW9KGtE4emlOw7gx5OPqcb4+rnlud70mx/e3mGiciDKHSLrD9ff+cM3b37+9Vc/+QnzMwIEIYHVpI0D0hH5KONdZESOvyAycW3eVwEjH1GQ9qZd0KSN6sI8qFnfvHvn17//7Xs5AmfqIe3S5teeeoFEP1Vv0U3EJGoza8Uo0kg+sUFbYuqp5+aee6n76c999uyZy6m7jqc6s+NpSg/n22axL0GPsrUHEwIarG9mPUJ/dNievchg8GiwYz7i7m+sotwZ7t1kwAtlsS0KM4voBZie6h0fbfc55bfdof1DGUwNFTHZQNB1OKibgrm7ypDJcJ9qEsdwTO8d3j8ad5hs8/TFefaNUxXqgUiBE1Vi8Zw48F5Fj28IFRNUcZb5QKZIjOz5Mh4JYBUG0MX5ubWHW4lKFRJlFy0JV2kfU3w8FcJ3yINC4JgKDvnSRzcMq7xwD04dBRcuwcoTlwgENiHJKuRYk2DwSFjHd4841YCuVUqA+bkFquzb26z92MaLQ+YGtqiY20TpN2LfWXt4NB26RBm1KP2ZskPTMzBUME0P7CHEvjfgh9guE8Nvf/Dx93/v9h9+jx2Ln2BTb40lvBf25NKL50QYuVZLME2N6PQSjZ8rf/jux1u7B5q5sWUA6m/vvvnOWz966+f+3J9yVu/kmiASncq23W+22TYxZN1wWEiMqivCqR3/C9lK/RRmb77xxp37a9aMXLs1fvv2x69fvrbYYLHyeH5mDuejw9KbWGglPMmpPXXtmZXPf/nKl7/6xdXVa4xYM8zlqA7SkwD7G+yTRAlBp+iIKS2MYNH2aXRcGTw+ZOtSu26aHY4rHzVnUCZjL63a/tFgj/5Odm1kYptnZ5Bi2vNkP4Njd4lj5jMlHcefOsxcZ8UZ6brLHnzwokj2sdbpYv7UJ1Z/8OONtZ32rfWD88ttpgFSamksAqlUrVM21cTE+IgHo1X3qN7qSQVuIF91J1tRuFSxx+yCgzvMG0w/H/xr88Zr5cDrybYoAYhdpypigMRfQKHsSn4smZiEM/nGQwDQBl0K4LzpWIVN5KZgBhuR7wp7isj6w7VHj9a3zO/rYyYmUKUxY3SSTH1xcZYzb+jtpDOUH8ghHZZVThicqQSCCmZBXV9eMRrI8mxwFOfdG3fe/Vf/4t3v/i5VID1TweBFYVBM9cbLhPuCoogSIYpHErLaXey2X3v+6vff/HB7n20lhRbVuLa/vfvum2+nhqZ9RSO6F/WQY4isKEvvYu08ycmE0dfo8xHPkOWGL9dg8N47P6ECpRHFYWN3++NHawtnLrKtT6s7u7PDQjoWJWorRRYfrBBfan/5K0997eufmZ87w3apdQzdDeHoKCMGOaEagWh3LbOXoQso3A2U1a3MBaIsYtXAdu1ov87WiKTb5jyndDNf5Wi46wgAw2TjneHRZsvxG7aKu4ut0wPMekgaP33Gjdm4gFWRO3vISU+y6XjgHhC0NOxAqo3Pr7Tbr658983j9Z3+TKe5NK0tITy32LSvisqjMix1oary55t6KFV04bAHkoNy6cHPsh6PM6eXSNM0CTWKQiK4+cLfyQjQUe00gjMjxND5tn5q5xRWah0rvBg1xOUxdUXTYhVSr7yWkBXfxVOWgk9uhIrNMI9WduGKxVMHu4zNM12MmejthYXuysqimT1Ro2Gk5UNIuQJFfiEX/mWiXOmEFneI8aRgtCX4/nf+zbvf+V160PWC+wTjXRyoUkdzEW9xVSvBEepakc46qo68j+emm09fPvOj925bcocm/pRK99bW6dliRReouRRW9EFIyHDmh0gTrLznrj8e2IBvcqn2TaLMDcHyR3du3VMXII1m6J67t7HOmXIcCcGgHSsmreUWEohCrNXqCytzX/jStS98+VW2u8JgmZ/DwJY26Og3w4VWyNivYzjca0wtU7qOjrbJv9Mn02HwZOA2WMfNwRat19H4YX36/FT3wuHRXo1ZzSP3zcaoa9Or9dZc7WiDDNd2P7HKjNFm+5ANf+hwbdAJQ0ExpFSx61PjITXZgzrVHJ9aap091bjz6PDeer+9cNwa7VNYRIQSSSrc6qN3k05xRcQ0HsGBHvGxPoJLTBTV0OOJuaIya9Iktrne/rUrPbJsZQ08arLGZbOgvtGvbz/MgDSdk7RDoKndgxY1MdG4ydnFrPgsAXCmQkcr86jTmQEXcMYxSL2M88KyDidRb4xJzEgVzKgnerrdOttCkp/1jxjnGj/3zLX5eXY0olZAExPJYN1w1HwMG0oJ7c0rtIK2fAeYV+lULlRY3/j2t9/69rf65P2yGcHiWWlClsXOXb6KhkUipO4VsO+88lnQEI1nV+a2DxYfbW3CPJ5gYL5eu86cBYfOqtqrgRIOmzVsvozVEJWE7wVGAH9hI456qTdnClDFGh3vUVWge8lA7lDLiUAHzKmcnV1g55JL56aZ/lX4pt7Smz9ba8/3+9uf/uxTiwvzrMqsj3ap/FDRd7M3jnc92qEHjK4cpj5jdAzwDEfMrqWDdYGm15AZEPQgtGaZLD10KoTdcVSyjvduj/s7dsSy7KsxPTV39ahzvcV48O6d+nCTXVWatQM5JI6doc603BkWwrNzAo00D9RIByDmqi2AsjlkFhibXGwe1Y4evtUd3lcJKjOKqTKrEhtRkhoqKlNpxZ5IDurJKIyfd65ARp/cXn/JFQukGC7VLw1rGYyE/P6N4/cfFbdx6099czlREwQmAIbYOXCc7W1PG9y0xWWeu7TKhCjGO5UjtGRA7fMRN94Se/nkwyv+ecHEP/3aaqu2yzL52aXLL718mb1DqN07XFKhLPKY2FPtCwJvwFSy+frkZwHRkUtVs4vv937jn+1vrKOhSTligKBQ5oBFHZUU4C6eoS5AdZVX7srLg47xce3a+WXOMmw0yLcUjTBnLrOdJmux2WK2wCWcCb5QDVT8Ct4iZIIGAnAZSPwnVZoXWCpQBvSfutxbPFgk+4QDdvVlVGqmNai3bI6zHfVTl5sMVaRYJp5ax63OaGppZqpz9fLZDtvQ9pnHcexuuAR3Xwy2aN6jIU7PN/M6x41OrX9QHx3UpleYJTc+fkhFiF5k+upSkaDhwAtV/HUqvHTrkKOrBfZ3Ptydnptimgg9prXG/Oh4wxNgXK7ErFXshcE0ZgEOWRk8rJdDOmAQtAAbs4Ax1Yt5jM6X63PGMoI7clJFcaXViZL8PDFz4reC8k3rS8w4rSFlqIHkEVf4UKd40TB4nG8aK8xTotoMQKKDMxTO091G7mZI2TAiKj/eHQ/RFUPmBCgEcNPXAIVjfSRU2ZDvMWbZDk8FZTDgszA/fWq52x9wsAgIGakFnJdEu+IUUrpFQgPHOIErwkkpgaQz4Tbv3ICtjx/du3v/wxtMgddBdnJVWpzYZOFHx6BJVv0YGMdCI/qtwuPtZ52DVtqdGeoPZkJc9fFslxG3QilMWqrI5ePQilGJkCATaSrN4iYfkQdALdroMQ2Mu50xm9wwWQQgNiOnMc2WbBTaJA4WBDH3htFasnCoUcM4IP+tH186Mzs323HDkuEuKsaIiUfsDevEpo1oahYOJjKv1FFbpscxfAuxZn0G0hz2x3g5XZnUDAwpaUY2EIDuZ9b1NYZH6/3tt9kCA9ykVBprMI0ATNDytCgSA87sDXrMvou9g2GtOztzuLuuPTCGoNJgqcWURy1pZAKm0zkaj9JVVKUM1GCM5js61eCL1gWJkjB9mRCnDwF8t9LF3S8cC3ZjAC9SG2tf9Sru1niikkAhZKHIHaU4EafCQiQyjBXLqOzU8JIOEW7lSQTmpURuIRMHZ2ZYP7Q2BX/kRGQ3aquwZyqVRUOE52JDykH2YX4nx5AuF2CRIMAJWLmv3bq58wh1y1eBVm2Cm768qqBmZgpXUmEA4g07IYVwkcFAaiL47AQgXhkSYoYS/FOtG87MTFG5xhvwoq18TShJD18Fy2seIgN9WIkWcfUifGJZSXkfsZ6r5XY1IMDcEojdy9EbiiNzYxJtOtLlEW7c/oKiG6vicBd3gDuotTgKaQDDDuBSvfFAl3lqyk1WmGW8H5THezekNmCzaM7kYdnA2WMSS3uBle3j4wcscDHByKlTSzz4AHs9fMhEPLbOZWQH2o4DuPDSYfcig+3sY4yfDfuYLoqKDcpkIOq6g2Hvjbc/2tk9pA+XTtYiFKrzVaDYrbrBR2cpK3gc8kHNn5o+gPrRAeUsXfFwVxFyoL58SSijMSlJ3GnZ0mcIfIjSCE6xZChCyEOhXSqdOuiaH2ERpYBVzgYKF5UAPsJBnAMkGY1YSOa748a7YZSJr0qykJcp5bLNxIvS+xVn8U7e5KF8yLZ4xAcY6ZumOhueSaJYmMajWEKJS9oijIryLqXKWa8J5sCIOtRIgvCDjdXqRwNmwtmzKFb+qP8y7BUo0UYSvowUHpJEkOINtpAUawqQCkIYYSEuu4Jb/Rj2O73FzCOgkLGWbTJwaztsgPPO+nTMM8OeL4LR2UJollXeuLt94/bG0+eY9cdBPu6YwmpNVMpAO9lPuzV3PGZvgb1WewFcJI9Gf5vxBfKjo6P1ET08nbPTbHjDPOchi2mG0w0GHJlVeECeihzwgJGOjukGJSg9TORNsMt26vBAM5hTcFqupXAaOXz1WV9GY4BV3M6UJnRt6vba8M13H7K0geY0czLIjlVKKQPEhdpU3kRNlVLQYuzejs7EibxEv1ZKApwYJpum65COW0aF2HPJuRmMElHcsauAvFP2DcbND2m91G4Zd/b4VjHsE4dYSzEC7n7qkZimeaD4uAmUV0GA0KW6qtciEFBAyqfwRBJd++VNERFSgFwlPKpkNIwea5KljXqRJbMrxCB+QgeA6Eb74mXi484/ljIOwaJ61KWxoCInVBslbDLlrlRSTrLUlAhsIg07vp3wRCyKPCrI8hlSAPkN7d5WZ3i8jzsnC9XqS1hYGEs82mqyFR++YKxCELmLxIVAWA5UsgQ/oydDghkzYrT77OWn3/t+b7pFkrbqSb2xxSpHO7yxVwcNXcpF1LpRMRcCD3cP2r/9u/c7X75w6ewUi3oZIbf/WhkOmrXtwf4mc+XpEjrce8A0auoqpio6Q6bZCkSzGww2+ztsDtNkzzKPCDjaI62nikyFKYmNmhMNazb+Hx6SpbuGpjnTmp5vdxaYTIHGWfE4brDtKCse6fo8JqMfHmtmg3H3xu2df/m7N/fdmtryjWYMVkitQ8H5g0neiub8UnmJQnvE6HxDRqZD0Z4hAzcXqNWYQLC0uHjh4gXimRDMJWNHJoabmDuMFWG3ZAv510KQA42x9Oitte/Wfv8WEQN+hyELTVWUaFSTvhWDqAwNMBGgcGeSaRdehfnJR7HDoLEvUueCNAC4U4lCcAJrn2YAhQf5KMSJDPi2+TWxadl7gi1BuQz4+FUXv2I3w9ruHnv4u4cdi2hBw3DC5vY2+8wRxPWeTswiKqnLt7pdBoNGLi+mIsg2Rn1mQNJrQRDnxmJmzA1nqpLpPxcJ6eB4uHShd/7UmRHLZM3pmjOrZ7AnpsGQS8NXRnPlhfdwKa8nlp33StjUh1MgRRRF5sWCBbs23jDby8+9NLt0pr95myp/VMEdo4ERVG9HC0bhbAVkM+ERgrfG2mbtv/6t289dW7p+ZfHMqe7y0qILXEZ7LM5l98f6aL7dvdY/3KiP9hm9pfZiZ35qdHDMMM+4tjdNXk7zgGhEW5i7sjC4zpMarDRYfcVAGCMDjam5dm+FORsYw+H+w/7hZvJJCiRyYsRp7h8NHzwcfnRn85331m7c3GCxig1LVOrsiSNFFnuecs+7+Qhp0XSO3XOkH8OfxBf7WViLay8vr8zOsxB1gSmVnHCPTbGCSlBTTMlVeYmJqFF5RQam0jihyXWePc5rQ8laLzYZAOgaX4mzcjdYcTO8EaiSizmCVMh4hM4EQjAvMavHwOWBvLjbFQ1dEq+ZcsklZbHCLkGinqyuIhgaQUiqCXMFf3DrzoWLKCqJ2dK0v76xyw6KqROMmBV3eExXtFMDOI0uqw6Yet2jB71xxFQ5NzNkojV6YSM32GIlCLyzLJN97UkUWBj72kCDaT/MC0DFW3t7M2fa3dnZ4S6JGatsn7pwkVRlGlEQOhks/SpuaTNoyTCHakqpGDFwkm8491MdRgKlE8rUxtoxUiPnK772+Z/9/X/yjxhzM/5azFgm62OePWmYsSdP2DJHIm7cT4UxL0s5MubNveb33tz58fu7504tXb54NDNTW11qz3TYELI51elNsR7zaIqhKrIhdAI3zGfGelJLIeWzNTeTpXdiBDBFVuW6TXbxgrvM+WOyVmdh6VnODSA4beUBaycONo/3NugjYjPLvcMa29utb+2zSeHdtZ0Hj3aP+sx9dEw+mShLC7A8Zp6yPpi8m1zVZE/S5RNLtvJn0jZbqnEya6czN7949vxZti3kiN7ZmY6dxJQBJFpFR7XOCiPByLCqptan1km+1FCZ/m2liBPpmUjAZI0Gh9ezrBGNq3gSqVdMSsXDH17BGpsSvdTkzKgFApdCSACjFVRCcdM/6PycuBvDwVl0J1ii3Vtxr779iEXw9ApgBe13CVDolG+o6WguFUyMU3tENkOAbDbYcX/N4ai3wNpT1+yx3petTtk0j10LHbdHvZY2LLXpshCCI36Zng21TDp2bpIVRks8Nqs7Jo9hOwNmcNCxxsD1wc72kM3z2K1kerW3conMGhtSHeg9x6Fgh+TIFO70jFuFMOO0DiOfiRnZNRmorxBRLP4SBdaojQogGs1LL33mh7/9rb0Hb7E3EjiR9cgDnI44Y4NKNnxGv4Rg9iuri6Dnrm/BxtqX+s37u3ce0GfF0jnmKLOLNfnlw6mpdzstxuAp9lhPw3EKJuBQpakMEtfEQV6GrIuWqiCmStqQY3Mwc/gbpDT2NaUsp5a1f8jZmMxS77N4hnm6WLDC2CFDNw8VDbBgK+a7picGH2ocLecGl8rqP7Xf2LAUqMszQ6C7eubshctXzp47u7K4yEx8WtYISMcUSuNyGhWNIuPJAoIOXGKfkOoIF3t3KBxp0ZPLJ4JaNMNZ2tm0IyFEiRpLqSpaorMidDE2pOeqiBFBdrjyVSIwXBK2xFsBVF8iI2ajvZhzCU8oEri5B5zZBi+IC21Z4AqyvJVbXMstd0P5wn8xo5Ja8mVgXsiAYUwuGaDH7tlelg4QqbqVUKM3N8NK3PWNDWKBswsZIZqd6VHf4SIUnd4ExOpZsksZQvLJTLtWu9d2BR9dd64RobrMeaMO1B6P2UP96dXzzzr3K22WxHciXr0Yq0UbRFGRVxHUHO4li8IizH4xAZODJbiKAj3JU7YYxR23L37iq2/8i48btEppj3IWRZ1l++8zH2GglJWSwcheNcxsYysgCnwIiZRqdgwbc6Vvh/Jiv19b38Mv/Ghq9HJSUWROSvSnJZJooa3R6w8Oa1+qXXy+iBkf1nIyVcpcMTLJPD17JBLlSXaOPeunVfjzI8avqH0OFmDTAOoDdPKaYEuCR1HMoOvNYPfPv/DCuXNnqI6ySWqDSXvpi2VXbhJfk94nphZrTnY/aFOg5MVBDJKcOmYjfQ5jZc4uO8CjBZzrAxYuTeucTiBCIDMJQKFKHq0JlRiQm7zGF6nMUgQqsGgrIWTc1+KMd4ywqCsc6aSbP4+QII2SPHGxpZhg0q4uCQoKzseOxa/wEkQFHdwlXPnirukA6z92fcS4dY/N+stKml6vyxAN7lmvMiQBUhlz6afVSiOVdgJRSulLImH6NUySl8ErdRt2aCGXJTFtbXtwGPPvIOxmpGQ5c5ef+eTPLSwuSpLoNecppREgRbs4FNs3XQKlNLrJZjLExJa8p+C1tywwmU7J+h7y6M70fOsLX91cu3X3jd9sM3bLgBbnfQ1uOHHHnK0kNAwWxMeN8cHYdjmJKtUrpTa3ToQV9Zkk/JMQvPHgJjsS1uZZiOCogt/aDSjo85V3NY63sHr5EfI6GQ6jNxpMCH5WKaMKkGAicFIRdA9r/R37i0JGB5jAiltTTz/zzIsvvXxqZQkh6IglhboTPOuNyN0psdj9iYWFGXIjPqlLq+qKIGURZNh8kgJhjnUONOjRAv1FFPigt7kk247ZFavkyx4ihSs6MF+Cx4mgmiP4pQCAdTIrapA1veFiuTsYsk7LFFYMUDwqN59Eqti94Q6vFEs0kXyHUKoERZsg8wIs1+TJRziTg6gOurqFeHGQ14RjcAHgHBjI8khUQllZr7OF/2AwTYt4Y3fPVbzs0+2s6RabWFH8pa45oLOFOiJpgI0YGJ+kmUUnGqvuJcQiWTafyw5FpAf0fLjPNmkjiuOD+tKF1//E+asvnl6dN/qsKkiWIGFfHfESk0BuIwIgrkpWVZp/nIgb83pgzJnzdOoMPNmdN6zv782/+Pmf2X10d+fu9zN7GZWie9Iuf0qtSqROZzxz2hbQPrGk8TrYxTGQwEtXjnzIhPYQjmBYx8cXDn6LNhqITzEMiGjyuJPcEw+S5lNQDF8mTNdJ7gDoApex74JSrVCDbzKSSN2LwkcezIUBWj195rOf/ezlixesu0AGL6oxNF7ZK415v1TtHEECHycNHLHDBYGIRAxT+TAnyx+qcKSAKeYj0SWFPuisNfumQ5Ys0CSaTEOGyw/aMi8XeaBHIwouIz/OeFT6iP5o3PT3dg9di3TYv3Xr/tLizNmzyxzkRdJQJQnhkxlFx6MPP3749PVza/c2GJycc78fqt1KF7Mo8aE6pS95/ysMuuazqDTOFQgcR9EBMfoAPAmWaq077tNSpEeMBZ4QhR26C2gPYMrWRlwq6e6uxAXW74IEK461TrfbJtmYlOga4lhcJrRYLbW4AC/DrmxDRLId7K5vNc6+/I3LT3/23JnlbtdR1WT90SP8FHFUrCxPJOFJHgSr8o9YxSy0/NIIEK7EukmAVIn5wjwbr3HO2u65M0+9/pXvP3iDIzK1UOygQKP02Fy0MWyO9xrOTbKYMnXQbQscMyjErFsY0grhaxLH0WG4FAgW0RBwgSBgoiWiSKMEIrwZvIIYIM8wBGP8xSnFgEHwDrDyG1GuSh9sxFF14EQZ9ezzz336M59ZmEGbpNmUgGyxNNVtd+bp2wdseLw3ZlOtspibWhqMUbslxzAWu402E5/oxWOnR/a0owmyTzkQY0bskfsuUW60GMfveIAMk43JFtKxljZAIsyIkh25N3aKEvJhtMi5ctItNccM/mH/xof3Tp9ZOXd+Ebf9/SMisdflvBZCsoJvsLN31OsssPVFozW9S39xqz83S0885mdOWYpJI0j8qquoIdYiH7kSCyGq1qxceBE/qSiYFyQ6UJZMl2iUdw19eORmQWarNHRxJN8oF+tpyOwJQk8n2QrTwiDNsgTSDJoiPZBzQpN9hxCZVi9ZKZOXVIebVFtRIXhr6alrr35tYXbx/LnFcCVvSiJceZNjHYj0OHsr0uat8hRgEkQnA3PxoL+M1Uq8YAwL853WtfOjwafvf/C522//M2SVlgQN47PkKNb9D6dq+wd1NoOhomE1yMzYHJKUwL/2gkMqXAWJCIIpKMGoLuNoQpW5yTecyVwBzzNgQPNRqVfr95JqXnzKJk9Q0U5HHU22iBvta3+wbwWtcf36ta985UsezmlGgpnQYJ9qdWYabdamMapDi5kGPzNSM8PF/AZ0Xiqcntz23KDdawxYfkCPn51SDTa5yBA0BYg7d9OzTd2pzSnOWGCZ7BRBmYGvEAqlnDGxYK9UqzveRlEE4ROC7DXCdgxUFOYXZtm4amGeLSNZ7rlDBhpJ6fCqbW5zmM8ciO+v3ZubZUMhZ1YlWkWl5F4l/sgeHjtBR1YQDjdpR0rfNIso07ov77RsUWuAAhWMFjLMVOR0mWadLaikZGe1bQ8sm/VTbv5eatpqOoR5OlJolcxhF+oebD0Es2zEQJw0Xe+LM+2X9jR7x/fY0PzpT36lO7d87vxyl01uZJg/6OSuMsOfPOp6csmtvhihzglSPOOhly+mmfLvt1jI6WZmp0+dPfP8p3/2zo3v1A62pKiP4OUhk3Yo9pujDZLqoNZFrQpWSKlNf7ZoMf+qEltiQMbDmPqo0JZvA5BJ5YMbYLwLmxw9tl5MXcOffKKsvJoOADWMKdDAEGiwmOb4oT05FIfyV19aXPrcZz/rwIExAjP05XHmWI+JqXY4OamJuXMHFAHRmxkKUR9QW8wUliHhTqzW97RvCwWPxHX0DMYcwCWXg7HBiEO/2T4naS9WY/VLvhI5IgqX6qF6LS9hXk1z/BNlMlnmFIdFcdw5mSIcMyTD0l7NiWtc61HR5uSfnO/CVnKPHrClzR6zcxEA6zRSvWw4VLrFI0ElUP359iQTKLCKAXxk2SC5FUjDFxzciQDrQjOss3F/PPqAjUVmbtnHaXu3LKOxOKJTzk5Ako37vtLXI1E2cLTZREWbQ9RdgE/rgPCUojNz/bMvv3L5mVfZYuH0qUUYkPzkMgXIf4n2eBSeCBzrkUfDJJjc45qqg2IrYDAEaiJOgC035xY655557tqLX333+/+1wICSxXvlLg9WdRqjvdZ4Y0iHN5lp6SQFLXQ4PYcMUNLoX2LFOWZtghKlbjz1DF1jyi//yhvesX4duWTeXANNYeWVUyr/vMf+DT6hafXm+BEbBNlXZDkkwRdefnluno0OLO+MVv7pnbbXGAuhFm9LE8wM4Juw5MsiAvRGnySHnPhEBwZG6PgAGZmbEVLDwVP2wj1dW8dsBuMAu51OZNEUPQpN/VWk0hV3uRQ2Mk+c/IIU/0zhYEd8T8Z9/oVLVH9Bs89i2dhZqtclyGhxvvPw0RYbKt29vYmB0WZQKzW7nMGDCksmgWrUQchGUQSPky5JofGSHZQVHyH4BstJsInFicraI13UJDOHk2n/s4NQur2MIwKyzgNFUCbQDKByj91TuadAK4MpIGc/RlypghfrJKlg/4jJ4Mzc4uL86dWXvvRV5gmcO73EBkzaoLlU0Z9secXAIkiYjebCcWE9UJpTkeBE3sAlvGFzJZSmhkHMduuzCzPPfPLrN975zmD7vsYQA9Kb/6gUR5ezjDcatel+bYH+rQqV1AJEPskvjOBmm10k1SW7vKpuyw9eccmli++g8e6LxuWIZmX9fhCzpgOB/ELlslZMa8TeHLXBeq2/bkFb+mPqLG/oLK+uAkWuWqE3F8f4XQ+uRVGFBcGYkZk9ikaLfc1aaw1p5t8xF50p38YXrQLqvEMm8LlOEKwOkhDJsMGeq0O2OYMO81aQmksRMg5QFKDUSsaX2kKEEjNJDZEhKOlY3NjcdMLFVGtnZ49ZI4xZ0rPSdnlbEIhiPNtjy6aFXveA9vHcLDtOIj2NdCYjYDQkR5e0hxg3qCl9GIhtq+OKvjAIUlg0zRY/7uEuKPwQgRKrsjBrV32ihvSAjTuKRyrF2K0AaQKUYhnEZDtjWwhsTMo0JJxpCtNcplXg8Jk5EdsrcDSBQzkLi/NPf+K15XPnutOt5cV5YkJNPWZ5wo08gkmFqgs/bfcrY6VInZ64AClNo/AeIZM6lLygiTpc6np/ZfXpV7/85rf+X8wlsCsmIUQFjpgFccAayMbwQSpn8+zWQ65ge6ACUVrsSNYqbopP2IGgT3xs7fhmLsoldh/VhcJO/mLlpQhIIojPBDBBEcipaIOtev8+e88iGt6YC7px/wsqLUZWVRTDFOzGOGGGDDrtAjYEHAEGZ5QiNsxg0QuLJxV75w9dUaRr+nBtFxgwzoRzdfmQE80oImgHM3MxXHHDH+wFU+Qrt5h+lYudeIOc7agODh882OJQYmYdPny0ib0h2BSDi50mDWsZkg0tGsvh4J/Tp9h7TPxGpB1RFFBWulReiVspmporJtQw4CjBSCgwOsRN5AUQIAJMUsPENW4CSQxdMA7ogjeym5BXAPID11dRC6Q5QM49Zv9DHGnWsriWOhu2Tm9ad7YLBTpJSS30A+WlNjc/0+jNPvfJz7GRyzI7RfTomrBorljiAT8TMXQsfMskb+ZwxUFZDFRAo2ZgKhc5FSBBRFJ0o5si08ri1I/nP/2Nj9/8zu6jj5Ira8r68oepgkDAUXvEfrS0uqhqoHAukwOQHO+O+ODDymAKUNzDC2/BJHCxeXkSneHKf95Lxm7mksqPn14lCVjx8CO4sNMS8aSnwU792LVjMIIuRK0KqFAwf5cuOxq7NGCQJbEkn1aShHRMgtHc6Vqzk1SZgmHMlkSAxhM4MdlWVmLLefCYbKjqMrpJS8ARM0pq4JSaC5NATIW3Y+7/61IXiRN8InzACc40DSaaWY9uU9BYFtHD1plinVwoFFVGOBUngfxCwnjhm15bTlJmfqKq0qnc88qnf8nIwheCVSoxrDCiKph4gwYZm60p3RM7zP0hX0/6SiwayFikmMKOCzVGdTkGk7236CTFyxLBierWiEgFpemS7n97UWg4o062q6Yb4donPnn6yrVOr7O6vIAmw1NhLLxVFl6x94QHvl4nLmEjHEcGfSo/XnhTyFy8VEixaTyQ9Py5MwtnLz//uT85bljmCszDv4JEW7AxTNOP1cAH92qDTbrMGclLkrcrmF+x2NhBsV/CW6MJO0Yd/7mbd+QKU8m3HCB3vlHB47NcjEKRjcc1ScAY1prZDbBx9LDBcQGjXZMW3E6yCiRibeTDB2vAwmHcpUZUUVxbJtLZz/mWrFWgI9++IOMSJKYw/u2jxvLJidhnzqoR5knNgqYuSdOWSYlbFjeDxHEhEynekEBxReUUEEXXaj7u+QQ2ICVDQg4+mfE102tfvXLG8HXyQWpdFm3MMjKsyVVTU1UG5sqjUCtf+pj42Lte/eSSPuEr4PAQliq+yjuY8lLSBsBxAMMEasJ84RuaEcepaUQP74hAoqUFv7H1gERMTsAwMJQZaKLfIFHIRlFUitiMeholmjeagaFgthf3yO1Bs/XUS6+0ep3ZmWn0YIZS8Vx4CEe8wlrkJmCYKflrkTX3KMQwlVCGUZDqk1dz64kiKlc0jnrRHbUvVsRffO7TP/7OPz148FHIiaFCWPSPq5bGEdbbfYaG2bKEs1DTJUo1kDyLirR/KMU8Ue1QZIfohE+lh3RJI+GmpJQknmJd2pIXgBYF2LZpqLpECQO0yGvHj5rDHbZowDpwQzzp5cmNZutHH7x36eLF5sIMPZZsBqgPSE1NNpKp89AokBbnjpGu7fpjKJ+eRlRkzw8wlGksN8tsNWs+uKMuzwfJQoikjZBS52JKPVnxYMfyEVhjjUCJsvJJ5IkFi9OqCe+oGz+33yzlhtGbBCkGbVHZK2SSSqToYni/uKkyXhxnrWw5dMoHhP2TI8MHVxAF6R9xNKlJNtAFvjCfwPiVmOO0BvYncJo8RkweyPAWFX3XIjHbMwjJL5jcYG3aWmqNkWPaCSCns9+UajJlMhW20jh//frZq5dRNQsO7TaKhA4a5SoqVEg5iGb4iFfRHq8KhNOEaVULSWErJIJ4JZyv+YyocSco5Xz/9Ory9ub2pRc+/9bDjynkDRB9KLVa8zOlmlHXZGHkXn88dVjvLI/GPea5MSzE6JhjAolQu8aDl9gtVMpdXCoy+a2vRp0GPzF84rJyVkvGq5+2q31jaVKNSv9guzVmUgmOWAj4Ed4fKoKoz9p4a/3RGz9+6/XXX8WOu6yowdqZSke0Ydxsd6nWqNbTaDyyc6PddSICXaYUwQyKOS+EGVzWiCz1bCLLBpqwBsz01TEFiw05koVUYbnqTIreqCqhbHVWxZYvBPcGf7wYl1wYSD5dEcy6eJlPPBXfAHpTHoMXlD5EZc4gPMSb2zvkwraBA4arWax/wvkouHxIUAfdil/5Rr1xJNZKiHwJJbRmSxbCLW906tO/CU1Ght2M0W4B49DT46YYOkzZS6+/w2HkjaylYJ9GMgnCU0FiZIYmJDHOYuDLz73YnWNCcXOBHZ5M8BAkEnyA039ew1reiQMc+I6qimegJ7cqhAiKzMBWmCqHeHELhuJFguOMs+n2yurypec+/fZ3/0mNLkWEKUjQI7FvXUlujCU1O8YE+4d3B5yHN7XUmGJgtcfsYarVtB0RgIctOXIAlywaImpWe8lFcucrKUDV5UJxlK0Q1rlAKjBv9IpQadmpD3ZbddassfxSdpTCGgz8mFdq/8CHQ0qkmzfeIeDnPvs5SFPc0qKML4UGU0Dp7YEKBl6MO+mVjM3EiPVTtyFFMBl0ygOP8ZxijT792UcMJtRZe24bjhKDYR10Z+KsLnlBbShHpguHfKpmNVBcCt9x5ZW9fLY2Dtl0SRkCiKMRbE7GxU2lVa9aiJrkm9oc5sig26OH448+XhscUU1nPpcrI2ioIBnBVEXByUtQFF4KvoJHdySMZYd9boENxyWcTsEGajM0PvkRKBFIWqS2wzvA9DVzx5PkgUuXXq12izRi/ScTVtEp4fRFq93O+aevkWZIAu7jUnV9ymMu4zOihqJOIMalMMVnke3kXiByjwTozWf1X9Q4wR0VnGASa220ujx/8fL1p1/58rvf+Q3nciKdgoLBGo2EeY2VxYF1ZKT0XbYJG3AOEvu3MXFgap7dVplmwyYTnpBscOzHBBYuJ4YSEck4/cul4fuqA3ozd2CrFero2P1oj91YGzQ6OTgMVOYQ6sGb6OEOOUx2pDYfRkF8a/07Nz/4N0fHL3/itdOnVqjLp2ZKHxGbXbCUx+Me6NIl3ph2AKtQo0Y0Zug3U1dYvnbMkWwsCXA80+kIGPyQDYsaHVY/DDyJjLRN5k02x0xXTnbCNJBSpdEGiJHmC9R6qAC1WK4qHthEZr//u99+8zOff2F5uUMdrEDEsk6CVbDYtBVCUUVsK2VjNu383vc+2NzYJa2z1+3u3gGniTBEEGqJv/I6oVr4QnGWIOGs8pGIxMOAjIbqiUuYN6rIISjlHUiBGRQOGE1B7NtzoTwztM/6sCPbWyN2YC+tZILRAiNyiGKCUybQcYpmT1+6dPrceRbZceJKMRG1rHGEC7ipuAovMlfUyFu5omSVFVOYuIohaSRYqg8MC6swfPSnl1BBmIC40Js8vzB//cXPv//Dbw84HN1yNOyknlGVTMhgL0qSu4OkFv4on617asebo33qQh1WzbsQvsU55EwP4ZfJ9NiHLf8Q9qG15243i5YHEseeGKPFElnyy/ECbDSE3aNnihL1ggqsmoMo1g91lKnpWw5g/4ptBR4Y77wPHz648+1vbV29du3y1WsrK6u0LRnharq5C9GB7lnyQlyRbKwIpk4CDmqnU6Nmj72tyeFhlGPQKYJMe20y/j1yMLav6x/upHxz9QHHmoSLWJW9RWE2Eam1Kmg+0HJ8JjftcPBwbeM3/un3n3r6/PVnzizMTdM4ARcClliM3GZV6pwKGdFita/FIXG3bq7/+I2bt29vMEMDE2TN9RZrq/YPmZcEpAS9xQwKA3nNTQZkpjBiAT+BU8uVrnlBjUYTiCamSeZE6U6flUlBYBsDnKFJjVTNMTmC41KOPbEGpdJCwMSsDzhLiN5CUk/giLJW6+L1p7qznGnW5PyRFOIRMTjhx0oZcssMb6pDLmQlXwETqqipfJawRRRAsUyZCvvmT34niE7avxj15wsLIIOZX5xZOn353JWXPnr7d6ivVfAyIhOWecaEbGANhkMQeQhzlmDMqTzknAsWrDNWwBxoBsPZxgFro+KhFRf2jUbzMtKEnQJYPPl9jd3NGG6ls6nYN8Ze0FrsQkKyUPdmdoFOeZDp4OuPNxdpaPzwGXOUV9LAqL/74Xtv3br10ekz5y9dvHrh4lnOTcewafMOxmxKaY1BtGIn72ZXFVvDZGuc0gct+jlsjpI+nAFq9s7xcGwLSYuErb7Qo3kLpzioEHXDwzaA2vHGt8/i4t0oLT7x4H3MkRCHv/+9D9586/apM3Nnzi2cO7O4uMjRiEhhQKybfkj5ZPx6WMPG33nn1scfb+1sH5KzkruiRCVgMIODX/aOlufZ+zYtaGN4QtoYl6HyALGM4SLL+aoAdTHUiWtM3xw0XCcHMv6p2wDHADB9PqYK3DQiMzm2WZue6ho51NHAROwwUGB7AAvwW4Nrt89fuwIS54SCyfHFcFc9YCJwcZNx/2UNbHmp2J0g1K+Ic+IRBMVRjVcIgqYKhVvxKJHimMD0wurKuadevfHu9zlqyoyBqEc0dWJUgUR5UK+CmapI35oF/5iCeNSs/mQr1t2hZ6AijfEpRaEIC6q8AoA/bnqJV38/ZDZgvOZbmJg+qqalYdaCxVPmY6Ux/ZIwTACJQdx8sYJwsHX7xvbdmzcWl1bOXrhA2Tu/sEjckZLBExu3BgU5E2WV7REQEyNNNjkNNvyRg3meIFhdRtSYpsSzlTPmHChUJSmujIr5UoL4BvfRoBmHsmhVagti6S2mDjje2Rptbx++995DJhWwp2e315qfc+4R2etHHz+c7s7Q184Akv3sWgt3TJ+E4RrZUBjubq95HOOQTQXgRbqPr3AQ2rAgM8VfhnkD2rc4R9cGLHBsUWDFHU1aa0IXAAVYKaj4MEnOrNElf1Qi2N6s7wl8nWkk5KqMnogSo3JTdKDp2aWF1QtnSTL0HlXso4rgBYw3ccpSYc9n4bliMZ/xBCiyRWCkKoRKODEmEkpwIbXWohu4q+Qu2gKY2m5vdvrs0y/PLp/fv/eTAmFcFS7IKSd6w8LKIBN+9q5X/xJPxFoDwTX2TBSV9CLdKiPRKMFKOoAbrMCAYUvmSEFFDFz5zC+veUczZjWmBOs/jNiqXCkByVtlYUkDplE99daHnPvR2q1HD+688aPWzOzC6unTq6unXRG/sDA11aEMJBlxo5uOLlMLKEoDeEseCzlVQSMBTKRuygr2f3fSO1kzXUzMKk26oREMSYhBtsjIB19yoHLyF4HJNJIE8EGZhGZjDMAaR8eNQ/bbU6jCORlQ4/iA3YbRGlaYphIVr1RHQanUkfzWh7//9GtfZO+GqTl2LfaSE2/abvnwJa9RevjguzIFedMTvgo4n3rJhok1l5GpNDg73Dvfmj1sc/odm0B5sYcGFk4tiANhzFKoa9JGpqGADGiQPMKX+qnz5+aWl9A3546khIXDMCt3voUFaUApLjxRknT59+FfnmFRpwqFjn5NhIjPBEhFJTxAE+kEFFxtLMzNMR995dy1/fvvk/+BqAQ3jCT9TnLOq2aMYuJJdGogFVsBNIB+2CiQYdzUHteQjy+CxVt+Kp5EUj5xKxkE37qYFVGk6u0qEA9dItcHXlsBwIThi5dJRXJevBQGlAi5BqP9zYc3th59+JO3aQ0zIZcZufNUAWfnusyS7c6wzQEboUxNdzmYG0RkxJgbhiRaLqa3cMbc0TGFD9/iLsYvPWpJIfhYcX6HAwErnvANc7kJqvbhmOoEKjWAmtVceDNCiR4gEqm8wAfhlTKvQOD53h/+zpWXvjgz8/m5mVN+8y+87TfRlBvB+DAYOMtr8YhrBSYz8lfw0tgNH7qZp8iYlLkMxL5ubhBk47bFQUxHnHPH8l9q/ZzKjTiCAYg4roMpcdVYPHO6050hQdAg1lNeReXr5ItvX3X/oxxW0IV7JUsw2SX2+SaUTmJL8Nwm7AofdhIVoRjaooHJDmdUdDurF6/f/EPGMuzd0iNZURoqmJ3dDwQxsnjBHyhIKUeRwC9phGRu+IEppI23iCjeEyDUGkI44oo7FFWxTPpl1qGXmQjVd6ibCmP6+vEJP76hX0HKWwh4k58IkbyQD4nJjzxSP6JP92D70aO7mDEoTEFNeq8p07nbcCZmneJI6w9fPqFO3ZXl+tPM4J2Zb07P7G2uwyoyopAqAcTAxA+tXBFBPVTGg4xKIvdmgnqrwaK+8hH9ElhclXeEitDKVHAiNOl+XDt48Ae/9V/OdKbmup+fn5+n+yG6NJ5kIATgsfAU9njPn27l8gVolBtG7U5FeB3iISBE0zGOl7Fg7DCnv4PmmNPK8dS21Ck2mSZVDKKITPMqLQRJtlrzKyuJJZYOaxxgkcWKz4oDHqGaW0AqsAkzspQwoSNY0gTolMBvY6SoO0jCvWhRuFyBSHWXS83TbuVsupnu4qnz9ud4GoU4gk3TkALSVhkULpatUQJKDsbHHOhbSRAC+RSTGk+K0Dnk9SpC4af3BExrFgo1V+F4kfnKJYauDy+aPWag9YqhQgn+iiXx8B5x1FolVmCFiguhGAMAkK4fdqQIGrUbLKkDiEX0ZGjQIRS1XBry22tUx6i2WJYlAYRq0BoiJhVplaR8Rf3KQ0WBAehwYHBG2MxjrEWqbm8BBQ16qBQWJGoC3rjDEn0ILN3YufWD3/un46ODrWdf/tz84gorB9xyELaKzgsjMgAi8Oat0phiTfQTinxm9QT7hFC8U+CGtmAwzSPwACXXYGpWn21NKBU9oaPTdX4sEMSJ4+SYvqnF89DRLn2gC8srWAzORpjGc3KJviAPAT/jG57hSF3wCPpim0TDSei8QBbZcIx6iswENAygsMcrnhWlgj5kdBrTqpk+c54tpE/vrG0WCoDzR1Ro7sS8CjVWlBxCqRsDYckt9lCUkJQKb9IyDnwWd5MTnsZvYlAP6QihEfuSj8JrSQk6ozQfPPMfq7c+xDfnQvQ4xZuTzHIQerY0dL0GhS8dcUSU7Vsm9zAwyVlk7HR2cMTBr4xmloJadsONEsh3pHO4KezjoJB4xI+vmAv1W+DYTI+bMjA/X0hhy62C5mHoEn9BCRGYZnUhy2uc0Ix+bYDQcoyyJrBBo1qDsChFzFJVD8kRSgxxH482b77xu7++ffvG25effo2crDvDLMte1/NYPcvW5GZ2QQy6U6blmbqLyEyUyrwK6iqOyROhXsO9vQM+Y8RFesd9jQLEcVaDsco4NIftoVYcWXXOIIBr+5HDELnwKEwTptmYX1qGVyIaXpSMG96VkKCO8FVQvPBG4Mq74lXyuqoL/vX0O8QSY76LQucA5gXMuCdE8RUokHgnV2CtzxLHup69vLv2HjmA9iiIZJU61g8S0FgbJKzswx21QCJPLsvFu3j1NaSOwS+onwbkKq/J1v1QTzaeZJZ3oirYhdUzf2lc0as2xWG3p+k0nF9aWllYZbe6hYUeB36y80XbujuToZmpC8fGp6u06S2kvbrPWjA69yHNDmdbW5vuasNCk/XNzUcPNzY2OGcRFiKHksC7Cgs3sDARLoLhCT9uzgWBEtU6sH4sostzxBdfuBeNYuVTF1+ZSIwi7SHUFyezmfQbJK4A8RIB/oap1FmKQjRVXoIMPwogthj86Ce/c+fDH/wmawznls5N95ZnF0/NL5+Z7s31aOrQ/9XpkfrJgTklkjRg6UWxMxgeH+7T63qwv3N8yDauzONkBP74wzd/QESTVMm/VYflE2nVhjs7P+igK6wxg9U0Rl2RCiLjhjXGc5JUwr9wmDuxS7WyM9NDJppQVcSrYzWjiAL6lSsOOkph4hg1VA4FFLS+VNBVUELE18BiDYAvKnECO0ELUGbA27XF7gedzsIq8WCNHx+ipKJuuS96ogxX0r/I0zZUDZa0YuavGHlI+iqYaYa/fARh2C2f+IsXb3UUtPn2AyXhRXgzPFcOLq4snz17/szZi+fZ4uri5al2dzxiQjFxRGBq6s2pHidfLtTYK9pCKRweMzaxz/L2/V3YcdIepw10lqYWzjGMdDjiuBr6Fw8PHj5ae7C29uDePe6PHj6g01ExnfCgYLKXNGzeCFb7fnkY/VWU+V2NAyhp/AkWFvKhm7YiHBD8UQegIWheanloYjItWd7Kd3Ur9lFhIEvgj4DmRmgkaolbYcT4AOHxaO/+9v797ds/JGoZ0Hb1PibKJoZz8/RsUgK2p7oLC6sDhiDJlDkj/nB3d+MRI3zMqXCuM4ORzg2s3b/NFPAGc0RATLnAcC85CvzaFqL4kBc4I1dC9a4WYHefqAPm7DPF23gzKfhPnXGaXl6WESMBMiiNuigqLLjiVKRXA35qp/E0BngFsZrUs1Jvpe2iKj+EUtkCicycw4Baf+xCPZeoCERQAoQVsXptbmkF/lNlK1AhhpjhBdu3a4eSsxAJFYwCX1ELG3KQKDEZ2hCTm8k/uoGXcMC9WLlJC1fSF/d4+YWaKKkXlhbOnbtw5erVq09dn1tcpqGKrTOlhBFG9MuUhIzmMjxF1/n2oDWTWecIwYSUNkcLH+9vZPNQeJI/9iVodhZb0zN0JLGdDaNedABcXpi/8tRT5IWHBwdr9+/fuX2L/3t37rL+lijXSmHHLv8MdZTaUdi0EhElg7mqApX4KUJE6QgeNQiYOEzUYL50hFCDQgGMBqBEKx9yaBwa0WotKi2a46P6hReVhYvqM5xFlywSlpa6HONOrYr5Hsdu0jY4fLC1USLRkbWHRlRmuloQsB+tc3jCKEhMhgzlMLjpFAdbvvJCEcngCJP5qT0BS2KAOqbtWjBYxy50t6ww4qChRKAiVeDGj000OuwrCfcWX5VoOBcZlS6XLpVKo63qHTBFFaiYvDKXMD4SSk2IQ0kCXFCWzMtgQVEQCAhT6k99qm+G9slll1fGTP1l3CcAIsofyRi81oMIEDagEtaJAyWUlkj9SJmnY5VwxOUVTAJJ0xv0I4W8+emoLjaWSOSQzwvnz19/6tr1515YXj1bTrVhvHZUgz0WgnAmDVUQtglhom4774Pjo/V6Y4MZDfQzw/ARAwBs6UgxzsJfZ33SjZqYYIU7hzixNkAG2YfHtgTTMRi9ZgH6paWVK69+jnry7sP79z56/4MPfnLzxkcHuztOPDAl2BapUjsBYVrJld31AArtN5opWUB0g5OO6qOA+qT54LdLoUj8Q8zSbpRiKkLFswoSxSWQFLEqyXL55AVzNLSyEUfWVCBeWPFObs5d//ylFc+bCqc4c9VD4SvmBfJEL/xRO8pAOAZNSMg54uUEaIb8qgQG3jKfi1TiGsnCFTMj2KkgdmGRYd4dhUyxDxlE8QrjBA7hKCXyhqsIHgVwgxetjEBhV47DuLasB1cJrmzl47EtloAA6iMG9TChNgHGIwkD+ZwXNDO3SN5ZG+zJaMKZOiQePCUNBQc35Sq+YTLvqsqA+FkISNPPwoUBSzieioAiKh90ooFSCnVPncXu2d/k/KmVeSafj9szFE3OvMLWmSHH8fGWQ4Rkpys6bY/ZYIeciKErT2g1D2I9KmPRmD09+tPMpi5cMjJPtDFc5Xai1BQyiYOOGJnlplmRukjjRhPLNuiyWz619MxnvrizsXHn/Xd+71u/ub62hixYFIyqcE3RgLqlFwihkRfOSlYsXQWM1lRB8YtCDBgzwF2yDinI+5PqEq8qi/ogG/NR8OgRMwphbrBBPUM6YNDVCyB+JSXItCoPaWJTfrVMSm5eEwUaeaEkVghb2rEhKrzZacPcWta7WGDhpQdY8MD8KQoyH8VphngbFEJo10QSy1EDxFCKB3k7EUpK1Qegkp9cT7zLpWiqixc9lVIxdPfbd14quLwkoJGkTcKD5TjkgfMSzwRpgbFx0uh25twooaICjNxW2uSlomdEBpV981E1XlHgJOBEyoqlQgmCxnnRUnhQjVqk9eHm9OyzL73+zHMvrJxanJ2ZoqO4zYxLBGD6+c76uNvjMNbG8UYL2+ZwCrcDdLSRIpxIQOUpOeABb/NA2+b0zLV6VPrZwNqCXLtXhtHowGSTfAjq1A+IR9myGtZ1FsRwhyh1ll6jU5+emz09++q5C6tnV/7x/+2/3Hj0CBqUOcYjg8ZmvEY3mnLbRw1ZlqNxZUP7URZkuSI9APHXEynM/p0tJpy/ElmCV0ozYGw+oTFHKYiDW/yMH5OvThR3YNCq40bIJKvCU4kyQslURvFJhDYBQ4FQkinCgIQuCdyxb6uTVn2c64HAqjJ5PZ+HDAUP2N6LGaBMSE01rhAhTyGbCqvyYhajuChavqSnoP7xHgYqcfF5wqH4ACRYAvkmBLLGSQiRVN/hXo+E1MPSOl/RIUqz/mAQpSvCGm1cAJrOO4z9mCEKI3/xwU963iquTd/Kp6vUw4hfk3jhTZSGqBwFkYt8+5b0wBf1zF6n/cqnPn3+6gvsMNapHTEBH1/smsoM2S39hWxG4tpZJ8kwXYEDB4wErJ89qti9jQ58CjBYZSGGmQ9dEZgmOdWA+WRU9mXGY4xlgVe8QEVHjuxZnstSivXUbvik8IdR5quOjnbpr2R66tlLT/3iL/38D773rY8/vLO3x7oZShRG9FO9iJL+P+OMcGh/FZSsAAAAAElFTkSuQmCC",
-      "text/plain": [
-       ""
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind him, Mrs.      \n",
-       "Mortimer's surprised expression captures the moment of unexpected enchantment.                                     \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "The gingerbread man mid-air, his icing buttons glistening, as he leaps off a wooden counter. Behind him, Mrs.      \n",
-       "Mortimer's surprised expression captures the moment of unexpected enchantment.                                     \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
A lively winter scene featuring children wearing colorful scarves and mittens as they pause from their snow-play to\n",
-       "gape at the gingerbread man sprinting past.                                                                        \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "A lively winter scene featuring children wearing colorful scarves and mittens as they pause from their snow-play to\n",
-       "gape at the gingerbread man sprinting past.                                                                        \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking towards the       \n",
-       "gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.               \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "A startled farmer in woolen attire stands in his snowy field, sheep surrounding him, all looking towards the       \n",
-       "gingerbread man as he speeds by. The sky is a brilliant blue, contrasting the white expanse of snow.               \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the gingerbread man     \n",
-       "precariously poised on his nose, steam rising subtly from the flowing water.                                       \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "A serene, yet suspenseful river scene. The fox, with his fur glistening, stands mid-river, the gingerbread man     \n",
-       "precariously poised on his nose, steam rising subtly from the flowing water.                                       \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
+       "The fox, licking his lips, ambled along the river, savoring his victory, leaving an air of mystery hovering above  \n",
+       "the shimmering waters, where the memory of the Gingerbread Man's spirited run lingered long after.                 \n"
       ]
      },
      "metadata": {},
@@ -875,26 +735,11 @@
     {
      "data": {
       "text/html": [
-       "
Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, daylight fading  \n",
-       "outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while crumbs of the   \n",
-       "day's adventures seem to linger, cherished in memory.                                                              \n",
+       "
                                                       User:                                                       \n",
        "
\n"
       ],
       "text/plain": [
-       "Back in the cozy kitchen, Mrs. Mortimer is busy baking once again. The room is warm and inviting, daylight fading  \n",
-       "outside, leaving a gentle glow inside. On the counter, gingerbread dough waits to be formed, while crumbs of the   \n",
-       "day's adventures seem to linger, cherished in memory.                                                              \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
+       "                                                       \u001b[1mUser:\u001b[0m                                                       \n"
       ]
      },
      "metadata": {},
@@ -916,45 +761,91 @@
     {
      "data": {
       "text/html": [
-       "
The story is charming and well-written, and the illustrations capture the essence of each scene beautifully. Here  \n",
-       "are a few suggestions to enhance the final presentation:                                                           \n",
-       "\n",
-       " 1 Coherence and Flow:                                                                                             \n",
-       "    • Make sure the illustrations follow the storyline smoothly. Check if each image matches the narrative context.\n",
-       " 2 Illustration Details:                                                                                           \n",
-       "    • In the second illustration, focus on making the gingerbread man’s leap dynamic yet clear, emphasizing Mrs.   \n",
-       "      Mortimer’s surprise.                                                                                         \n",
-       "    • The third illustration with the children can have a bit more focus on their expressions of amazement.        \n",
-       " 3 Consistency:                                                                                                    \n",
-       "    • Ensure that the style of all illustrations is consistent from beginning to end to maintain a cohesive look.  \n",
-       " 4 Final Scene:                                                                                                    \n",
-       "    • The cozy kitchen scene could use more warmth—soft lighting and gentle shadows can add to the nostalgia.      \n",
-       " 5 Text Placement:                                                                                                 \n",
-       "    • Consider how text might integrate with the illustrations for a seamless experience. Ensure there's space for \n",
-       "      the text without overlapping important visual details.                                                       \n",
-       "\n",
-       "Implement these suggestions for refinement. Let me know when the revisions are ready!                              \n",
+       "
Thank you for submitting the draft and illustrations for the short story, \"The Escape of the Gingerbread Man.\"     \n",
+       "Let's go through the story and illustrations critically:                                                           \n",
+       "\n",
+       "                                                  Story Feedback:                                                  \n",
+       "\n",
+       " 1 Plot & Structure:                                                                                               \n",
+       "    • The story follows the traditional gingerbread man tale closely, which might appeal to readers looking for a  \n",
+       "      classic retelling. Consider adding a unique twist or additional layer to make it stand out.                  \n",
+       " 2 Character Development:                                                                                          \n",
+       "    • The gingerbread man is depicted with a cheeky personality, which is consistent throughout. However, for the  \n",
+       "      old woman, cow, horse, and fox, incorporating a bit more personality might enrich the narrative.             \n",
+       " 3 Pacing:                                                                                                         \n",
+       "    • The story moves at a brisk pace, fitting for the short story format. Ensure that each scene provides enough  \n",
+       "      space to breathe, especially during the climactic encounter with the fox.                                    \n",
+       " 4 Tone & Language:                                                                                                \n",
+       "    • The tone is playful and suitable for a fairy-tale audience. The language is accessible, though some richer   \n",
+       "      descriptive elements could enhance the overall atmosphere.                                                   \n",
+       " 5 Moral/Lesson:                                                                                                   \n",
+       "    • The ending carries the traditional moral of caution against naivety. Consider if there are other themes you  \n",
+       "      wish to explore or highlight within the story.                                                               \n",
+       "\n",
+       "                                              Illustration Feedback:                                               \n",
+       "\n",
+       " 1 Illustration 1: A Rustic Kitchen Scene                                                                          \n",
+       "    • The visual captures the essence of a cozy, magical kitchen well. Adding small whimsical elements that hint at\n",
+       "      the gingerbread man’s impending animation might spark more curiosity.                                        \n",
+       " 2 Illustration 2: A Frolic Through the Meadow                                                                     \n",
+       "    • The vibrant colors and dynamic composition effectively convey the chase scene. Make sure the sense of speed  \n",
+       "      and energy of the Gingerbread Man is accentuated, possibly with more expressive motion lines or postures.    \n",
+       " 3 Illustration 3: A Bridge Over a Sparkling River                                                                 \n",
+       "    • The river and reflection are beautifully rendered. The fox, however, could benefit from a more cunning       \n",
+       "      appearance, with sharper features that emphasize its sly nature.                                             \n",
+       "\n",
+       "                                                    Conclusion:                                                    \n",
+       "\n",
+       "Overall, the draft is well-structured, and the illustrations complement the story effectively. With slight         \n",
+       "enhancements in the narrative's depth and character detail, along with minor adjustments to the illustrations, the \n",
+       "project will meet the user's requirements admirably.                                                               \n",
+       "\n",
+       "Please make the suggested revisions, and once those are implemented, the story should be ready for approval. Let me\n",
+       "know if you have any questions or need further guidance!                                                           \n",
        "
\n"
       ],
       "text/plain": [
-       "The story is charming and well-written, and the illustrations capture the essence of each scene beautifully. Here  \n",
-       "are a few suggestions to enhance the final presentation:                                                           \n",
-       "\n",
-       "\u001b[1;33m 1 \u001b[0m\u001b[1mCoherence and Flow\u001b[0m:                                                                                             \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mMake sure the illustrations follow the storyline smoothly. Check if each image matches the narrative context.\n",
-       "\u001b[1;33m 2 \u001b[0m\u001b[1mIllustration Details\u001b[0m:                                                                                           \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mIn the second illustration, focus on making the gingerbread man’s leap dynamic yet clear, emphasizing Mrs.   \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mMortimer’s surprise.                                                                                         \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe third illustration with the children can have a bit more focus on their expressions of amazement.        \n",
-       "\u001b[1;33m 3 \u001b[0m\u001b[1mConsistency\u001b[0m:                                                                                                    \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mEnsure that the style of all illustrations is consistent from beginning to end to maintain a cohesive look.  \n",
-       "\u001b[1;33m 4 \u001b[0m\u001b[1mFinal Scene\u001b[0m:                                                                                                    \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe cozy kitchen scene could use more warmth—soft lighting and gentle shadows can add to the nostalgia.      \n",
-       "\u001b[1;33m 5 \u001b[0m\u001b[1mText Placement\u001b[0m:                                                                                                 \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mConsider how text might integrate with the illustrations for a seamless experience. Ensure there's space for \n",
-       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mthe text without overlapping important visual details.                                                       \n",
-       "\n",
-       "Implement these suggestions for refinement. Let me know when the revisions are ready!                              \n"
+       "Thank you for submitting the draft and illustrations for the short story, \"The Escape of the Gingerbread Man.\"     \n",
+       "Let's go through the story and illustrations critically:                                                           \n",
+       "\n",
+       "                                                  \u001b[1mStory Feedback:\u001b[0m                                                  \n",
+       "\n",
+       "\u001b[1;33m 1 \u001b[0m\u001b[1mPlot & Structure:\u001b[0m                                                                                               \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe story follows the traditional gingerbread man tale closely, which might appeal to readers looking for a  \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mclassic retelling. Consider adding a unique twist or additional layer to make it stand out.                  \n",
+       "\u001b[1;33m 2 \u001b[0m\u001b[1mCharacter Development:\u001b[0m                                                                                          \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe gingerbread man is depicted with a cheeky personality, which is consistent throughout. However, for the  \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mold woman, cow, horse, and fox, incorporating a bit more personality might enrich the narrative.             \n",
+       "\u001b[1;33m 3 \u001b[0m\u001b[1mPacing:\u001b[0m                                                                                                         \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe story moves at a brisk pace, fitting for the short story format. Ensure that each scene provides enough  \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mspace to breathe, especially during the climactic encounter with the fox.                                    \n",
+       "\u001b[1;33m 4 \u001b[0m\u001b[1mTone & Language:\u001b[0m                                                                                                \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe tone is playful and suitable for a fairy-tale audience. The language is accessible, though some richer   \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mdescriptive elements could enhance the overall atmosphere.                                                   \n",
+       "\u001b[1;33m 5 \u001b[0m\u001b[1mMoral/Lesson:\u001b[0m                                                                                                   \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe ending carries the traditional moral of caution against naivety. Consider if there are other themes you  \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mwish to explore or highlight within the story.                                                               \n",
+       "\n",
+       "                                              \u001b[1mIllustration Feedback:\u001b[0m                                               \n",
+       "\n",
+       "\u001b[1;33m 1 \u001b[0m\u001b[1mIllustration 1: A Rustic Kitchen Scene\u001b[0m                                                                          \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe visual captures the essence of a cozy, magical kitchen well. Adding small whimsical elements that hint at\n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mthe gingerbread man’s impending animation might spark more curiosity.                                        \n",
+       "\u001b[1;33m 2 \u001b[0m\u001b[1mIllustration 2: A Frolic Through the Meadow\u001b[0m                                                                     \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe vibrant colors and dynamic composition effectively convey the chase scene. Make sure the sense of speed  \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mand energy of the Gingerbread Man is accentuated, possibly with more expressive motion lines or postures.    \n",
+       "\u001b[1;33m 3 \u001b[0m\u001b[1mIllustration 3: A Bridge Over a Sparkling River\u001b[0m                                                                 \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m • \u001b[0mThe river and reflection are beautifully rendered. The fox, however, could benefit from a more cunning       \n",
+       "\u001b[1;33m   \u001b[0m\u001b[1;33m   \u001b[0mappearance, with sharper features that emphasize its sly nature.                                             \n",
+       "\n",
+       "                                                    \u001b[1mConclusion:\u001b[0m                                                    \n",
+       "\n",
+       "Overall, the draft is well-structured, and the illustrations complement the story effectively. With slight         \n",
+       "enhancements in the narrative's depth and character detail, along with minor adjustments to the illustrations, the \n",
+       "project will meet the user's requirements admirably.                                                               \n",
+       "\n",
+       "Please make the suggested revisions, and once those are implemented, the story should be ready for approval. Let me\n",
+       "know if you have any questions or need further guidance!                                                           \n"
       ]
      },
      "metadata": {},
@@ -976,15 +867,23 @@
     {
      "data": {
       "text/html": [
-       "
A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. An elderly baker,    \n",
-       "Mrs. Mortimer, with rosy cheeks and glasses, is seen rolling out dough with focused determination. Snow gently     \n",
-       "blankets the world outside the window.                                                                             \n",
+       "
{\n",
+       "    'character_appearence': 'An elderly woman with flour-dusted hands shaping gingerbread dough. Sunlight casts a \n",
+       "golden hue in the cozy kitchen, with rustic decorations and trinkets on shelves.',\n",
+       "    'style_attributes': 'Photo-realistic with warm and golden hues.',\n",
+       "    'worn_and_carried': 'The woman wears a flour-covered apron and a gentle smile.',\n",
+       "    'scenario': 'An old woman baking gingerbread in a warm, rustic cottage kitchen.'\n",
+       "}\n",
        "
\n"
       ],
       "text/plain": [
-       "A warm, rustic kitchen filled with jars of spices and the soft glow of a crackling fireplace. An elderly baker,    \n",
-       "Mrs. Mortimer, with rosy cheeks and glasses, is seen rolling out dough with focused determination. Snow gently     \n",
-       "blankets the world outside the window.                                                                             \n"
+       "\u001b[1m{\u001b[0m\n",
+       "    \u001b[32m'character_appearence'\u001b[0m: \u001b[32m'An elderly woman with flour-dusted hands shaping gingerbread dough. Sunlight casts a \u001b[0m\n",
+       "\u001b[32mgolden hue in the cozy kitchen, with rustic decorations and trinkets on shelves.'\u001b[0m,\n",
+       "    \u001b[32m'style_attributes'\u001b[0m: \u001b[32m'Photo-realistic with warm and golden hues.'\u001b[0m,\n",
+       "    \u001b[32m'worn_and_carried'\u001b[0m: \u001b[32m'The woman wears a flour-covered apron and a gentle smile.'\u001b[0m,\n",
+       "    \u001b[32m'scenario'\u001b[0m: \u001b[32m'An old woman baking gingerbread in a warm, rustic cottage kitchen.'\u001b[0m\n",
+       "\u001b[1m}\u001b[0m\n"
       ]
      },
      "metadata": {},
@@ -992,8 +891,8 @@
     },
     {
      "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
+      "image/jpeg": "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",
+      "image/png": "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",
       "text/plain": [
        ""
       ]
@@ -1004,13 +903,21 @@
     {
      "data": {
       "text/html": [
-       "
A gingerbread man leaps off a wooden counter, icing buttons glistening, while Mrs. Mortimer looks on in surprise.  \n",
-       "The kitchen backdrop is filled with pots and pans, and a window shows snow falling outside.                        \n",
+       "
{\n",
+       "    'character_appearence': 'A gingerbread man with bright bead-like eyes and a wide smile, running joyfully.',\n",
+       "    'style_attributes': 'Photo-realistic with vibrant and lively colors.',\n",
+       "    'worn_and_carried': 'The gingerbread man has white icing features and a cheeky appearance.',\n",
+       "    'scenario': 'The gingerbread man running through a colorful meadow, followed by an old woman, cow, and horse.'\n",
+       "}\n",
        "
\n"
       ],
       "text/plain": [
-       "A gingerbread man leaps off a wooden counter, icing buttons glistening, while Mrs. Mortimer looks on in surprise.  \n",
-       "The kitchen backdrop is filled with pots and pans, and a window shows snow falling outside.                        \n"
+       "\u001b[1m{\u001b[0m\n",
+       "    \u001b[32m'character_appearence'\u001b[0m: \u001b[32m'A gingerbread man with bright bead-like eyes and a wide smile, running joyfully.'\u001b[0m,\n",
+       "    \u001b[32m'style_attributes'\u001b[0m: \u001b[32m'Photo-realistic with vibrant and lively colors.'\u001b[0m,\n",
+       "    \u001b[32m'worn_and_carried'\u001b[0m: \u001b[32m'The gingerbread man has white icing features and a cheeky appearance.'\u001b[0m,\n",
+       "    \u001b[32m'scenario'\u001b[0m: \u001b[32m'The gingerbread man running through a colorful meadow, followed by an old woman, cow, and horse.'\u001b[0m\n",
+       "\u001b[1m}\u001b[0m\n"
       ]
      },
      "metadata": {},
@@ -1018,8 +925,8 @@
     },
     {
      "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
+      "image/jpeg": "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",
+      "image/png": "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",
       "text/plain": [
        ""
       ]
@@ -1030,13 +937,21 @@
     {
      "data": {
       "text/html": [
-       "
Children in colorful scarves and mittens, pausing their snow-play, gaze in amazement as a gingerbread man rushes   \n",
-       "past. The scene is lively with snowmen and a snow-draped village setting.                                          \n",
+       "
{\n",
+       "    'character_appearence': 'A sly fox with cunning eyes, engaging with the gingerbread man.',\n",
+       "    'style_attributes': 'Photo-realistic with a focus on sly and clever features.',\n",
+       "    'worn_and_carried': 'The fox has sharp features and a lolled tail.',\n",
+       "    'scenario': 'The gingerbread man on a wooden bridge, facing a sly fox by a sparkling river under sunlight.'\n",
+       "}\n",
        "
\n"
       ],
       "text/plain": [
-       "Children in colorful scarves and mittens, pausing their snow-play, gaze in amazement as a gingerbread man rushes   \n",
-       "past. The scene is lively with snowmen and a snow-draped village setting.                                          \n"
+       "\u001b[1m{\u001b[0m\n",
+       "    \u001b[32m'character_appearence'\u001b[0m: \u001b[32m'A sly fox with cunning eyes, engaging with the gingerbread man.'\u001b[0m,\n",
+       "    \u001b[32m'style_attributes'\u001b[0m: \u001b[32m'Photo-realistic with a focus on sly and clever features.'\u001b[0m,\n",
+       "    \u001b[32m'worn_and_carried'\u001b[0m: \u001b[32m'The fox has sharp features and a lolled tail.'\u001b[0m,\n",
+       "    \u001b[32m'scenario'\u001b[0m: \u001b[32m'The gingerbread man on a wooden bridge, facing a sly fox by a sparkling river under sunlight.'\u001b[0m\n",
+       "\u001b[1m}\u001b[0m\n"
       ]
      },
      "metadata": {},
@@ -1044,8 +959,8 @@
     },
     {
      "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
+      "image/jpeg": "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",
+      "image/png": "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",
       "text/plain": [
        ""
       ]
@@ -1056,50 +971,11 @@
     {
      "data": {
       "text/html": [
-       "
A startled farmer in winter attire stands in a snowy field with sheep looking towards the gingerbread man as he    \n",
-       "speeds by. The sky is bright blue against the white snow landscape.                                                \n",
-       "
\n"
-      ],
-      "text/plain": [
-       "A startled farmer in winter attire stands in a snowy field with sheep looking towards the gingerbread man as he    \n",
-       "speeds by. The sky is bright blue against the white snow landscape.                                                \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "
A serene river scene with a fox standing in the water, his fur glistening, while a gingerbread man is poised on his\n",
-       "nose. The icy water flows gently around them.                                                                      \n",
+       "
                                                      Writer:                                                      \n",
        "
\n"
       ],
       "text/plain": [
-       "A serene river scene with a fox standing in the water, his fur glistening, while a gingerbread man is poised on his\n",
-       "nose. The icy water flows gently around them.                                                                      \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "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",
-      "image/png": "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",
-      "text/plain": [
-       ""
+       "                                                      \u001b[1mWriter:\u001b[0m                                                      \n"
       ]
      },
      "metadata": {},
@@ -1108,24 +984,157 @@
     {
      "data": {
       "text/html": [
-       "
A cozy kitchen with Mrs. Mortimer baking again. The room is warm and inviting with the daylight fading outside.    \n",
-       "Fresh gingerbread dough is on the counter, capturing a nostalgic and warm atmosphere.                              \n",
+       "
Certainly! Here’s the final version of the short story with the enhanced illustrations for \"The Escape of the      \n",
+       "Gingerbread Man.\"                                                                                                  \n",
+       "\n",
+       "Title: The Escape of the Gingerbread Man                                                                           \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Illustration 1: A Rustic Kitchen Scene In a quaint little cottage at the edge of an enchanted forest, an elderly   \n",
+       "woman, with flour-dusted hands, carefully shapes gingerbread dough on a wooden counter. The aroma of ginger,       \n",
+       "cinnamon, and cloves wafts through the air as a warm breeze from the open window dances with fluttering curtains.  \n",
+       "The sunlight gently permeates the cozy kitchen, casting a golden hue over the flour-dusted surfaces and the rolling\n",
+       "pin. Heartfelt trinkets and rustic decorations adorn the shelves—a sign of a lived-in, lovingly nurtured home.     \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Story:                                                                                                             \n",
+       "\n",
+       "Once there was an old woman who lived alone in a charming cottage, her days filled with the joyful art of baking.  \n",
+       "One sunny afternoon, she decided to make a special gingerbread man to keep her company. As she shaped him tenderly \n",
+       "and placed him in the oven, she couldn't help but smile at the delight he might bring.                             \n",
+       "\n",
+       "But to her astonishment, once she opened the oven door to check on her creation, the gingerbread man leapt out,    \n",
+       "suddenly alive. His eyes were bright as beads, and his smile cheeky and wide. \"Run, run, as fast as you can! You   \n",
+       "can't catch me, I'm the Gingerbread Man!\" he laughed, darting towards the door.                                    \n",
+       "\n",
+       "The old woman, chuckling at the unexpected mischief, gave chase, but her footsteps were slow with the weight of    \n",
+       "age. The Gingerbread Man raced out of the door and into the sunny afternoon.                                       \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Illustration 2: A Frolic Through the Meadow The Gingerbread Man darts through a vibrant meadow, his arms swinging  \n",
+       "joyously by his sides. Behind him trails the old woman, her apron flapping in the wind as she gently tries to catch\n",
+       "up. Wildflowers of every color bloom vividly under the radiant sky, painting the scene with shades of nature's     \n",
+       "brilliance. Birds flit through the sky and a stream babbles nearby, oblivious to the chase taking place below.     \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Continuing his sprint, the Gingerbread Man encountered a cow grazing peacefully. Intrigued, the cow trotted        \n",
+       "forward. \"Stop, Gingerbread Man! I wish to eat you!\" she called, but the Gingerbread Man only twirled in a teasing \n",
+       "jig, flashing his icing smile before darting off again.                                                            \n",
+       "\n",
+       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, leaving the cow in his    \n",
+       "spicy wake.                                                                                                        \n",
+       "\n",
+       "As he zoomed across the meadow, he spied a cautious horse in a nearby paddock, who neighed, \"Oh! You look          \n",
+       "delicious! I want to eat you!\" But the Gingerbread Man only laughed, his feet barely touching the earth. The horse \n",
+       "joined the trail, hooves pounding, but even he couldn't match the Gingerbread Man's pace.                          \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "Illustration 3: A Bridge Over a Sparkling River Arriving at a wooden bridge across a shimmering river, the         \n",
+       "Gingerbread Man pauses momentarily, his silhouette against the glistening water. Sunlight sparkles off the water's \n",
+       "soft ripples casting reflections that dance like small constellations. A sly fox emerges from the shadows of a     \n",
+       "blooming willow on the riverbank, his eyes alight with cunning and curiosity.                                      \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "The Gingerbread Man bounded onto the bridge and skirted past a sly, watching fox. \"Foolish Gingerbread Man,\" the   \n",
+       "fox mused aloud, \"you might have outrun them all, but you can't possibly swim across that river.\"                  \n",
+       "\n",
+       "Pausing, the Gingerbread Man considered this dilemma. But the fox, oh so clever, offered a dangerous solution.     \n",
+       "\"Climb on my back, and I'll carry you across safely,\" he suggested with a sly smile.                               \n",
+       "\n",
+       "Gingerbread thought himself smarter than that but hesitated, fearing the water or being pursued by the tired,      \n",
+       "hungry crowd now gathering. \"Promise you won't eat me?\" he ventured.                                               \n",
+       "\n",
+       "\"Of course,\" the fox reassured, a gleam in his eyes that the others pondered from a distance.                      \n",
+       "\n",
+       "As they crossed the river, the gingerbread man confident on his ride, the old woman, cow, and horse hoped for his  \n",
+       "safety. Yet, nearing the middle, the crafty fox tilted his chin and swiftly snapped, swallowing the gingerbread man\n",
+       "whole.                                                                                                             \n",
+       "\n",
+       "Bewildered but awed by the clever twist they had witnessed, the old woman hung her head while the cow and horse    \n",
+       "ambled away, pondering the fate of the boisterous Gingerbread Man.                                                 \n",
+       "\n",
+       "The fox, licking his lips, ambled along the river, savoring his victory, leaving an air of mystery hovering above  \n",
+       "the shimmering waters, where the memory of the Gingerbread Man's spirited run lingered long after.                 \n",
+       "\n",
+       "───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "I hope you enjoy the enhanced version of the tale!                                                                 \n",
        "
\n"
       ],
       "text/plain": [
-       "A cozy kitchen with Mrs. Mortimer baking again. The room is warm and inviting with the daylight fading outside.    \n",
-       "Fresh gingerbread dough is on the counter, capturing a nostalgic and warm atmosphere.                              \n"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAEAAQADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDz4atZ4/j/ACp66tZ/32H1Worfwpq90NyWoC+ryKv8zVz/AIQTWBn5YODg4nU4rzv7Pv0Z6X19Lqho1Ozb/lsB9QakS+tD0nT86mi+HWuyruWKLHrv4rN1jwtqGiFBdKhLc4jbcR9amWXcqu7mkcdzOysaS3VqTjz0P41n6u8Ze32OrcNnBzWI0bL1Uj8KhaV4iSo59xU08GoyUky6mKbjZorx8XSf74/nXdMcVwcR/fqT13Cu5Zsk808xWsScA9JATXH3v/H7N/vn+ddaTXI3n/H7P/vn+dTgF7zLxj91DUPFTRnioI+lSpXfJHJBlgHipoD8pquOlS25+U1hJaG8XqXYDiTFdl4CP/Exuv8Arkv/AKFXFxH5xXY+BGxqVz/1xH/oQrlzBf8ACfU/rqjehrWijrfEWqzWSWtraY+1XkvloTztHc1Xm8J2l1d21xPc3EzRHLCRshz/AEqn4pb7Nqmkak4PkQSlZG/u571R18Na3ltqFhezefPKq7Fk3Kw9h0r5rD0pclNUpcrknd+fby0Oypa83NXStp+v3neggAAdBS7q85k1PVLCbUYIroskSrITIMnnqB6VZudbv3tYFt7kx+XCrMSMmQkgVg8rndWkrP8AyuV7eOt1sd9u96Xf71w0+valaNcI8iu0M0aghMZBHNH/AAk960ctwu3YGdVQjpgA9az/ALNrPVWK9rDZnc76RpAqlmOAOprh4vFt4Y7RmjjPmn5gD7gcfnWt4lupY9AmaNipbAJ9s81nLAVIVIwnpd2GpxlFyj0JJvFMSXccS2dy8TttEyr8tbPmAjNYE+qwaTZ2geF2R1CgoMgHFU7jxfawu4aKTCkrnHcVq8JKol7KD/zKUoQvzyOgutQgtTGJX2mRtq+5pk0o2muL1TxDbXslo/lSgRSb2yvQV0UV4l3aJOmdjjIzVTwcqUYyktzWjUhOTUXsZkrZmb61c0s/8TCH61nuf3hq/pPOow/Wvt6fwo+XqfEz0ezPyrWvC3FY1oeBWrCeBXWjke58dSTyCVmXcFJyAG6Uq3soGNz/AEzW2LSD/nmKetnBnPliuf66dP1Mzba/vywEM06+mHIrotIvNQtLsXc0peVeBvO7I96rRQoh+VQKsA4rmr4yclyx0R00MJCLUnujom8V3bjm3tj9YxVaTXppc7rW1/79CsjNAPNcXNI9C9yLVIo9TkWR4YonX+KJAtPL9acelRMOapzlOyk9jNQUW2uo7dXLXn/H7N/vn+ddMSK5i8P+mzf75rswS95nLi37qGx9KlSoEqVDXbI5ok4PFS25+U1COlSwcKaxktDeO5ciPziuu8CtjVbgesP9RXHRH5xXWeCGxrMvvB/UVzY9f7DU/rsdOG/jRPQ5o454jHKiujDBVhkGqFroemWc3m29pGknZgOn0q4XpA9fDxlOKai9Ge86aerRVl0azmE+9CTMoVznqBXJ6rawLr9vbDKCBYxEo/j+auuvb9LKEOwLMxwqjqTWbDtvdRWeSJVliH6Gu3C1alO85bW/r/I561GM/dW5dl0O1nlklctukdXbnuvSo38O2bPIQXVXJJQHjJGDWLHqs/8AZV4BMxlExjRieRk8V0lijw2caPIZGC8sx5NRU9tSWsvIcFTqbLzKcfhyzjlhcFv3X3R+Oa07m3jurZ4JRlGGCKXdVHVr02mnSOv3z8qfU8CseerVmk3dmvJGEXZaGZLoU11Esf8AacjQxHMa4HBHTPrVY+FBIMz3TOxkLtgYBzW9Yx+RZRRnqF5+tSO+K6Fi60HaMvyJWEpS1kjl5fDBJwbk7c4wB/D6VpWkDWWnrbs+/YMAn0q+78VUnf5DVuvVqpRm7lww9Om7xRnsfnNaGjnOpQ/Ws0n5q0dF/wCQlF9a+vhsj5Kp8TPRrXoK1ITWVbHgVpRHiu1HJLc+YVNSLzWf/aduOzflSjVoR/A/5V5To1Ox6yqw7mooxTqyv7Xj7ROaDq4PSB6j6vU7F+2prqaoNKDWSNVboLWQ08ahct92xmP0Bo+rVOw/bw7mmTkUwg1UWbUX+5pk5/4CamWHWZPu6VL+JxTWHmtxOvFikEGuavP+Pyb/AHjXVLpuvSHb/Zqr7tKBXLX8UsN/NHOgSVXIZQc4NdeGg4ydzmxE1JKxEhqVaiWpFrpkYRZMDxUkJ4qHtUkR4rNo2TLcR+cV1Pgpv+J5J/1wP8xXJwn566jwa2Nbb/rgf5iufHL/AGKodOFf7+PqehlqQNUDSUnmD1r4flPpSlqw3XMDFsBQSCRkZpICtpb3FzI+Rgkt61dcpIBvANNkWGSPy3VSnoa3U/dUWjNwd20ciYJENqy5xK5kYe45qdtcvUjjRHLOzHt0rptsHy/Ivy9Pajy7fIIRMj2rqeLjL44XOVYOUfglY5YazqKKzB3Iyeo71FPq17csvmKXEbbgoHfoK6/EP91KT9wD0QU1iqad/ZjeEqNW9ocv/bOpIgkbJQjG3HIxU1rq9xd31pCpO1gS59a6CRoAhwEPHSsfTVU3b3E6Rw7cqi57etNVac4N8lhexqwnFc97m0/AxVKdvlNPmvIP+eyf99VnzXkBBHnJn61z0qcr7HdOSS3DPzVp6J/yEoqywc81q6GP+JlHX2ENkfHT3Z6FbngVoxnis236CtCM8V1o5WfNsXiOyjGBo9mx9THU48UxqP3ejWQ9/KFcmq/OMdjWkqfKKwa8zb2r7I2v+Etmzxp9qv0iFI3jGWIgNaqCf7qCsgpmqV+Cmwikopvf8Q9vLy+46X/hOJMY+zn/AMdH9KX/AITK5ZMiAgf7w/wrjAxPer0X/HqT/tCiVKI1iJ/0jek8XXnaIfixqOPxHfXBI2oMfU1gvyatacuXf6UvZQ7Cdep3NR9XvT/Eg+grF1BTNI1xIxMjda0mQVTvkxBVRhGLukZurOWkmZqID3qdIQWxuNQxgjmrI4Jq2xJsc1vgcMarzM0GNp6+taQXMYrO1EbdlEdWDk+41LmQJuzzVm01y8065863YK5XbyM8VmqSQBSyjkVcoRkuWS0CNWcXdPU3x4x1l+s6j6LTD4u1kn/j5A/4CKxox0ppHJrD6nh19hfca/W8R/O/vNs+KdYKA/ajk/7IqM+JtXP/AC9t+VZZ4jT8aB0prC0P5F9wfWa387+80X8Rav8A8/jVH/b+qsebySqDDLAChRh6pYeivsr7g9vVf2n95qDVtRZebuX86P7QvT1upf8Avqq8YyoqULUeyh/Kh+1qfzMf9suz1uZf++quaeJri8jR5ZGDHpuNVIoGkdVA6nFdfo2hvFcwyuOnNJUHJNxQva2aUmU4NPjOoXERBbYRwTWxDYW8YBEKA+uKiiVV8T3kZ/jjyPwNajLgVnyJGqk2QhcVraEP+JhHWZitbQh/p6VpFEM7uA8Cr0Z4rPhNXozxXQjBnyig+YHHetSNPk5rOhGUz2rVgP7r8ax6g9gVBjms/U1AjT61olz0xVPUxm3U+9HUSZkLWhEv+iN/vCqKjFX1yLFz6MKqY0RbctV/TU/fN9KoIxJGa1dOXEhPtUB0JXQbqp3y5hNX5EO/g8VVvV/cMfaqZC3MdBke1TKmSpzUCkd6sxfNwuaZZdXG0CszVBhkrRRX9KqanGzImASc9qcdyXsZsQywFSSqc0+CCRXBKnHrT5UJPSr5tRW0Iowf0qL+I1aVCB+FR+WM53Ci4DX+4lJ0GalYJtXLYxTC0XQEk0XGNhO6XmnAfvSKWNQsnFL91mek3qaJaFyFcpirkNsZGwBUWlwPMnI5zXUWdksSgkc1vRoOp6GNWsoEVhpyxsjMOciu6WMJEpA6CuXB+dR711jf8e4/3a9L2cYUpJHCpuVRNnDX10tn4ygdztV1ZST+FdExBGR0NcH45Zl1WNgcEdD+ArrNGlabSLd2OWKDmvBmtEz1oS95oukVraEv+mqaya39Eiw4bFTFls6uE9KvRniqEJ6VcjNbpmTPl+OFgFABIBzxWkgAjJHQmsxLq5JI3kgnoKuq58rh+hORisdbkvYm2KOSeahvYHuYQkIyQc0wTlv4ufSrdiMu7AkqcY9j3od0StDIGk3PcKPxq0to0NnIJWUcg1sMKpaiM2MmOuKTk2EZamSWgjPMoz9Ku2lxDGrSsxKAelYOxnfHer1uCYJoT/dzWkoJIE3cvy63a4+SNifpSR3qXsbIIyMdc1ltbjaBmrOnLtd8eoodraD1LX2WEDhaimP2aPdGACTirjdKqXw/0cfWs1uJMqG9nPRsVJJM5tlYtk7sZqqOTU/3rVf9+tWFx8Tsw5NV5id3WrYAVeKqykbulKO4CFiVNVSfmq1/A1U/4jWsSWTP/qlqID5hUp/1Qpg60wRKh/e1LIPuj1aoo2zLk1Iz5dPZqzlubxOp0SNRETjvW4WwKwNFmAiYE962t4Ir1sM17NHm4hP2jHBvnH1rrA2YV/3a49Tlx9a9N0TwlJrFnFcC9jiVh93GSKqrUUYO/UzpxfOmeXato0erasrSsQidh3rchgSCFYoxhFGAK9LT4V2fm+ZJfzFv9lQKuJ8NdLA+a4uD+IrxHCTPVVSKPLFGWArqNLTag+ldePhxo45Etzn/AHh/hVpPBdrCuIrmUfUA0KnIftYmJD0FW0NS32kyaYqu0iujHAI4OahjOad7OzGtVdHzDFtwccU5pfJumB6Yziq8ZNTXkTyXAwOo/pUrczlsVUk2XRPbNa+jzM7zK3TII/WqS6eFjDtknP5Vp6XblJJH/hYDbTm00Qi+RmqepcWjfQ1fxzVHVxizfH901m1qiYPU5gkE8HFXrA7xKMciM81m5NX9KOZZR6xmt5/CXHcZKcCn6YczMO2RUkkWSRilsoTFOec5xWSkuUpmhIOeKpX2Rb/jV5vU8VTv8G245OaS3IRmKeani+aBR/t1AEb0qxApEQB9c1oxol5yapyH5quE81SmyGojuAFh5bVYht7XyRLKrj154NU/+WZ+tXvOLWCw44Heid9LFwSe50+h6HoWqqo8x1b0Y100fgXQUI3kH6tXAaCrebJ8xAC/1rvLnVLSXywGYqrZ4XkDBHf615NbDzlOX79xR6uHo05U1JxLh8J+HbRRK8Uez+8elSx6d4WjCt5dttzgMVyM1lHULR0Af7RKqoVIYD3p66hbyxOi2TsinI4GRwBzx7VzywCfxV2dMaVO3wHSWM3hgSCNbe2YnoDH1q1PceE40LPp8JA4wseP5VysWomIRslm3y4OM/8A1veotWu7k2xhuLZYxJyMnJ4//XSWChTi3CtO/k3YX1SjUnrT/IwNc1ONdXl+wxeTbbgUjBJwPrXReD/HGoWOqIN+6J5ArRkdvauakgRmDNjpSeHiDriIRkG4Ar2nVlOlBN3tY8apRjCtNJaXPpOPxdZsVV1ZXI6dahuPGUCKfIjEjDqM+nWuYfToniijicoxUk7h979abb29tYsyunzYG6QjGD6AflXco2jdnNbmqcsEdSfFjKoZrYYPcGr1t4giuvlQASAZKmuFmubq7by408uBTncR1HpSrLcW9wGP3cbQQuCcc4JqqUea9y8TTVJLudBr1887wIfuhzx+FV4d3BxxWYNTS/mjjHHlAsxJ7muW1r4gCxu5LSyiMgThpD0z7V5ldyVVqJ10IpwSbseOItawwWfpwowMe1ZajGDWvHbu90WGMKq/yrTqcr2Jol/d/OvFPtI2WeUngEDjGMU8qMje4AHvzRHJHEzPJMNp6FmoZCTsWNvtVLU1LWUvqFP8qe2qWsbH98n0GTUTahBqCtCu4MwK7ttKzJimmc0kW4c1c0+ErOxH90itBNNhQfM7sfbAp3kpbqTGvX1OauTbRUZK5VlBzjmo1RgHbkYHFBnZj1pssjFJPmPC1nFFkPmPggsfzpQUMTAsOorMYs3OTU0RIgf61v7MlMsmWFe+TR56rGSAao5y1SyH91xVciFck+1Z7UZV+SKqDirCHgU3FLYVxZABDkDvUybvKGBwRUMuPI/GrELZgH0rOexrT1L+ikmaYAH/AFf9a77RTZWmlxTzoocu6lmXcTwMfhzXI+CLeO61t4ZgSjRHIzivShpdhDAFMK+WhLfMcgGvFxePjha9nG7PawtpUOR9zLsr1t7ynDqMDbt6jBwasSiSYMRBIBLt3kDHpWZqGvW6ZhsIEAU/6zH8qzP+EqnNyIRKhkH8JFL67i6kfcikvM61h0nd6HQymaOWUiH5XwAM9B/+uqur276hLH5EewgHdnHNFh4nh3ql9apgnHmKOn1FdhAbeVFkhCFWGQVFcGJzPE01y1I6Mtx9k72PHdUlmtL1raQ/cxxVjw66QazFLIwCCZWPGab43JPiy6x0AX/0EU7w4ytqltvUMpkXIPevoKEuahTn3SPnq0uatN+bParrU4obJdqeayIHBHT0xWRL450+WBjLburxnau3B3GppNPS0CWsPmMjQNJlueSRxXlPlltWlhKL8obCOcDNd9Wo4ROnLMHDEVJTn9k9Rg8YabO2xy0Rbj5lGAe2TmtGJZdZukhhGI4SCWcbeT6etePaugiMRVYY3xjy4mz+Ne0eBJZG8PwPcZyVB56nnAp4TESndMvNsvp0qcasH1OQ8Y2sulofslwY5JX2u3TIGa557SMwJIk8MjEjdH3x711fj0wNJAtw2A0xH49q4+02yyXNsFU+W23duwQO1ZTjebPOTskcpGqKwBjB57mp9Rd1vXWNioPYHFOiizID2zSamu67d84x/ia5k9SUVApJ5JJp14N2mSZ/hZf60Ic0+5X/AIldx7bT+tOL95DtoYQXnvWppfFwg96zFNaOl5+1rXRPYzibpGailXO38amHSoZPvD8ah7GUFaRjyfKuQMgVGrb4pTj+GopWbcRnIqWEfuHHtQo2NrlAfIcdqlzmJsVDJkNT0OYWzW5BGODUp+ZKhJxUyjKihgQsOakzgU1+WoI4FADnOUAzU0cmIlHtUDDEefSposNFjpipnsaU2dX4Bx/wkH/bI103iLUJrq7XS7XJyQH29WJ6CuM8G3QtdZeU9BGRXeeErbzbm41WXDMG2pn+8eSfyrwq+GVTHc0tkke1hJKnQdR9PzLWm+DLe3CtqEhd9uTGvAX8abpnhzydTnluoYmgGRGMdfc10n2vc2Cq1IJFYc/pXsJYS3uo4alfETleTMTUPCNneRlrRjDKB06qTWV4auprK8k025BXDEKD2PpXXSzTB4/s65B6muU8WZttWtrlSFmbBwPUV5mY0qNenJU4tW8tD0cFVqT/AHdR3vscb40fb4lvABydv8hVbw8S1/ADkHeM1qeKrHzb6fVJiUQhflI5Jx0FZHhy4X+0LZzhQZM8124ZWwtJeSPHqX9tNep7xaSPNp6maPYVG3rnjtiuX1/wImsq1zYukVx1wxwGrpbDztR0hFjljRiu1T15+lc3fC/srye2luHCBAqyK23n1FddZxS5pbF4SvVpSXstzF0D4dXrX4fUtkcKHO0MCZMenoK7dpnhuUs4FCRoUXB6de35VzlteXK3VkouS0UZJdmfJJPrXYeHvs873D3brllyPmHHNaYSUPsjzGria7Xtdl2OJ8aQS3djbbgI5fMLtk9DWHZeH9RCSyRSRHzgC2ecmuh+IV/a2spMTiRScKR61z2k+KtsaQ+S2OzZrmqy95tGdON7Jo5pcjAHWoNUfE2CeCM1OgPBJ+tUdd/4+IxnqD/Os4q7MloiKCTJxVqfnTbof7IP6isu3bEigVrTD/iX3Q/6Zj+YpuNpIroYKupAHSr+nH/TFIrM2mtHSwfPTPrW9RaGUdzoBwKjcZYfSpD1pjjDKazexnH4jBNupJyxz2FTEBUcDstJPIYyTvA56VA17EEYE5YjtQk2a6FSTGeaFHyMBUTzA9BTfNYdOK6EibjipNSZ2rgnFVyzHqTSU7CJS60nm+g/Oo6KLAOaRmGCeKnDYAHtVap2GAD7UpFwNzRMJdfIPvIa9O8HMDps8YYE+ZyvccV5p4dfy7sPtDYQ8Guni1drG6W4sEKMRhwTw1eZ7b2OJ5mro9vD03VwvIu53mRHMybwAexFMimdbeUo5G1h91c5rLsfFVjcY+1AQy989DV2TxTpUJKi4RnAztWvRjVoyXNGSsck4VIPllHU1LF3nYyMroF6bu/4VyXi62nvNahe3KukCc/N/FnNJrHi7zwItPDKP4n6Zrn4HvbiXZHG8jMeccmuDHY1Tp+zp/Ns9PBYWcJe1np5GL4n1m7fUTBOmwKo+XrjiqmhRGa5tkVipLjkdqh8VxTwa28dwhWQIuQT7VJ4bdkvYGHZgea1pr/Zotdjxa1vrE/U9Xgtp7W2+W6kUFtzYByOn+H60y7sJZroG7nlLSAEZccVUfVLhN0ckKNEe7PWjoYudc1aO0hijLEAF852L3NYqbaSN4xjG7ZUt9HCO4MmQDx8x5qV7GUK2yZImXsjEcV6Lr+k2mj6VCsWPNJwTtA3VlWT2N5pF9HcMqzJESpXAbNcOIzH2FX2HLr1126nRSw/taftU9L2PKfGKGPTYQX3kzEls57Vy2nxyvMDEGZgegFezWvh7w74o/0C5uJhLCCQFOMn2qzp/wAKriGDak0USjoCvJq45gpxSpRbl2tt6lLCU41nHEz5ErdNX6Hi8E2+dQTkdxVfXhmaEjvu/pSS61aR8W9szH+82Fqhc6tNcMCY4xjpxn+deuqbvc8RNIms4HllARc45rVmWOOzuVeVQ7ptUNxzketc213cMMeawHovA/SoDknJPNV7K7u2PnLTCJCQ0yn/AHBmpYL+O1YGONnI/vcVn0ZrRxT3JTNOXXLqQnaEQH0FVHvbmT707n8ar0oBNOyRNgJJ6kmm0ZNFMYUVraR4fuNXVnSaGBAcBpSfm+gAq9d+BNct1LwwLdp1zA2T+R5qHUgnZstU5NXSObop8sMtvIYpo3jcdVdSCKv6Dod14g1RLG02hiMs7nAUepqnJJXexKTbsZtFekyfBrWPKDQX9rIfTkVk3Xws8UW2SLaKUf7Eg/risliKT+0aOhUXQ4wmrgh83GD2FXLjwnr9qSJdJuuO6xlh+lVxb3VqT59vNH/voRTlOLXusUYuO6Oi8JIj61HG6gqVIINdLq2gA3MYtXCI55B7VyvhGXOvx+m016PKolZWOcqeK+ZzGpOlibp9D18FNqnocy3hZXAEl2OO4HNLF4TtVcMbuRiK6MRDnqc0qxDPSuL65WtbmOtzTd2lczY/DlqoLGWQj61q6BYWthczNFuLMByxzSnCDG9V+rU1Lq2glDtdxKO+XFc9SpUqRcW27lSq3VmzzP4h5fxdcEA4CKOntVTws0balEkrqg3DknHetDxfMt34nuJLZxIhC/MpyOlUbG3WWZVkjDZ9RX2OFhfCQi9NEfPVJ2rN+Z6BqEVjDsPmhhn1rc8G6jY6fqq3HnCMPtj3dh65rzy706FAp8tiCPU8VWNrDHEQzyKpOSAxqXhU1bmNfrOux7942SeSwW/gn+0W6DBKHJUn2riPB1hdaxeztzguFYdMCvP7Lxnq+jny4bszW46RTnOB9a7Hw98W1s3LyaWAzH5mTkH8q8zEZXUbbgt7X6+u+p7OFzWFLCOjF+90vp/wD1Oz8IWmhap/aNoxIGP3THOPU5rQ1HxH5QAhUqe+6uUtfi9otyoE1qUz/eOP5iman4v0PVyhgnjiboR5iH+tZYvD4yEZPDyspWutb/J9DihJ4iqpYl81ut0fMwAx938zS49QBSncerUhAHQ5NfUnjCogYnJ4FRkdcdKkJyOtEcMkpwiM30FAEWKAM1p2uk3E748sgVqQeF3lbmUcdgDmlcLnM7SOccVJHG7/AHVJ57V2q+G7a2jRioct04LZqW2s4km8h/LVsZ+7gL9e1FxXOLTTbuUnZA31PFTLo0pALSIAfQ5r0CHR98Bkgffn5WIHQd++Ko3MCWY3Mjuw5YKhIouK7MCzla1byQ7AIMDHFai+Iry0mzDLyeOOnStWzutDuzsvIGjk4G6ROnvkVs23hHwtflXi1goRztEi/wBRXHUhrqdtOroc1Nr0V/arb3thb3AXgFk+YfjTNKv7XRpZnsbcRGUANk56elehWnw40QXIuI7yaQ56GVcfkBXBeJtHudD1eSG4gCxSMWhdfusvtWDSirLY2jLnld7mrb+M7qLq/wCRIrXtfHsmfmc/ia8+BQj7pH41KqKejY+tZNQejRunJHq1t4yt7lfnb9BWlBq2n3C7XMZB7OP8a8dVCBw/61ZjMijIdvwNZSw0JbMtVJLoevppGgXUolNlbrJ/z0RQD+Yqy3grSbgZhvp4WPo+f515HDqd7Bwszcetadt4t1O2IAkBHvmspYTruKUlLbQ7O7+GF453WmvM3s4/qKxLr4Z+JEGFlWYeqzEZ/On2nxAuo8ebFn6Gty0+I0XAfcv1q4UXH7P5GEqbfU4e58Fa7aMS2mXch9cbx+hrN/s2SzhZLvTnQk5JeIg/rXs9n48sJsBpkyf71a8Wv6fdrg+S6ntkGuqM7br8DCVKR833UFvuZkj257AVUtVCPkA8Dg19LXOm+Gr2BmurG02AZZmQDA+teQeI9V8FwXr22k6RJJtO0zpMVX3wO9dccRGxzujK+hh+bNe2yoSuEHC45/8Ar1F/ZhmU722j+8a9Xs/hnp2o2Nte2GrTiGRA8ZKg9agvPhZqJYtb39uw/uspWtrdSdtGeO3XhKWTcTMu/PA6ZqgfBWpxtugc+xU//Xr2GT4deI4lKpHaS9876zNQ8L66EQS6TcI0feEkg/lWikluTJdjzWXSvEumRo7XTIG6K4Of1FRNf6/FGC0tvKO4IUkfnXokMbwrINQtr1Hz8m5M/nk1HeNYKVBeOQEDh4yBn8q1VR9zNrseXwaHdzH59sf+8efyq5HocSLueZm4ydvAFacdn9pDMZ/mHZe//wCqpY7AxFioIHIyM8+vFZXHdmfb6faRDeE3YOMYyT+NXQYY1CpCq5PLE5Iq3ZaNdSPO6IVRPny6nDD69KuiAtJsNoERWGVLcZ9zmlcDMaWVUjVk3qTgFRjP+eat/ZjIyk2xSQkBlXGCO/WumXQLFBvVP3hUEKhY4J6HA6/nWzbacVLiG0VTGBgyDLgexJNS5IqxhQJLJYKsEDylVwpcgDOegX86t6d4enmtW82yhjkJxgqOmff+ddObB38om2UsBgMDzVpAQViLwRyD5SCcsf5Vm52NFC5zcGkNHcCGdDEmNoyAQT9e1dHBp6qot3t4poem5WPFX5rZ4okYgPITjKJuxTVhntGERjeRm53MowfapbuUlYrjQdNuAVk0wKOfmK43E9sg1k3vgDRp3fEM8TMch1OQp/GuytwsiBiwVhwyjtTmGZVVjHyMgE4NAzyq88BarpsQuNJuZ5SOiK33ufyHH1rnNe0nxJfWog1G0vdiHcjbMgH8K9/CpFG/AzjIVTzUMM9vO6oBJu9CP58VSt1QHyw+japa/dmbj+Fhg0gfVITh4Vf8K+qJbK1u0LCxWYe4A/nWfN4H0O9QGTTliYk5w2CfyptQlvEanKOzPmtNUkjOJrV19xVuHW7XOCzL9RXt2ofCzTJdxtTKh7KcMKwL34NM3MU8Dk9iMGs3QpPyNFiJo8+i1CCQfLIp/GrAmjfuK1b34RalCT5cEmR3ibIrn7vwZrdgSA0y4/voRWbwl/hkaLFrqjQV46eNh6NXNvb6zaffh3gelRf2tcQnE1vKv4VDw1aJosTSludYiZPDVKplTHlysuP7rYrlodejz/rNp96vRa4jEfOp+hqL1I/EjROnLZmtqmpX6aeY3upTHIcFS3UVztqpnuQOxNXdRvEurNNp5VuayEneDDJ97NaQtJXM5+6z6A+HvirTbTQU06efy2hY43nHBNdWfGGjmbykuomf/fAr550vQ9d1Kya6t7KQRdc7sFvpVZpby1dop4pkZeMMCP51opSiuWMjPlpzd2j6bg17T5zhbhM/7wP8q0ElSQZR1Yexr5Zi1CVSDsBI74IP6UXfjjWtOnhWwvJ4WHzMC+4H25rSM59bMznRh00PqZ4o5Bh0Vh/tDNUp9C0u5/1thA3/AAACqvhvV5dW8OWF/cxGGaeFXdD2Nab3AQdRWntI9Tn5Xex4SPDNtG6sXREbjggHH16Vpp4ZgjCCJ3AOdwUcGpjqui6cxCNLduvTYvH68VWn8X3bgpa2kUK9mYbm+vpWMq8V1NIYWpLobNtoqGDZ5BdDg/MetOYaTaZW7a1D9kAB21yr3+r3oIkvJ8Hsp2j9KYmmSnh2564Nc0sV2OuGB/mZv3Xii1gOy1ty+OAxworMl8R380hEPlQgnny05/M1FHpowMryenFXYfDt3MQVUqPXGKwdectEdMcPShujPe81GVSJLycr6BiKrJb7mwZCCTnJOK6y38HjObi6JH91B/jWzbeH9NtwMW6ufV+an2VSW5Tq047HEQX15bKBBdyjHbORV9Nf1Y7fMnL46ZX/AArt47S3j4SCNfogqYRLjGxcfStFRmtpGbrQe8TjV8S3YPzxR5xg7c8/nmpJPETysxKP22gvnFdPNplpcj97bo3vjBqmfC2nuDjzE+jf41X+0R2dyLYeW6sYukXu69MzSpbsDzvYkMDW5CZrmfzLa9hDv0BIPPbjPSoh4OQ4MV0w/wB5aa/hK5GNs8ZPTuKpVcQvihch0MO9p2Om07T5rO3QPKrO3LMW4yfQelaKWzEjMikDp8vNcXHoOrWvzRyvgdAkn9Ksxajq9o2xpM+0i1axfL8cGjN4O/wSTOuFsgzzknqT1pRbxqc4J/GsGHX7kY823jb1KnFTHV0mZT+9j5yccitViqD6mUsNWj0NsDb/AAjFMliWVcMEx7iqgvbWdQvmsvruHWp454mJ2TK2D93I4raM4S2Zg4yjujPvfDel3xIls4WJHPyAVzF/8MNEugwRXic9NrcV3rSYXO3I9jVVmePARev3QQTVarVMlvueSX/wYgl3GC6Un/bT/CuVvvgzqcJZoDC4HcSbT+te8zm6mXEbupz8x8n730zUH2C4W1aN/wDSC/8ABI2PcdBR7SfXUFynzunw28SRTGKOPqOd0ilcfXNaNp8MNdYrOs1szRt8ykEgY9fWvdPsb7wGe1hWPng7mH1qA6pLb3Rto7FpI2OFlD5Le+2ocl1SHzS2ueew6z460KA+bo9pf2yDO6A7cAe3/wBanf8ACx9OuJBBrnhi7iY4zmEOPrzjivVo7dZIFM4+cj7pAFZ+oTWMVkwuxCtuOvmHjH1qZSglqio83RnAQR/D7WbkLHttZmPAO6LJ/lW7H4A8I2siX7WYuNmCrSSlh6jivMfiHb6UZBcadtEjtysb5A9OnqKwtH8Ra3ptsY0uZUtdwODnaCK0jSi0mjOVaV7bnu+s6/ZWEKyG5Nv/AArg9PoK4XVvibdyxS21lLhcf6x8AsB6eledXE017PJcmR3ychnOAefU9fwqrcXlrEMJ++k6kdFB+nemqUYPXUhupV02PS1t4FPCE1btrCe4YCC3J98cV09hoVrbgNIvmv8A7Q4H4VrqgUYUBQOwry40G9We5Kulsc3beGbhlzPMiegHNaEfhu3Vwzyu3svFa/PrTxzWqoQ7GTrTfUhhtIIB+7iQe+OfzqQrz0pwXJ70/AxzWnKZ3GCOnqoFJuApQw9aLBceOKXGTTc09TTsIkVPanqo74/KkRgaeJEJ6jj3q0kQ7kgfYOfyp+ScEgZqEOD3FPDBh8pANUTYcJCSRUjQQzpiRQw/lSKg69TUd3d2lhEZbqdIo167jjNDXcT30MjUrZbCVQrBo3GVz1HtVVZEOM1Wu5Vurl3gDeUTlcsW/Hk1DGXGQxJNeNU5XN8ux61OMuRc25pbgOjdaFc76qIzE4K5H0qxkQr5krpEn952wP1qLDaSLayOB8rsPoasJPNgZuJQR6N/jXH6n4203T5RBZpJqN2ekdtyM+5qOG38ZeIE3zS2+iWjdBjdIR/n6V00qdaXwuxy1XTXxHX33ie20qJnvbuFR2yfm/Ks/wAO+Ij4onujbLN5EJ4uHXCnPYe9Z9j4L8OaXcLPqUj6hc9d942QT7J/9aruq+LbTTYiImit4VTKbuAfYAf0r0IQnFXlK5wVZ09oxNOa0js2ZmuxCDyWQYJqjrHiqx02y4kBKAY2v87V5jqHj99Vvi+FjhgTc7scbj2+WuIuNSudQvjKSFjUkKX+6D1Faqi766HL7a691HpmueNJLaeORVYTdGy+QvpiuK1rxnc3yeS0jMNjje2TuyeOO3esSe7KgnJc4yHfjFZn23yifLXcxGM+lacsIkqnOo231NJvNubdQ8hXA+ViOmKpy3sMci4Zp2UYwxzg/wAhVGSaWRcSSEr/AHR0qHcB0HFJ1GzqhQUVZlme7muOGbav90VXyB0FJyadjb2qDdJLY99XxzdpjzdAn6ciOUMc+3HNKnxEt1bFzo2pwj1EQcfoaqi3jyG84nGRg4p5iixjcpNcP1h9js+rLuX4/iJoDNtle6t/ea3ZR+eK0bfxf4fuSBDq1oW9Gk2/zrCGwDbkAVFJZWM4Ilt7d/8AejBoWIXVCeHfRnbxX1pcY8q4hkz02ODVjrXmr+HdFf8A5cYlPrGSn8jTU0CKFy9tqOowHsEuSVH4GrVaD7kOhUWx6aFFPAx2ryptO1+Jt1t4pvl9Ay5q7FrniuxiCPqNlc7ehniCk/XBFWpwezIdOot0eldqUVwMni7UZrNVN1Z2lyD8xjjMin8zVI+JvEUSGY6pZyoiliq22C2BnHWjnje1w5JWvY9LKqe2M1LFGg6Vx2m+OU1KziuU06TEgzhXBxWrD4lgbG61uF9sA/1rRRd9jNyRuMuTgHGPesTW9cls4HtrF4/tbD5c87fc/wCeabrmo3ctvGmnQ4eQ8SSttCj1x3rH03T47Nnlkdri8fl5H7n29K5a1bkdo7nTSo8yvLYgsPFniW6t1tYrTLjIe7lj8tB9B1NWX0UXdwl3fXEs8wORufABz2FXLq+trNPMup44kHuM1zN145iEht9JsnuZDwhIJyfp1rF1KtXY2jCnTR1yW8aR9go9OgrL1DxNoul5DzrJKP4I/mP+FY9v4Y8V+Jn36ndCwtzz5fU4/wB0f1NdTpHgnStFcNGFuLnGRLOoY/hngVpDCN/EzGpjYR21Odj1jxLr3Gi6SYIT0uJ1wPqM4/Sr9r8OJL5vtXiLVp71xz5KNtSut1TVoNN015bh0ijVcBz/AEFec6h8R7B1KhLm5IOwKW2oT9Bxj8666eHUfhRwzxjmt7I763sNI0C1RdPsELEfdgUFvxJrn9b8Z21uJCbtbdEO0RRfNM3HckfKK89m8TaxqitGsjQQv/yztgR3wNzfl0zXPT2hsFd724wx3CNc4LMCAc55HXviun2F9WcXt5XvFHR6146uLqWOHTEW184bTO53yHnkknpWBqN/HexQzLIfMjUo7Mep9eayLnybacTJMQu3C+aDwSOSB1NURfCMEW6EsRgyy9vovQfrTTjBWiaRpzqJcxOtusSGd5ECZ+84P6DvSTaggbMCbj/fdRwfYdqz3ZnO6RyzepOaY0nHFQ5tnRCjGO5LJK0hzI5P1qEyYHFR5Zjgcmpkti33/wAhUuy3NUuxGCXPHNSJCTyeKmxHCvOB7CozMWO1FwKV77FbbjvkTrUEsu75RVg2ziMyMe2QKoqvzE04WeopXR//2Q==",
-      "image/png": "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",
-      "text/plain": [
-       ""
+       "Certainly! Here’s the final version of the short story with the enhanced illustrations for \"The Escape of the      \n",
+       "Gingerbread Man.\"                                                                                                  \n",
+       "\n",
+       "\u001b[1mTitle: The Escape of the Gingerbread Man\u001b[0m                                                                           \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mIllustration 1: A Rustic Kitchen Scene\u001b[0m In a quaint little cottage at the edge of an enchanted forest, an elderly   \n",
+       "woman, with flour-dusted hands, carefully shapes gingerbread dough on a wooden counter. The aroma of ginger,       \n",
+       "cinnamon, and cloves wafts through the air as a warm breeze from the open window dances with fluttering curtains.  \n",
+       "The sunlight gently permeates the cozy kitchen, casting a golden hue over the flour-dusted surfaces and the rolling\n",
+       "pin. Heartfelt trinkets and rustic decorations adorn the shelves—a sign of a lived-in, lovingly nurtured home.     \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mStory:\u001b[0m                                                                                                             \n",
+       "\n",
+       "Once there was an old woman who lived alone in a charming cottage, her days filled with the joyful art of baking.  \n",
+       "One sunny afternoon, she decided to make a special gingerbread man to keep her company. As she shaped him tenderly \n",
+       "and placed him in the oven, she couldn't help but smile at the delight he might bring.                             \n",
+       "\n",
+       "But to her astonishment, once she opened the oven door to check on her creation, the gingerbread man leapt out,    \n",
+       "suddenly alive. His eyes were bright as beads, and his smile cheeky and wide. \"Run, run, as fast as you can! You   \n",
+       "can't catch me, I'm the Gingerbread Man!\" he laughed, darting towards the door.                                    \n",
+       "\n",
+       "The old woman, chuckling at the unexpected mischief, gave chase, but her footsteps were slow with the weight of    \n",
+       "age. The Gingerbread Man raced out of the door and into the sunny afternoon.                                       \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mIllustration 2: A Frolic Through the Meadow\u001b[0m The Gingerbread Man darts through a vibrant meadow, his arms swinging  \n",
+       "joyously by his sides. Behind him trails the old woman, her apron flapping in the wind as she gently tries to catch\n",
+       "up. Wildflowers of every color bloom vividly under the radiant sky, painting the scene with shades of nature's     \n",
+       "brilliance. Birds flit through the sky and a stream babbles nearby, oblivious to the chase taking place below.     \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "Continuing his sprint, the Gingerbread Man encountered a cow grazing peacefully. Intrigued, the cow trotted        \n",
+       "forward. \"Stop, Gingerbread Man! I wish to eat you!\" she called, but the Gingerbread Man only twirled in a teasing \n",
+       "jig, flashing his icing smile before darting off again.                                                            \n",
+       "\n",
+       "\"Run, run, as fast as you can! You can't catch me, I'm the Gingerbread Man!\" he taunted, leaving the cow in his    \n",
+       "spicy wake.                                                                                                        \n",
+       "\n",
+       "As he zoomed across the meadow, he spied a cautious horse in a nearby paddock, who neighed, \"Oh! You look          \n",
+       "delicious! I want to eat you!\" But the Gingerbread Man only laughed, his feet barely touching the earth. The horse \n",
+       "joined the trail, hooves pounding, but even he couldn't match the Gingerbread Man's pace.                          \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "\u001b[1mIllustration 3: A Bridge Over a Sparkling River\u001b[0m Arriving at a wooden bridge across a shimmering river, the         \n",
+       "Gingerbread Man pauses momentarily, his silhouette against the glistening water. Sunlight sparkles off the water's \n",
+       "soft ripples casting reflections that dance like small constellations. A sly fox emerges from the shadows of a     \n",
+       "blooming willow on the riverbank, his eyes alight with cunning and curiosity.                                      \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "The Gingerbread Man bounded onto the bridge and skirted past a sly, watching fox. \"Foolish Gingerbread Man,\" the   \n",
+       "fox mused aloud, \"you might have outrun them all, but you can't possibly swim across that river.\"                  \n",
+       "\n",
+       "Pausing, the Gingerbread Man considered this dilemma. But the fox, oh so clever, offered a dangerous solution.     \n",
+       "\"Climb on my back, and I'll carry you across safely,\" he suggested with a sly smile.                               \n",
+       "\n",
+       "Gingerbread thought himself smarter than that but hesitated, fearing the water or being pursued by the tired,      \n",
+       "hungry crowd now gathering. \"Promise you won't eat me?\" he ventured.                                               \n",
+       "\n",
+       "\"Of course,\" the fox reassured, a gleam in his eyes that the others pondered from a distance.                      \n",
+       "\n",
+       "As they crossed the river, the gingerbread man confident on his ride, the old woman, cow, and horse hoped for his  \n",
+       "safety. Yet, nearing the middle, the crafty fox tilted his chin and swiftly snapped, swallowing the gingerbread man\n",
+       "whole.                                                                                                             \n",
+       "\n",
+       "Bewildered but awed by the clever twist they had witnessed, the old woman hung her head while the cow and horse    \n",
+       "ambled away, pondering the fate of the boisterous Gingerbread Man.                                                 \n",
+       "\n",
+       "The fox, licking his lips, ambled along the river, savoring his victory, leaving an air of mystery hovering above  \n",
+       "the shimmering waters, where the memory of the Gingerbread Man's spirited run lingered long after.                 \n",
+       "\n",
+       "\u001b[33m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n",
+       "I hope you enjoy the enhanced version of the tale!                                                                 \n"
       ]
      },
      "metadata": {},
@@ -1155,7 +1164,7 @@
     "await runtime.publish_message(\n",
     "    GroupChatMessage(\n",
     "        body=UserMessage(\n",
-    "            content=\"Please write a short story about the gingerbread man with photo-realistic illustrations.\",\n",
+    "            content=\"Please write a short story about the gingerbread man with up to 3 photo-realistic illustrations.\",\n",
     "            source=\"User\",\n",
     "        )\n",
     "    ),\n",

From 4ff062d5b3c622fe9f9879f90b02cfab82ead908 Mon Sep 17 00:00:00 2001
From: Zac 
Date: Mon, 21 Oct 2024 07:39:09 -0400
Subject: [PATCH 005/173] Updated gpt-4o pointer version to latest (#3855)

---
 .../src/autogen_core/components/models/_model_info.py           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py b/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
index 5f728f6d3b63..f54df6fade5b 100644
--- a/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
+++ b/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
@@ -5,7 +5,7 @@
 # Based on: https://platform.openai.com/docs/models/continuous-model-upgrades
 # This is a moving target, so correctness is checked by the model value returned by openai against expected values at runtime``
 _MODEL_POINTERS = {
-    "gpt-4o": "gpt-4o-2024-05-13",
+    "gpt-4o": "gpt-4o-2024-08-06",
     "gpt-4o-mini": "gpt-4o-mini-2024-07-18",
     "gpt-4-turbo": "gpt-4-turbo-2024-04-09",
     "gpt-4-turbo-preview": "gpt-4-0125-preview",

From f747b3c88403bf18c7e19a434da03f301d2190a3 Mon Sep 17 00:00:00 2001
From: Victor Dibia 
Date: Mon, 21 Oct 2024 05:45:44 -0700
Subject: [PATCH 006/173] Add Tutorial for AgentChat Docs (#3849)

---
 .../guides/code-execution.ipynb               | 379 ------------------
 .../agentchat-user-guide/guides/index.md      |  22 -
 .../guides/tool_use.ipynb                     | 185 ---------
 .../user-guide/agentchat-user-guide/index.md  |  38 +-
 .../agentchat-user-guide/installation.md      |  78 ++++
 .../agentchat-user-guide/quickstart.ipynb     | 133 ++++++
 .../agentchat-user-guide/quickstart.md        |  49 ---
 .../agentchat-user-guide/stocksnippet.md      |  54 ---
 .../{guides => tutorial}/.gitignore           |   0
 .../tutorial/agents.ipynb                     | 320 +++++++++++++++
 .../agentchat-user-guide/tutorial/index.md    |  54 +++
 .../tutorial/introduction.ipynb               | 120 ++++++
 .../selector-group-chat.ipynb                 |   0
 .../agentchat-user-guide/tutorial/teams.ipynb | 216 ++++++++++
 .../tutorial/termination.ipynb                | 206 ++++++++++
 .../agentchat-user-guide/warning.md           |   5 +
 16 files changed, 1160 insertions(+), 699 deletions(-)
 delete mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/code-execution.ipynb
 delete mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/index.md
 delete mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/tool_use.ipynb
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
 delete mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.md
 delete mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/stocksnippet.md
 rename python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/{guides => tutorial}/.gitignore (100%)
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/index.md
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
 rename python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/{guides => tutorial}/selector-group-chat.ipynb (100%)
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
 create mode 100644 python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/warning.md

diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/code-execution.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/code-execution.ipynb
deleted file mode 100644
index a715728ae4c6..000000000000
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/code-execution.ipynb
+++ /dev/null
@@ -1,379 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Code Execution\n",
-    "\n",
-    "\n",
-    "AgentChat offers a `CodeExecutorAgent` agent that can execute code in messages it receives. \n",
-    "\n",
-    ":::{note}\n",
-    "See [here](pkg-info-autogen-agentchat) for installation instructions.\n",
-    ":::\n",
-    "\n",
-    ":::{warning}\n",
-    "🚧 Under construction 🚧\n",
-    ":::"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "--------------------------------------------------------------------------------\n",
-      "user:\n",
-      "Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "coding_assistant:\n",
-      "To create a plot of NVIDIA and TSLA stock returns from January 1, 2024, year-to-date, we will perform the following steps:\n",
-      "\n",
-      "1. **Install Required Libraries:**\n",
-      "   We'll need `pandas`, `matplotlib`, and `yfinance` to fetch and plot the stock data. Make sure these libraries are installed.\n",
-      "\n",
-      "2. **Fetch the Stock Data:**\n",
-      "   Use the `yfinance` library to download the stock data for NVIDIA (ticker: NVDA) and Tesla (ticker: TSLA) from January 1, 2024.\n",
-      "\n",
-      "3. **Calculate Stock Returns:**\n",
-      "   Calculate the percentage returns of both stocks over the date range.\n",
-      "\n",
-      "4. **Plot the Data:**\n",
-      "   Plot NVIDIA and Tesla returns using `matplotlib` and save the plot as 'nvidia_tesla_2024_ytd.png'.\n",
-      "\n",
-      "Here's the complete code to perform these steps:\n",
-      "\n",
-      "```python\n",
-      "# filename: plot_nvidia_tesla_2024_ytd.py\n",
-      "\n",
-      "import pandas as pd\n",
-      "import matplotlib.pyplot as plt\n",
-      "import yfinance as yf\n",
-      "\n",
-      "# Step 1: Fetch the Stock Data\n",
-      "start_date = \"2024-01-01\"\n",
-      "end_date = pd.Timestamp.now().strftime('%Y-%m-%d')\n",
-      "\n",
-      "nvda = yf.download('NVDA', start=start_date, end=end_date)\n",
-      "tsla = yf.download('TSLA', start=start_date, end=end_date)\n",
-      "\n",
-      "# Step 2: Calculate the returns\n",
-      "nvda['Returns'] = nvda['Adj Close'].pct_change()\n",
-      "tsla['Returns'] = tsla['Adj Close'].pct_change()\n",
-      "\n",
-      "# Step 3: Drop the first NaN values from the dataset\n",
-      "nvda = nvda.dropna(subset=['Returns'])\n",
-      "tsla = tsla.dropna(subset=['Returns'])\n",
-      "\n",
-      "# Step 4: Plot the Data\n",
-      "plt.figure(figsize=(10, 6))\n",
-      "plt.plot(nvda['Returns'].index, (nvda['Returns'] + 1).cumprod() - 1, label='NVIDIA (NVDA)')\n",
-      "plt.plot(tsla['Returns'].index, (tsla['Returns'] + 1).cumprod() - 1, label='Tesla (TSLA)')\n",
-      "\n",
-      "# Adding titles and labels\n",
-      "plt.title('NVIDIA and Tesla Stock Returns YTD (2024)')\n",
-      "plt.xlabel('Date')\n",
-      "plt.ylabel('Cumulative Return')\n",
-      "plt.legend()\n",
-      "\n",
-      "# Save the plot\n",
-      "plt.savefig('nvidia_tesla_2024_ytd.png')\n",
-      "\n",
-      "# Display a confirmation message\n",
-      "print(\"The plot has been saved as 'nvidia_tesla_2024_ytd.png'.\")\n",
-      "```\n",
-      "\n",
-      "Please save the code above in a file named `plot_nvidia_tesla_2024_ytd.py` and execute it. This will generate the plot of NVIDIA and Tesla stock returns for the year 2024 up to today's date and save it as `'nvidia_tesla_2024_ytd.png'`.\n",
-      "\n",
-      "After running the code, check that the file `nvidia_tesla_2024_ytd.png` has been created in the directory. If there are any errors or issues, let me know so I can help you resolve them.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "code_executor:\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/workspace/plot_nvidia_tesla_2024_ytd.py\", line 3, in \n",
-      "    import pandas as pd\n",
-      "ModuleNotFoundError: No module named 'pandas'\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "coding_assistant:\n",
-      "It seems that the `pandas` library is not installed in your environment. Let's update the script to include the installation of the required libraries within the code itself.\n",
-      "\n",
-      "Here's the updated script that installs the necessary libraries before executing the main tasks:\n",
-      "\n",
-      "```python\n",
-      "# filename: plot_nvidia_tesla_2024_ytd.py\n",
-      "\n",
-      "import subprocess\n",
-      "import sys\n",
-      "\n",
-      "# Function to install required libraries\n",
-      "def install(package):\n",
-      "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", package])\n",
-      "\n",
-      "# Install the required libraries\n",
-      "try:\n",
-      "    import pandas as pd\n",
-      "except ImportError:\n",
-      "    install(\"pandas\")\n",
-      "    import pandas as pd\n",
-      "    \n",
-      "try:\n",
-      "    import matplotlib.pyplot as plt\n",
-      "except ImportError:\n",
-      "    install(\"matplotlib\")\n",
-      "    import matplotlib.pyplot as plt\n",
-      "\n",
-      "try:\n",
-      "    import yfinance as yf\n",
-      "except ImportError:\n",
-      "    install(\"yfinance\")\n",
-      "    import yfinance as yf\n",
-      "\n",
-      "# Step 1: Fetch the Stock Data\n",
-      "start_date = \"2024-01-01\"\n",
-      "end_date = pd.Timestamp.now().strftime('%Y-%m-%d')\n",
-      "\n",
-      "nvda = yf.download('NVDA', start=start_date, end=end_date)\n",
-      "tsla = yf.download('TSLA', start=start_date, end=end_date)\n",
-      "\n",
-      "# Step 2: Calculate the returns\n",
-      "nvda['Returns'] = nvda['Adj Close'].pct_change()\n",
-      "tsla['Returns'] = tsla['Adj Close'].pct_change()\n",
-      "\n",
-      "# Step 3: Drop the first NaN values from the dataset\n",
-      "nvda = nvda.dropna(subset=['Returns'])\n",
-      "tsla = tsla.dropna(subset=['Returns'])\n",
-      "\n",
-      "# Step 4: Plot the Data\n",
-      "plt.figure(figsize=(10, 6))\n",
-      "plt.plot(nvda['Returns'].index, (nvda['Returns'] + 1).cumprod() - 1, label='NVIDIA (NVDA)')\n",
-      "plt.plot(tsla['Returns'].index, (tsla['Returns'] + 1).cumprod() - 1, label='Tesla (TSLA)')\n",
-      "\n",
-      "# Adding titles and labels\n",
-      "plt.title('NVIDIA and Tesla Stock Returns YTD (2024)')\n",
-      "plt.xlabel('Date')\n",
-      "plt.ylabel('Cumulative Return')\n",
-      "plt.legend()\n",
-      "\n",
-      "# Save the plot\n",
-      "plt.savefig('nvidia_tesla_2024_ytd.png')\n",
-      "\n",
-      "# Display a confirmation message\n",
-      "print(\"The plot has been saved as 'nvidia_tesla_2024_ytd.png'.\")\n",
-      "```\n",
-      "\n",
-      "Please save the code above in a file named `plot_nvidia_tesla_2024_ytd.py` and execute it again. This script will handle the installation of any missing libraries automatically before proceeding with the data fetching, processing, and plotting tasks.\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "code_executor:\n",
-      "Collecting pandas\n",
-      "  Downloading pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (89 kB)\n",
-      "Collecting numpy>=1.26.0 (from pandas)\n",
-      "  Downloading numpy-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (60 kB)\n",
-      "Collecting python-dateutil>=2.8.2 (from pandas)\n",
-      "  Downloading python_dateutil-2.9.0.post0-py2.py3-none-any.whl.metadata (8.4 kB)\n",
-      "Collecting pytz>=2020.1 (from pandas)\n",
-      "  Downloading pytz-2024.2-py2.py3-none-any.whl.metadata (22 kB)\n",
-      "Collecting tzdata>=2022.7 (from pandas)\n",
-      "  Downloading tzdata-2024.2-py2.py3-none-any.whl.metadata (1.4 kB)\n",
-      "Collecting six>=1.5 (from python-dateutil>=2.8.2->pandas)\n",
-      "  Downloading six-1.16.0-py2.py3-none-any.whl.metadata (1.8 kB)\n",
-      "Downloading pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.7 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 12.7/12.7 MB 9.6 MB/s eta 0:00:00\n",
-      "Downloading numpy-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (16.0 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 16.0/16.0 MB 8.6 MB/s eta 0:00:00\n",
-      "Downloading python_dateutil-2.9.0.post0-py2.py3-none-any.whl (229 kB)\n",
-      "Downloading pytz-2024.2-py2.py3-none-any.whl (508 kB)\n",
-      "Downloading tzdata-2024.2-py2.py3-none-any.whl (346 kB)\n",
-      "Downloading six-1.16.0-py2.py3-none-any.whl (11 kB)\n",
-      "Installing collected packages: pytz, tzdata, six, numpy, python-dateutil, pandas\n",
-      "Successfully installed numpy-2.1.1 pandas-2.2.3 python-dateutil-2.9.0.post0 pytz-2024.2 six-1.16.0 tzdata-2024.2\n",
-      "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\n",
-      "Collecting matplotlib\n",
-      "  Downloading matplotlib-3.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (11 kB)\n",
-      "Collecting contourpy>=1.0.1 (from matplotlib)\n",
-      "  Downloading contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.4 kB)\n",
-      "Collecting cycler>=0.10 (from matplotlib)\n",
-      "  Downloading cycler-0.12.1-py3-none-any.whl.metadata (3.8 kB)\n",
-      "Collecting fonttools>=4.22.0 (from matplotlib)\n",
-      "  Downloading fonttools-4.54.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (163 kB)\n",
-      "Collecting kiwisolver>=1.3.1 (from matplotlib)\n",
-      "  Downloading kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.3 kB)\n",
-      "Requirement already satisfied: numpy>=1.23 in /usr/local/lib/python3.12/site-packages (from matplotlib) (2.1.1)\n",
-      "Collecting packaging>=20.0 (from matplotlib)\n",
-      "  Downloading packaging-24.1-py3-none-any.whl.metadata (3.2 kB)\n",
-      "Collecting pillow>=8 (from matplotlib)\n",
-      "  Downloading pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl.metadata (9.2 kB)\n",
-      "Collecting pyparsing>=2.3.1 (from matplotlib)\n",
-      "  Downloading pyparsing-3.1.4-py3-none-any.whl.metadata (5.1 kB)\n",
-      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/site-packages (from matplotlib) (2.9.0.post0)\n",
-      "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
-      "Downloading matplotlib-3.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (8.3 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 8.3/8.3 MB 10.1 MB/s eta 0:00:00\n",
-      "Downloading contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (320 kB)\n",
-      "Downloading cycler-0.12.1-py3-none-any.whl (8.3 kB)\n",
-      "Downloading fonttools-4.54.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.9 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 9.5 MB/s eta 0:00:00\n",
-      "Downloading kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.5 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1.5/1.5 MB 10.8 MB/s eta 0:00:00\n",
-      "Downloading packaging-24.1-py3-none-any.whl (53 kB)\n",
-      "Downloading pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl (4.5 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.5/4.5 MB 8.9 MB/s eta 0:00:00\n",
-      "Downloading pyparsing-3.1.4-py3-none-any.whl (104 kB)\n",
-      "Installing collected packages: pyparsing, pillow, packaging, kiwisolver, fonttools, cycler, contourpy, matplotlib\n",
-      "Successfully installed contourpy-1.3.0 cycler-0.12.1 fonttools-4.54.1 kiwisolver-1.4.7 matplotlib-3.9.2 packaging-24.1 pillow-10.4.0 pyparsing-3.1.4\n",
-      "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\n",
-      "Collecting yfinance\n",
-      "  Downloading yfinance-0.2.43-py2.py3-none-any.whl.metadata (11 kB)\n",
-      "Requirement already satisfied: pandas>=1.3.0 in /usr/local/lib/python3.12/site-packages (from yfinance) (2.2.3)\n",
-      "Requirement already satisfied: numpy>=1.16.5 in /usr/local/lib/python3.12/site-packages (from yfinance) (2.1.1)\n",
-      "Collecting requests>=2.31 (from yfinance)\n",
-      "  Downloading requests-2.32.3-py3-none-any.whl.metadata (4.6 kB)\n",
-      "Collecting multitasking>=0.0.7 (from yfinance)\n",
-      "  Downloading multitasking-0.0.11-py3-none-any.whl.metadata (5.5 kB)\n",
-      "Collecting lxml>=4.9.1 (from yfinance)\n",
-      "  Downloading lxml-5.3.0-cp312-cp312-manylinux_2_28_x86_64.whl.metadata (3.8 kB)\n",
-      "Collecting platformdirs>=2.0.0 (from yfinance)\n",
-      "  Downloading platformdirs-4.3.6-py3-none-any.whl.metadata (11 kB)\n",
-      "Requirement already satisfied: pytz>=2022.5 in /usr/local/lib/python3.12/site-packages (from yfinance) (2024.2)\n",
-      "Collecting frozendict>=2.3.4 (from yfinance)\n",
-      "  Downloading frozendict-2.4.4-py312-none-any.whl.metadata (23 kB)\n",
-      "Collecting peewee>=3.16.2 (from yfinance)\n",
-      "  Downloading peewee-3.17.6.tar.gz (3.0 MB)\n",
-      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.0/3.0 MB 18.8 MB/s eta 0:00:00\n",
-      "  Installing build dependencies: started\n",
-      "  Installing build dependencies: finished with status 'done'\n",
-      "  Getting requirements to build wheel: started\n",
-      "  Getting requirements to build wheel: finished with status 'done'\n",
-      "  Preparing metadata (pyproject.toml): started\n",
-      "  Preparing metadata (pyproject.toml): finished with status 'done'\n",
-      "Collecting beautifulsoup4>=4.11.1 (from yfinance)\n",
-      "  Downloading beautifulsoup4-4.12.3-py3-none-any.whl.metadata (3.8 kB)\n",
-      "Collecting html5lib>=1.1 (from yfinance)\n",
-      "  Downloading html5lib-1.1-py2.py3-none-any.whl.metadata (16 kB)\n",
-      "Collecting soupsieve>1.2 (from beautifulsoup4>=4.11.1->yfinance)\n",
-      "  Downloading soupsieve-2.6-py3-none-any.whl.metadata (4.6 kB)\n",
-      "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.12/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n",
-      "Collecting webencodings (from html5lib>=1.1->yfinance)\n",
-      "  Downloading webencodings-0.5.1-py2.py3-none-any.whl.metadata (2.1 kB)\n",
-      "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/site-packages (from pandas>=1.3.0->yfinance) (2.9.0.post0)\n",
-      "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/site-packages (from pandas>=1.3.0->yfinance) (2024.2)\n",
-      "Collecting charset-normalizer<4,>=2 (from requests>=2.31->yfinance)\n",
-      "  Downloading charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (33 kB)\n",
-      "Collecting idna<4,>=2.5 (from requests>=2.31->yfinance)\n",
-      "  Downloading idna-3.10-py3-none-any.whl.metadata (10 kB)\n",
-      "Collecting urllib3<3,>=1.21.1 (from requests>=2.31->yfinance)\n",
-      "  Downloading urllib3-2.2.3-py3-none-any.whl.metadata (6.5 kB)\n",
-      "Collecting certifi>=2017.4.17 (from requests>=2.31->yfinance)\n",
-      "  Downloading certifi-2024.8.30-py3-none-any.whl.metadata (2.2 kB)\n",
-      "Downloading yfinance-0.2.43-py2.py3-none-any.whl (84 kB)\n",
-      "Downloading beautifulsoup4-4.12.3-py3-none-any.whl (147 kB)\n",
-      "Downloading frozendict-2.4.4-py312-none-any.whl (16 kB)\n",
-      "Downloading html5lib-1.1-py2.py3-none-any.whl (112 kB)\n",
-      "Downloading lxml-5.3.0-cp312-cp312-manylinux_2_28_x86_64.whl (4.9 MB)\n",
-      "   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.9/4.9 MB 11.5 MB/s eta 0:00:00\n",
-      "Downloading multitasking-0.0.11-py3-none-any.whl (8.5 kB)\n",
-      "Downloading platformdirs-4.3.6-py3-none-any.whl (18 kB)\n",
-      "Downloading requests-2.32.3-py3-none-any.whl (64 kB)\n",
-      "Downloading certifi-2024.8.30-py3-none-any.whl (167 kB)\n",
-      "Downloading charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (141 kB)\n",
-      "Downloading idna-3.10-py3-none-any.whl (70 kB)\n",
-      "Downloading soupsieve-2.6-py3-none-any.whl (36 kB)\n",
-      "Downloading urllib3-2.2.3-py3-none-any.whl (126 kB)\n",
-      "Downloading webencodings-0.5.1-py2.py3-none-any.whl (11 kB)\n",
-      "Building wheels for collected packages: peewee\n",
-      "  Building wheel for peewee (pyproject.toml): started\n",
-      "  Building wheel for peewee (pyproject.toml): finished with status 'done'\n",
-      "  Created wheel for peewee: filename=peewee-3.17.6-py3-none-any.whl size=138891 sha256=2ebfaa05ebbf22e164164fd4c2b09d7c7c279dd785fbd5ac8419c7f62c32f90f\n",
-      "  Stored in directory: /root/.cache/pip/wheels/a6/5e/0f/8319805c4115320e0d3e8fb5799b114a2e4c4a3d6c7e523b06\n",
-      "Successfully built peewee\n",
-      "Installing collected packages: webencodings, peewee, multitasking, urllib3, soupsieve, platformdirs, lxml, idna, html5lib, frozendict, charset-normalizer, certifi, requests, beautifulsoup4, yfinance\n",
-      "Successfully installed beautifulsoup4-4.12.3 certifi-2024.8.30 charset-normalizer-3.3.2 frozendict-2.4.4 html5lib-1.1 idna-3.10 lxml-5.3.0 multitasking-0.0.11 peewee-3.17.6 platformdirs-4.3.6 requests-2.32.3 soupsieve-2.6 urllib3-2.2.3 webencodings-0.5.1 yfinance-0.2.43\n",
-      "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "[*********************100%***********************]  1 of 1 completed\n",
-      "The plot has been saved as 'nvidia_tesla_2024_ytd.png'.\n",
-      "\n",
-      "\n",
-      "--------------------------------------------------------------------------------\n",
-      "coding_assistant:\n",
-      "The plot has been successfully saved as `nvidia_tesla_2024_ytd.png`. You should now see the file in your directory. This file contains the year-to-date cumulative return plot of NVIDIA and Tesla stocks for the year 2024.\n",
-      "\n",
-      "If you need any further assistance, feel free to ask. TERMINATE\n",
-      "\n",
-      "TeamRunResult(result='The plot has been successfully saved as `nvidia_tesla_2024_ytd.png`. You should now see the file in your directory. This file contains the year-to-date cumulative return plot of NVIDIA and Tesla stocks for the year 2024.\\n\\nIf you need any further assistance, feel free to ask. TERMINATE')\n"
-     ]
-    }
-   ],
-   "source": [
-    "from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent\n",
-    "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
-    "from autogen_ext.code_executors import DockerCommandLineCodeExecutor\n",
-    "\n",
-    "async with DockerCommandLineCodeExecutor(work_dir=\"coding\") as code_executor:  # type: ignore[syntax]\n",
-    "    code_executor_agent = CodeExecutorAgent(\"code_executor\", code_executor=code_executor)\n",
-    "    coding_assistant_agent = CodingAssistantAgent(\n",
-    "        \"coding_assistant\", model_client=OpenAIChatCompletionClient(model=\"gpt-4o\")\n",
-    "    )\n",
-    "    group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent])\n",
-    "    result = await group_chat.run(\n",
-    "        task=\"Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'.\",\n",
-    "        termination_condition=StopMessageTermination(),\n",
-    "    )\n",
-    "    print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       ""
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from IPython.display import Image\n",
-    "\n",
-    "Image(filename=\"coding/nvidia_tesla_2024_ytd.png\")  # type: ignore"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/index.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/index.md
deleted file mode 100644
index d25e8e6cb47d..000000000000
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/index.md
+++ /dev/null
@@ -1,22 +0,0 @@
----
-myst:
-  html_meta:
-    "description lang=en": |
-      User Guide for AutoGen AgentChat, a framework for building multi-agent applications with AI agents.
----
-
-# Guides
-
-```{warning}
-🚧 Under construction 🚧
-```
-
-```{toctree}
-:maxdepth: 1
-:hidden:
-
-tool_use
-code-execution
-selector-group-chat
-```
-
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/tool_use.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/tool_use.ipynb
deleted file mode 100644
index 4a345497aa92..000000000000
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/tool_use.ipynb
+++ /dev/null
@@ -1,185 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tool Use\n",
-    "\n",
-    "The `AgentChat` api provides a `ToolUseAssistantAgent` with presets for adding tools that the agent can call as part of it's response. \n",
-    "\n",
-    ":::{note}\n",
-    "\n",
-    "The example presented here is a work in progress 🚧. Also, tool uses here assumed the `model_client` used by the agent supports tool calling. \n",
-    "::: "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from autogen_agentchat.agents import ToolUseAssistantAgent\n",
-    "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
-    "from autogen_core.components.tools import FunctionTool"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In AgentChat, a Tool is a function wrapped in the `FunctionTool` class exported from `autogen_core.components.tools`.   "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "async def get_weather(city: str) -> str:\n",
-    "    return f\"The weather in {city} is 72 degrees and Sunny.\"\n",
-    "\n",
-    "\n",
-    "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, agents that use tools are defined in the following manner. \n",
-    "\n",
-    "-  An agent is instantiated based on the  `ToolUseAssistantAgent` class in AgentChat. The agent is aware of the tools it can use by passing a `tools_schema` attribute to the class, which is passed to the `model_client` when the agent generates a response.\n",
-    "-  An agent Team is defined that takes a list of `tools`.  Effectively, the `ToolUseAssistantAgent` can generate messages that call tools, and the team is responsible executing those tool calls and returning the results."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-08T20:34:31.935149]:\u001b[0m\n",
-      "\n",
-      "What's the weather in New York?"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-08T20:34:33.080494], Weather_Assistant:\u001b[0m\n",
-      "\n",
-      "The weather in New York is 72 degrees and sunny. \n",
-      "\n",
-      "TERMINATE"
-     ]
-    }
-   ],
-   "source": [
-    "assistant = ToolUseAssistantAgent(\n",
-    "    \"Weather_Assistant\",\n",
-    "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
-    "    registered_tools=[get_weather_tool],\n",
-    ")\n",
-    "team = RoundRobinGroupChat([assistant])\n",
-    "result = await team.run(\"What's the weather in New York?\", termination_condition=StopMessageTermination())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using Langchain Tools \n",
-    "\n",
-    "AutoGen also provides direct support for tools from LangChain via the `autogen_ext`  package.\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# pip install langchain, langchain-community, wikipedia , autogen-ext\n",
-    "\n",
-    "import wikipedia\n",
-    "from autogen_ext.tools.langchain import LangChainToolAdapter\n",
-    "from langchain.tools import WikipediaQueryRun\n",
-    "from langchain_community.utilities import WikipediaAPIWrapper\n",
-    "\n",
-    "api_wrapper = WikipediaAPIWrapper(wiki_client=wikipedia, top_k_results=1, doc_content_chars_max=100)\n",
-    "tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n",
-    "\n",
-    "langchain_wikipedia_tool = LangChainToolAdapter(tool)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-08T20:44:08.218758]:\u001b[0m\n",
-      "\n",
-      "Who was the first president of the United States?\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-08T20:44:11.240067], WikiPedia_Assistant:\u001b[0m\n",
-      "\n",
-      "The first president of the United States was George Washington, who served from April 30, 1789, to March 4, 1797. \n",
-      "\n",
-      "TERMINATE"
-     ]
-    }
-   ],
-   "source": [
-    "wikipedia_assistant = ToolUseAssistantAgent(\n",
-    "    \"WikiPedia_Assistant\",\n",
-    "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
-    "    registered_tools=[langchain_wikipedia_tool],\n",
-    ")\n",
-    "team = RoundRobinGroupChat([wikipedia_assistant])\n",
-    "result = await team.run(\n",
-    "    \"Who was the first president of the United States?\", termination_condition=StopMessageTermination()\n",
-    ")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.12.5"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/index.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/index.md
index 48e0736262b1..0c6fdeb37235 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/index.md
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/index.md
@@ -11,31 +11,49 @@ AgentChat is a high-level package for building multi-agent applications built on
 
 AgentChat aims to provide intuitive defaults, such as **Agents** with preset behaviors and **Teams** with predefined communication protocols, to simplify building multi-agent applications.
 
+```{include} warning.md
+
+```
+
 ```{tip}
 If you are interested in implementing complex agent interaction behaviours, defining custom messaging protocols, or orchestration mechanisms, consider using the [ `autogen-core`](../core-user-guide/index.md) package.
 
 ```
 
-## Agents
+::::{grid} 2 2 2 2
+:gutter: 3
+
+:::{grid-item-card} {fas}`download;pst-color-primary` Installation
+:link: ./installation.html
+
+How to install AgentChat
+:::
+
+:::{grid-item-card} {fas}`rocket;pst-color-primary` Quickstart
+:link: ./quickstart.html
 
-Agents provide presets for how an agent might respond to received messages. The following Agents are currently supported:
+Build your first agent
+:::
 
-- `CodingAssistantAgent` - Generates responses using an LLM on receipt of a message
-- `CodeExecutionAgent` - Extracts and executes code snippets found in received messages and returns the output
-- `ToolUseAssistantAgent` - Responds with tool call messages based on received messages and a list of tool schemas provided at initialization
+:::{grid-item-card} {fas}`graduation-cap;pst-color-primary` Tutorial
+:link: ./tutorial/index.html
 
-## Teams
+Step-by-step guide to using AgentChat
+:::
 
-Teams define how groups of agents communicate to address tasks. The following Teams are currently supported:
+:::{grid-item-card} {fas}`code;pst-color-primary` Examples
+:link: ./examples/index.html
 
-- `RoundRobinGroupChat` - A team where agents take turns sending messages (in a round robin fashion) until a termination condition is met
-- `SelectorGroupChat` - A team where a model is used to select the next agent to send a message based on the current conversation history.
+Sample code and use cases
+:::
+::::
 
 ```{toctree}
 :maxdepth: 1
 :hidden:
 
+installation
 quickstart
-guides/index
+tutorial/index
 examples/index
 ```
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
new file mode 100644
index 000000000000..6c614142fb77
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
@@ -0,0 +1,78 @@
+---
+myst:
+  html_meta:
+    "description lang=en": |
+      Installing AutoGen AgentChat
+---
+
+# Installation
+
+## Create a virtual environment (optional)
+
+When installing AgentChat locally, we recommend using a virtual environment for the installation. This will ensure that the dependencies for AgentChat are isolated from the rest of your system.
+
+``````{tab-set}
+
+`````{tab-item} venv
+
+Create and activate:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+```
+
+To deactivate later, run:
+
+```bash
+deactivate
+```
+
+`````
+
+`````{tab-item} conda
+
+[Install Conda](https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html) if you have not already.
+
+
+Create and activate:
+
+```bash
+conda create -n autogen python=3.10
+conda activate autogen
+```
+
+To deactivate later, run:
+
+```bash
+conda deactivate
+```
+
+
+`````
+
+
+
+``````
+
+## Intall the AgentChat package using pip:
+
+Install the `autogen-agentchat` package using pip:
+
+```bash
+
+pip install autogen-agentchat==0.4.0dev1
+```
+
+## Install Docker for Code Execution
+
+We recommend using Docker for code execution.
+To install Docker, follow the instructions for your operating system on the [Docker website](https://docs.docker.com/get-docker/).
+
+A simple example of how to use Docker for code execution is shown below:
+
+
+
+To learn more about agents that execute code, see the [agents tutorial](./tutorial/agents.ipynb).
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
new file mode 100644
index 000000000000..5a2bc0d22df8
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -0,0 +1,133 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Quickstart"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{include} warning.md\n",
+    "\n",
+    "```\n",
+    "\n",
+    ":::{note}\n",
+    "For installation instructions, please refer to the [installation guide](./installation).\n",
+    ":::\n",
+    "\n",
+    "\n",
+    "\n",
+    "An agent is a software entity that communicates via messages, maintains its own state, and performs actions in response to received messages or changes in its state. \n",
+    "\n",
+    "In AgentChat, agents can be rapidly implemented using preset agent configurations. To illustrate this, we will begin with creating an agent that can address tasks by responding to messages it receives. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:32.381165]:\u001b[0m\n",
+      "\n",
+      "What is the weather in New York?\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:33.698359], writing_agent:\u001b[0m\n",
+      "\n",
+      "The weather in New York is currently 73 degrees and sunny. TERMINATE\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:33.698749], Termination:\u001b[0m\n",
+      "\n",
+      "Maximal number of messages 1 reached, current message count: 1\n",
+      " TeamRunResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), StopMessage(source='writing_agent', content='The weather in New York is currently 73 degrees and sunny. TERMINATE')])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import logging\n",
+    "\n",
+    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
+    "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat\n",
+    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
+    "from autogen_core.components.tools import FunctionTool\n",
+    "\n",
+    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
+    "logger.addHandler(ConsoleLogHandler())\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "\n",
+    "# define a tool\n",
+    "async def get_weather(city: str) -> str:\n",
+    "    return f\"The weather in {city} is 73 degrees and Sunny.\"\n",
+    "\n",
+    "\n",
+    "# wrap the tool for use with the agent\n",
+    "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")\n",
+    "\n",
+    "# define an agent\n",
+    "weather_agent = ToolUseAssistantAgent(\n",
+    "    name=\"writing_agent\",\n",
+    "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-2024-08-06\"),\n",
+    "    registered_tools=[get_weather_tool],\n",
+    ")\n",
+    "\n",
+    "# add the agent to a team\n",
+    "agent_team = RoundRobinGroupChat([weather_agent])\n",
+    "result = await agent_team.run(\n",
+    "    task=\"What is the weather in New York?\",\n",
+    "    termination_condition=MaxMessageTermination(max_messages=1),\n",
+    ")\n",
+    "print(\"\\n\", result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The code snippet above introduces two high level concepts in AgentChat: `Agent` and `Team`.  An Agent helps us define what actions are taken when a message is received. Specifically, we use the `ToolUseAssistantAgent` preset - an agent that can be given a function that it can then use to address tasks.  A Team helps us define the rules for how agents interact with each other.  In the  `RoundRobinGroupChat` team, agents receive messages in a sequential round-robin fashion.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What's Next?\n",
+    "\n",
+    "Now that you have a basic understanding of how to define an agent and a team, consider following the [tutorial](./tutorial/index) for a walkthrough on other features of AgentChat.\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "agnext",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.md
deleted file mode 100644
index 23b97b1c8f38..000000000000
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-myst:
-  html_meta:
-    "description lang=en": |
-      Quick Start Guide for AgentChat: Migrating from AutoGen 0.2x to 0.4x.
----
-
-# Quick Start
-
-AgentChat API, introduced in AutoGen 0.4x, offers a similar level of abstraction as the default Agent classes in AutoGen 0.2x.
-
-## Installation
-
-Install the `autogen-agentchat` package using pip:
-
-```bash
-
-pip install autogen-agentchat==0.4.0dev1
-```
-
-:::{note}
-For further installation instructions, please refer to the [package information](pkg-info-autogen-agentchat).
-:::
-
-## Creating a Simple Agent Team
-
-The following example illustrates creating a simple agent team with two agents that interact to solve a task.
-
-1. `CodingAssistantAgent` that generates responses using an LLM model.
-2. `CodeExecutorAgent` that executes code snippets and returns the output.
-
-Because the `CodeExecutorAgent` uses a Docker command-line code executor to execute code snippets,
-you need to have [Docker installed](https://docs.docker.com/engine/install/) and running on your machine.
-
-The task is to "Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
-
-```{include} stocksnippet.md
-
-```
-
-```{tip}
-AgentChat in v0.4x provides similar abstractions to the default agents in v0.2x. The `CodingAssistantAgent` and `CodeExecutorAgent` in v0.4x are equivalent to the `AssistantAgent` and `UserProxyAgent` with code execution in v0.2x.
-```
-
-If you are exploring migrating your code from AutoGen 0.2x to 0.4x, the following are some key differences to consider:
-
-1. In v0.4x, agent interactions are managed by `Teams` (e.g., `RoundRobinGroupChat`), replacing direct chat initiation.
-2. v0.4x uses async/await syntax for improved performance and scalability.
-3. Configuration in v0.4x is more modular, with separate components for code execution and LLM clients.
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/stocksnippet.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/stocksnippet.md
deleted file mode 100644
index a4e827428302..000000000000
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/stocksnippet.md
+++ /dev/null
@@ -1,54 +0,0 @@
-``````{tab-set}
-
-`````{tab-item} AgentChat (v0.4x)
-```python
-import asyncio
-import logging
-from autogen_agentchat import EVENT_LOGGER_NAME
-from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
-from autogen_agentchat.logging import ConsoleLogHandler
-from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination
-from autogen_ext.code_executors import DockerCommandLineCodeExecutor
-from autogen_core.components.models import OpenAIChatCompletionClient
-
-logger = logging.getLogger(EVENT_LOGGER_NAME)
-logger.addHandler(ConsoleLogHandler())
-logger.setLevel(logging.INFO)
-
-async def main() -> None:
-    async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor:
-        code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor)
-        coding_assistant_agent = CodingAssistantAgent(
-            "coding_assistant", model_client=OpenAIChatCompletionClient(model="gpt-4o", api_key="YOUR_API_KEY")
-        )
-        group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent])
-        result = await group_chat.run(
-            task="Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'.",
-            termination_condition=StopMessageTermination(),
-        )
-
-asyncio.run(main())
-```
-`````
-
-`````{tab-item} v0.2x
-```python
-from autogen.coding import DockerCommandLineCodeExecutor
-from autogen import AssistantAgent, UserProxyAgent, config_list_from_json
-
-llm_config = {"model": "gpt-4o", "api_type": "openai", "api_key": "YOUR_API_KEY"}
-code_executor = DockerCommandLineCodeExecutor(work_dir="coding")
-assistant = AssistantAgent("assistant", llm_config=llm_config)
-code_executor_agent = UserProxyAgent(
-    "code_executor_agent",
-    code_execution_config={"executor": code_executor},
-)
-result = code_executor_agent.initiate_chat(
-    assistant,
-    message="Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'.",
-)
-code_executor.stop()
-```
-`````
-
-``````
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/.gitignore b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/.gitignore
similarity index 100%
rename from python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/.gitignore
rename to python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/.gitignore
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
new file mode 100644
index 000000000000..649c90dc3985
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -0,0 +1,320 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "# Agents\n",
+    "\n",
+    "An agent is a software entity that communicates via messages, maintains its own state, and performs actions in response to received messages or changes in its state. \n",
+    "\n",
+    "```{include} ../warning.md\n",
+    "\n",
+    "```\n",
+    "\n",
+    "AgentChat provides a set of preset Agents, each with variations in how an agent might respond to received messages. \n",
+    "\n",
+    "Each agent inherits from a {py:class}`~autogen_agentchat.agents.BaseChatAgent`   class with a few generic properties:\n",
+    "\n",
+    "- `name`: The name of the agent. This is used by the team to uniquely identify the agent. It should be unique within the team.\n",
+    "- `description`: The description of the agent. This is used by the team to make decisions about which agents to use. The description should detail the agent's capabilities and how to interact with it.\n",
+    " \n",
+    "```{tip}\n",
+    "How do agents send and receive messages? \n",
+    "\n",
+    "AgentChat is built on the `autogen-core` package, which handles the details of sending and receiving messages. `autogen-core` provides a runtime environment, which facilitates communication between agents (message sending and delivery), manages their identities and lifecycles, and enforces security and privacy boundaries. \n",
+    "AgentChat handles the details of instantiating a runtime and registering agents with the runtime.\n",
+    "\n",
+    "To learn more about the runtime in `autogen-core`, see the [autogen-core documentation on agents and runtime](../../core-user-guide/framework/agent-and-agent-runtime.ipynb).\n",
+    "```\n",
+    "\n",
+    "Each agent also implements an {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages` method that defines the behavior of the agent in response to a message.\n",
+    "\n",
+    "\n",
+    "To begin, let us import the required classes and set up a model client that will be used by agents.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "\n",
+    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
+    "from autogen_agentchat.agents import CodingAssistantAgent, TextMessage, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, SelectorGroupChat\n",
+    "from autogen_core.base import CancellationToken\n",
+    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
+    "from autogen_core.components.tools import FunctionTool\n",
+    "\n",
+    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
+    "logger.addHandler(ConsoleLogHandler())\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "\n",
+    "# Create an OpenAI model client.\n",
+    "model_client = OpenAIChatCompletionClient(\n",
+    "    model=\"gpt-4o-2024-08-06\",\n",
+    "    # api_key=\"sk-...\", # Optional if you have an OPENAI_API_KEY env variable set.\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    ""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "## ToolUseAssistantAgent\n",
+    "\n",
+    "This agent responds to messages by making appropriate tool or function calls.\n",
+    "\n",
+    "```{tip}\n",
+    "Understanding Tool Calling\n",
+    "\n",
+    "Large Language Models (LLMs) are typically limited to generating text or code responses. However, many complex tasks benefit from the ability to use external tools that perform specific actions, such as fetching data from APIs or databases.\n",
+    "\n",
+    "To address this limitation, modern LLMs can now accept a list of available tool schemas (descriptions of tools and their arguments) and generate a tool call message. This capability is known as **Tool Calling** or **Function Calling** and is becoming a popular pattern in building intelligent agent-based applications.\n",
+    "\n",
+    "For more information on tool calling, refer to the documentation from [OpenAI](https://platform.openai.com/docs/guides/function-calling) and [Anthropic](https://docs.anthropic.com/en/docs/build-with-claude/tool-use).\n",
+    "```\n",
+    "\n",
+    "To set up a ToolUseAssistantAgent in AgentChat, follow these steps:\n",
+    "\n",
+    "1. Define the tool, typically as a Python function.\n",
+    "2. Wrap the function in the `FunctionTool` class from the `autogen-core` package. This ensures the function schema can be correctly parsed and used for tool calling.\n",
+    "3. Attach the tool to the agent.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "async def get_weather(city: str) -> str:\n",
+    "    return f\"The weather in {city} is 72 degrees and Sunny.\"\n",
+    "\n",
+    "\n",
+    "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")\n",
+    "\n",
+    "tool_use_agent = ToolUseAssistantAgent(\n",
+    "    \"tool_use_agent\",\n",
+    "    system_message=\"You are a helpful assistant that solves tasks by only using your tools.\",\n",
+    "    model_client=model_client,\n",
+    "    registered_tools=[get_weather_tool],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "source='tool_use_agent' content=\"Could you please specify a city in France for which you'd like to get the current weather?\"\n"
+     ]
+    }
+   ],
+   "source": [
+    "tool_result = await tool_use_agent.on_messages(\n",
+    "    messages=[\n",
+    "        TextMessage(content=\"What is the weather right now in France?\", source=\"user\"),\n",
+    "    ],\n",
+    "    cancellation_token=CancellationToken(),\n",
+    ")\n",
+    "print(tool_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that the response generated by the ToolUseAssistantAgent is a tool call message which can then be executed to get the right result. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "## CodeExecutionAgent \n",
+    "\n",
+    "This agent preset extracts and executes code snippets found in received messages and returns the output. It is typically used within a team where a `CodingAssistantAgent` is also present - the `CodingAssistantAgent` can generate code snippets, which the `CodeExecutionAgent` receives and executes to make progress on a task. \n",
+    "\n",
+    "```{note}\n",
+    "It is recommended that the `CodeExecutionAgent` uses a Docker container to execute code snippets. This ensures that the code snippets are executed in a safe and isolated environment. To use Docker, your environment must have Docker installed and running. \n",
+    "If you do not have Docker installed, you can install it from the [Docker website](https://docs.docker.com/get-docker/) or alternatively skip the next cell.\n",
+    "```\n",
+    "\n",
+    "In the code snippet below, we show how to set up a `CodeExecutionAgent` that uses the `DockerCommandLineCodeExecutor` class to execute code snippets in a Docker container. The `work_dir` parameter indicates where all executed files are first saved locally before being executed in the Docker container.\n",
+    "\n",
+    "\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "source='code_executor' content='No code blocks found in the thread.'\n"
+     ]
+    }
+   ],
+   "source": [
+    "from autogen_agentchat.agents import CodeExecutorAgent\n",
+    "from autogen_ext.code_executors import DockerCommandLineCodeExecutor\n",
+    "\n",
+    "async with DockerCommandLineCodeExecutor(work_dir=\"coding\") as code_executor:  # type: ignore[syntax]\n",
+    "    code_executor_agent = CodeExecutorAgent(\"code_executor\", code_executor=code_executor)\n",
+    "    code_execution_result = await code_executor_agent.on_messages(\n",
+    "        messages=[\n",
+    "            TextMessage(content=\"Here is some code \\n ```python print('Hello world') \\n``` \", source=\"user\"),\n",
+    "        ],\n",
+    "        cancellation_token=CancellationToken(),\n",
+    "    )\n",
+    "    print(code_execution_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Building Custom Agents\n",
+    "\n",
+    "In many cases, you may have agents with custom behaviors that do not fall into any of the preset agent categories. In such cases, you can build custom agents by subclassing the {py:class}`~autogen_agentchat.agents.BaseChatAgent`   class and implementing the  {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages`  method.\n",
+    "\n",
+    "A common example is an agent that can be part of a team but primarily is driven by human input. Other examples include agents that respond with specific text, tool or function calls. \n",
+    "\n",
+    "In the example below we show hot to implement a `UserProxyAgent` - an agent that asks the user to enter some text and then returns that message as a response.  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "source='user_proxy_agent' content='Hello there'\n"
+     ]
+    }
+   ],
+   "source": [
+    "import asyncio\n",
+    "from typing import Sequence\n",
+    "\n",
+    "from autogen_agentchat.agents import (\n",
+    "    BaseChatAgent,\n",
+    "    ChatMessage,\n",
+    "    StopMessage,\n",
+    "    TextMessage,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "class UserProxyAgent(BaseChatAgent):\n",
+    "    def __init__(self, name: str) -> None:\n",
+    "        super().__init__(name, \"A human user.\")\n",
+    "\n",
+    "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:\n",
+    "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
+    "        if \"TERMINATE\" in user_input:\n",
+    "            return StopMessage(content=\"User has terminated the conversation.\", source=self.name)\n",
+    "        return TextMessage(content=user_input, source=self.name)\n",
+    "\n",
+    "\n",
+    "user_proxy_agent = UserProxyAgent(name=\"user_proxy_agent\")\n",
+    "\n",
+    "user_proxy_agent_result = await user_proxy_agent.on_messages(\n",
+    "    messages=[\n",
+    "        TextMessage(content=\"What is the weather right now in France?\", source=\"user\"),\n",
+    "    ],\n",
+    "    cancellation_token=CancellationToken(),\n",
+    ")\n",
+    "print(user_proxy_agent_result)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "So far, we have learned a few key concepts:\n",
+    "\n",
+    "- How to define agents   \n",
+    "- How to send messages to agents by calling the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages`  method on the {py:class}`~autogen_agentchat.agents.BaseChatAgent` class and viewing the agent's response \n",
+    "- An overview of the different types of agents available in AgentChat\n",
+    "- How to build custom agents\n",
+    "\n",
+    "However, the ability to address complex tasks is often best served by groups of agents that interact as a team. Let us review how to build these teams."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "agnext",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/index.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/index.md
new file mode 100644
index 000000000000..246629aec1a1
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/index.md
@@ -0,0 +1,54 @@
+---
+myst:
+  html_meta:
+    "description lang=en": |
+      Tutorial for AutoGen AgentChat, a framework for building multi-agent applications with AI agents.
+---
+
+# Tutorial
+
+Tutorial to get started with AgentChat.
+
+```{include} ../warning.md
+
+```
+
+::::{grid} 2 2 2 3
+:gutter: 3
+
+:::{grid-item-card} {fas}`book-open;pst-color-primary` Introduction
+:link: ./introduction.html
+
+Overview of agents and teams in AgentChat
+:::
+
+:::{grid-item-card} {fas}`users;pst-color-primary` Agents
+:link: ./agents.html
+
+Building agents that use LLMs, tools, and execute code.
+:::
+
+:::{grid-item-card} {fas}`users;pst-color-primary` Teams  
+:link: ./teams.html
+
+Coordinating multiple agents in teams.
+:::
+
+:::{grid-item-card} {fas}`flag-checkered;pst-color-primary` Chat Termination
+:link: ./termination.html
+
+Determining when to end a task.
+:::
+
+::::
+
+```{toctree}
+:maxdepth: 1
+:hidden:
+
+introduction
+agents
+teams
+termination
+selector-group-chat
+```
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
new file mode 100644
index 000000000000..d75ffc4b2169
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Introduction\n",
+    "\n",
+    "\n",
+    "AgentChat provides intuitive defaults, such as **Agents** with preset behaviors and **Teams** with predefined communication protocols, to simplify building multi-agent applications.\n",
+    "\n",
+    ":::{note}\n",
+    "For installation instructions, please refer to the [installation guide](../installation.md).\n",
+    ":::\n",
+    "\n",
+    "\n",
+    "## Defining a Model Client \n",
+    "\n",
+    "In many cases, an agent will require access to a generative model. AgentChat utilizes the model clients provided by the [ `autogen-core`](../../core-user-guide/framework/model-clients.ipynb) package to access models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CreateResult(finish_reason='stop', content='The capital of France is Paris.', usage=RequestUsage(prompt_tokens=15, completion_tokens=7), cached=False, logprobs=None)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from autogen_core.components.models import OpenAIChatCompletionClient, UserMessage\n",
+    "\n",
+    "# Create an OpenAI model client.\n",
+    "model_client = OpenAIChatCompletionClient(\n",
+    "    model=\"gpt-4o-2024-08-06\",\n",
+    "    # api_key=\"sk-...\", # Optional if you have an OPENAI_API_KEY env variable set.\n",
+    ")\n",
+    "model_client_result = await model_client.create(\n",
+    "    messages=[\n",
+    "        UserMessage(content=\"What is the capital of France?\", source=\"user\"),\n",
+    "    ]\n",
+    ")\n",
+    "print(model_client_result)  # \"Paris\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Handling Logs\n",
+    "\n",
+    "As agents interact with each other, they generate logs that can be useful in building and debugging multi-agent systems. Your application can consume these logs by attaching a log handler to the AgentChat events. AgentChat also provides a default log handler that writes logs to the console and file.\n",
+    "\n",
+    "Attache the log handler before running your application to view agent message logs. \n",
+    "\n",
+    "```{tip}\n",
+    "You can implement your own log handler and attach it to the AgentChat events.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "\n",
+    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
+    "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "\n",
+    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
+    "logger.addHandler(ConsoleLogHandler())\n",
+    "logger.setLevel(logging.INFO)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Whats Next ?\n",
+    "\n",
+    "Now that we have installed the `autogen-agentchat` package, let's move on to exploring how to build agents using the agent presets provided by the package."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "agnext",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
similarity index 100%
rename from python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/guides/selector-group-chat.ipynb
rename to python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
new file mode 100644
index 000000000000..2d414d18026d
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -0,0 +1,216 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Teams\n",
+    "\n",
+    "Teams define how groups of agents communicate to address tasks. AgentChat provides several preset team configurations to simplify building multi-agent applications.\n",
+    "\n",
+    "```{include} ../warning.md\n",
+    "\n",
+    "```\n",
+    "\n",
+    "A team may consist of a single agent or multiple agents. An important configuration for each team involves defining the order in which agents send messages and determining when the team should terminate.\n",
+    "\n",
+    "In the following section, we will begin by defining agents."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "\n",
+    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
+    "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, SelectorGroupChat\n",
+    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
+    "from autogen_core.components.tools import FunctionTool\n",
+    "\n",
+    "# Set up a log handler to print logs to the console.\n",
+    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
+    "logger.addHandler(ConsoleLogHandler())\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "\n",
+    "# Create an OpenAI model client.\n",
+    "model_client = OpenAIChatCompletionClient(\n",
+    "    model=\"gpt-4o-2024-08-06\",\n",
+    "    # api_key=\"sk-...\", # Optional if you have an OPENAI_API_KEY env variable set.\n",
+    ")\n",
+    "\n",
+    "writing_assistant_agent = CodingAssistantAgent(\n",
+    "    name=\"writing_assistant_agent\",\n",
+    "    system_message=\"You are a helpful assistant that solve tasks by generating text responses and code.\",\n",
+    "    model_client=model_client,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "async def get_weather(city: str) -> str:\n",
+    "    return f\"The weather in {city} is 72 degrees and Sunny.\"\n",
+    "\n",
+    "\n",
+    "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")\n",
+    "\n",
+    "tool_use_agent = ToolUseAssistantAgent(\n",
+    "    \"tool_use_agent\",\n",
+    "    system_message=\"You are a helpful assistant that solves tasks by only using your tools.\",\n",
+    "    model_client=model_client,\n",
+    "    registered_tools=[get_weather_tool],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### RoundRobinGroupChat\n",
+    "\n",
+    "A team where agents take turns sending messages (in a round robin fashion) until a termination condition is met. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:04.692283]:\u001b[0m\n",
+      "\n",
+      "Write a Haiku about the weather in Paris\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:05.961670], tool_use_agent:\u001b[0m\n",
+      "\n",
+      "Golden sun above,  \n",
+      "Paris basks in warmth and light,  \n",
+      "Seine flows in sunshine.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:05.962309], Termination:\u001b[0m\n",
+      "\n",
+      "Maximal number of messages 1 reached, current message count: 1"
+     ]
+    }
+   ],
+   "source": [
+    "round_robin_team = RoundRobinGroupChat([tool_use_agent, writing_assistant_agent])\n",
+    "round_robin_team_result = await round_robin_team.run(\n",
+    "    \"Write a Haiku about the weather in Paris\", termination_condition=MaxMessageTermination(max_messages=1)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Similarly, we can define a team where the agents solve a problem by _writing and executing code_ in a round-robin fashion. \n",
+    "\n",
+    "```python \n",
+    "async with DockerCommandLineCodeExecutor(work_dir=\"coding\") as code_executor:\n",
+    "    code_executor_agent = CodeExecutorAgent(\n",
+    "        \"code_executor\", code_executor=code_executor)\n",
+    "    code_execution_team = RoundRobinGroupChat([writing_assistant_agent, code_executor_agent])\n",
+    "    code_execution_team_result = await code_execution_team.run(\"Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png\", termination_condition=MaxMessageTermination(max_messages=12))\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SelctorGroupChat\n",
+    "\n",
+    "A team where a generative model (LLM) is used to select the next agent to send a message based on the current conversation history.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:05.967894]:\u001b[0m\n",
+      "\n",
+      "What is the weather in paris right now? Also write a haiku about it.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:07.214716], tool_use_agent:\u001b[0m\n",
+      "\n",
+      "The weather in Paris is currently 72 degrees and Sunny.\n",
+      "\n",
+      "Here's a Haiku about it:\n",
+      "\n",
+      "Golden sun above,  \n",
+      "Paris basks in warmth and light,  \n",
+      "Seine flows in sunshine.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:08.320789], writing_assistant_agent:\u001b[0m\n",
+      "\n",
+      "I can't check the real-time weather, but you can use a weather website or app to find the current weather in Paris. If you need a fresh haiku, here's one for sunny weather:\n",
+      "\n",
+      "Paris bathed in sun,  \n",
+      "Gentle warmth embraces all,  \n",
+      "Seine sparkles with light.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-20T09:01:08.321296], Termination:\u001b[0m\n",
+      "\n",
+      "Maximal number of messages 2 reached, current message count: 2"
+     ]
+    }
+   ],
+   "source": [
+    "llm_team = SelectorGroupChat([tool_use_agent, writing_assistant_agent], model_client=model_client)\n",
+    "\n",
+    "llm_team_result = await llm_team.run(\n",
+    "    \"What is the weather in paris right now? Also write a haiku about it.\",\n",
+    "    termination_condition=MaxMessageTermination(max_messages=2),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What's Next?\n",
+    "\n",
+    "In this section, we reviewed how to define model clients, agents, and teams in AgentChat. Here are some other concepts to explore further:\n",
+    "\n",
+    "- Termination Conditions: Define conditions that determine when a team should stop running. In this sample, we used a `MaxMessageTermination` condition to stop the team after a certain number of messages. Explore other termination conditions supported in the AgentChat package."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "agnext",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
new file mode 100644
index 000000000000..bdb1dccff3f3
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -0,0 +1,206 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Termination \n",
+    "\n",
+    "\n",
+    "In the previous section, we explored how to define agents, and organize them into teams that can solve tasks by communicating (a conversation). However, conversations can go on forever, and in many cases, we need to know _when_ to stop them. This is the role of the termination condition.\n",
+    "\n",
+    "AgentChat supports several termination condition by providing a base  `TerminationCondition` class and several implementations that inherit from it.\n",
+    "\n",
+    "A termination condition is a callable that takes a sequence of ChatMessage objects  since the last time the condition was called, and returns a StopMessage if the conversation should be terminated, or None otherwise. Once a termination condition has been reached, it must be reset before it can be used again.\n",
+    "\n",
+    "Some important things to note about termination conditions: \n",
+    "- They are stateful, and must be reset before they can be used again. \n",
+    "- They can be combined using the AND and OR operators. \n",
+    "- They are implemented/enforced by the team, and not by the agents. An agent may signal or request termination e.g., by  sending a StopMessage, but the team is responsible for enforcing it.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To begin, let us define a simple team with only one agent and then explore how multiple termination conditions can be applied to guide the resulting behavior."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import logging\n",
+    "\n",
+    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
+    "from autogen_agentchat.agents import CodingAssistantAgent\n",
+    "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, StopMessageTermination\n",
+    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
+    "\n",
+    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
+    "logger.addHandler(ConsoleLogHandler())\n",
+    "logger.setLevel(logging.INFO)\n",
+    "\n",
+    "\n",
+    "model_client = OpenAIChatCompletionClient(\n",
+    "    model=\"gpt-4o-2024-08-06\",\n",
+    "    temperature=1,\n",
+    "    # api_key=\"sk-...\", # Optional if you have an OPENAI_API_KEY env variable set.\n",
+    ")\n",
+    "\n",
+    "writing_assistant_agent = CodingAssistantAgent(\n",
+    "    name=\"writing_assistant_agent\",\n",
+    "    system_message=\"You are a helpful assistant that solve tasks by generating text responses and code.\",\n",
+    "    model_client=model_client,\n",
+    ")\n",
+    "\n",
+    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## MaxMessageTermination \n",
+    "\n",
+    "The simplest termination condition is the `MaxMessageTermination` condition, which terminates the conversation after a fixed number of messages. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:28.807176]:\u001b[0m\n",
+      "\n",
+      "Write a unique, Haiku about the weather in Paris\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:29.604935], writing_assistant_agent:\u001b[0m\n",
+      "\n",
+      "Gentle rain whispers,  \n",
+      "Eiffel veiled in mist’s embrace,  \n",
+      "Spring’s soft sigh in France.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:30.168531], writing_assistant_agent:\u001b[0m\n",
+      "\n",
+      "Gentle rain whispers,  \n",
+      "Eiffel veiled in mist’s embrace,  \n",
+      "Spring’s soft sigh in France.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:31.213291], writing_assistant_agent:\u001b[0m\n",
+      "\n",
+      "Gentle rain whispers,  \n",
+      "Eiffel veiled in mist’s embrace,  \n",
+      "Spring’s soft sigh in France.\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:31.213655], Termination:\u001b[0m\n",
+      "\n",
+      "Maximal number of messages 3 reached, current message count: 3"
+     ]
+    }
+   ],
+   "source": [
+    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])\n",
+    "round_robin_team_result = await round_robin_team.run(\n",
+    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=MaxMessageTermination(max_messages=3)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We see that the conversation is terminated after the specified number of messages have been sent by the agent."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## StopMessageTermination\n",
+    "\n",
+    "In this scenario, the team terminates the conversation if any agent sends a `StopMessage`. So, when does an agent send a `StopMessage`? Typically, this is implemented in the `on_message` method of the agent, where the agent can check the incoming message and decide to send a `StopMessage` based on some condition. \n",
+    "\n",
+    "A common pattern here is prompt the agent (or some agent participating in the conversation) to emit a specific text string in it's response, which can be used to trigger the termination condition. \n",
+    "\n",
+    "In fact, if you review the code implementation for the default `CodingAssistantAgent` class provided by AgentChat, you will observe two things\n",
+    "- The default `system_message` instructs the agent to end their response with the word \"terminate\" if they deem the task to be completed\n",
+    "- in the `on_message` method, the agent checks if the incoming message contains the text \"terminate\" and returns a `StopMessage` if it does. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:31.218855]:\u001b[0m\n",
+      "\n",
+      "Write a unique, Haiku about the weather in Paris\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:31.752676], writing_assistant_agent:\u001b[0m\n",
+      "\n",
+      "Mist hugs the Eiffel,  \n",
+      "Soft rain kisses cobblestones,  \n",
+      "Autumn whispers past.  \n",
+      "\n",
+      "TERMINATE\n",
+      "--------------------------------------------------------------------------- \n",
+      "\u001b[91m[2024-10-19T12:19:31.753265], Termination:\u001b[0m\n",
+      "\n",
+      "Stop message received"
+     ]
+    }
+   ],
+   "source": [
+    "writing_assistant_agent = CodingAssistantAgent(\n",
+    "    name=\"writing_assistant_agent\",\n",
+    "    system_message=\"You are a helpful assistant that solve tasks by generating text responses and code. Respond with TERMINATE when the task is done.\",\n",
+    "    model_client=model_client,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])\n",
+    "\n",
+    "round_robin_team_result = await round_robin_team.run(\n",
+    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=StopMessageTermination()\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "agnext",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/warning.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/warning.md
new file mode 100644
index 000000000000..102d9282ce2e
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/warning.md
@@ -0,0 +1,5 @@
+```{warning}
+
+AgentChat is Work in Progress. APIs may change in future releases.
+
+```

From 00e500ea90f83f774b9fe146ca2b7e2a79b6907b Mon Sep 17 00:00:00 2001
From: Mark Douthwaite 
Date: Tue, 22 Oct 2024 09:35:20 +0100
Subject: [PATCH 007/173] Fix small typos in AutoGen 0.4 docs (#3871)

---
 .../core-concepts/agent-identity-and-lifecycle.md               | 2 +-
 .../docs/src/user-guide/core-user-guide/quickstart.ipynb        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
index 31225585f618..95f1a8f05522 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
@@ -20,7 +20,7 @@ Agent ID = (Agent Type, Agent Key)
 ```
 
 The agent type is not an agent class.
-It associate an agent with a specific
+It associates an agent with a specific
 factory function, which produces instances of agents
 of the same agent type.
 For example, different factory functions can produce the same
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
index c882455e3d1f..e5d545cb6521 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
@@ -93,7 +93,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You might have already noticed, The agents' logic, whether it is using model or code executor,\n",
+    "You might have already noticed, the agents' logic, whether it is using model or code executor,\n",
     "is completely decoupled from\n",
     "how messages are delivered. This is the core idea: the framework provides\n",
     "a communication infrastructure, and the agents are responsible for their own\n",

From b7509b3659e16f8a0f579c10bffcc0ec3d1db2bb Mon Sep 17 00:00:00 2001
From: Gerardo Moreno <69287011+gziz@users.noreply.github.com>
Date: Tue, 22 Oct 2024 01:39:07 -0700
Subject: [PATCH 008/173] SelectorGroupChat Docs Update (#3876)

---
 .../tutorial/selector-group-chat.ipynb        | 41 +++++++++++++++++++
 .../agentchat-user-guide/tutorial/teams.ipynb |  2 +-
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index ed2a4bf8ecd6..6db803b7d721 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -7,6 +7,30 @@
     "# Selector Group Chat"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `SelectorGroupChat` implements a team coordination pattern where participants take turns publishing messages, with the next speaker selected by a generative model (LLM) based on the conversation context. This enables dynamic and context-aware multi-agent conversations.\n",
+    "\n",
+    "\n",
+    "`SelectorGroupChat` provides several key features:\n",
+    "- Dynamic speaker selection using an LLM to analyze conversation context\n",
+    "- Configurable participant roles and descriptions\n",
+    "- Optional prevention of consecutive turns by the same speaker\n",
+    "- Customizable selection prompting\n",
+    "\n",
+    "\n",
+    "### Speaker Selection Process\n",
+    "\n",
+    "The chat uses an LLM to select the next speaker by:\n",
+    "1. Analyzing the conversation history\n",
+    "2. Evaluating participant roles and descriptions\n",
+    "3. Using a configurable prompt template to make the selection\n",
+    "4. Validating that exactly one participant is selected\n",
+    "\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -30,6 +54,14 @@
     "from autogen_core.components.tools import FunctionTool"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Defining Agents\n",
+    "The `UserProxyAgent` allows the user to input messages directly. This agent waits for user input and returns a text message or a stop message if the user decides to terminate the conversation."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -67,6 +99,15 @@
     "    return f\"Booked flight {flight} on {date}\""
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `ToolUseAssistantAgent` is responsible for calling external tools. In this example, two tools are defined: `flight_search` and `flight_booking`.\n",
+    "\n",
+    "Additionally, the `CodingAssistantAgent` serves as a general travel assistant with predefined behavior specified in the `system_message`."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
index 2d414d18026d..ce30aee61cb1 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -127,7 +127,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### SelctorGroupChat\n",
+    "### SelectorGroupChat\n",
     "\n",
     "A team where a generative model (LLM) is used to select the next agent to send a message based on the current conversation history.\n"
    ]

From 38f62e1609f7eac7f40147be72afa3d05a577e9f Mon Sep 17 00:00:00 2001
From: Leonardo Pinheiro 
Date: Wed, 23 Oct 2024 01:40:41 +1000
Subject: [PATCH 009/173] migrate models (#3848)

* migrate models

* Update python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py

Co-authored-by: Eric Zhu 

* refactor missing imports

* ignore type check errors

* Update python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py

Co-authored-by: Eric Zhu 

* update packages index page

---------

Co-authored-by: Leonardo Pinheiro 
Co-authored-by: Eric Zhu 
---
 README.md                                     |   2 +-
 .../Templates/MagenticOne/scenario.py         |   2 -
 .../GAIA/Templates/MagenticOne/scenario.py    |   1 -
 .../Templates/MagenticOne/scenario.py         |   2 -
 .../Templates/MagenticOne/scenario.py         |   2 -
 .../tests/test_group_chat.py                  |   3 +-
 .../autogen-core/docs/src/packages/index.md   |   7 +-
 .../examples/company-research.ipynb           |   4 +-
 .../examples/literature-review.ipynb          |   4 +-
 .../examples/travel-planning.ipynb            |   2 +-
 .../tutorial/selector-group-chat.ipynb        |   4 +-
 .../cookbook/azure-openai-with-aad-auth.md    |   2 +-
 .../cookbook/structured-output-agent.ipynb    |   3 +-
 .../cookbook/tool-use-with-intervention.ipynb |   4 +-
 .../design-patterns/group-chat.ipynb          |   2 +-
 .../design-patterns/handoffs.ipynb            |   4 +-
 .../design-patterns/reflection.ipynb          |   2 +-
 .../framework/model-clients.ipynb             |  16 +-
 .../core-user-guide/quickstart.ipynb          |   2 +-
 .../components/models/__init__.py             |  36 +-
 python/packages/autogen-ext/pyproject.toml    |   4 +
 .../_azure_container_code_executor.py         |   2 +-
 .../code_executors/_docker_code_executor.py   |   8 +-
 .../src/autogen_ext/models/__init__.py        |   9 +
 .../autogen_ext/models/_openai/_model_info.py | 122 +++
 .../models/_openai/_openai_client.py          | 856 ++++++++++++++++++
 .../models/_openai/config/__init__.py         |  51 ++
 .../autogen_ext/tools/_langchain_adapter.py   |   2 +-
 .../tests/models/test_openai_model_client.py} |   9 +-
 .../autogen-magentic-one/pyproject.toml       |   1 +
 .../src/autogen_magentic_one/utils.py         |   7 +-
 python/pyproject.toml                         |   1 +
 python/uv.lock                                |  20 +
 33 files changed, 1141 insertions(+), 55 deletions(-)
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/models/__init__.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/models/_openai/config/__init__.py
 rename python/packages/{autogen-core/tests/test_model_client.py => autogen-ext/tests/models/test_openai_model_client.py} (95%)

diff --git a/README.md b/README.md
index 966b343332a3..c21169a16bac 100644
--- a/README.md
+++ b/README.md
@@ -114,7 +114,7 @@ from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
 from autogen_agentchat.logging import ConsoleLogHandler
 from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination
 from autogen_ext.code_executor.docker_executor import DockerCommandLineCodeExecutor
-from autogen_core.components.models import OpenAIChatCompletionClient
+from autogen_ext.models import OpenAIChatCompletionClient
 
 logger = logging.getLogger(EVENT_LOGGER_NAME)
 logger.addHandler(ConsoleLogHandler())
diff --git a/python/packages/agbench/benchmarks/AssistantBench/Templates/MagenticOne/scenario.py b/python/packages/agbench/benchmarks/AssistantBench/Templates/MagenticOne/scenario.py
index 3d79a16614a4..17d9125195d1 100644
--- a/python/packages/agbench/benchmarks/AssistantBench/Templates/MagenticOne/scenario.py
+++ b/python/packages/agbench/benchmarks/AssistantBench/Templates/MagenticOne/scenario.py
@@ -12,9 +12,7 @@
 from autogen_core.application import SingleThreadedAgentRuntime
 from autogen_core.application.logging import EVENT_LOGGER_NAME
 from autogen_core.components.models import (
-    AzureOpenAIChatCompletionClient,
     ChatCompletionClient,
-    ModelCapabilities,
     UserMessage,
     LLMMessage,
 )
diff --git a/python/packages/agbench/benchmarks/GAIA/Templates/MagenticOne/scenario.py b/python/packages/agbench/benchmarks/GAIA/Templates/MagenticOne/scenario.py
index 4058d75f3971..6c7f8ab763a5 100644
--- a/python/packages/agbench/benchmarks/GAIA/Templates/MagenticOne/scenario.py
+++ b/python/packages/agbench/benchmarks/GAIA/Templates/MagenticOne/scenario.py
@@ -12,7 +12,6 @@
 from autogen_core.application import SingleThreadedAgentRuntime
 from autogen_core.application.logging import EVENT_LOGGER_NAME
 from autogen_core.components.models import (
-    AzureOpenAIChatCompletionClient,
     ChatCompletionClient,
     ModelCapabilities,
     UserMessage,
diff --git a/python/packages/agbench/benchmarks/HumanEval/Templates/MagenticOne/scenario.py b/python/packages/agbench/benchmarks/HumanEval/Templates/MagenticOne/scenario.py
index 3229eba12589..a9b62a1e38e1 100644
--- a/python/packages/agbench/benchmarks/HumanEval/Templates/MagenticOne/scenario.py
+++ b/python/packages/agbench/benchmarks/HumanEval/Templates/MagenticOne/scenario.py
@@ -7,8 +7,6 @@
 from autogen_core.components import DefaultSubscription, DefaultTopicId
 from autogen_core.components.code_executor import LocalCommandLineCodeExecutor
 from autogen_core.components.models import (
-    AzureOpenAIChatCompletionClient,
-    ModelCapabilities,
     UserMessage,
 )
 
diff --git a/python/packages/agbench/benchmarks/WebArena/Templates/MagenticOne/scenario.py b/python/packages/agbench/benchmarks/WebArena/Templates/MagenticOne/scenario.py
index 79a36862f9d2..5cbf5c4c2134 100644
--- a/python/packages/agbench/benchmarks/WebArena/Templates/MagenticOne/scenario.py
+++ b/python/packages/agbench/benchmarks/WebArena/Templates/MagenticOne/scenario.py
@@ -13,9 +13,7 @@
 from autogen_core.components import DefaultSubscription, DefaultTopicId
 from autogen_core.components.code_executor import LocalCommandLineCodeExecutor
 from autogen_core.components.models import (
-    AzureOpenAIChatCompletionClient,
     ChatCompletionClient,
-    ModelCapabilities,
     UserMessage,
     SystemMessage,
     LLMMessage,
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index e297c8fd5100..21fb2ad4082c 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -24,8 +24,9 @@
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
 from autogen_core.components.code_executor import LocalCommandLineCodeExecutor
-from autogen_core.components.models import FunctionExecutionResult, OpenAIChatCompletionClient
+from autogen_core.components.models import FunctionExecutionResult
 from autogen_core.components.tools import FunctionTool
+from autogen_ext.models import OpenAIChatCompletionClient
 from openai.resources.chat.completions import AsyncCompletions
 from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
diff --git a/python/packages/autogen-core/docs/src/packages/index.md b/python/packages/autogen-core/docs/src/packages/index.md
index f04f20a297ab..62efe6446a5a 100644
--- a/python/packages/autogen-core/docs/src/packages/index.md
+++ b/python/packages/autogen-core/docs/src/packages/index.md
@@ -65,9 +65,10 @@ pip install autogen-ext==0.4.0dev1
 
 Extras:
 
-- `langchain-tools` needed for {py:class}`~autogen_ext.tools.LangChainToolAdapter`
-- `azure-code-executor` needed for {py:class}`~autogen_ext.code_executors.ACADynamicSessionsCodeExecutor`
-- `docker-code-executor` needed for {py:class}`~autogen_ext.code_executors.DockerCommandLineCodeExecutor`
+- `langchain` needed for {py:class}`~autogen_ext.tools.LangChainToolAdapter`
+- `azure` needed for {py:class}`~autogen_ext.code_executors.ACADynamicSessionsCodeExecutor`
+- `docker` needed for {py:class}`~autogen_ext.code_executors.DockerCommandLineCodeExecutor`
+- `openai` needed for {py:class}`~autogen_ext.models.OpenAIChatCompletionClient`
 
 [{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev1/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
 :::
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
index 6d051f472406..a627f877ce41 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
@@ -24,8 +24,8 @@
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
-    "from autogen_core.components.tools import FunctionTool"
+    "from autogen_core.components.tools import FunctionTool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
   {
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
index b28f523f7401..8857d9d32145 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
@@ -24,8 +24,8 @@
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
-    "from autogen_core.components.tools import FunctionTool"
+    "from autogen_core.components.tools import FunctionTool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
   {
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
index da6775400579..2683eb8a40ed 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
@@ -19,7 +19,7 @@
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient"
+    "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
   {
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index 6db803b7d721..7636f14d9240 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -50,8 +50,8 @@
     ")\n",
     "from autogen_agentchat.teams import SelectorGroupChat, StopMessageTermination\n",
     "from autogen_core.base import CancellationToken\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
-    "from autogen_core.components.tools import FunctionTool"
+    "from autogen_core.components.tools import FunctionTool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
   {
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/azure-openai-with-aad-auth.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/azure-openai-with-aad-auth.md
index a40cf0475c5d..c8e4b632bd03 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/azure-openai-with-aad-auth.md
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/azure-openai-with-aad-auth.md
@@ -15,7 +15,7 @@ pip install azure-identity
 ## Using the Model Client
 
 ```python
-from autogen_core.components.models import AzureOpenAIChatCompletionClient
+from autogen_ext.models import AzureOpenAIChatCompletionClient
 from azure.identity import DefaultAzureCredential, get_bearer_token_provider
 
 # Create the token provider
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/structured-output-agent.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/structured-output-agent.ipynb
index 17b9141c5ae7..fa50d6da2797 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/structured-output-agent.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/structured-output-agent.ipynb
@@ -65,7 +65,8 @@
     "import os\n",
     "from typing import Optional\n",
     "\n",
-    "from autogen_core.components.models import AzureOpenAIChatCompletionClient, UserMessage\n",
+    "from autogen_core.components.models import UserMessage\n",
+    "from autogen_ext.models import AzureOpenAIChatCompletionClient\n",
     "\n",
     "\n",
     "# Function to get environment variable and ensure it is not None\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/tool-use-with-intervention.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/tool-use-with-intervention.ipynb
index 44f9978e59ef..e7c41c41feb4 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/tool-use-with-intervention.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/cookbook/tool-use-with-intervention.ipynb
@@ -26,13 +26,13 @@
     "from autogen_core.components.models import (\n",
     "    ChatCompletionClient,\n",
     "    LLMMessage,\n",
-    "    OpenAIChatCompletionClient,\n",
     "    SystemMessage,\n",
     "    UserMessage,\n",
     ")\n",
     "from autogen_core.components.tool_agent import ToolAgent, ToolException, tool_agent_caller_loop\n",
     "from autogen_core.components.tools import PythonCodeExecutionTool, ToolSchema\n",
-    "from autogen_ext.code_executors import DockerCommandLineCodeExecutor"
+    "from autogen_ext.code_executors import DockerCommandLineCodeExecutor\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
   {
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb
index 14dc6d2e9fef..3238656c426b 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/group-chat.ipynb
@@ -86,11 +86,11 @@
     "    AssistantMessage,\n",
     "    ChatCompletionClient,\n",
     "    LLMMessage,\n",
-    "    OpenAIChatCompletionClient,\n",
     "    SystemMessage,\n",
     "    UserMessage,\n",
     ")\n",
     "from autogen_core.components.tools import FunctionTool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "from IPython.display import display  # type: ignore\n",
     "from pydantic import BaseModel\n",
     "from rich.console import Console\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/handoffs.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/handoffs.ipynb
index 05b7d8fc39d8..6fb9f71782b0 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/handoffs.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/handoffs.ipynb
@@ -65,11 +65,11 @@
     "    FunctionExecutionResult,\n",
     "    FunctionExecutionResultMessage,\n",
     "    LLMMessage,\n",
-    "    OpenAIChatCompletionClient,\n",
     "    SystemMessage,\n",
     "    UserMessage,\n",
     ")\n",
     "from autogen_core.components.tools import FunctionTool, Tool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "from pydantic import BaseModel"
    ]
   },
@@ -459,7 +459,7 @@
     "We have defined the AI agents, the Human Agent, the User Agent, the tools, and the topic types.\n",
     "Now we can create the team of agents.\n",
     "\n",
-    "For the AI agents, we use the {py:class}`~autogen_core.components.models.OpenAIChatCompletionClient`\n",
+    "For the AI agents, we use the {py:class}~autogen_ext.models.OpenAIChatCompletionClient`\n",
     "and `gpt-4o-mini` model.\n",
     "\n",
     "After creating the agent runtime, we register each of the agent by providing\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/reflection.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/reflection.ipynb
index 3aef80a7d4d3..f00e313b144b 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/reflection.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/reflection.ipynb
@@ -444,7 +444,7 @@
    "source": [
     "from autogen_core.application import SingleThreadedAgentRuntime\n",
     "from autogen_core.components import DefaultTopicId\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
     "runtime = SingleThreadedAgentRuntime()\n",
     "await ReviewerAgent.register(\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
index 0927b7390d06..b2b60be1458b 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
@@ -18,11 +18,11 @@
     "## Built-in Model Clients\n",
     "\n",
     "Currently there are two built-in model clients:\n",
-    "{py:class}`~autogen_core.components.models.OpenAIChatCompletionClient` and\n",
-    "{py:class}`~autogen_core.components.models.AzureOpenAIChatCompletionClient`.\n",
+    "{py:class}~autogen_ext.models.OpenAIChatCompletionClient` and\n",
+    "{py:class}`~autogen_ext.models.AzureOpenAIChatCompletionClient`.\n",
     "Both clients are asynchronous.\n",
     "\n",
-    "To use the {py:class}`~autogen_core.components.models.OpenAIChatCompletionClient`, you need to provide the API key\n",
+    "To use the {py:class}~autogen_ext.models.OpenAIChatCompletionClient`, you need to provide the API key\n",
     "either through the environment variable `OPENAI_API_KEY` or through the `api_key` argument."
    ]
   },
@@ -32,7 +32,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from autogen_core.components.models import OpenAIChatCompletionClient, UserMessage\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient, UserMessage\n",
     "\n",
     "# Create an OpenAI model client.\n",
     "model_client = OpenAIChatCompletionClient(\n",
@@ -45,7 +45,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can call the {py:meth}`~autogen_core.components.models.OpenAIChatCompletionClient.create` method to create a\n",
+    "You can call the {py:meth}~autogen_ext.models.OpenAIChatCompletionClient.create` method to create a\n",
     "chat completion request, and await for an {py:class}`~autogen_core.components.models.CreateResult` object in return."
    ]
   },
@@ -79,7 +79,7 @@
    "source": [
     "### Streaming Response\n",
     "\n",
-    "You can use the {py:meth}`~autogen_core.components.models.OpenAIChatCompletionClient.create_streaming` method to create a\n",
+    "You can use the {py:meth}~autogen_ext.models.OpenAIChatCompletionClient.create_streaming` method to create a\n",
     "chat completion request with streaming response."
    ]
   },
@@ -151,7 +151,7 @@
    "source": [
     "### Azure OpenAI\n",
     "\n",
-    "To use the {py:class}`~autogen_core.components.models.AzureOpenAIChatCompletionClient`, you need to provide\n",
+    "To use the {py:class}`~autogen_ext.models.AzureOpenAIChatCompletionClient`, you need to provide\n",
     "the deployment id, Azure Cognitive Services endpoint, api version, and model capabilities.\n",
     "For authentication, you can either provide an API key or an Azure Active Directory (AAD) token credential.\n",
     "To use AAD authentication, you need to first install the `azure-identity` package."
@@ -184,7 +184,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from autogen_core.components.models import AzureOpenAIChatCompletionClient\n",
+    "from autogen_ext.models import AzureOpenAIChatCompletionClient\n",
     "from azure.identity import DefaultAzureCredential, get_bearer_token_provider\n",
     "\n",
     "# Create the token provider\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
index e5d545cb6521..7a74e27b2623 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb
@@ -312,8 +312,8 @@
     "import tempfile\n",
     "\n",
     "from autogen_core.application import SingleThreadedAgentRuntime\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "from autogen_ext.code_executors import DockerCommandLineCodeExecutor\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
     "work_dir = tempfile.mkdtemp()\n",
     "\n",
diff --git a/python/packages/autogen-core/src/autogen_core/components/models/__init__.py b/python/packages/autogen-core/src/autogen_core/components/models/__init__.py
index a21e4367fdda..f57c82289ddc 100644
--- a/python/packages/autogen-core/src/autogen_core/components/models/__init__.py
+++ b/python/packages/autogen-core/src/autogen_core/components/models/__init__.py
@@ -1,10 +1,11 @@
+import importlib
+import warnings
+from typing import TYPE_CHECKING, Any
+
 from ._model_client import ChatCompletionClient, ModelCapabilities
-from ._openai_client import (
-    AzureOpenAIChatCompletionClient,
-    OpenAIChatCompletionClient,
-)
 from ._types import (
     AssistantMessage,
+    ChatCompletionTokenLogprob,
     CreateResult,
     FinishReasons,
     FunctionExecutionResult,
@@ -12,9 +13,14 @@
     LLMMessage,
     RequestUsage,
     SystemMessage,
+    TopLogprob,
     UserMessage,
 )
 
+if TYPE_CHECKING:
+    from ._openai_client import AzureOpenAIChatCompletionClient, OpenAIChatCompletionClient
+
+
 __all__ = [
     "AzureOpenAIChatCompletionClient",
     "OpenAIChatCompletionClient",
@@ -29,4 +35,26 @@
     "RequestUsage",
     "FinishReasons",
     "CreateResult",
+    "TopLogprob",
+    "ChatCompletionTokenLogprob",
 ]
+
+
+def __getattr__(name: str) -> Any:
+    deprecated_classes = {
+        "AzureOpenAIChatCompletionClient": "autogen_ext.models.AzureOpenAIChatCompletionClient",
+        "OpenAIChatCompletionClient": "autogen_ext.modelsChatCompletionClient",
+    }
+    if name in deprecated_classes:
+        warnings.warn(
+            f"{name} moved to autogen_ext. " f"Please import it from {deprecated_classes[name]}.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        # Dynamically import the class from the current module
+        module = importlib.import_module("._openai_client", __name__)
+        attr = getattr(module, name)
+        # Cache the attribute in the module's global namespace
+        globals()[name] = attr
+        return attr
+    raise AttributeError(f"module {__name__} has no attribute {name}")
diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index 717ad4003f57..f773414e8947 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -23,6 +23,10 @@ dependencies = [
 langchain-tools = ["langchain_core~= 0.3.3"]
 azure-code-executor = ["azure-core"]
 docker-code-executor = ["docker~=7.0"]
+langchain = ["langchain_core~= 0.3.3"]
+azure = ["azure-core", "azure-identity"]
+docker = ["docker~=7.0"]
+openai = ["openai>=1.3"]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/autogen_ext"]
diff --git a/python/packages/autogen-ext/src/autogen_ext/code_executors/_azure_container_code_executor.py b/python/packages/autogen-ext/src/autogen_ext/code_executors/_azure_container_code_executor.py
index 2852c4592a88..d7c5bd555308 100644
--- a/python/packages/autogen-ext/src/autogen_ext/code_executors/_azure_container_code_executor.py
+++ b/python/packages/autogen-ext/src/autogen_ext/code_executors/_azure_container_code_executor.py
@@ -48,7 +48,7 @@ class ACADynamicSessionsCodeExecutor(CodeExecutor):
 
     .. note::
 
-        This class requires the :code:`azure-code-executor` extra for the :code:`autogen-ext` package.
+        This class requires the :code:`azure` extra for the :code:`autogen-ext` package.
 
 
     **This will execute LLM generated code on an Azure dynamic code container.**
diff --git a/python/packages/autogen-ext/src/autogen_ext/code_executors/_docker_code_executor.py b/python/packages/autogen-ext/src/autogen_ext/code_executors/_docker_code_executor.py
index 0ea8c3157943..eb807db46293 100644
--- a/python/packages/autogen-ext/src/autogen_ext/code_executors/_docker_code_executor.py
+++ b/python/packages/autogen-ext/src/autogen_ext/code_executors/_docker_code_executor.py
@@ -52,7 +52,7 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
 
     .. note::
 
-        This class requires the :code:`docker-code-executor` extra for the :code:`autogen-ext` package.
+        This class requires the :code:`docker` extra for the :code:`autogen-ext` package.
 
 
     The executor first saves each code block in a file in the working
@@ -160,7 +160,7 @@ def __init__(
             from docker.models.containers import Container
         except ImportError as e:
             raise RuntimeError(
-                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker-code-executor' extra."
+                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker' extra."
             ) from e
 
         self._container: Container | None = None
@@ -305,7 +305,7 @@ async def stop(self) -> None:
             from docker.errors import NotFound
         except ImportError as e:
             raise RuntimeError(
-                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker-code-executor' extra."
+                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker' extra."
             ) from e
 
         client = docker.from_env()
@@ -324,7 +324,7 @@ async def start(self) -> None:
             from docker.errors import ImageNotFound
         except ImportError as e:
             raise RuntimeError(
-                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker-code-executor' extra."
+                "Missing dependecies for DockerCommandLineCodeExecutor. Please ensure the autogen-ext package was installed with the 'docker' extra."
             ) from e
 
         # Start a container from the image, read to exec commands later
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/__init__.py b/python/packages/autogen-ext/src/autogen_ext/models/__init__.py
new file mode 100644
index 000000000000..e7b2b76ae362
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/models/__init__.py
@@ -0,0 +1,9 @@
+from ._openai._openai_client import (
+    AzureOpenAIChatCompletionClient,
+    OpenAIChatCompletionClient,
+)
+
+__all__ = [
+    "AzureOpenAIChatCompletionClient",
+    "OpenAIChatCompletionClient",
+]
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
new file mode 100644
index 000000000000..79747ab679d3
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
@@ -0,0 +1,122 @@
+from typing import Dict
+
+from autogen_core.components.models import ModelCapabilities
+
+# Based on: https://platform.openai.com/docs/models/continuous-model-upgrades
+# This is a moving target, so correctness is checked by the model value returned by openai against expected values at runtime``
+_MODEL_POINTERS = {
+    "gpt-4o": "gpt-4o-2024-08-06",
+    "gpt-4o-mini": "gpt-4o-mini-2024-07-18",
+    "gpt-4-turbo": "gpt-4-turbo-2024-04-09",
+    "gpt-4-turbo-preview": "gpt-4-0125-preview",
+    "gpt-4": "gpt-4-0613",
+    "gpt-4-32k": "gpt-4-32k-0613",
+    "gpt-3.5-turbo": "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-16k": "gpt-3.5-turbo-16k-0613",
+}
+
+_MODEL_CAPABILITIES: Dict[str, ModelCapabilities] = {
+    "gpt-4o-2024-08-06": {
+        "vision": True,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4o-2024-05-13": {
+        "vision": True,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4o-mini-2024-07-18": {
+        "vision": True,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4-turbo-2024-04-09": {
+        "vision": True,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4-0125-preview": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4-1106-preview": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4-1106-vision-preview": {
+        "vision": True,
+        "function_calling": False,
+        "json_output": False,
+    },
+    "gpt-4-0613": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-4-32k-0613": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-3.5-turbo-0125": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-3.5-turbo-1106": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-3.5-turbo-instruct": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-3.5-turbo-0613": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+    "gpt-3.5-turbo-16k-0613": {
+        "vision": False,
+        "function_calling": True,
+        "json_output": True,
+    },
+}
+
+_MODEL_TOKEN_LIMITS: Dict[str, int] = {
+    "gpt-4o-2024-08-06": 128000,
+    "gpt-4o-2024-05-13": 128000,
+    "gpt-4o-mini-2024-07-18": 128000,
+    "gpt-4-turbo-2024-04-09": 128000,
+    "gpt-4-0125-preview": 128000,
+    "gpt-4-1106-preview": 128000,
+    "gpt-4-1106-vision-preview": 128000,
+    "gpt-4-0613": 8192,
+    "gpt-4-32k-0613": 32768,
+    "gpt-3.5-turbo-0125": 16385,
+    "gpt-3.5-turbo-1106": 16385,
+    "gpt-3.5-turbo-instruct": 4096,
+    "gpt-3.5-turbo-0613": 4096,
+    "gpt-3.5-turbo-16k-0613": 16385,
+}
+
+
+def resolve_model(model: str) -> str:
+    if model in _MODEL_POINTERS:
+        return _MODEL_POINTERS[model]
+    return model
+
+
+def get_capabilties(model: str) -> ModelCapabilities:
+    resolved_model = resolve_model(model)
+    return _MODEL_CAPABILITIES[resolved_model]
+
+
+def get_token_limit(model: str) -> int:
+    resolved_model = resolve_model(model)
+    return _MODEL_TOKEN_LIMITS[resolved_model]
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
new file mode 100644
index 000000000000..c67b9f3b1075
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
@@ -0,0 +1,856 @@
+import asyncio
+import inspect
+import json
+import logging
+import math
+import re
+import warnings
+from asyncio import Task
+from typing import (
+    Any,
+    AsyncGenerator,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Type,
+    Union,
+    cast,
+)
+
+import tiktoken
+from autogen_core.application.logging import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
+from autogen_core.application.logging.events import LLMCallEvent
+from autogen_core.base import CancellationToken
+from autogen_core.components import (
+    FunctionCall,
+    Image,
+)
+from autogen_core.components.models import (
+    AssistantMessage,
+    ChatCompletionClient,
+    ChatCompletionTokenLogprob,
+    CreateResult,
+    FunctionExecutionResultMessage,
+    LLMMessage,
+    ModelCapabilities,
+    RequestUsage,
+    SystemMessage,
+    TopLogprob,
+    UserMessage,
+)
+from autogen_core.components.tools import Tool, ToolSchema
+from openai import AsyncAzureOpenAI, AsyncOpenAI
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionAssistantMessageParam,
+    ChatCompletionContentPartParam,
+    ChatCompletionContentPartTextParam,
+    ChatCompletionMessageParam,
+    ChatCompletionMessageToolCallParam,
+    ChatCompletionRole,
+    ChatCompletionSystemMessageParam,
+    ChatCompletionToolMessageParam,
+    ChatCompletionToolParam,
+    ChatCompletionUserMessageParam,
+    ParsedChatCompletion,
+    ParsedChoice,
+    completion_create_params,
+)
+from openai.types.chat.chat_completion import Choice
+from openai.types.shared_params import FunctionDefinition, FunctionParameters
+from pydantic import BaseModel
+from typing_extensions import Unpack
+
+from . import _model_info
+from .config import AzureOpenAIClientConfiguration, OpenAIClientConfiguration
+
+logger = logging.getLogger(EVENT_LOGGER_NAME)
+trace_logger = logging.getLogger(TRACE_LOGGER_NAME)
+
+openai_init_kwargs = set(inspect.getfullargspec(AsyncOpenAI.__init__).kwonlyargs)
+aopenai_init_kwargs = set(inspect.getfullargspec(AsyncAzureOpenAI.__init__).kwonlyargs)
+
+create_kwargs = set(completion_create_params.CompletionCreateParamsBase.__annotations__.keys()) | set(
+    ("timeout", "stream")
+)
+# Only single choice allowed
+disallowed_create_args = set(["stream", "messages", "function_call", "functions", "n"])
+required_create_args: Set[str] = set(["model"])
+
+
+def _azure_openai_client_from_config(config: Mapping[str, Any]) -> AsyncAzureOpenAI:
+    # Take a copy
+    copied_config = dict(config).copy()
+
+    # Do some fixups
+    copied_config["azure_deployment"] = copied_config.get("azure_deployment", config.get("model"))
+    if copied_config["azure_deployment"] is not None:
+        copied_config["azure_deployment"] = copied_config["azure_deployment"].replace(".", "")
+    copied_config["azure_endpoint"] = copied_config.get("azure_endpoint", copied_config.pop("base_url", None))
+
+    # Shave down the config to just the AzureOpenAIChatCompletionClient kwargs
+    azure_config = {k: v for k, v in copied_config.items() if k in aopenai_init_kwargs}
+    return AsyncAzureOpenAI(**azure_config)
+
+
+def _openai_client_from_config(config: Mapping[str, Any]) -> AsyncOpenAI:
+    # Shave down the config to just the OpenAI kwargs
+    openai_config = {k: v for k, v in config.items() if k in openai_init_kwargs}
+    return AsyncOpenAI(**openai_config)
+
+
+def _create_args_from_config(config: Mapping[str, Any]) -> Dict[str, Any]:
+    create_args = {k: v for k, v in config.items() if k in create_kwargs}
+    create_args_keys = set(create_args.keys())
+    if not required_create_args.issubset(create_args_keys):
+        raise ValueError(f"Required create args are missing: {required_create_args - create_args_keys}")
+    if disallowed_create_args.intersection(create_args_keys):
+        raise ValueError(f"Disallowed create args are present: {disallowed_create_args.intersection(create_args_keys)}")
+    return create_args
+
+
+# TODO check types
+# oai_system_message_schema = type2schema(ChatCompletionSystemMessageParam)
+# oai_user_message_schema = type2schema(ChatCompletionUserMessageParam)
+# oai_assistant_message_schema = type2schema(ChatCompletionAssistantMessageParam)
+# oai_tool_message_schema = type2schema(ChatCompletionToolMessageParam)
+
+
+def type_to_role(message: LLMMessage) -> ChatCompletionRole:
+    if isinstance(message, SystemMessage):
+        return "system"
+    elif isinstance(message, UserMessage):
+        return "user"
+    elif isinstance(message, AssistantMessage):
+        return "assistant"
+    else:
+        return "tool"
+
+
+def user_message_to_oai(message: UserMessage) -> ChatCompletionUserMessageParam:
+    assert_valid_name(message.source)
+    if isinstance(message.content, str):
+        return ChatCompletionUserMessageParam(
+            content=message.content,
+            role="user",
+            name=message.source,
+        )
+    else:
+        parts: List[ChatCompletionContentPartParam] = []
+        for part in message.content:
+            if isinstance(part, str):
+                oai_part = ChatCompletionContentPartTextParam(
+                    text=part,
+                    type="text",
+                )
+                parts.append(oai_part)
+            elif isinstance(part, Image):
+                # TODO: support url based images
+                # TODO: support specifying details
+                parts.append(part.to_openai_format())
+            else:
+                raise ValueError(f"Unknown content type: {part}")
+        return ChatCompletionUserMessageParam(
+            content=parts,
+            role="user",
+            name=message.source,
+        )
+
+
+def system_message_to_oai(message: SystemMessage) -> ChatCompletionSystemMessageParam:
+    return ChatCompletionSystemMessageParam(
+        content=message.content,
+        role="system",
+    )
+
+
+def func_call_to_oai(message: FunctionCall) -> ChatCompletionMessageToolCallParam:
+    return ChatCompletionMessageToolCallParam(
+        id=message.id,
+        function={
+            "arguments": message.arguments,
+            "name": message.name,
+        },
+        type="function",
+    )
+
+
+def tool_message_to_oai(
+    message: FunctionExecutionResultMessage,
+) -> Sequence[ChatCompletionToolMessageParam]:
+    return [
+        ChatCompletionToolMessageParam(content=x.content, role="tool", tool_call_id=x.call_id) for x in message.content
+    ]
+
+
+def assistant_message_to_oai(
+    message: AssistantMessage,
+) -> ChatCompletionAssistantMessageParam:
+    assert_valid_name(message.source)
+    if isinstance(message.content, list):
+        return ChatCompletionAssistantMessageParam(
+            tool_calls=[func_call_to_oai(x) for x in message.content],
+            role="assistant",
+            name=message.source,
+        )
+    else:
+        return ChatCompletionAssistantMessageParam(
+            content=message.content,
+            role="assistant",
+            name=message.source,
+        )
+
+
+def to_oai_type(message: LLMMessage) -> Sequence[ChatCompletionMessageParam]:
+    if isinstance(message, SystemMessage):
+        return [system_message_to_oai(message)]
+    elif isinstance(message, UserMessage):
+        return [user_message_to_oai(message)]
+    elif isinstance(message, AssistantMessage):
+        return [assistant_message_to_oai(message)]
+    else:
+        return tool_message_to_oai(message)
+
+
+def calculate_vision_tokens(image: Image, detail: str = "auto") -> int:
+    MAX_LONG_EDGE = 2048
+    BASE_TOKEN_COUNT = 85
+    TOKENS_PER_TILE = 170
+    MAX_SHORT_EDGE = 768
+    TILE_SIZE = 512
+
+    if detail == "low":
+        return BASE_TOKEN_COUNT
+
+    width, height = image.image.size
+
+    # Scale down to fit within a MAX_LONG_EDGE x MAX_LONG_EDGE square if necessary
+
+    if width > MAX_LONG_EDGE or height > MAX_LONG_EDGE:
+        aspect_ratio = width / height
+        if aspect_ratio > 1:
+            # Width is greater than height
+            width = MAX_LONG_EDGE
+            height = int(MAX_LONG_EDGE / aspect_ratio)
+        else:
+            # Height is greater than or equal to width
+            height = MAX_LONG_EDGE
+            width = int(MAX_LONG_EDGE * aspect_ratio)
+
+    # Resize such that the shortest side is MAX_SHORT_EDGE if both dimensions exceed MAX_SHORT_EDGE
+    aspect_ratio = width / height
+    if width > MAX_SHORT_EDGE and height > MAX_SHORT_EDGE:
+        if aspect_ratio > 1:
+            # Width is greater than height
+            height = MAX_SHORT_EDGE
+            width = int(MAX_SHORT_EDGE * aspect_ratio)
+        else:
+            # Height is greater than or equal to width
+            width = MAX_SHORT_EDGE
+            height = int(MAX_SHORT_EDGE / aspect_ratio)
+
+    # Calculate the number of tiles based on TILE_SIZE
+
+    tiles_width = math.ceil(width / TILE_SIZE)
+    tiles_height = math.ceil(height / TILE_SIZE)
+    total_tiles = tiles_width * tiles_height
+    # Calculate the total tokens based on the number of tiles and the base token count
+
+    total_tokens = BASE_TOKEN_COUNT + TOKENS_PER_TILE * total_tiles
+
+    return total_tokens
+
+
+def _add_usage(usage1: RequestUsage, usage2: RequestUsage) -> RequestUsage:
+    return RequestUsage(
+        prompt_tokens=usage1.prompt_tokens + usage2.prompt_tokens,
+        completion_tokens=usage1.completion_tokens + usage2.completion_tokens,
+    )
+
+
+def convert_tools(
+    tools: Sequence[Tool | ToolSchema],
+) -> List[ChatCompletionToolParam]:
+    result: List[ChatCompletionToolParam] = []
+    for tool in tools:
+        if isinstance(tool, Tool):
+            tool_schema = tool.schema
+        else:
+            assert isinstance(tool, dict)
+            tool_schema = tool
+
+        result.append(
+            ChatCompletionToolParam(
+                type="function",
+                function=FunctionDefinition(
+                    name=tool_schema["name"],
+                    description=(tool_schema["description"] if "description" in tool_schema else ""),
+                    parameters=(
+                        cast(FunctionParameters, tool_schema["parameters"]) if "parameters" in tool_schema else {}
+                    ),
+                ),
+            )
+        )
+    # Check if all tools have valid names.
+    for tool_param in result:
+        assert_valid_name(tool_param["function"]["name"])
+    return result
+
+
+def normalize_name(name: str) -> str:
+    """
+    LLMs sometimes ask functions while ignoring their own format requirements, this function should be used to replace invalid characters with "_".
+
+    Prefer _assert_valid_name for validating user configuration or input
+    """
+    return re.sub(r"[^a-zA-Z0-9_-]", "_", name)[:64]
+
+
+def assert_valid_name(name: str) -> str:
+    """
+    Ensure that configured names are valid, raises ValueError if not.
+
+    For munging LLM responses use _normalize_name to ensure LLM specified names don't break the API.
+    """
+    if not re.match(r"^[a-zA-Z0-9_-]+$", name):
+        raise ValueError(f"Invalid name: {name}. Only letters, numbers, '_' and '-' are allowed.")
+    if len(name) > 64:
+        raise ValueError(f"Invalid name: {name}. Name must be less than 64 characters.")
+    return name
+
+
+class BaseOpenAIChatCompletionClient(ChatCompletionClient):
+    def __init__(
+        self,
+        client: Union[AsyncOpenAI, AsyncAzureOpenAI],
+        create_args: Dict[str, Any],
+        model_capabilities: Optional[ModelCapabilities] = None,
+    ):
+        self._client = client
+        if model_capabilities is None and isinstance(client, AsyncAzureOpenAI):
+            raise ValueError("AzureOpenAIChatCompletionClient requires explicit model capabilities")
+        elif model_capabilities is None:
+            self._model_capabilities = _model_info.get_capabilties(create_args["model"])
+        else:
+            self._model_capabilities = model_capabilities
+
+        self._resolved_model: Optional[str] = None
+        if "model" in create_args:
+            self._resolved_model = _model_info.resolve_model(create_args["model"])
+
+        if (
+            "response_format" in create_args
+            and create_args["response_format"]["type"] == "json_object"
+            and not self._model_capabilities["json_output"]
+        ):
+            raise ValueError("Model does not support JSON output")
+
+        self._create_args = create_args
+        self._total_usage = RequestUsage(prompt_tokens=0, completion_tokens=0)
+        self._actual_usage = RequestUsage(prompt_tokens=0, completion_tokens=0)
+
+    @classmethod
+    def create_from_config(cls, config: Dict[str, Any]) -> ChatCompletionClient:
+        return OpenAIChatCompletionClient(**config)
+
+    async def create(
+        self,
+        messages: Sequence[LLMMessage],
+        tools: Sequence[Tool | ToolSchema] = [],
+        json_output: Optional[bool] = None,
+        extra_create_args: Mapping[str, Any] = {},
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> CreateResult:
+        # Make sure all extra_create_args are valid
+        extra_create_args_keys = set(extra_create_args.keys())
+        if not create_kwargs.issuperset(extra_create_args_keys):
+            raise ValueError(f"Extra create args are invalid: {extra_create_args_keys - create_kwargs}")
+
+        # Copy the create args and overwrite anything in extra_create_args
+        create_args = self._create_args.copy()
+        create_args.update(extra_create_args)
+
+        # Declare use_beta_client
+        use_beta_client: bool = False
+        response_format_value: Optional[Type[BaseModel]] = None
+
+        if "response_format" in create_args:
+            value = create_args["response_format"]
+            # If value is a Pydantic model class, use the beta client
+            if isinstance(value, type) and issubclass(value, BaseModel):
+                response_format_value = value
+                use_beta_client = True
+            else:
+                # response_format_value is not a Pydantic model class
+                use_beta_client = False
+                response_format_value = None
+
+        # Remove 'response_format' from create_args to prevent passing it twice
+        create_args_no_response_format = {k: v for k, v in create_args.items() if k != "response_format"}
+
+        # TODO: allow custom handling.
+        # For now we raise an error if images are present and vision is not supported
+        if self.capabilities["vision"] is False:
+            for message in messages:
+                if isinstance(message, UserMessage):
+                    if isinstance(message.content, list) and any(isinstance(x, Image) for x in message.content):
+                        raise ValueError("Model does not support vision and image was provided")
+
+        if json_output is not None:
+            if self.capabilities["json_output"] is False and json_output is True:
+                raise ValueError("Model does not support JSON output")
+
+            if json_output is True:
+                create_args["response_format"] = {"type": "json_object"}
+            else:
+                create_args["response_format"] = {"type": "text"}
+
+        if self.capabilities["json_output"] is False and json_output is True:
+            raise ValueError("Model does not support JSON output")
+
+        oai_messages_nested = [to_oai_type(m) for m in messages]
+        oai_messages = [item for sublist in oai_messages_nested for item in sublist]
+
+        if self.capabilities["function_calling"] is False and len(tools) > 0:
+            raise ValueError("Model does not support function calling")
+        future: Union[Task[ParsedChatCompletion[BaseModel]], Task[ChatCompletion]]
+        if len(tools) > 0:
+            converted_tools = convert_tools(tools)
+            if use_beta_client:
+                # Pass response_format_value if it's not None
+                if response_format_value is not None:
+                    future = asyncio.ensure_future(
+                        self._client.beta.chat.completions.parse(
+                            messages=oai_messages,
+                            tools=converted_tools,
+                            response_format=response_format_value,
+                            **create_args_no_response_format,
+                        )
+                    )
+                else:
+                    future = asyncio.ensure_future(
+                        self._client.beta.chat.completions.parse(
+                            messages=oai_messages,
+                            tools=converted_tools,
+                            **create_args_no_response_format,
+                        )
+                    )
+            else:
+                future = asyncio.ensure_future(
+                    self._client.chat.completions.create(
+                        messages=oai_messages,
+                        stream=False,
+                        tools=converted_tools,
+                        **create_args,
+                    )
+                )
+        else:
+            if use_beta_client:
+                if response_format_value is not None:
+                    future = asyncio.ensure_future(
+                        self._client.beta.chat.completions.parse(
+                            messages=oai_messages,
+                            response_format=response_format_value,
+                            **create_args_no_response_format,
+                        )
+                    )
+                else:
+                    future = asyncio.ensure_future(
+                        self._client.beta.chat.completions.parse(
+                            messages=oai_messages,
+                            **create_args_no_response_format,
+                        )
+                    )
+            else:
+                future = asyncio.ensure_future(
+                    self._client.chat.completions.create(
+                        messages=oai_messages,
+                        stream=False,
+                        **create_args,
+                    )
+                )
+
+        if cancellation_token is not None:
+            cancellation_token.link_future(future)
+        result: Union[ParsedChatCompletion[BaseModel], ChatCompletion] = await future
+        if use_beta_client:
+            result = cast(ParsedChatCompletion[Any], result)
+
+        if result.usage is not None:
+            logger.info(
+                LLMCallEvent(
+                    prompt_tokens=result.usage.prompt_tokens,
+                    completion_tokens=result.usage.completion_tokens,
+                )
+            )
+
+        usage = RequestUsage(
+            # TODO backup token counting
+            prompt_tokens=result.usage.prompt_tokens if result.usage is not None else 0,
+            completion_tokens=(result.usage.completion_tokens if result.usage is not None else 0),
+        )
+
+        if self._resolved_model is not None:
+            if self._resolved_model != result.model:
+                warnings.warn(
+                    f"Resolved model mismatch: {self._resolved_model} != {result.model}. Model mapping may be incorrect.",
+                    stacklevel=2,
+                )
+
+        # Limited to a single choice currently.
+        choice: Union[ParsedChoice[Any], ParsedChoice[BaseModel], Choice] = result.choices[0]
+        if choice.finish_reason == "function_call":
+            raise ValueError("Function calls are not supported in this context")
+
+        content: Union[str, List[FunctionCall]]
+        if choice.finish_reason == "tool_calls":
+            assert choice.message.tool_calls is not None
+            assert choice.message.function_call is None
+
+            # NOTE: If OAI response type changes, this will need to be updated
+            content = [
+                FunctionCall(
+                    id=x.id,
+                    arguments=x.function.arguments,
+                    name=normalize_name(x.function.name),
+                )
+                for x in choice.message.tool_calls
+            ]
+            finish_reason = "function_calls"
+        else:
+            finish_reason = choice.finish_reason
+            content = choice.message.content or ""
+        logprobs: Optional[List[ChatCompletionTokenLogprob]] = None
+        if choice.logprobs and choice.logprobs.content:
+            logprobs = [
+                ChatCompletionTokenLogprob(
+                    token=x.token,
+                    logprob=x.logprob,
+                    top_logprobs=[TopLogprob(logprob=y.logprob, bytes=y.bytes) for y in x.top_logprobs],
+                    bytes=x.bytes,
+                )
+                for x in choice.logprobs.content
+            ]
+        response = CreateResult(
+            finish_reason=finish_reason,  # type: ignore
+            content=content,
+            usage=usage,
+            cached=False,
+            logprobs=logprobs,
+        )
+
+        _add_usage(self._actual_usage, usage)
+        _add_usage(self._total_usage, usage)
+
+        # TODO - why is this cast needed?
+        return response
+
+    async def create_stream(
+        self,
+        messages: Sequence[LLMMessage],
+        tools: Sequence[Tool | ToolSchema] = [],
+        json_output: Optional[bool] = None,
+        extra_create_args: Mapping[str, Any] = {},
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> AsyncGenerator[Union[str, CreateResult], None]:
+        # Make sure all extra_create_args are valid
+        extra_create_args_keys = set(extra_create_args.keys())
+        if not create_kwargs.issuperset(extra_create_args_keys):
+            raise ValueError(f"Extra create args are invalid: {extra_create_args_keys - create_kwargs}")
+
+        # Copy the create args and overwrite anything in extra_create_args
+        create_args = self._create_args.copy()
+        create_args.update(extra_create_args)
+
+        oai_messages_nested = [to_oai_type(m) for m in messages]
+        oai_messages = [item for sublist in oai_messages_nested for item in sublist]
+
+        # TODO: allow custom handling.
+        # For now we raise an error if images are present and vision is not supported
+        if self.capabilities["vision"] is False:
+            for message in messages:
+                if isinstance(message, UserMessage):
+                    if isinstance(message.content, list) and any(isinstance(x, Image) for x in message.content):
+                        raise ValueError("Model does not support vision and image was provided")
+
+        if json_output is not None:
+            if self.capabilities["json_output"] is False and json_output is True:
+                raise ValueError("Model does not support JSON output")
+
+            if json_output is True:
+                create_args["response_format"] = {"type": "json_object"}
+            else:
+                create_args["response_format"] = {"type": "text"}
+
+        if len(tools) > 0:
+            converted_tools = convert_tools(tools)
+            stream_future = asyncio.ensure_future(
+                self._client.chat.completions.create(
+                    messages=oai_messages,
+                    stream=True,
+                    tools=converted_tools,
+                    **create_args,
+                )
+            )
+        else:
+            stream_future = asyncio.ensure_future(
+                self._client.chat.completions.create(messages=oai_messages, stream=True, **create_args)
+            )
+        if cancellation_token is not None:
+            cancellation_token.link_future(stream_future)
+        stream = await stream_future
+
+        stop_reason = None
+        maybe_model = None
+        content_deltas: List[str] = []
+        full_tool_calls: Dict[int, FunctionCall] = {}
+        completion_tokens = 0
+        logprobs: Optional[List[ChatCompletionTokenLogprob]] = None
+        while True:
+            try:
+                chunk_future = asyncio.ensure_future(anext(stream))
+                if cancellation_token is not None:
+                    cancellation_token.link_future(chunk_future)
+                chunk = await chunk_future
+                choice = chunk.choices[0]
+                stop_reason = choice.finish_reason
+                maybe_model = chunk.model
+                # First try get content
+                if choice.delta.content is not None:
+                    content_deltas.append(choice.delta.content)
+                    if len(choice.delta.content) > 0:
+                        yield choice.delta.content
+                    continue
+
+                # Otherwise, get tool calls
+                if choice.delta.tool_calls is not None:
+                    for tool_call_chunk in choice.delta.tool_calls:
+                        idx = tool_call_chunk.index
+                        if idx not in full_tool_calls:
+                            # We ignore the type hint here because we want to fill in type when the delta provides it
+                            full_tool_calls[idx] = FunctionCall(id="", arguments="", name="")
+
+                        if tool_call_chunk.id is not None:
+                            full_tool_calls[idx].id += tool_call_chunk.id
+
+                        if tool_call_chunk.function is not None:
+                            if tool_call_chunk.function.name is not None:
+                                full_tool_calls[idx].name += tool_call_chunk.function.name
+                            if tool_call_chunk.function.arguments is not None:
+                                full_tool_calls[idx].arguments += tool_call_chunk.function.arguments
+                if choice.logprobs and choice.logprobs.content:
+                    logprobs = [
+                        ChatCompletionTokenLogprob(
+                            token=x.token,
+                            logprob=x.logprob,
+                            top_logprobs=[TopLogprob(logprob=y.logprob, bytes=y.bytes) for y in x.top_logprobs],
+                            bytes=x.bytes,
+                        )
+                        for x in choice.logprobs.content
+                    ]
+
+            except StopAsyncIteration:
+                break
+
+        model = maybe_model or create_args["model"]
+        model = model.replace("gpt-35", "gpt-3.5")  # hack for Azure API
+
+        # TODO fix count token
+        prompt_tokens = 0
+        # prompt_tokens = count_token(messages, model=model)
+        if stop_reason is None:
+            raise ValueError("No stop reason found")
+
+        content: Union[str, List[FunctionCall]]
+        if len(content_deltas) > 1:
+            content = "".join(content_deltas)
+            completion_tokens = 0
+            # completion_tokens = count_token(content, model=model)
+        else:
+            completion_tokens = 0
+            # TODO: fix assumption that dict values were added in order and actually order by int index
+            # for tool_call in full_tool_calls.values():
+            #     # value = json.dumps(tool_call)
+            #     # completion_tokens += count_token(value, model=model)
+            #     completion_tokens += 0
+            content = list(full_tool_calls.values())
+
+        usage = RequestUsage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+        )
+        if stop_reason == "function_call":
+            raise ValueError("Function calls are not supported in this context")
+        if stop_reason == "tool_calls":
+            stop_reason = "function_calls"
+
+        result = CreateResult(
+            finish_reason=stop_reason,  # type: ignore
+            content=content,
+            usage=usage,
+            cached=False,
+            logprobs=logprobs,
+        )
+
+        _add_usage(self._actual_usage, usage)
+        _add_usage(self._total_usage, usage)
+
+        yield result
+
+    def actual_usage(self) -> RequestUsage:
+        return self._actual_usage
+
+    def total_usage(self) -> RequestUsage:
+        return self._total_usage
+
+    def count_tokens(self, messages: Sequence[LLMMessage], tools: Sequence[Tool | ToolSchema] = []) -> int:
+        model = self._create_args["model"]
+        try:
+            encoding = tiktoken.encoding_for_model(model)
+        except KeyError:
+            trace_logger.warning(f"Model {model} not found. Using cl100k_base encoding.")
+            encoding = tiktoken.get_encoding("cl100k_base")
+        tokens_per_message = 3
+        tokens_per_name = 1
+        num_tokens = 0
+
+        # Message tokens.
+        for message in messages:
+            num_tokens += tokens_per_message
+            oai_message = to_oai_type(message)
+            for oai_message_part in oai_message:
+                for key, value in oai_message_part.items():
+                    if value is None:
+                        continue
+
+                    if isinstance(message, UserMessage) and isinstance(value, list):
+                        typed_message_value = cast(List[ChatCompletionContentPartParam], value)
+
+                        assert len(typed_message_value) == len(
+                            message.content
+                        ), "Mismatch in message content and typed message value"
+
+                        # We need image properties that are only in the original message
+                        for part, content_part in zip(typed_message_value, message.content, strict=False):
+                            if isinstance(content_part, Image):
+                                # TODO: add detail parameter
+                                num_tokens += calculate_vision_tokens(content_part)
+                            elif isinstance(part, str):
+                                num_tokens += len(encoding.encode(part))
+                            else:
+                                try:
+                                    serialized_part = json.dumps(part)
+                                    num_tokens += len(encoding.encode(serialized_part))
+                                except TypeError:
+                                    trace_logger.warning(f"Could not convert {part} to string, skipping.")
+                    else:
+                        if not isinstance(value, str):
+                            try:
+                                value = json.dumps(value)
+                            except TypeError:
+                                trace_logger.warning(f"Could not convert {value} to string, skipping.")
+                                continue
+                        num_tokens += len(encoding.encode(value))
+                        if key == "name":
+                            num_tokens += tokens_per_name
+        num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
+
+        # Tool tokens.
+        oai_tools = convert_tools(tools)
+        for tool in oai_tools:
+            function = tool["function"]
+            tool_tokens = len(encoding.encode(function["name"]))
+            if "description" in function:
+                tool_tokens += len(encoding.encode(function["description"]))
+            tool_tokens -= 2
+            if "parameters" in function:
+                parameters = function["parameters"]
+                if "properties" in parameters:
+                    assert isinstance(parameters["properties"], dict)
+                    for propertiesKey in parameters["properties"]:  # pyright: ignore
+                        assert isinstance(propertiesKey, str)
+                        tool_tokens += len(encoding.encode(propertiesKey))
+                        v = parameters["properties"][propertiesKey]  # pyright: ignore
+                        for field in v:  # pyright: ignore
+                            if field == "type":
+                                tool_tokens += 2
+                                tool_tokens += len(encoding.encode(v["type"]))  # pyright: ignore
+                            elif field == "description":
+                                tool_tokens += 2
+                                tool_tokens += len(encoding.encode(v["description"]))  # pyright: ignore
+                            elif field == "enum":
+                                tool_tokens -= 3
+                                for o in v["enum"]:  # pyright: ignore
+                                    tool_tokens += 3
+                                    tool_tokens += len(encoding.encode(o))  # pyright: ignore
+                            else:
+                                trace_logger.warning(f"Not supported field {field}")
+                    tool_tokens += 11
+                    if len(parameters["properties"]) == 0:  # pyright: ignore
+                        tool_tokens -= 2
+            num_tokens += tool_tokens
+        num_tokens += 12
+        return num_tokens
+
+    def remaining_tokens(self, messages: Sequence[LLMMessage], tools: Sequence[Tool | ToolSchema] = []) -> int:
+        token_limit = _model_info.get_token_limit(self._create_args["model"])
+        return token_limit - self.count_tokens(messages, tools)
+
+    @property
+    def capabilities(self) -> ModelCapabilities:
+        return self._model_capabilities
+
+
+class OpenAIChatCompletionClient(BaseOpenAIChatCompletionClient):
+    def __init__(self, **kwargs: Unpack[OpenAIClientConfiguration]):
+        if "model" not in kwargs:
+            raise ValueError("model is required for OpenAIChatCompletionClient")
+
+        model_capabilities: Optional[ModelCapabilities] = None
+        copied_args = dict(kwargs).copy()
+        if "model_capabilities" in kwargs:
+            model_capabilities = kwargs["model_capabilities"]
+            del copied_args["model_capabilities"]
+
+        client = _openai_client_from_config(copied_args)
+        create_args = _create_args_from_config(copied_args)
+        self._raw_config = copied_args
+        super().__init__(client, create_args, model_capabilities)
+
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+        state["_client"] = None
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self._client = _openai_client_from_config(state["_raw_config"])
+
+
+class AzureOpenAIChatCompletionClient(BaseOpenAIChatCompletionClient):
+    def __init__(self, **kwargs: Unpack[AzureOpenAIClientConfiguration]):
+        if "model" not in kwargs:
+            raise ValueError("model is required for OpenAIChatCompletionClient")
+
+        model_capabilities: Optional[ModelCapabilities] = None
+        copied_args = dict(kwargs).copy()
+        if "model_capabilities" in kwargs:
+            model_capabilities = kwargs["model_capabilities"]
+            del copied_args["model_capabilities"]
+
+        client = _azure_openai_client_from_config(copied_args)
+        create_args = _create_args_from_config(copied_args)
+        self._raw_config = copied_args
+        super().__init__(client, create_args, model_capabilities)
+
+    def __getstate__(self) -> Dict[str, Any]:
+        state = self.__dict__.copy()
+        state["_client"] = None
+        return state
+
+    def __setstate__(self, state: Dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self._client = _azure_openai_client_from_config(state["_raw_config"])
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/config/__init__.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/config/__init__.py
new file mode 100644
index 000000000000..b6729a70d11e
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/config/__init__.py
@@ -0,0 +1,51 @@
+from typing import Awaitable, Callable, Dict, List, Literal, Optional, Union
+
+from autogen_core.components.models import ModelCapabilities
+from typing_extensions import Required, TypedDict
+
+
+class ResponseFormat(TypedDict):
+    type: Literal["text", "json_object"]
+
+
+class CreateArguments(TypedDict, total=False):
+    frequency_penalty: Optional[float]
+    logit_bias: Optional[Dict[str, int]]
+    max_tokens: Optional[int]
+    n: Optional[int]
+    presence_penalty: Optional[float]
+    response_format: ResponseFormat
+    seed: Optional[int]
+    stop: Union[Optional[str], List[str]]
+    temperature: Optional[float]
+    top_p: Optional[float]
+    user: str
+
+
+AsyncAzureADTokenProvider = Callable[[], Union[str, Awaitable[str]]]
+
+
+class BaseOpenAIClientConfiguration(CreateArguments, total=False):
+    model: str
+    api_key: str
+    timeout: Union[float, None]
+    max_retries: int
+
+
+# See OpenAI docs for explanation of these parameters
+class OpenAIClientConfiguration(BaseOpenAIClientConfiguration, total=False):
+    organization: str
+    base_url: str
+    # Not required
+    model_capabilities: ModelCapabilities
+
+
+class AzureOpenAIClientConfiguration(BaseOpenAIClientConfiguration, total=False):
+    # Azure specific
+    azure_endpoint: Required[str]
+    azure_deployment: str
+    api_version: Required[str]
+    azure_ad_token: str
+    azure_ad_token_provider: AsyncAzureADTokenProvider
+    # Must be provided
+    model_capabilities: Required[ModelCapabilities]
diff --git a/python/packages/autogen-ext/src/autogen_ext/tools/_langchain_adapter.py b/python/packages/autogen-ext/src/autogen_ext/tools/_langchain_adapter.py
index 60bdb69b1741..4ac3e6b6371b 100644
--- a/python/packages/autogen-ext/src/autogen_ext/tools/_langchain_adapter.py
+++ b/python/packages/autogen-ext/src/autogen_ext/tools/_langchain_adapter.py
@@ -17,7 +17,7 @@ class LangChainToolAdapter(BaseTool[BaseModel, Any]):
 
     .. note::
 
-        This class requires the :code:`docker-code-executor` extra for the :code:`autogen-ext` package.
+        This class requires the :code:`langchain` extra for the :code:`autogen-ext` package.
 
 
     Args:
diff --git a/python/packages/autogen-core/tests/test_model_client.py b/python/packages/autogen-ext/tests/models/test_openai_model_client.py
similarity index 95%
rename from python/packages/autogen-core/tests/test_model_client.py
rename to python/packages/autogen-ext/tests/models/test_openai_model_client.py
index b0bed99ba959..f712ef75c5b2 100644
--- a/python/packages/autogen-core/tests/test_model_client.py
+++ b/python/packages/autogen-ext/tests/models/test_openai_model_client.py
@@ -7,18 +7,17 @@
 from autogen_core.components import Image
 from autogen_core.components.models import (
     AssistantMessage,
-    AzureOpenAIChatCompletionClient,
     CreateResult,
     FunctionExecutionResult,
     FunctionExecutionResultMessage,
     LLMMessage,
-    OpenAIChatCompletionClient,
     SystemMessage,
     UserMessage,
 )
-from autogen_core.components.models._model_info import resolve_model
-from autogen_core.components.models._openai_client import calculate_vision_tokens
 from autogen_core.components.tools import FunctionTool
+from autogen_ext.models import AzureOpenAIChatCompletionClient, OpenAIChatCompletionClient
+from autogen_ext.models._openai._model_info import resolve_model
+from autogen_ext.models._openai._openai_client import calculate_vision_tokens
 from openai.resources.chat.completions import AsyncCompletions
 from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, ChoiceDelta
@@ -166,7 +165,7 @@ def tool2(test1: int, test2: List[int]) -> str:
 
     mockcalculate_vision_tokens = MagicMock()
     monkeypatch.setattr(
-        "autogen_core.components.models._openai_client.calculate_vision_tokens", mockcalculate_vision_tokens
+        "autogen_ext.models._openai._openai_client.calculate_vision_tokens", mockcalculate_vision_tokens
     )
 
     num_tokens = client.count_tokens(messages, tools=tools)
diff --git a/python/packages/autogen-magentic-one/pyproject.toml b/python/packages/autogen-magentic-one/pyproject.toml
index 72f6ef6f4033..a82de9bd6141 100644
--- a/python/packages/autogen-magentic-one/pyproject.toml
+++ b/python/packages/autogen-magentic-one/pyproject.toml
@@ -18,6 +18,7 @@ classifiers = [
 
 dependencies = [
     "autogen-core",
+    "autogen-ext",
     "beautifulsoup4",
     "aiofiles",
     "requests",
diff --git a/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py b/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
index e47b24b25816..64c07313c557 100644
--- a/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
+++ b/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
@@ -8,11 +8,10 @@
 from autogen_core.application.logging.events import LLMCallEvent
 from autogen_core.components import Image
 from autogen_core.components.models import (
-    AzureOpenAIChatCompletionClient,
     ChatCompletionClient,
     ModelCapabilities,
-    OpenAIChatCompletionClient,
 )
+from autogen_ext.models import AzureOpenAIChatCompletionClient, OpenAIChatCompletionClient
 
 from .messages import (
     AgentEvent,
@@ -66,7 +65,7 @@ def create_completion_client_from_env(env: Dict[str, str] | None = None, **kwarg
 
     # Instantiate the correct client
     if _provider == "openai":
-        return OpenAIChatCompletionClient(**_kwargs)
+        return OpenAIChatCompletionClient(**_kwargs)  # type: ignore
     elif _provider == "azure":
         if _kwargs.get("azure_ad_token_provider", "").lower() == "default":
             if _default_azure_ad_token_provider is None:
@@ -76,7 +75,7 @@ def create_completion_client_from_env(env: Dict[str, str] | None = None, **kwarg
                     DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
                 )
             _kwargs["azure_ad_token_provider"] = _default_azure_ad_token_provider
-        return AzureOpenAIChatCompletionClient(**_kwargs)
+        return AzureOpenAIChatCompletionClient(**_kwargs)  # type: ignore
     else:
         raise ValueError(f"Unknown OAI provider '{_provider}'")
 
diff --git a/python/pyproject.toml b/python/pyproject.toml
index e99f1dc38d8f..6bc826cd448f 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -24,6 +24,7 @@ dev-dependencies = [
 
 [tool.uv.sources]
 autogen-core = { workspace = true }
+autogen-ext = { workspace = true }
 
 [tool.ruff]
 line-length = 120
diff --git a/python/uv.lock b/python/uv.lock
index fd386de0563b..e06a93ca7f35 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -491,22 +491,40 @@ dependencies = [
 ]
 
 [package.optional-dependencies]
+azure = [
+    { name = "azure-core" },
+    { name = "azure-identity" },
+]
 azure-code-executor = [
     { name = "azure-core" },
 ]
+docker = [
+    { name = "docker" },
+]
 docker-code-executor = [
     { name = "docker" },
 ]
+langchain = [
+    { name = "langchain-core" },
+]
 langchain-tools = [
     { name = "langchain-core" },
 ]
+openai = [
+    { name = "openai" },
+]
 
 [package.metadata]
 requires-dist = [
     { name = "autogen-core", editable = "packages/autogen-core" },
+    { name = "azure-core", marker = "extra == 'azure'" },
     { name = "azure-core", marker = "extra == 'azure-code-executor'" },
+    { name = "azure-identity", marker = "extra == 'azure'" },
+    { name = "docker", marker = "extra == 'docker'", specifier = "~=7.0" },
     { name = "docker", marker = "extra == 'docker-code-executor'", specifier = "~=7.0" },
+    { name = "langchain-core", marker = "extra == 'langchain'", specifier = "~=0.3.3" },
     { name = "langchain-core", marker = "extra == 'langchain-tools'", specifier = "~=0.3.3" },
+    { name = "openai", marker = "extra == 'openai'", specifier = ">=1.3" },
 ]
 
 [[package]]
@@ -516,6 +534,7 @@ source = { editable = "packages/autogen-magentic-one" }
 dependencies = [
     { name = "aiofiles" },
     { name = "autogen-core" },
+    { name = "autogen-ext" },
     { name = "beautifulsoup4" },
     { name = "mammoth" },
     { name = "markdownify" },
@@ -548,6 +567,7 @@ dev = [
 requires-dist = [
     { name = "aiofiles" },
     { name = "autogen-core", editable = "packages/autogen-core" },
+    { name = "autogen-ext", editable = "packages/autogen-ext" },
     { name = "beautifulsoup4" },
     { name = "mammoth" },
     { name = "markdownify" },

From dbd65c05a4deaac7b24197af0363f4363e82cc32 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 14:19:40 -0400
Subject: [PATCH 010/173] Add __version__ to new packages (#3881)

---
 .../autogen-agentchat/src/autogen_agentchat/__init__.py       | 4 ++++
 python/packages/autogen-core/src/autogen_core/__init__.py     | 3 +++
 python/packages/autogen-ext/src/autogen_ext/__init__.py       | 3 +++
 .../autogen-magentic-one/src/autogen_magentic_one/__init__.py | 4 ++++
 4 files changed, 14 insertions(+)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/__init__.py
index 2891d4ce393f..39b7b1c7498b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/__init__.py
@@ -1,2 +1,6 @@
+import importlib.metadata
+
 TRACE_LOGGER_NAME = "autogen_agentchat"
 EVENT_LOGGER_NAME = "autogen_agentchat.events"
+
+__version__ = importlib.metadata.version("autogen_agentchat")
diff --git a/python/packages/autogen-core/src/autogen_core/__init__.py b/python/packages/autogen-core/src/autogen_core/__init__.py
index e69de29bb2d1..9935d7ecf32e 100644
--- a/python/packages/autogen-core/src/autogen_core/__init__.py
+++ b/python/packages/autogen-core/src/autogen_core/__init__.py
@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("autogen_core")
diff --git a/python/packages/autogen-ext/src/autogen_ext/__init__.py b/python/packages/autogen-ext/src/autogen_ext/__init__.py
index e69de29bb2d1..bd2c9ca453aa 100644
--- a/python/packages/autogen-ext/src/autogen_ext/__init__.py
+++ b/python/packages/autogen-ext/src/autogen_ext/__init__.py
@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__ = importlib.metadata.version("autogen_ext")
diff --git a/python/packages/autogen-magentic-one/src/autogen_magentic_one/__init__.py b/python/packages/autogen-magentic-one/src/autogen_magentic_one/__init__.py
index e3a60a372fc5..7a98be30016d 100644
--- a/python/packages/autogen-magentic-one/src/autogen_magentic_one/__init__.py
+++ b/python/packages/autogen-magentic-one/src/autogen_magentic_one/__init__.py
@@ -1 +1,5 @@
+import importlib.metadata
+
 ABOUT = "This is Magentic-One."
+
+__version__ = importlib.metadata.version("autogen_magentic_one")

From 8a4930a9be337a6c35bdc0315b068b8e83814076 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 22 Oct 2024 19:23:02 +0100
Subject: [PATCH 011/173] Refactor agentchat to separate base interfaces from
 implementations (#3877)

---
 .../src/autogen_agentchat/agents/__init__.py  | 20 -----
 .../agents/_code_executor_agent.py            |  3 +-
 .../agents/_coding_assistant_agent.py         |  3 +-
 .../agents/_tool_use_assistant_agent.py       |  4 +-
 .../src/autogen_agentchat/base/__init__.py    | 14 +++
 .../{agents => base}/_base_chat_agent.py      | 58 ++----------
 .../src/autogen_agentchat/base/_base_task.py  | 20 +++++
 .../src/autogen_agentchat/base/_base_team.py  | 10 +++
 .../_base_termination.py}                     | 88 +-----------------
 .../logging/_console_log_handler.py           |  2 +-
 .../src/autogen_agentchat/messages.py         | 62 +++++++++++++
 .../src/autogen_agentchat/teams/__init__.py   |  3 +-
 .../src/autogen_agentchat/teams/_base_team.py | 17 ----
 .../src/autogen_agentchat/teams/_events.py    |  2 +-
 .../_group_chat/_base_chat_agent_container.py |  3 +-
 .../teams/_group_chat/_base_group_chat.py     | 11 ++-
 .../_group_chat/_base_group_chat_manager.py   |  2 +-
 .../_group_chat/_round_robin_group_chat.py    |  3 +-
 .../teams/_group_chat/_selector_group_chat.py |  4 +-
 .../autogen_agentchat/teams/_terminations.py  | 90 +++++++++++++++++++
 .../tests/test_group_chat.py                  |  6 +-
 .../tests/test_termination_condition.py       |  2 +-
 .../tutorial/agents.ipynb                     | 15 ++--
 .../tutorial/selector-group-chat.ipynb        |  8 +-
 .../agentchat-user-guide/tutorial/teams.ipynb |  4 +-
 .../tutorial/termination.ipynb                |  8 +-
 26 files changed, 246 insertions(+), 216 deletions(-)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
 rename python/packages/autogen-agentchat/src/autogen_agentchat/{agents => base}/_base_chat_agent.py (60%)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
 rename python/packages/autogen-agentchat/src/autogen_agentchat/{teams/_termination.py => base/_base_termination.py} (61%)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
 delete mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_base_team.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index 21813ed4ed85..e5f1bd8b691b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -1,29 +1,9 @@
-from ._base_chat_agent import (
-    BaseChatAgent,
-    BaseMessage,
-    BaseToolUseChatAgent,
-    ChatMessage,
-    MultiModalMessage,
-    StopMessage,
-    TextMessage,
-    ToolCallMessage,
-    ToolCallResultMessage,
-)
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
 from ._tool_use_assistant_agent import ToolUseAssistantAgent
 
 __all__ = [
-    "BaseChatAgent",
-    "BaseMessage",
-    "BaseToolUseChatAgent",
-    "ChatMessage",
     "CodeExecutorAgent",
     "CodingAssistantAgent",
-    "MultiModalMessage",
-    "StopMessage",
-    "TextMessage",
-    "ToolCallMessage",
-    "ToolCallResultMessage",
     "ToolUseAssistantAgent",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
index 3c695dc0b9e4..c38facbe5010 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
@@ -3,7 +3,8 @@
 from autogen_core.base import CancellationToken
 from autogen_core.components.code_executor import CodeBlock, CodeExecutor, extract_markdown_code_blocks
 
-from ._base_chat_agent import BaseChatAgent, ChatMessage, TextMessage
+from ..base import BaseChatAgent
+from ..messages import ChatMessage, TextMessage
 
 
 class CodeExecutorAgent(BaseChatAgent):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
index 36edd0bcd3d4..b93621519764 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
@@ -9,7 +9,8 @@
     UserMessage,
 )
 
-from ._base_chat_agent import BaseChatAgent, ChatMessage, MultiModalMessage, StopMessage, TextMessage
+from ..base import BaseChatAgent
+from ..messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
 
 
 class CodingAssistantAgent(BaseChatAgent):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
index 0453abc593ea..bb6ace764726 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
@@ -12,8 +12,8 @@
 )
 from autogen_core.components.tools import Tool
 
-from ._base_chat_agent import (
-    BaseToolUseChatAgent,
+from ..base import BaseToolUseChatAgent
+from ..messages import (
     ChatMessage,
     MultiModalMessage,
     StopMessage,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
new file mode 100644
index 000000000000..3b942afbdbae
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
@@ -0,0 +1,14 @@
+from ._base_chat_agent import BaseChatAgent, BaseToolUseChatAgent
+from ._base_task import TaskResult, TaskRunner
+from ._base_team import Team
+from ._base_termination import TerminatedException, TerminationCondition
+
+__all__ = [
+    "BaseChatAgent",
+    "BaseToolUseChatAgent",
+    "Team",
+    "TerminatedException",
+    "TerminationCondition",
+    "TaskResult",
+    "TaskRunner",
+]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py
similarity index 60%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py
index b52745968747..184e9061a35e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py
@@ -2,59 +2,13 @@
 from typing import List, Sequence
 
 from autogen_core.base import CancellationToken
-from autogen_core.components import FunctionCall, Image
-from autogen_core.components.models import FunctionExecutionResult
 from autogen_core.components.tools import Tool
-from pydantic import BaseModel
 
+from ..messages import ChatMessage
+from ._base_task import TaskResult, TaskRunner
 
-class BaseMessage(BaseModel):
-    """A base message."""
 
-    source: str
-    """The name of the agent that sent this message."""
-
-
-class TextMessage(BaseMessage):
-    """A text message."""
-
-    content: str
-    """The content of the message."""
-
-
-class MultiModalMessage(BaseMessage):
-    """A multimodal message."""
-
-    content: List[str | Image]
-    """The content of the message."""
-
-
-class ToolCallMessage(BaseMessage):
-    """A message containing a list of function calls."""
-
-    content: List[FunctionCall]
-    """The list of function calls."""
-
-
-class ToolCallResultMessage(BaseMessage):
-    """A message containing the results of function calls."""
-
-    content: List[FunctionExecutionResult]
-    """The list of function execution results."""
-
-
-class StopMessage(BaseMessage):
-    """A message requesting stop of a conversation."""
-
-    content: str
-    """The content for the stop message."""
-
-
-ChatMessage = TextMessage | MultiModalMessage | StopMessage | ToolCallMessage | ToolCallResultMessage
-"""A message used by agents in a team."""
-
-
-class BaseChatAgent(ABC):
+class BaseChatAgent(TaskRunner, ABC):
     """Base class for a chat agent that can participant in a team."""
 
     def __init__(self, name: str, description: str) -> None:
@@ -81,6 +35,12 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         """Handle incoming messages and return a response message."""
         ...
 
+    async def run(
+        self, task: str, *, source: str = "user", cancellation_token: CancellationToken | None = None
+    ) -> TaskResult:
+        # TODO: Implement this method.
+        raise NotImplementedError
+
 
 class BaseToolUseChatAgent(BaseChatAgent):
     """Base class for a chat agent that can use tools.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py
new file mode 100644
index 000000000000..103721557796
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py
@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Protocol, Sequence
+
+from ..messages import ChatMessage
+
+
+@dataclass
+class TaskResult:
+    """Result of running a task."""
+
+    messages: Sequence[ChatMessage]
+    """Messages produced by the task."""
+
+
+class TaskRunner(Protocol):
+    """A task runner."""
+
+    async def run(self, task: str) -> TaskResult:
+        """Run the task."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
new file mode 100644
index 000000000000..5c3677fdc1ef
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from ._base_task import TaskResult, TaskRunner
+from ._base_termination import TerminationCondition
+
+
+class Team(TaskRunner, Protocol):
+    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TaskResult:
+        """Run the team on a given task until the termination condition is met."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_termination.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_termination.py
similarity index 61%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/teams/_termination.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_termination.py
index 78e20a93bbbb..0d0a056eab4c 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_termination.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_termination.py
@@ -2,7 +2,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Sequence
 
-from ..agents import ChatMessage, MultiModalMessage, StopMessage, TextMessage
+from ..messages import ChatMessage, StopMessage
 
 
 class TerminatedException(BaseException): ...
@@ -127,89 +127,3 @@ async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
     async def reset(self) -> None:
         for condition in self._conditions:
             await condition.reset()
-
-
-class StopMessageTermination(TerminationCondition):
-    """Terminate the conversation if a StopMessage is received."""
-
-    def __init__(self) -> None:
-        self._terminated = False
-
-    @property
-    def terminated(self) -> bool:
-        return self._terminated
-
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
-        if self._terminated:
-            raise TerminatedException("Termination condition has already been reached")
-        for message in messages:
-            if isinstance(message, StopMessage):
-                self._terminated = True
-                return StopMessage(content="Stop message received", source="StopMessageTermination")
-        return None
-
-    async def reset(self) -> None:
-        self._terminated = False
-
-
-class MaxMessageTermination(TerminationCondition):
-    """Terminate the conversation after a maximum number of messages have been exchanged.
-
-    Args:
-        max_messages: The maximum number of messages allowed in the conversation.
-    """
-
-    def __init__(self, max_messages: int) -> None:
-        self._max_messages = max_messages
-        self._message_count = 0
-
-    @property
-    def terminated(self) -> bool:
-        return self._message_count >= self._max_messages
-
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
-        if self.terminated:
-            raise TerminatedException("Termination condition has already been reached")
-        self._message_count += len(messages)
-        if self._message_count >= self._max_messages:
-            return StopMessage(
-                content=f"Maximal number of messages {self._max_messages} reached, current message count: {self._message_count}",
-                source="MaxMessageTermination",
-            )
-        return None
-
-    async def reset(self) -> None:
-        self._message_count = 0
-
-
-class TextMentionTermination(TerminationCondition):
-    """Terminate the conversation if a specific text is mentioned.
-
-    Args:
-        text: The text to look for in the messages.
-    """
-
-    def __init__(self, text: str) -> None:
-        self._text = text
-        self._terminated = False
-
-    @property
-    def terminated(self) -> bool:
-        return self._terminated
-
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
-        if self._terminated:
-            raise TerminatedException("Termination condition has already been reached")
-        for message in messages:
-            if isinstance(message, TextMessage | StopMessage) and self._text in message.content:
-                self._terminated = True
-                return StopMessage(content=f"Text '{self._text}' mentioned", source="TextMentionTermination")
-            elif isinstance(message, MultiModalMessage):
-                for item in message.content:
-                    if isinstance(item, str) and self._text in item:
-                        self._terminated = True
-                        return StopMessage(content=f"Text '{self._text}' mentioned", source="TextMentionTermination")
-        return None
-
-    async def reset(self) -> None:
-        self._terminated = False
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
index 5ff7c689a587..d0fb4ab08a11 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
@@ -3,7 +3,7 @@
 import sys
 from datetime import datetime
 
-from ..agents import ChatMessage, StopMessage, TextMessage
+from ..messages import ChatMessage, StopMessage, TextMessage
 from ..teams._events import (
     ContentPublishEvent,
     SelectSpeakerEvent,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
new file mode 100644
index 000000000000..6aac22248d50
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -0,0 +1,62 @@
+from typing import List
+
+from autogen_core.components import FunctionCall, Image
+from autogen_core.components.models import FunctionExecutionResult
+from pydantic import BaseModel
+
+
+class BaseMessage(BaseModel):
+    """A base message."""
+
+    source: str
+    """The name of the agent that sent this message."""
+
+
+class TextMessage(BaseMessage):
+    """A text message."""
+
+    content: str
+    """The content of the message."""
+
+
+class MultiModalMessage(BaseMessage):
+    """A multimodal message."""
+
+    content: List[str | Image]
+    """The content of the message."""
+
+
+class ToolCallMessage(BaseMessage):
+    """A message containing a list of function calls."""
+
+    content: List[FunctionCall]
+    """The list of function calls."""
+
+
+class ToolCallResultMessage(BaseMessage):
+    """A message containing the results of function calls."""
+
+    content: List[FunctionExecutionResult]
+    """The list of function execution results."""
+
+
+class StopMessage(BaseMessage):
+    """A message requesting stop of a conversation."""
+
+    content: str
+    """The content for the stop message."""
+
+
+ChatMessage = TextMessage | MultiModalMessage | StopMessage | ToolCallMessage | ToolCallResultMessage
+"""A message used by agents in a team."""
+
+
+__all__ = [
+    "BaseMessage",
+    "TextMessage",
+    "MultiModalMessage",
+    "ToolCallMessage",
+    "ToolCallResultMessage",
+    "StopMessage",
+    "ChatMessage",
+]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
index f1a79cff7153..e305a9e5c995 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
@@ -1,9 +1,8 @@
 from ._group_chat._round_robin_group_chat import RoundRobinGroupChat
 from ._group_chat._selector_group_chat import SelectorGroupChat
-from ._termination import MaxMessageTermination, StopMessageTermination, TerminationCondition, TextMentionTermination
+from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination
 
 __all__ = [
-    "TerminationCondition",
     "MaxMessageTermination",
     "TextMentionTermination",
     "StopMessageTermination",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_base_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_base_team.py
deleted file mode 100644
index 312524b8c7c2..000000000000
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_base_team.py
+++ /dev/null
@@ -1,17 +0,0 @@
-from dataclasses import dataclass
-from typing import List, Protocol
-
-from ..agents import ChatMessage
-from ._termination import TerminationCondition
-
-
-@dataclass
-class TeamRunResult:
-    messages: List[ChatMessage]
-    """The messages generated by the team."""
-
-
-class BaseTeam(Protocol):
-    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TeamRunResult:
-        """Run the team on a given task until the termination condition is met."""
-        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
index acdc9bdbd0b6..5bfeff417841 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
@@ -1,7 +1,7 @@
 from autogen_core.base import AgentId
 from pydantic import BaseModel, ConfigDict
 
-from ..agents import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
+from ..messages import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
 
 
 class ContentPublishEvent(BaseModel):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
index 3ec378f73c52..275e505d6d3a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
@@ -8,7 +8,8 @@
 from autogen_core.components.tool_agent import ToolException
 
 from ... import EVENT_LOGGER_NAME
-from ...agents import BaseChatAgent, MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
+from ...base import BaseChatAgent
+from ...messages import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
 from .._events import ContentPublishEvent, ContentRequestEvent, ToolCallEvent, ToolCallResultEvent
 from ._sequential_routed_agent import SequentialRoutedAgent
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 633fc0f85242..08f44a1af665 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -8,15 +8,14 @@
 from autogen_core.components.tool_agent import ToolAgent
 from autogen_core.components.tools import Tool
 
-from ...agents import BaseChatAgent, BaseToolUseChatAgent, ChatMessage, TextMessage
-from .._base_team import BaseTeam, TeamRunResult
+from ...base import BaseChatAgent, BaseToolUseChatAgent, TaskResult, Team, TerminationCondition
+from ...messages import ChatMessage, TextMessage
 from .._events import ContentPublishEvent, ContentRequestEvent
-from .._termination import TerminationCondition
 from ._base_chat_agent_container import BaseChatAgentContainer
 from ._base_group_chat_manager import BaseGroupChatManager
 
 
-class BaseGroupChat(BaseTeam, ABC):
+class BaseGroupChat(Team, ABC):
     """The base class for group chat teams.
 
     To implement a group chat team, first create a subclass of :class:`BaseGroupChatManager` and then
@@ -69,7 +68,7 @@ def _factory() -> ToolAgent:
 
         return _factory
 
-    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TeamRunResult:
+    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TaskResult:
         """Run the team and return the result."""
         # Create intervention handler for termination.
 
@@ -170,4 +169,4 @@ async def collect_group_chat_messages(
         await runtime.stop_when_idle()
 
         # Return the result.
-        return TeamRunResult(messages=group_chat_messages)
+        return TaskResult(messages=group_chat_messages)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
index 38170053abdc..5f59e9e631d7 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
@@ -6,8 +6,8 @@
 from autogen_core.components import event
 
 from ... import EVENT_LOGGER_NAME
+from ...base import TerminationCondition
 from .._events import ContentPublishEvent, ContentRequestEvent, TerminationEvent
-from .._termination import TerminationCondition
 from ._sequential_routed_agent import SequentialRoutedAgent
 
 event_logger = logging.getLogger(EVENT_LOGGER_NAME)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index 6ebacaac34d9..daab986027ed 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -1,8 +1,7 @@
 from typing import Callable, List
 
-from ...agents import BaseChatAgent
+from ...base import BaseChatAgent, TerminationCondition
 from .._events import ContentPublishEvent
-from .._termination import TerminationCondition
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 473b92f324f1..f000cbd69dc2 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -5,9 +5,9 @@
 from autogen_core.components.models import ChatCompletionClient, SystemMessage
 
 from ... import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
-from ...agents import BaseChatAgent, MultiModalMessage, StopMessage, TextMessage
+from ...base import BaseChatAgent, TerminationCondition
+from ...messages import MultiModalMessage, StopMessage, TextMessage
 from .._events import ContentPublishEvent, SelectSpeakerEvent
-from .._termination import TerminationCondition
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py
new file mode 100644
index 000000000000..191e14f8566c
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py
@@ -0,0 +1,90 @@
+from typing import Sequence
+
+from ..base import TerminatedException, TerminationCondition
+from ..messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
+
+
+class StopMessageTermination(TerminationCondition):
+    """Terminate the conversation if a StopMessage is received."""
+
+    def __init__(self) -> None:
+        self._terminated = False
+
+    @property
+    def terminated(self) -> bool:
+        return self._terminated
+
+    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+        if self._terminated:
+            raise TerminatedException("Termination condition has already been reached")
+        for message in messages:
+            if isinstance(message, StopMessage):
+                self._terminated = True
+                return StopMessage(content="Stop message received", source="StopMessageTermination")
+        return None
+
+    async def reset(self) -> None:
+        self._terminated = False
+
+
+class MaxMessageTermination(TerminationCondition):
+    """Terminate the conversation after a maximum number of messages have been exchanged.
+
+    Args:
+        max_messages: The maximum number of messages allowed in the conversation.
+    """
+
+    def __init__(self, max_messages: int) -> None:
+        self._max_messages = max_messages
+        self._message_count = 0
+
+    @property
+    def terminated(self) -> bool:
+        return self._message_count >= self._max_messages
+
+    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+        if self.terminated:
+            raise TerminatedException("Termination condition has already been reached")
+        self._message_count += len(messages)
+        if self._message_count >= self._max_messages:
+            return StopMessage(
+                content=f"Maximal number of messages {self._max_messages} reached, current message count: {self._message_count}",
+                source="MaxMessageTermination",
+            )
+        return None
+
+    async def reset(self) -> None:
+        self._message_count = 0
+
+
+class TextMentionTermination(TerminationCondition):
+    """Terminate the conversation if a specific text is mentioned.
+
+    Args:
+        text: The text to look for in the messages.
+    """
+
+    def __init__(self, text: str) -> None:
+        self._text = text
+        self._terminated = False
+
+    @property
+    def terminated(self) -> bool:
+        return self._terminated
+
+    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+        if self._terminated:
+            raise TerminatedException("Termination condition has already been reached")
+        for message in messages:
+            if isinstance(message, TextMessage | StopMessage) and self._text in message.content:
+                self._terminated = True
+                return StopMessage(content=f"Text '{self._text}' mentioned", source="TextMentionTermination")
+            elif isinstance(message, MultiModalMessage):
+                for item in message.content:
+                    if isinstance(item, str) and self._text in item:
+                        self._terminated = True
+                        return StopMessage(content=f"Text '{self._text}' mentioned", source="TextMentionTermination")
+        return None
+
+    async def reset(self) -> None:
+        self._terminated = False
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 21fb2ad4082c..54e759663389 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -7,15 +7,13 @@
 import pytest
 from autogen_agentchat import EVENT_LOGGER_NAME
 from autogen_agentchat.agents import (
-    BaseChatAgent,
-    ChatMessage,
     CodeExecutorAgent,
     CodingAssistantAgent,
-    StopMessage,
-    TextMessage,
     ToolUseAssistantAgent,
 )
+from autogen_agentchat.base import BaseChatAgent
 from autogen_agentchat.logging import FileLogHandler
+from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage
 from autogen_agentchat.teams import (
     RoundRobinGroupChat,
     SelectorGroupChat,
diff --git a/python/packages/autogen-agentchat/tests/test_termination_condition.py b/python/packages/autogen-agentchat/tests/test_termination_condition.py
index fe850542f264..c3f575d34adb 100644
--- a/python/packages/autogen-agentchat/tests/test_termination_condition.py
+++ b/python/packages/autogen-agentchat/tests/test_termination_condition.py
@@ -1,5 +1,5 @@
 import pytest
-from autogen_agentchat.agents import StopMessage, TextMessage
+from autogen_agentchat.messages import StopMessage, TextMessage
 from autogen_agentchat.teams import MaxMessageTermination, StopMessageTermination, TextMentionTermination
 
 
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index 649c90dc3985..55fc8c203cab 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -16,7 +16,7 @@
     "\n",
     "AgentChat provides a set of preset Agents, each with variations in how an agent might respond to received messages. \n",
     "\n",
-    "Each agent inherits from a {py:class}`~autogen_agentchat.agents.BaseChatAgent`   class with a few generic properties:\n",
+    "Each agent inherits from a {py:class}`~autogen_agentchat.base.BaseChatAgent`   class with a few generic properties:\n",
     "\n",
     "- `name`: The name of the agent. This is used by the team to uniquely identify the agent. It should be unique within the team.\n",
     "- `description`: The description of the agent. This is used by the team to make decisions about which agents to use. The description should detail the agent's capabilities and how to interact with it.\n",
@@ -30,7 +30,7 @@
     "To learn more about the runtime in `autogen-core`, see the [autogen-core documentation on agents and runtime](../../core-user-guide/framework/agent-and-agent-runtime.ipynb).\n",
     "```\n",
     "\n",
-    "Each agent also implements an {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages` method that defines the behavior of the agent in response to a message.\n",
+    "Each agent also implements an {py:meth}`~autogen_agentchat.base.BaseChatAgent.on_messages` method that defines the behavior of the agent in response to a message.\n",
     "\n",
     "\n",
     "To begin, let us import the required classes and set up a model client that will be used by agents.\n"
@@ -45,8 +45,9 @@
     "import logging\n",
     "\n",
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
-    "from autogen_agentchat.agents import CodingAssistantAgent, TextMessage, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
+    "from autogen_agentchat.messages import TextMessage\n",
     "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, SelectorGroupChat\n",
     "from autogen_core.base import CancellationToken\n",
     "from autogen_core.components.models import OpenAIChatCompletionClient\n",
@@ -250,8 +251,8 @@
     "import asyncio\n",
     "from typing import Sequence\n",
     "\n",
-    "from autogen_agentchat.agents import (\n",
-    "    BaseChatAgent,\n",
+    "from autogen_agentchat.base import BaseChatAgent\n",
+    "from autogen_agentchat.messages import (\n",
     "    ChatMessage,\n",
     "    StopMessage,\n",
     "    TextMessage,\n",
@@ -298,7 +299,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -312,7 +313,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index 7636f14d9240..399fb5a4de2a 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -41,13 +41,11 @@
     "from typing import Sequence\n",
     "\n",
     "from autogen_agentchat.agents import (\n",
-    "    BaseChatAgent,\n",
-    "    ChatMessage,\n",
     "    CodingAssistantAgent,\n",
-    "    StopMessage,\n",
-    "    TextMessage,\n",
     "    ToolUseAssistantAgent,\n",
     ")\n",
+    "from autogen_agentchat.base import BaseChatAgent\n",
+    "from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage\n",
     "from autogen_agentchat.teams import SelectorGroupChat, StopMessageTermination\n",
     "from autogen_core.base import CancellationToken\n",
     "from autogen_core.components.tools import FunctionTool\n",
@@ -270,7 +268,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
index ce30aee61cb1..d957a90c52f2 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -194,7 +194,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -208,7 +208,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
index bdb1dccff3f3..444e56b2b695 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -9,7 +9,7 @@
     "\n",
     "In the previous section, we explored how to define agents, and organize them into teams that can solve tasks by communicating (a conversation). However, conversations can go on forever, and in many cases, we need to know _when_ to stop them. This is the role of the termination condition.\n",
     "\n",
-    "AgentChat supports several termination condition by providing a base  `TerminationCondition` class and several implementations that inherit from it.\n",
+    "AgentChat supports several termination condition by providing a base {py:class}`~autogen_agentchat.base.TerminationCondition` class and several implementations that inherit from it.\n",
     "\n",
     "A termination condition is a callable that takes a sequence of ChatMessage objects  since the last time the condition was called, and returns a StopMessage if the conversation should be terminated, or None otherwise. Once a termination condition has been reached, it must be reset before it can be used again.\n",
     "\n",
@@ -66,7 +66,7 @@
    "source": [
     "## MaxMessageTermination \n",
     "\n",
-    "The simplest termination condition is the `MaxMessageTermination` condition, which terminates the conversation after a fixed number of messages. \n"
+    "The simplest termination condition is the {py:class}`~autogen_agentchat.teams.MaxMessageTermination` condition, which terminates the conversation after a fixed number of messages. \n"
    ]
   },
   {
@@ -184,7 +184,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -198,7 +198,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

From bfa0b3b94fd0c9de2cc9c369815737558e0a8a4d Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 15:32:03 -0400
Subject: [PATCH 012/173] Automate removing the awaiting-op-response label
 (#3888)

---
 .github/workflows/issue-user-responded.yml | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 .github/workflows/issue-user-responded.yml

diff --git a/.github/workflows/issue-user-responded.yml b/.github/workflows/issue-user-responded.yml
new file mode 100644
index 000000000000..3a055ef99beb
--- /dev/null
+++ b/.github/workflows/issue-user-responded.yml
@@ -0,0 +1,17 @@
+name: Remove awaiting-op-response label if op responded
+on:
+  issue_comment:
+    types: [created]
+jobs:
+  label_issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - run: gh issue edit "$NUMBER" --remove-label "$LABELS"
+        if: ${{ github.event.comment.user.login == github.event.issue.user.login && contains(github.event.issue.labels.*.name, 'awaiting-op-response') }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GH_REPO: ${{ github.repository }}
+          NUMBER: ${{ github.event.issue.number }}
+          LABELS: awaiting-op-response

From 5391804cfe0c780c2f39b5ab089f38f105aa55e4 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 15:40:06 -0400
Subject: [PATCH 013/173] Add pull-requests permission (#3889)

---
 .github/workflows/issue-user-responded.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/issue-user-responded.yml b/.github/workflows/issue-user-responded.yml
index 3a055ef99beb..793bf4168902 100644
--- a/.github/workflows/issue-user-responded.yml
+++ b/.github/workflows/issue-user-responded.yml
@@ -7,6 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       issues: write
+      pull-requests: write
     steps:
       - run: gh issue edit "$NUMBER" --remove-label "$LABELS"
         if: ${{ github.event.comment.user.login == github.event.issue.user.login && contains(github.event.issue.labels.*.name, 'awaiting-op-response') }}

From c4492ca043013ab38ef1713729360dda12379b2a Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 22 Oct 2024 13:27:06 -0700
Subject: [PATCH 014/173] Allow callable to be used as `registered_tools` in
 `ToolUseAssistantAgent`. (#3891)

* Allow callable to be used as `registered_tools` in `ToolUseAssistantAgent`.

* fix
---
 .../agents/_tool_use_assistant_agent.py       |  29 ++++-
 .../tests/test_tool_use_assistant_agent.py    | 120 ++++++++++++++++++
 2 files changed, 144 insertions(+), 5 deletions(-)
 create mode 100644 python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
index bb6ace764726..d9cc57b040fc 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
@@ -1,4 +1,4 @@
-from typing import List, Sequence
+from typing import Any, Awaitable, Callable, List, Sequence
 
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
@@ -10,7 +10,7 @@
     SystemMessage,
     UserMessage,
 )
-from autogen_core.components.tools import Tool
+from autogen_core.components.tools import FunctionTool, Tool
 
 from ..base import BaseToolUseChatAgent
 from ..messages import (
@@ -27,21 +27,40 @@ class ToolUseAssistantAgent(BaseToolUseChatAgent):
     """An agent that provides assistance with tool use.
 
     It responds with a StopMessage when 'terminate' is detected in the response.
+
+    Args:
+        name (str): The name of the agent.
+        model_client (ChatCompletionClient): The model client to use for inference.
+        registered_tools (List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]): The tools to register with the agent.
+        description (str, optional): The description of the agent.
+        system_message (str, optional): The system message for the model.
     """
 
     def __init__(
         self,
         name: str,
         model_client: ChatCompletionClient,
-        registered_tools: List[Tool],
+        registered_tools: List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]],
         *,
         description: str = "An agent that provides assistance with ability to use tools.",
         system_message: str = "You are a helpful AI assistant. Solve tasks using your tools. Reply with 'TERMINATE' when the task has been completed.",
     ):
-        super().__init__(name=name, description=description, registered_tools=registered_tools)
+        tools: List[Tool] = []
+        for tool in registered_tools:
+            if isinstance(tool, Tool):
+                tools.append(tool)
+            elif callable(tool):
+                if hasattr(tool, "__doc__") and tool.__doc__ is not None:
+                    description = tool.__doc__
+                else:
+                    description = ""
+                tools.append(FunctionTool(tool, description=description))
+            else:
+                raise ValueError(f"Unsupported tool type: {type(tool)}")
+        super().__init__(name=name, description=description, registered_tools=tools)
         self._model_client = model_client
         self._system_messages = [SystemMessage(content=system_message)]
-        self._tool_schema = [tool.schema for tool in registered_tools]
+        self._tool_schema = [tool.schema for tool in tools]
         self._model_context: List[LLMMessage] = []
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
diff --git a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
new file mode 100644
index 000000000000..6243152272dd
--- /dev/null
+++ b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
@@ -0,0 +1,120 @@
+import asyncio
+import json
+from typing import Any, AsyncGenerator, List
+
+import pytest
+from autogen_agentchat.agents import ToolUseAssistantAgent
+from autogen_agentchat.messages import (
+    TextMessage,
+    ToolCallMessage,
+    ToolCallResultMessage,
+)
+from autogen_core.base import CancellationToken
+from autogen_core.components.models import FunctionExecutionResult, OpenAIChatCompletionClient
+from autogen_core.components.tools import FunctionTool
+from openai.resources.chat.completions import AsyncCompletions
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall, Function
+from openai.types.completion_usage import CompletionUsage
+
+
+class _MockChatCompletion:
+    def __init__(self, chat_completions: List[ChatCompletion]) -> None:
+        self._saved_chat_completions = chat_completions
+        self._curr_index = 0
+
+    async def mock_create(
+        self, *args: Any, **kwargs: Any
+    ) -> ChatCompletion | AsyncGenerator[ChatCompletionChunk, None]:
+        await asyncio.sleep(0.1)
+        completion = self._saved_chat_completions[self._curr_index]
+        self._curr_index += 1
+        return completion
+
+
+def _pass_function(input: str) -> str:
+    return "pass"
+
+
+async def _fail_function(input: str) -> str:
+    return "fail"
+
+
+async def _echo_function(input: str) -> str:
+    return input
+
+
+@pytest.mark.asyncio
+async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id1",
+            choices=[
+                Choice(
+                    finish_reason="tool_calls",
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=None,
+                        tool_calls=[
+                            ChatCompletionMessageToolCall(
+                                id="1",
+                                type="function",
+                                function=Function(
+                                    name="pass",
+                                    arguments=json.dumps({"input": "pass"}),
+                                ),
+                            )
+                        ],
+                        role="assistant",
+                    ),
+                )
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="Hello", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(
+                    finish_reason="stop", index=0, message=ChatCompletionMessage(content="TERMINATE", role="assistant")
+                )
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+    tool_use_agent = ToolUseAssistantAgent(
+        "tool_use_agent",
+        model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        registered_tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
+    )
+    response = await tool_use_agent.on_messages(
+        messages=[TextMessage(content="Test", source="user")], cancellation_token=CancellationToken()
+    )
+    assert isinstance(response, ToolCallMessage)
+    tool_call_results = [FunctionExecutionResult(content="", call_id=call.id) for call in response.content]
+
+    response = await tool_use_agent.on_messages(
+        messages=[ToolCallResultMessage(content=tool_call_results, source="test")],
+        cancellation_token=CancellationToken(),
+    )
+    assert isinstance(response, TextMessage)

From 631018776369c71dfa285e75507faec6caab00a1 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 16:40:38 -0400
Subject: [PATCH 015/173] Rename enhancement -> feature (#3886)

Co-authored-by: Eric Zhu 
---
 .github/ISSUE_TEMPLATE/feature_request.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index 57f360761a76..4b7bd8f4824e 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,6 +1,6 @@
 name: Feature Request
 description: Request a new feature or enhancement
-labels: ["enhancement"]
+labels: ["feature"]
 
 body:
   - type: textarea

From d3d736510ce44f7ee7c3dc9a8a1091ca1c43dacc Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 17:37:10 -0400
Subject: [PATCH 016/173] Multiversion docs build (#3842)

* test multiversion build

* Work on multiversion build

* update refs

* cancel in progress

* add docs dir

* add version switcher

* add version switcher

* add preferred

* version banner and hacky value override...

* add release version
---
 .github/workflows/docs.yml                    | 58 ++++++++++++++-----
 docs/switcher.json                            | 22 +++++++
 .../src/_static/override-switcher-button.js   | 15 +++++
 python/packages/autogen-core/docs/src/conf.py | 27 +++++++--
 4 files changed, 102 insertions(+), 20 deletions(-)
 create mode 100644 docs/switcher.json
 create mode 100644 python/packages/autogen-core/docs/src/_static/override-switcher-button.js

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 17996088f515..51faf7cf1c35 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -6,7 +6,10 @@ on:
   push:
     branches:
       - main
-      - staging
+
+  pull_request:
+    branches:
+      - main
 
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -17,38 +20,64 @@ permissions:
   pages: write
   id-token: write
 
-# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
 concurrency:
-  group: "pages"
-  cancel-in-progress: false
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
 
 jobs:
   build-04:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        version:
+          [
+            { ref: main, dest-dir: dev },
+            { ref: "v0.4.0dev0", dest-dir: "0.4.0dev0" },
+            { ref: "v0.4.0dev1", dest-dir: "0.4.0dev1" },
+          ]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
         with:
-          lfs: 'true'
+          lfs: "true"
+          ref: ${{ matrix.version.ref }}
       - run: curl -LsSf https://astral.sh/uv/install.sh | sh
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: "3.11"
       - run: |
           uv sync --locked --all-extras
           source .venv/bin/activate
           poe --directory ./packages/autogen-core docs-build
-          mkdir -p docs-staging/dev/
-          mv ./packages/autogen-core/docs/build/* docs-staging/dev/
+          mkdir -p docs-staging/${{ matrix.version.dest-dir }}/
+          mv ./packages/autogen-core/docs/build/* docs-staging/${{ matrix.version.dest-dir }}/
         working-directory: ./python
+        env:
+          PY_DOCS_DIR: ${{ matrix.version.dest-dir }}/
+          PY_SWITCHER_VERSION: ${{ matrix.version.dest-dir }}
+      - uses: actions/upload-artifact@v4
+        with:
+          path: "./python/docs-staging"
+          name: "${{ matrix.version.dest-dir }}-docs"
+
+  gen-redirects:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          lfs: "true"
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
       - name: generate redirects
         run: |
+          mkdir -p python/docs-staging/
           python python/packages/autogen-core/docs/redirects/redirects.py python/docs-staging
       - uses: actions/upload-artifact@v4
         with:
           path: "./python/docs-staging"
-          name: "04-docs"
+          name: "redirects"
 
   build-02:
     runs-on: ubuntu-latest
@@ -112,8 +141,8 @@ jobs:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
-    needs: [build-02, build-04]
-    if: ${{ needs.build-02.result == 'success' && needs.build-04.result == 'success' && github.ref == 'refs/heads/main' }}
+    needs: [build-02, build-04, gen-redirects]
+    if: ${{ needs.build-02.result == 'success' && needs.build-04.result == 'success' && needs.gen-redirects.result == 'success' && github.ref == 'refs/heads/main' }}
     steps:
       - uses: actions/download-artifact@v4
         with:
@@ -122,8 +151,9 @@ jobs:
       - name: Copy 02-docs
         run: |
           mkdir -p deploy/
-          cp -r artifacts/02-docs/* deploy/
-          cp -r artifacts/04-docs/* deploy/
+          for dir in artifacts/*; do
+            cp -r $dir/* deploy/
+          done
 
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3
diff --git a/docs/switcher.json b/docs/switcher.json
new file mode 100644
index 000000000000..bea742de395c
--- /dev/null
+++ b/docs/switcher.json
@@ -0,0 +1,22 @@
+[
+    {
+        "name": "0.2 (stable)",
+        "version": "0.2-stable",
+        "url": "/autogen/0.2/"
+    },
+    {
+        "version": "dev",
+        "url": "/autogen/dev/"
+    },
+    {
+        "name": "0.4.0.dev0",
+        "version": "0.4.0.dev0",
+        "url": "/autogen/0.4.0.dev0/"
+    },
+    {
+        "name": "0.4.0.dev1",
+        "version": "0.4.0.dev1",
+        "url": "/autogen/0.4.0.dev1/",
+        "preferred": true
+    }
+]
diff --git a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
new file mode 100644
index 000000000000..5406cd07e4f3
--- /dev/null
+++ b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
@@ -0,0 +1,15 @@
+// When body is ready
+document.addEventListener('DOMContentLoaded', function() {
+    // TODO: Please find a better way to override the button text in a better way...
+    // Set a timer for 3 seconds to wait for the button to be rendered.
+    setTimeout(function() {
+        // Get the button with class "pst-button-link-to-stable-version". There is only one.
+        var button = document.querySelector('.pst-button-link-to-stable-version');
+        if (!button) {
+            // If the button is not found, return.
+            return;
+        }
+        // Set the button's text to "Switch to latest dev release"
+        button.textContent = "Switch to latest dev release";
+    }, 500);
+});
diff --git a/python/packages/autogen-core/docs/src/conf.py b/python/packages/autogen-core/docs/src/conf.py
index 489e6534d9cf..11341873d141 100644
--- a/python/packages/autogen-core/docs/src/conf.py
+++ b/python/packages/autogen-core/docs/src/conf.py
@@ -3,19 +3,21 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
-import pydata_sphinx_theme
 from sphinx.application import Sphinx
 from typing import Any, Dict
 from pathlib import Path
 import sys
+import os
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
+import autogen_core
 
 project = "autogen_core"
 copyright = "2024, Microsoft"
 author = "Microsoft"
-version = "0.2"
+version = "0.4"
+release = autogen_core.__version__
 
 
 sys.path.append(str(Path(".").resolve()))
@@ -60,7 +62,14 @@
     "strikethrough",
 ]
 
-html_baseurl = "/autogen/dev/"
+if (path := os.getenv("PY_DOCS_DIR")) is None:
+    path = "dev"
+
+
+if (switcher_version := os.getenv("PY_SWITCHER_VERSION")) is None:
+    switcher_version = "dev"
+
+html_baseurl = f"/autogen/{path}/"
 
 # -- Options for HTML output -------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
@@ -70,7 +79,6 @@
 html_theme = "pydata_sphinx_theme"
 html_static_path = ["_static"]
 html_css_files = ["custom.css"]
-html_sidebars = {'packages/index': []}
 
 html_logo = "_static/images/logo/logo.svg"
 html_favicon = "_static/images/logo/favicon-512x512.png"
@@ -108,10 +116,17 @@
     "footer_center": ["footer-middle-links"],
     "footer_end": ["theme-version"],
     "pygments_light_style": "xcode",
-    "pygments_dark_style": "monokai"
+    "pygments_dark_style": "monokai",
+    "navbar_start": ["navbar-logo", "version-switcher"],
+    "switcher": {
+        "json_url": "https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json",
+        "version_match": switcher_version,
+    },
+    "show_version_warning_banner": True,
+
 }
 
-html_js_files = ["custom-icon.js"]
+html_js_files = ["custom-icon.js", "override-switcher-button.js"]
 html_sidebars = {
     "packages/index": [],
 }

From a9d292780bd7328244b45ef794e741a09776e1ab Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Tue, 22 Oct 2024 17:46:04 -0400
Subject: [PATCH 017/173] Update switcher.json (#3894)

---
 docs/switcher.json | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/switcher.json b/docs/switcher.json
index bea742de395c..3f39782bbb29 100644
--- a/docs/switcher.json
+++ b/docs/switcher.json
@@ -9,14 +9,14 @@
         "url": "/autogen/dev/"
     },
     {
-        "name": "0.4.0.dev0",
-        "version": "0.4.0.dev0",
-        "url": "/autogen/0.4.0.dev0/"
+        "name": "0.4.0dev0",
+        "version": "0.4.0dev0",
+        "url": "/autogen/0.4.0dev0/"
     },
     {
-        "name": "0.4.0.dev1",
-        "version": "0.4.0.dev1",
-        "url": "/autogen/0.4.0.dev1/",
+        "name": "0.4.0dev1",
+        "version": "0.4.0dev1",
+        "url": "/autogen/0.4.0dev1/",
         "preferred": true
     }
 ]

From 15fc18ccbf7fd297a55efbc993c50d5a0253e305 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 22 Oct 2024 21:57:21 -0700
Subject: [PATCH 018/173] add package workflow for 0.2 (#3892)

* add package workflow for 0.2

* Update workflow
---
 .github/python-package-0.2.yml | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 .github/python-package-0.2.yml

diff --git a/.github/python-package-0.2.yml b/.github/python-package-0.2.yml
new file mode 100644
index 000000000000..67e1d36c581f
--- /dev/null
+++ b/.github/python-package-0.2.yml
@@ -0,0 +1,30 @@
+name: AgentChat 0.2 Pypi Package
+
+on:
+  push:
+    tags:
+      - "0.2.*"
+  workflow_dispatch:
+permissions: {}
+jobs:
+  deploy:
+    strategy:
+      matrix:
+        os: ["ubuntu-latest"]
+        python-version: [3.10]
+    runs-on: ${{ matrix.os }}
+    environment:
+      name: package
+      url: https://pypi.org/p/autogen-agentchat
+    permissions:
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build
+        shell: pwsh
+        run: |
+          pip install twine
+          python setup.py sdist bdist_wheel
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

From fe3b4be4106721848d0d970ce589b32ad614810d Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 22 Oct 2024 22:11:19 -0700
Subject: [PATCH 019/173] Move workflow file to workflows folder (#3898)

---
 .github/{ => workflows}/python-package-0.2.yml | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename .github/{ => workflows}/python-package-0.2.yml (100%)

diff --git a/.github/python-package-0.2.yml b/.github/workflows/python-package-0.2.yml
similarity index 100%
rename from .github/python-package-0.2.yml
rename to .github/workflows/python-package-0.2.yml

From 6edbbdc75a5763058bd5e6c4eaf06c48f02c4c49 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 22 Oct 2024 22:32:18 -0700
Subject: [PATCH 020/173] specify branch to deploy (#3899)

---
 .github/workflows/python-package-0.2.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/python-package-0.2.yml b/.github/workflows/python-package-0.2.yml
index 67e1d36c581f..aa7591e0a43b 100644
--- a/.github/workflows/python-package-0.2.yml
+++ b/.github/workflows/python-package-0.2.yml
@@ -5,6 +5,11 @@ on:
     tags:
       - "0.2.*"
   workflow_dispatch:
+    inputs:
+      branch:
+        description: 'Branch to deploy the package'
+        required: true
+        default: '0.2'
 permissions: {}
 jobs:
   deploy:
@@ -21,6 +26,8 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.branch }}
       - name: Build
         shell: pwsh
         run: |

From acce081a1f0cf3bb0d2257d9f154546af9cc3de4 Mon Sep 17 00:00:00 2001
From: SeryioGonzalez 
Date: Wed, 23 Oct 2024 14:55:21 +0200
Subject: [PATCH 021/173] Update topic-and-subscription.md (#3901)

---
 .../core-user-guide/core-concepts/topic-and-subscription.md   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/topic-and-subscription.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/topic-and-subscription.md
index 1c93bfd9286b..0e645a3fac05 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/topic-and-subscription.md
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/topic-and-subscription.md
@@ -76,7 +76,7 @@ For Python API, use {py:class}`~autogen_core.components.TypeSubscription`.
 Type-Based Subscription = Topic Type --> Agent Type
 ```
 
-Generally speaking, type-based subscription is the preferred way to delcare
+Generally speaking, type-based subscription is the preferred way to declare
 subscriptions. It is portable and data-independent:
 developers do not need to write application code that depends on specific agent IDs.
 
@@ -208,4 +208,4 @@ of the agent
 if it does not exist.
 
 To support multiple topics per tenant, you can use different topic types,
-just like the single-tenant, multiple topics scenario.
\ No newline at end of file
+just like the single-tenant, multiple topics scenario.

From 6c0d0db9cc58c3beb53effa910fcc9d9765976ad Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Wed, 23 Oct 2024 08:24:36 -0700
Subject: [PATCH 022/173] Update dev version (#3900)

* Update dev version

* Update uv

* C#

* update versions

---------

Co-authored-by: Jack Gerrits 
Co-authored-by: Jack Gerrits 
---
 .github/workflows/docs.yml                    |  1 +
 README.md                                     | 41 ++++++++++---------
 docs/switcher.json                            |  7 +++-
 .../packages/autogen-agentchat/pyproject.toml |  4 +-
 .../packages/autogen-core/docs/src/index.md   |  6 +--
 .../autogen-core/docs/src/packages/index.md   | 13 +++---
 .../agentchat-user-guide/installation.md      |  4 +-
 python/packages/autogen-core/pyproject.toml   |  2 +-
 python/packages/autogen-ext/pyproject.toml    |  6 +--
 python/uv.lock                                | 23 ++++++-----
 10 files changed, 58 insertions(+), 49 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 51faf7cf1c35..13aeea090aa6 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -34,6 +34,7 @@ jobs:
             { ref: main, dest-dir: dev },
             { ref: "v0.4.0dev0", dest-dir: "0.4.0dev0" },
             { ref: "v0.4.0dev1", dest-dir: "0.4.0dev1" },
+            { ref: "v0.4.0dev2", dest-dir: "0.4.0dev2" },
           ]
     steps:
       - name: Checkout
diff --git a/README.md b/README.md
index c21169a16bac..24f4b959765e 100644
--- a/README.md
+++ b/README.md
@@ -10,6 +10,7 @@
 # AutoGen
 
 > [!IMPORTANT]
+>
 > - (10/13/24) Interested in the standard AutoGen as a prior user? Find it at the actively-maintained *AutoGen* [0.2 branch](https://github.com/microsoft/autogen/tree/0.2) and `autogen-agentchat~=0.2` PyPi package.
 > - (10/02/24) [AutoGen 0.4](https://microsoft.github.io/autogen/dev) is a from-the-ground-up rewrite of AutoGen. Learn more about the history, goals and future at [this blog post](https://microsoft.github.io/autogen/blog). We’re excited to work with the community to gather feedback, refine, and improve the project before we officially release 0.4. This is a big change, so AutoGen 0.2 is still available, maintained, and developed in the [0.2 branch](https://github.com/microsoft/autogen/tree/0.2).
 
@@ -18,11 +19,11 @@ It simplifies the creation of event-driven, distributed, scalable, and resilient
 It allows you to quickly build systems where AI agents collaborate and perform tasks autonomously
 or with human oversight.
 
-* [Key Features](#key-features)
-* [API Layering](#api-layering)
-* [Quickstart](#quickstart)
-* [Roadmap](#roadmap)
-* [FAQs](#faqs)
+- [Key Features](#key-features)
+- [API Layering](#api-layering)
+- [Quickstart](#quickstart)
+- [Roadmap](#roadmap)
+- [FAQs](#faqs)
 
 AutoGen streamlines AI development and research, enabling the use of multiple large language models (LLMs), integrated tools, and advanced multi-agent design patterns. You can develop and test your agent systems locally, then deploy to a distributed cloud environment as your needs grow.
 
@@ -100,7 +101,7 @@ We look forward to your contributions!
 First install the packages:
 
 ```bash
-pip install autogen-agentchat==0.4.0dev1 autogen-ext==0.4.0dev1
+pip install autogen-agentchat==0.4.0dev2 autogen-ext==0.4.0dev2
 ```
 
 The following code uses code execution, you need to have [Docker installed](https://docs.docker.com/engine/install/)
@@ -135,7 +136,8 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
-### C#
+### C\#
+
 The .NET SDK does not yet support all of the interfaces that the python SDK offers but we are working on bringing them to parity.
 To use the .NET SDK, you need to add a package reference to the src in your project.
 We will release nuget packages soon and will update these instructions when that happens.
@@ -229,13 +231,13 @@ dotnet run
 ## Roadmap
 
 - AutoGen 0.2 - This is the current stable release of AutoGen. We will continue to accept bug fixes and minor enhancements to this version.
-- AutoGen 0.4 - This is the first release of the new architecture. This release is still in _preview_. We will be focusing on the stability of the interfaces, documentation, tutorials, samples, and a collection of built-in agents which you can use. We are excited to work with our community to define the future of AutoGen. We are looking for feedback and contributions to help shape the future of this project. Here are some major planned items:
-    - More programming languages (e.g., TypeScript)
-    - More built-in agents and multi-agent workflows
-    - Deployment of distributed agents
-    - Re-implementation/migration of AutoGen Studio
-    - Integration with other agent frameworks and data sources
-    - Advanced RAG techniques and memory services
+- AutoGen 0.4 - This is the first release of the new architecture. This release is still in *preview*. We will be focusing on the stability of the interfaces, documentation, tutorials, samples, and a collection of built-in agents which you can use. We are excited to work with our community to define the future of AutoGen. We are looking for feedback and contributions to help shape the future of this project. Here are some major planned items:
+  - More programming languages (e.g., TypeScript)
+  - More built-in agents and multi-agent workflows
+  - Deployment of distributed agents
+  - Re-implementation/migration of AutoGen Studio
+  - Integration with other agent frameworks and data sources
+  - Advanced RAG techniques and memory services
 
 

   
@@ -286,7 +288,7 @@ pip install autogen-agentchat~=0.2
 
 ### Will AutoGen Studio be supported in 0.4?
 
-Yes, this is on the [roadmap](#Roadmap).
+Yes, this is on the [roadmap](#roadmap).
 Our current plan is to enable an implementation of AutoGen Studio
 on the AgentChat high level API which implements a set of agent functionalities
 (agents, teams, etc).
@@ -317,11 +319,11 @@ Use GitHub [Discussions](https://github.com/microsoft/autogen/discussions) for g
 
 ### Do you use Discord for communications?
 
-We are unable to use Discord for project discussions. Therefore, we request that all discussions take place on https://github.com/microsoft/autogen/discussions/ going forward.
+We are unable to use Discord for project discussions. Therefore, we request that all discussions take place on  going forward.
 
 ### What about forks?
 
-https://github.com/microsoft/autogen/ remains the only official repo for development and support of AutoGen.
+ remains the only official repo for development and support of AutoGen.
 We are aware that there are thousands of forks of AutoGen, including many for personal development and startups building with or on top of the library. We are not involved with any of these forks and are not aware of any plans related to them.
 
 ### What is the status of the license and open source?
@@ -329,6 +331,7 @@ We are aware that there are thousands of forks of AutoGen, including many for pe
 Our project remains fully open-source and accessible to everyone. We understand that some forks use different licenses to align with different interests. We will continue to use the most permissive license (MIT) for the project.
 
 ### Can you clarify the current state of the packages?
+
 Currently, we are unable to make releases to the `pyautogen` package via Pypi due to a change to package ownership that was done without our involvement. Additionally, we are moving to using multiple packages to align with the new design. Please see details [here](https://microsoft.github.io/autogen/dev/packages/index.html).
 
 ### Can I still be involved?
@@ -351,9 +354,9 @@ see the [LICENSE](LICENSE) file, and grant you a license to any code in the repo
 Microsoft, Windows, Microsoft Azure, and/or other Microsoft products and services referenced in the documentation
 may be either trademarks or registered trademarks of Microsoft in the United States and/or other countries.
 The licenses for this project do not grant you rights to use any Microsoft names, logos, or trademarks.
-Microsoft's general trademark guidelines can be found at http://go.microsoft.com/fwlink/?LinkID=254653.
+Microsoft's general trademark guidelines can be found at .
 
-Privacy information can be found at https://go.microsoft.com/fwlink/?LinkId=521839
+Privacy information can be found at 
 
 Microsoft and any contributors reserve all other rights, whether under their respective copyrights, patents,
 or trademarks, whether by implication, estoppel, or otherwise.
diff --git a/docs/switcher.json b/docs/switcher.json
index 3f39782bbb29..db73c14f70fd 100644
--- a/docs/switcher.json
+++ b/docs/switcher.json
@@ -16,7 +16,12 @@
     {
         "name": "0.4.0dev1",
         "version": "0.4.0dev1",
-        "url": "/autogen/0.4.0dev1/",
+        "url": "/autogen/0.4.0dev1/"
+    },
+    {
+        "name": "0.4.0dev2",
+        "version": "0.4.0dev2",
+        "url": "/autogen/0.4.0dev2/",
         "preferred": true
     }
 ]
diff --git a/python/packages/autogen-agentchat/pyproject.toml b/python/packages/autogen-agentchat/pyproject.toml
index e2fefc61eb40..f67756b03b15 100644
--- a/python/packages/autogen-agentchat/pyproject.toml
+++ b/python/packages/autogen-agentchat/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-agentchat"
-version = "0.4.0dev1"
+version = "0.4.0dev2"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen agents and teams library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0dev1",
+    "autogen-core==0.4.0dev2",
 ]
 
 [tool.uv]
diff --git a/python/packages/autogen-core/docs/src/index.md b/python/packages/autogen-core/docs/src/index.md
index e8b12059638c..1b23b2ba7954 100644
--- a/python/packages/autogen-core/docs/src/index.md
+++ b/python/packages/autogen-core/docs/src/index.md
@@ -43,7 +43,6 @@ A framework for building AI agents and multi-agent applications
 
 

 
-
 

 
 {fas}`people-group;pst-color-primary`
@@ -63,7 +61,7 @@ AgentChat 

 High-level API that includes preset agents and teams for building multi-agent systems.
 
 ```sh
-pip install autogen-agentchat==0.4.0dev1
+pip install autogen-agentchat==0.4.0dev2
 ```
 
 💡 *Start here if you are looking for an API similar to AutoGen 0.2*
@@ -84,7 +82,7 @@ Get Started
 Provides building blocks for creating asynchronous, event driven multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0dev1
+pip install autogen-core==0.4.0dev2
 ```
 
 +++
diff --git a/python/packages/autogen-core/docs/src/packages/index.md b/python/packages/autogen-core/docs/src/packages/index.md
index 62efe6446a5a..0046f50af9ef 100644
--- a/python/packages/autogen-core/docs/src/packages/index.md
+++ b/python/packages/autogen-core/docs/src/packages/index.md
@@ -29,11 +29,10 @@ myst:
 Library that is at a similar level of abstraction as AutoGen 0.2, including default agents and group chat.
 
 ```sh
-pip install autogen-agentchat==0.4.0dev1
+pip install autogen-agentchat==0.4.0dev2
 ```
 
-
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev1/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
 :::
 
 (pkg-info-autogen-core)=
@@ -45,10 +44,10 @@ pip install autogen-agentchat==0.4.0dev1
 Implements the core functionality of the AutoGen framework, providing basic building blocks for creating multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0dev1
+pip install autogen-core==0.4.0dev2
 ```
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev1/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
 :::
 
 (pkg-info-autogen-ext)=
@@ -60,7 +59,7 @@ pip install autogen-core==0.4.0dev1
 Implementations of core components that interface with external services, or use extra dependencies. For example, Docker based code execution.
 
 ```sh
-pip install autogen-ext==0.4.0dev1
+pip install autogen-ext==0.4.0dev2
 ```
 
 Extras:
@@ -70,7 +69,7 @@ Extras:
 - `docker` needed for {py:class}`~autogen_ext.code_executors.DockerCommandLineCodeExecutor`
 - `openai` needed for {py:class}`~autogen_ext.models.OpenAIChatCompletionClient`
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev1/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
 :::
 
 (pkg-info-autogen-magentic-one)=
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
index 6c614142fb77..52fe9f070ca1 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
@@ -55,13 +55,13 @@ conda deactivate
 
 ``````
 
-## Intall the AgentChat package using pip:
+## Intall the AgentChat package using pip
 
 Install the `autogen-agentchat` package using pip:
 
 ```bash
 
-pip install autogen-agentchat==0.4.0dev1
+pip install autogen-agentchat==0.4.0dev2
 ```
 
 ## Install Docker for Code Execution
diff --git a/python/packages/autogen-core/pyproject.toml b/python/packages/autogen-core/pyproject.toml
index 9cf50ef4e932..dcd4fb0d784f 100644
--- a/python/packages/autogen-core/pyproject.toml
+++ b/python/packages/autogen-core/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-core"
-version = "0.4.0dev1"
+version = "0.4.0dev2"
 license = {file = "LICENSE-CODE"}
 description = "Foundational interfaces and agent runtime implementation for AutoGen"
 readme = "README.md"
diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index f773414e8947..4e8da5a5aa49 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-ext"
-version = "0.4.0dev1"
+version = "0.4.0dev2"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen extensions library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0dev1",
+    "autogen-core==0.4.0dev2",
 ]
 
 
@@ -56,4 +56,4 @@ test = "pytest -n auto"
 [tool.mypy]
 [[tool.mypy.overrides]]
 module = "docker.*"
-ignore_missing_imports = true
\ No newline at end of file
+ignore_missing_imports = true
diff --git a/python/uv.lock b/python/uv.lock
index e06a93ca7f35..ed20c3784d79 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -16,9 +16,12 @@ resolution-markers = [
     "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux')",
     "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux')",
     "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "python_full_version >= '3.12.4' and platform_system == 'Darwin'",
-    "python_full_version >= '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "(python_full_version >= '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version < '3.13' and platform_system == 'Darwin'",
+    "python_full_version >= '3.13' and platform_system == 'Darwin'",
+    "python_full_version < '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",
+    "(python_full_version < '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",
 ]
 
 [manifest]
@@ -360,7 +363,7 @@ wheels = [
 
 [[package]]
 name = "autogen-agentchat"
-version = "0.4.0.dev1"
+version = "0.4.0.dev2"
 source = { editable = "packages/autogen-agentchat" }
 dependencies = [
     { name = "autogen-core" },
@@ -371,7 +374,7 @@ requires-dist = [{ name = "autogen-core", editable = "packages/autogen-core" }]
 
 [[package]]
 name = "autogen-core"
-version = "0.4.0.dev1"
+version = "0.4.0.dev2"
 source = { editable = "packages/autogen-core" }
 dependencies = [
     { name = "aiohttp" },
@@ -436,7 +439,7 @@ requires-dist = [
     { name = "opentelemetry-api", specifier = "~=1.27.0" },
     { name = "pillow" },
     { name = "protobuf", specifier = "~=4.25.1" },
-    { name = "pydantic", specifier = ">=2.0.0,<3.0.0" },
+    { name = "pydantic", specifier = "<3.0.0,>=2.0.0" },
     { name = "tiktoken" },
     { name = "typing-extensions" },
 ]
@@ -484,7 +487,7 @@ dev = [
 
 [[package]]
 name = "autogen-ext"
-version = "0.4.0.dev1"
+version = "0.4.0.dev2"
 source = { editable = "packages/autogen-ext" }
 dependencies = [
     { name = "autogen-core" },
@@ -578,7 +581,7 @@ requires-dist = [
     { name = "pdfminer-six" },
     { name = "playwright" },
     { name = "puremagic" },
-    { name = "pydantic", specifier = ">=2.0.0,<3.0.0" },
+    { name = "pydantic", specifier = "<3.0.0,>=2.0.0" },
     { name = "pydub" },
     { name = "python-pptx" },
     { name = "requests" },
@@ -3443,7 +3446,7 @@ name = "psycopg"
 version = "3.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d1/ad/7ce016ae63e231575df0498d2395d15f005f05e32d3a2d439038e1bd0851/psycopg-3.2.3.tar.gz", hash = "sha256:a5764f67c27bec8bfac85764d23c534af2c27b893550377e37ce59c12aac47a2", size = 155550 }
@@ -4537,7 +4540,7 @@ name = "sqlalchemy"
 version = "2.0.32"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "greenlet", marker = "(python_full_version < '3.13' and platform_machine == 'AMD64') or (python_full_version < '3.13' and platform_machine == 'WIN32') or (python_full_version < '3.13' and platform_machine == 'aarch64') or (python_full_version < '3.13' and platform_machine == 'amd64') or (python_full_version < '3.13' and platform_machine == 'ppc64le') or (python_full_version < '3.13' and platform_machine == 'win32') or (python_full_version < '3.13' and platform_machine == 'x86_64')" },
     { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/af/6f/967e987683908af816aa3072c1a6997ac9933cf38d66b0474fb03f253323/SQLAlchemy-2.0.32.tar.gz", hash = "sha256:c1b88cc8b02b6a5f0efb0345a03672d4c897dc7d92585176f88c67346f565ea8", size = 9546691 }

From 13b7ae502e752071e126a90d0d8bcbecf9f6ee1a Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 11:41:17 -0400
Subject: [PATCH 023/173] Use install uv action (#3906)

Co-authored-by: Eric Zhu 
---
 .github/workflows/checks.yml                | 28 +++++++++++++++------
 .github/workflows/docs.yml                  |  4 ++-
 .github/workflows/single-python-package.yml |  4 ++-
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 3b66dd20ca02..944e7e4f9ccb 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -15,7 +15,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -31,7 +33,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -57,7 +61,9 @@ jobs:
           ]
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -83,7 +89,9 @@ jobs:
           ]
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -107,7 +115,9 @@ jobs:
           ]
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -129,7 +139,9 @@ jobs:
         package: ["./packages/autogen-core"]
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -145,7 +157,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 13aeea090aa6..870066477b19 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -42,7 +42,9 @@ jobs:
         with:
           lfs: "true"
           ref: ${{ matrix.version.ref }}
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
diff --git a/.github/workflows/single-python-package.yml b/.github/workflows/single-python-package.yml
index f0c8a01d7fac..db761e2c2563 100644
--- a/.github/workflows/single-python-package.yml
+++ b/.github/workflows/single-python-package.yml
@@ -32,7 +32,9 @@ jobs:
           ref: ${{ github.event.inputs.ref }}
       # Require ref to be a tag
       - run: git show-ref --verify refs/tags/${{ github.event.inputs.ref }}
-      - run: curl -LsSf https://astral.sh/uv/install.sh | sh
+      - uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
       - run: uv build --package ${{ github.event.inputs.package }} --out-dir dist/
         working-directory: python
       - name: Publish package to PyPI

From 0811102ed77d806c09d662a4e4c76e48f1538a15 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 12:11:59 -0400
Subject: [PATCH 024/173] Update all versions to match normalized dev scheme
 (#3909)

---
 .github/workflows/docs.yml                    |   6 +-
 README.md                                     |   2 +-
 docs/switcher.json                            |  16 +-
 .../packages/autogen-agentchat/pyproject.toml |   4 +-
 .../docs/redirects/redirect_urls.txt          | 704 +++++++++---------
 .../autogen-core/docs/redirects/redirects.py  |   5 +-
 .../src/_static/override-switcher-button.js   |  21 +-
 .../packages/autogen-core/docs/src/index.md   |   4 +-
 .../autogen-core/docs/src/packages/index.md   |   6 +-
 .../agentchat-user-guide/installation.md      |   2 +-
 python/packages/autogen-core/pyproject.toml   |   2 +-
 python/packages/autogen-ext/pyproject.toml    |   4 +-
 12 files changed, 398 insertions(+), 378 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 870066477b19..84e4d2c69337 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -32,9 +32,9 @@ jobs:
         version:
           [
             { ref: main, dest-dir: dev },
-            { ref: "v0.4.0dev0", dest-dir: "0.4.0dev0" },
-            { ref: "v0.4.0dev1", dest-dir: "0.4.0dev1" },
-            { ref: "v0.4.0dev2", dest-dir: "0.4.0dev2" },
+            { ref: "v0.4.0.dev0", dest-dir: "0.4.0.dev0" },
+            { ref: "v0.4.0.dev1", dest-dir: "0.4.0.dev1" },
+            { ref: "v0.4.0.dev2", dest-dir: "0.4.0.dev2" },
           ]
     steps:
       - name: Checkout
diff --git a/README.md b/README.md
index 24f4b959765e..43bdd263d310 100644
--- a/README.md
+++ b/README.md
@@ -101,7 +101,7 @@ We look forward to your contributions!
 First install the packages:
 
 ```bash
-pip install autogen-agentchat==0.4.0dev2 autogen-ext==0.4.0dev2
+pip install autogen-agentchat==0.4.0.dev2 autogen-ext==0.4.0.dev2
 ```
 
 The following code uses code execution, you need to have [Docker installed](https://docs.docker.com/engine/install/)
diff --git a/docs/switcher.json b/docs/switcher.json
index db73c14f70fd..364394a4f3f7 100644
--- a/docs/switcher.json
+++ b/docs/switcher.json
@@ -9,19 +9,19 @@
         "url": "/autogen/dev/"
     },
     {
-        "name": "0.4.0dev0",
-        "version": "0.4.0dev0",
+        "name": "0.4.0.dev0",
+        "version": "0.4.0.dev0",
         "url": "/autogen/0.4.0dev0/"
     },
     {
-        "name": "0.4.0dev1",
-        "version": "0.4.0dev1",
-        "url": "/autogen/0.4.0dev1/"
+        "name": "0.4.0.dev1",
+        "version": "0.4.0.dev1",
+        "url": "/autogen/0.4.0.dev1/"
     },
     {
-        "name": "0.4.0dev2",
-        "version": "0.4.0dev2",
-        "url": "/autogen/0.4.0dev2/",
+        "name": "0.4.0.dev2",
+        "version": "0.4.0.dev2",
+        "url": "/autogen/0.4.0.dev2/",
         "preferred": true
     }
 ]
diff --git a/python/packages/autogen-agentchat/pyproject.toml b/python/packages/autogen-agentchat/pyproject.toml
index f67756b03b15..48874b9de662 100644
--- a/python/packages/autogen-agentchat/pyproject.toml
+++ b/python/packages/autogen-agentchat/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-agentchat"
-version = "0.4.0dev2"
+version = "0.4.0.dev2"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen agents and teams library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0dev2",
+    "autogen-core==0.4.0.dev2",
 ]
 
 [tool.uv]
diff --git a/python/packages/autogen-core/docs/redirects/redirect_urls.txt b/python/packages/autogen-core/docs/redirects/redirect_urls.txt
index 9502a312de0c..79b5fbe99e34 100644
--- a/python/packages/autogen-core/docs/redirects/redirect_urls.txt
+++ b/python/packages/autogen-core/docs/redirects/redirect_urls.txt
@@ -1,351 +1,353 @@
-/autogen/
-/autogen/docs/Getting-Started
-/autogen/docs/installation/
-/autogen/docs/tutorial/introduction
-/autogen/docs/topics
-/autogen/docs/reference/agentchat/conversable_agent
-/autogen/docs/FAQ
-/autogen/docs/autogen-studio/getting-started
-/autogen/docs/ecosystem
-/autogen/docs/contributor-guide/contributing
-/autogen/docs/Research
-/autogen/docs/Examples
-/autogen/docs/notebooks
-/autogen/docs/Gallery
-/autogen/blog
-/autogen/docs/Use-Cases/agent_chat
-/autogen/docs/Use-Cases/enhanced_inference
-/autogen/docs/tutorial
-/autogen/docs/tutorial/chat-termination
-/autogen/docs/tutorial/human-in-the-loop
-/autogen/docs/tutorial/code-executors
-/autogen/docs/tutorial/tool-use
-/autogen/docs/tutorial/conversation-patterns
-/autogen/docs/tutorial/what-next
-/autogen/docs/topics/code-execution/cli-code-executor
-/autogen/docs/topics/openai-assistant/gpt_assistant_agent
-/autogen/docs/topics/groupchat/customized_speaker_selection
-/autogen/docs/topics/non-openai-models/about-using-nonopenai-models
-/autogen/docs/topics/handling_long_contexts/compressing_text_w_llmligua
-/autogen/docs/topics/llm-caching
-/autogen/docs/topics/llm-observability
-/autogen/docs/topics/llm_configuration
-/autogen/docs/topics/prompting-and-reasoning/react
-/autogen/docs/topics/retrieval_augmentation
-/autogen/docs/topics/task_decomposition
-/autogen/docs/autogen-studio
-/autogen/docs/contributor-guide
-/autogen/docs/Migration-Guide
-/autogen/docs/reference/agentchat/conversable_agent/
-/autogen/docs/installation/Docker
-/autogen/docs/installation/Optional-Dependencies
-/autogen/docs/reference/agentchat/contrib/agent_eval/
-/autogen/docs/reference/agentchat/agent
-/autogen/docs/reference/agentchat/assistant_agent
-/autogen/docs/reference/agentchat/chat
-/autogen/docs/reference/agentchat/groupchat
-/autogen/docs/reference/agentchat/user_proxy_agent
-/autogen/docs/reference/agentchat/utils
-/autogen/docs/reference/browser_utils/abstract_markdown_browser
-/autogen/docs/reference/cache/abstract_cache_base
-/autogen/docs/reference/coding/jupyter/base
-/autogen/docs/reference/io/base
-/autogen/docs/reference/logger/base_logger
-/autogen/docs/reference/oai/anthropic
-/autogen/docs/reference/code_utils
-/autogen/docs/reference/exception_utils
-/autogen/docs/reference/function_utils
-/autogen/docs/reference/graph_utils
-/autogen/docs/reference/math_utils
-/autogen/docs/reference/retrieve_utils
-/autogen/docs/reference/runtime_logging
-/autogen/docs/reference/token_count_utils
-/autogen/docs/reference/oai/client
-/autogen/blog/2023/07/14/Local-LLMs
-/autogen/blog/2024/01/26/Custom-Models
-/autogen/docs/autogen-studio/usage
-/autogen/docs/autogen-studio/faqs
-/autogen/docs/ecosystem/agentops
-/autogen/docs/ecosystem/azure_cosmos_db
-/autogen/docs/ecosystem/composio
-/autogen/docs/ecosystem/databricks
-/autogen/docs/ecosystem/llamaindex
-/autogen/docs/ecosystem/mem0
-/autogen/docs/ecosystem/memgpt
-/autogen/docs/ecosystem/microsoft-fabric
-/autogen/docs/ecosystem/ollama
-/autogen/docs/ecosystem/pgvector
-/autogen/docs/ecosystem/portkey
-/autogen/docs/ecosystem/promptflow
-/autogen/docs/contributor-guide/docker
-/autogen/docs/contributor-guide/documentation
-/autogen/docs/contributor-guide/file-bug-report
-/autogen/docs/contributor-guide/maintainer
-/autogen/docs/contributor-guide/pre-commit
-/autogen/docs/contributor-guide/tests
-/autogen/docs/notebooks/agentchat_auto_feedback_from_code_execution
-/autogen/docs/notebooks/agentchat_RetrieveChat
-/autogen/docs/notebooks/agentchat_RetrieveChat_qdrant
-/autogen/docs/notebooks/agentchat_groupchat
-/autogen/docs/notebooks/agentchat_groupchat_vis
-/autogen/docs/notebooks/agentchat_groupchat_research
-/autogen/docs/notebooks/agentchat_groupchat_finite_state_machine
-/autogen/docs/notebooks/agentchat_society_of_mind
-/autogen/docs/notebooks/agentchat_groupchat_customized
-/autogen/docs/notebooks/agentchat_multi_task_chats
-/autogen/docs/notebooks/agentchat_multi_task_async_chats
-/autogen/docs/notebooks/agentchats_sequential_chats
-/autogen/docs/notebooks/agentchat_nestedchat
-/autogen/docs/notebooks/agentchat_nested_sequential_chats
-/autogen/docs/notebooks/agentchat_nestedchat_optiguide
-/autogen/docs/notebooks/agentchat_nested_chats_chess
-/autogen/docs/notebooks/agentchat_function_call_currency_calculator
-/autogen/docs/notebooks/agentchat_function_call_async
-/autogen/docs/notebooks/agentchat_groupchat_RAG
-/autogen/docs/notebooks/agentchat_video_transcript_translate_with_whisper
-/autogen/docs/notebooks/agentchat_webscraping_with_apify
-/autogen/docs/notebooks/agentchat_teaching
-/autogen/docs/notebooks/agentchat_teachability
-/autogen/docs/notebooks/agentchat_nested_chats_chess_altmodels
-/autogen/docs/notebooks/agentchat_transform_messages
-/autogen/docs/Use-Cases/enhanced_inference/
-/autogen/docs/notebooks/JSON_mode_example
-/autogen/docs/notebooks/agentchat_RetrieveChat_mongodb
-/autogen/docs/notebooks/agentchat_RetrieveChat_pgvector
-/autogen/docs/notebooks/agentchat_agentops
-/autogen/docs/notebooks/agentchat_agentoptimizer
-/autogen/docs/notebooks/agentchat_azr_ai_search
-/autogen/docs/notebooks/agentchat_custom_model
-/autogen/docs/notebooks/agentchat_databricks_dbrx
-/autogen/docs/notebooks/agentchat_function_call_code_writing
-/autogen/docs/notebooks/agentchat_function_call_with_composio
-/autogen/docs/notebooks/agentchat_group_chat_with_llamaindex_agents
-/autogen/docs/notebooks/agentchat_groupchat_stateflow
-/autogen/docs/notebooks/agentchat_image_generation_capability
-/autogen/docs/notebooks/agentchat_lmm_gpt-4v
-/autogen/docs/notebooks/agentchat_logging
-/autogen/docs/notebooks/agentchat_memory_using_mem0
-/autogen/docs/notebooks/agentchat_oai_assistant_function_call
-/autogen/docs/notebooks/agentchat_oai_assistant_groupchat
-/autogen/docs/notebooks/agentchat_oai_code_interpreter
-/autogen/docs/notebooks/agentchat_websockets
-/autogen/docs/notebooks/gpt_assistant_agent_function_call
-/autogen/blog/2024/10/02/new-autogen-architecture-preview
-/autogen/blog/2024/07/25/AgentOps
-/autogen/blog/2024/06/24/AltModels-Classes
-/autogen/blog/2024/06/21/AgentEval
-/autogen/blog/2024/05/24/Agent
-/autogen/blog/2024/03/11/AutoDefense/Defending%20LLMs%20Against%20Jailbreak%20Attacks%20with%20AutoDefense
-/autogen/blog/2024/03/03/AutoGen-Update
-/autogen/blog/2024/02/29/StateFlow
-/autogen/blog/2024/02/11/FSM-GroupChat
-/autogen/blog/2024/02/02/AutoAnny
-/autogen/blog/2024/01/25/AutoGenBench
-/autogen/blog/2024/01/23/Code-execution-in-docker
-/autogen/blog/2023/12/29/AgentDescriptions
-/autogen/blog/2023/12/23/AgentOptimizer
-/autogen/blog/2023/12/01/AutoGenStudio
-/autogen/blog/2023/11/26/Agent-AutoBuild
-/autogen/blog/2023/11/20/AgentEval
-/autogen/blog/2023/11/13/OAI-assistants
-/autogen/blog/2023/11/09/EcoAssistant
-/autogen/blog/2023/11/06/LMM-Agent
-/autogen/blog/2023/10/26/TeachableAgent
-/autogen/blog/2023/10/18/RetrieveChat
-/autogen/blog/2023/06/28/MathChat
-/autogen/blog/2023/05/18/GPT-adaptive-humaneval
-/autogen/blog/2023/04/21/LLM-tuning-math
-/autogen/blog/tags/auto-gen
-/autogen/docs/notebooks/agentchat_agentops/
-/autogen/blog/tags/llm
-/autogen/blog/tags/agent
-/autogen/blog/tags/observability
-/autogen/blog/tags/agent-ops
-/autogen/docs/topics/non-openai-models/cloud-gemini
-/autogen/docs/topics/handling_long_contexts/intro_to_transform_messages
-/autogen/docs/reference/oai/gemini
-/autogen/blog/tags/mistral-ai
-/autogen/blog/tags/anthropic
-/autogen/blog/tags/together-ai
-/autogen/blog/tags/gemini
-/autogen/blog/2023/11/20/AgentEval/
-/autogen/blog/tags/gpt
-/autogen/blog/tags/evaluation
-/autogen/blog/tags/task-utility
-/autogen/docs/topics/prompting-and-reasoning/reflection
-/autogen/docs/topics/code-execution/user-defined-functions
-/autogen/blog/2023/12/01/AutoGenStudio/
-/autogen/blog/tags/thoughts
-/autogen/blog/tags/interview-notes
-/autogen/blog/tags/research
-/autogen/blog/tags/news
-/autogen/blog/tags/summary
-/autogen/blog/tags/roadmap
-/autogen/blog/2024/02/11/FSM-GroupChat/
-/autogen/docs/notebooks/agentchat_groupchat_finite_state_machine/
-/autogen/blog/page/2
-/autogen/docs/reference/coding/local_commandline_code_executor
-/autogen/docs/reference/coding/docker_commandline_code_executor
-/autogen/docs/reference/coding/jupyter/jupyter_code_executor
-/autogen/docs/topics/code-execution/jupyter-code-executor
-/autogen/docs/topics/code-execution/custom-executor
-/autogen/docs/topics/groupchat/resuming_groupchat
-/autogen/docs/topics/groupchat/transform_messages_speaker_selection
-/autogen/docs/tags/orchestration
-/autogen/docs/tags/group-chat
-/autogen/docs/topics/non-openai-models/best-tips-for-nonopenai-models
-/autogen/docs/topics/non-openai-models/cloud-anthropic
-/autogen/docs/topics/non-openai-models/cloud-bedrock
-/autogen/docs/topics/non-openai-models/cloud-cerebras
-/autogen/docs/topics/non-openai-models/cloud-cohere
-/autogen/docs/topics/non-openai-models/cloud-gemini_vertexai
-/autogen/docs/topics/non-openai-models/cloud-groq
-/autogen/docs/topics/non-openai-models/cloud-mistralai
-/autogen/docs/topics/non-openai-models/cloud-togetherai
-/autogen/docs/topics/non-openai-models/local-litellm-ollama
-/autogen/docs/topics/non-openai-models/local-lm-studio
-/autogen/docs/topics/non-openai-models/local-ollama
-/autogen/docs/topics/non-openai-models/local-vllm
-/autogen/docs/topics/non-openai-models/transforms-for-nonopenai-models
-/autogen/docs/notebooks/agentchat_custom_model/
-/autogen/docs/reference/cache/disk_cache
-/autogen/docs/reference/cache/redis_cache
-/autogen/docs/reference/oai/openai_utils
-/autogen/docs/reference/cache/
-/autogen/docs/reference/agentchat/contrib/retrieve_user_proxy_agent
-/autogen/docs/reference/agentchat/contrib/agent_eval/criterion
-/autogen/docs/reference/agentchat/contrib/agent_eval/critic_agent
-/autogen/docs/reference/agentchat/contrib/agent_eval/quantifier_agent
-/autogen/docs/reference/agentchat/contrib/agent_eval/subcritic_agent
-/autogen/docs/reference/agentchat/contrib/agent_eval/task
-/autogen/docs/reference/agentchat/contrib/capabilities/agent_capability
-/autogen/docs/reference/agentchat/contrib/graph_rag/document
-/autogen/docs/reference/agentchat/contrib/vectordb/base
-/autogen/docs/reference/agentchat/contrib/agent_builder
-/autogen/docs/reference/agentchat/contrib/agent_optimizer
-/autogen/docs/reference/agentchat/contrib/gpt_assistant_agent
-/autogen/docs/reference/agentchat/contrib/img_utils
-/autogen/docs/reference/agentchat/contrib/llamaindex_conversable_agent
-/autogen/docs/reference/agentchat/contrib/llava_agent
-/autogen/docs/reference/agentchat/contrib/math_user_proxy_agent
-/autogen/docs/reference/agentchat/contrib/multimodal_conversable_agent
-/autogen/docs/reference/agentchat/contrib/qdrant_retrieve_user_proxy_agent
-/autogen/docs/reference/agentchat/contrib/retrieve_assistant_agent
-/autogen/docs/reference/agentchat/contrib/society_of_mind_agent
-/autogen/docs/reference/agentchat/contrib/text_analyzer_agent
-/autogen/docs/reference/agentchat/contrib/web_surfer
-/autogen/docs/reference/browser_utils/markdown_search
-/autogen/docs/reference/browser_utils/mdconvert
-/autogen/docs/reference/browser_utils/playwright_markdown_browser
-/autogen/docs/reference/browser_utils/requests_markdown_browser
-/autogen/docs/reference/browser_utils/selenium_markdown_browser
-/autogen/docs/reference/cache/cache_factory
-/autogen/docs/reference/cache/cosmos_db_cache
-/autogen/docs/reference/cache/in_memory_cache
-/autogen/docs/reference/coding/jupyter/docker_jupyter_server
-/autogen/docs/reference/coding/jupyter/embedded_ipython_code_executor
-/autogen/docs/reference/coding/jupyter/jupyter_client
-/autogen/docs/reference/coding/jupyter/local_jupyter_server
-/autogen/docs/reference/coding/base
-/autogen/docs/reference/coding/factory
-/autogen/docs/reference/coding/func_with_reqs
-/autogen/docs/reference/coding/markdown_code_extractor
-/autogen/docs/reference/coding/utils
-/autogen/docs/reference/io/console
-/autogen/docs/reference/io/websockets
-/autogen/docs/reference/logger/file_logger
-/autogen/docs/reference/oai/bedrock
-/autogen/docs/reference/oai/cerebras
-/autogen/docs/reference/oai/client_utils
-/autogen/docs/reference/oai/cohere
-/autogen/docs/reference/oai/completion
-/autogen/docs/reference/oai/groq
-/autogen/docs/reference/oai/mistral
-/autogen/docs/reference/oai/ollama
-/autogen/docs/reference/oai/rate_limiters
-/autogen/docs/reference/oai/together
-/autogen/docs/Contribute
-/autogen/docs/tags/code-generation
-/autogen/docs/tags/debugging
-/autogen/docs/tags/rag
-/autogen/docs/tags/nested-chat
-/autogen/docs/tags/sequential-chats
-/autogen/docs/tags/hierarchical-chat
-/autogen/docs/tags/tool-use
-/autogen/docs/tags/function-call
-/autogen/docs/tags/async
-/autogen/docs/tags/whisper
-/autogen/docs/tags/web-scraping
-/autogen/docs/tags/apify
-/autogen/docs/tags/teaching
-/autogen/docs/tags/teachability
-/autogen/docs/tags/capability
-/autogen/docs/tags/long-context-handling
-/autogen/blog/2023/12/29/AgentDescriptions/
-/autogen/docs/tags/json
-/autogen/docs/tags/description
-/autogen/docs/tags/prompt-hacking
-/autogen/docs/tags/monitoring
-/autogen/docs/tags/optimization
-/autogen/docs/tags/tool-function
-/autogen/docs/tags/azure-identity
-/autogen/docs/tags/azure-ai-search
-/autogen/docs/tags/custom-model
-/autogen/docs/topics/non-openai-models/cloud-mistralai/
-/autogen/docs/tutorial/conversation-patterns/
-/autogen/docs/tags/dbrx
-/autogen/docs/tags/databricks
-/autogen/docs/tags/open-source
-/autogen/docs/tags/lakehouse
-/autogen/docs/tags/data-intelligence
-/autogen/docs/tags/software-engineering
-/autogen/docs/tags/agents
-/autogen/docs/tags/react
-/autogen/docs/tags/llama-index
-/autogen/docs/tags/research
-/autogen/docs/tags/multimodal
-/autogen/docs/tags/gpt-4-v
-/autogen/docs/tags/logging
-/autogen/docs/tags/memory
-/autogen/docs/tags/open-ai-assistant
-/autogen/docs/tags/code-interpreter
-/autogen/docs/reference/io/base/IOStream
-/autogen/docs/reference/io/websockets/IOWebsockets
-/autogen/docs/tags/websockets
-/autogen/docs/tags/streaming
-/autogen/docs/tags/gpt-assistant
-/autogen/docs/Installation
-/autogen/docs/reference/agentchat/agentchat/
-/autogen/blog/tags/ui
-/autogen/blog/tags/web
-/autogen/blog/tags/ux
-/autogen/blog/tags/openai-assistant
-/autogen/blog/tags/rag
-/autogen/blog/tags/cost-effectiveness
-/autogen/blog/tags/lmm
-/autogen/blog/tags/multimodal
-/autogen/blog/tags/teach
-/autogen/blog/tags
-/autogen/blog/tags/llm/page/2
-/autogen/docs/tags/gemini
-/autogen/blog/page/3
-/autogen/docs/tags/resume
-/autogen/docs/reference/agentchat/contrib/capabilities/transform_messages
-/autogen/docs/tags
-/autogen/docs/contributor-guide/contributing/
-/autogen/docs/tags/vertexai
-/autogen/docs/installation
-/autogen/docs/reference/agentchat/contrib/capabilities/generate_images
-/autogen/docs/reference/agentchat/contrib/capabilities/teachability
-/autogen/docs/reference/agentchat/contrib/capabilities/text_compressors
-/autogen/docs/reference/agentchat/contrib/capabilities/transforms
-/autogen/docs/reference/agentchat/contrib/capabilities/transforms_util
-/autogen/docs/reference/agentchat/contrib/capabilities/vision_capability
-/autogen/docs/reference/agentchat/contrib/graph_rag/graph_query_engine
-/autogen/docs/reference/agentchat/contrib/graph_rag/graph_rag_capability
-/autogen/docs/reference/agentchat/contrib/vectordb/chromadb
-/autogen/docs/reference/agentchat/contrib/vectordb/couchbase
-/autogen/docs/reference/agentchat/contrib/vectordb/mongodb
-/autogen/docs/reference/agentchat/contrib/vectordb/pgvectordb
-/autogen/docs/reference/agentchat/contrib/vectordb/qdrant
-/autogen/docs/reference/agentchat/contrib/vectordb/utils
+/autogen/,/autogen/0.2/0.2/
+/autogen/docs/Getting-Started,/autogen/0.2/docs/Getting-Started
+/autogen/docs/installation/,/autogen/0.2/docs/installation/
+/autogen/docs/tutorial/introduction,/autogen/0.2/docs/tutorial/introduction
+/autogen/docs/topics,/autogen/0.2/docs/topics
+/autogen/docs/reference/agentchat/conversable_agent,/autogen/0.2/docs/reference/agentchat/conversable_agent
+/autogen/docs/FAQ,/autogen/0.2/docs/FAQ
+/autogen/docs/autogen-studio/getting-started,/autogen/0.2/docs/autogen-studio/getting-started
+/autogen/docs/ecosystem,/autogen/0.2/docs/ecosystem
+/autogen/docs/contributor-guide/contributing,/autogen/0.2/docs/contributor-guide/contributing
+/autogen/docs/Research,/autogen/0.2/docs/Research
+/autogen/docs/Examples,/autogen/0.2/docs/Examples
+/autogen/docs/notebooks,/autogen/0.2/docs/notebooks
+/autogen/docs/Gallery,/autogen/0.2/docs/Gallery
+/autogen/blog,/autogen/0.2/blog
+/autogen/docs/Use-Cases/agent_chat,/autogen/0.2/docs/Use-Cases/agent_chat
+/autogen/docs/Use-Cases/enhanced_inference,/autogen/0.2/docs/Use-Cases/enhanced_inference
+/autogen/docs/tutorial,/autogen/0.2/docs/tutorial
+/autogen/docs/tutorial/chat-termination,/autogen/0.2/docs/tutorial/chat-termination
+/autogen/docs/tutorial/human-in-the-loop,/autogen/0.2/docs/tutorial/human-in-the-loop
+/autogen/docs/tutorial/code-executors,/autogen/0.2/docs/tutorial/code-executors
+/autogen/docs/tutorial/tool-use,/autogen/0.2/docs/tutorial/tool-use
+/autogen/docs/tutorial/conversation-patterns,/autogen/0.2/docs/tutorial/conversation-patterns
+/autogen/docs/tutorial/what-next,/autogen/0.2/docs/tutorial/what-next
+/autogen/docs/topics/code-execution/cli-code-executor,/autogen/0.2/docs/topics/code-execution/cli-code-executor
+/autogen/docs/topics/openai-assistant/gpt_assistant_agent,/autogen/0.2/docs/topics/openai-assistant/gpt_assistant_agent
+/autogen/docs/topics/groupchat/customized_speaker_selection,/autogen/0.2/docs/topics/groupchat/customized_speaker_selection
+/autogen/docs/topics/non-openai-models/about-using-nonopenai-models,/autogen/0.2/docs/topics/non-openai-models/about-using-nonopenai-models
+/autogen/docs/topics/handling_long_contexts/compressing_text_w_llmligua,/autogen/0.2/docs/topics/handling_long_contexts/compressing_text_w_llmligua
+/autogen/docs/topics/llm-caching,/autogen/0.2/docs/topics/llm-caching
+/autogen/docs/topics/llm-observability,/autogen/0.2/docs/topics/llm-observability
+/autogen/docs/topics/llm_configuration,/autogen/0.2/docs/topics/llm_configuration
+/autogen/docs/topics/prompting-and-reasoning/react,/autogen/0.2/docs/topics/prompting-and-reasoning/react
+/autogen/docs/topics/retrieval_augmentation,/autogen/0.2/docs/topics/retrieval_augmentation
+/autogen/docs/topics/task_decomposition,/autogen/0.2/docs/topics/task_decomposition
+/autogen/docs/autogen-studio,/autogen/0.2/docs/autogen-studio
+/autogen/docs/contributor-guide,/autogen/0.2/docs/contributor-guide
+/autogen/docs/Migration-Guide,/autogen/0.2/docs/Migration-Guide
+/autogen/docs/reference/agentchat/conversable_agent/,/autogen/0.2/docs/reference/agentchat/conversable_agent/
+/autogen/docs/installation/Docker,/autogen/0.2/docs/installation/Docker
+/autogen/docs/installation/Optional-Dependencies,/autogen/0.2/docs/installation/Optional-Dependencies
+/autogen/docs/reference/agentchat/contrib/agent_eval/,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/
+/autogen/docs/reference/agentchat/agent,/autogen/0.2/docs/reference/agentchat/agent
+/autogen/docs/reference/agentchat/assistant_agent,/autogen/0.2/docs/reference/agentchat/assistant_agent
+/autogen/docs/reference/agentchat/chat,/autogen/0.2/docs/reference/agentchat/chat
+/autogen/docs/reference/agentchat/groupchat,/autogen/0.2/docs/reference/agentchat/groupchat
+/autogen/docs/reference/agentchat/user_proxy_agent,/autogen/0.2/docs/reference/agentchat/user_proxy_agent
+/autogen/docs/reference/agentchat/utils,/autogen/0.2/docs/reference/agentchat/utils
+/autogen/docs/reference/browser_utils/abstract_markdown_browser,/autogen/0.2/docs/reference/browser_utils/abstract_markdown_browser
+/autogen/docs/reference/cache/abstract_cache_base,/autogen/0.2/docs/reference/cache/abstract_cache_base
+/autogen/docs/reference/coding/jupyter/base,/autogen/0.2/docs/reference/coding/jupyter/base
+/autogen/docs/reference/io/base,/autogen/0.2/docs/reference/io/base
+/autogen/docs/reference/logger/base_logger,/autogen/0.2/docs/reference/logger/base_logger
+/autogen/docs/reference/oai/anthropic,/autogen/0.2/docs/reference/oai/anthropic
+/autogen/docs/reference/code_utils,/autogen/0.2/docs/reference/code_utils
+/autogen/docs/reference/exception_utils,/autogen/0.2/docs/reference/exception_utils
+/autogen/docs/reference/function_utils,/autogen/0.2/docs/reference/function_utils
+/autogen/docs/reference/graph_utils,/autogen/0.2/docs/reference/graph_utils
+/autogen/docs/reference/math_utils,/autogen/0.2/docs/reference/math_utils
+/autogen/docs/reference/retrieve_utils,/autogen/0.2/docs/reference/retrieve_utils
+/autogen/docs/reference/runtime_logging,/autogen/0.2/docs/reference/runtime_logging
+/autogen/docs/reference/token_count_utils,/autogen/0.2/docs/reference/token_count_utils
+/autogen/docs/reference/oai/client,/autogen/0.2/docs/reference/oai/client
+/autogen/blog/2023/07/14/Local-LLMs,/autogen/0.2/blog/2023/07/14/Local-LLMs
+/autogen/blog/2024/01/26/Custom-Models,/autogen/0.2/blog/2024/01/26/Custom-Models
+/autogen/docs/autogen-studio/usage,/autogen/0.2/docs/autogen-studio/usage
+/autogen/docs/autogen-studio/faqs,/autogen/0.2/docs/autogen-studio/faqs
+/autogen/docs/ecosystem/agentops,/autogen/0.2/docs/ecosystem/agentops
+/autogen/docs/ecosystem/azure_cosmos_db,/autogen/0.2/docs/ecosystem/azure_cosmos_db
+/autogen/docs/ecosystem/composio,/autogen/0.2/docs/ecosystem/composio
+/autogen/docs/ecosystem/databricks,/autogen/0.2/docs/ecosystem/databricks
+/autogen/docs/ecosystem/llamaindex,/autogen/0.2/docs/ecosystem/llamaindex
+/autogen/docs/ecosystem/mem0,/autogen/0.2/docs/ecosystem/mem0
+/autogen/docs/ecosystem/memgpt,/autogen/0.2/docs/ecosystem/memgpt
+/autogen/docs/ecosystem/microsoft-fabric,/autogen/0.2/docs/ecosystem/microsoft-fabric
+/autogen/docs/ecosystem/ollama,/autogen/0.2/docs/ecosystem/ollama
+/autogen/docs/ecosystem/pgvector,/autogen/0.2/docs/ecosystem/pgvector
+/autogen/docs/ecosystem/portkey,/autogen/0.2/docs/ecosystem/portkey
+/autogen/docs/ecosystem/promptflow,/autogen/0.2/docs/ecosystem/promptflow
+/autogen/docs/contributor-guide/docker,/autogen/0.2/docs/contributor-guide/docker
+/autogen/docs/contributor-guide/documentation,/autogen/0.2/docs/contributor-guide/documentation
+/autogen/docs/contributor-guide/file-bug-report,/autogen/0.2/docs/contributor-guide/file-bug-report
+/autogen/docs/contributor-guide/maintainer,/autogen/0.2/docs/contributor-guide/maintainer
+/autogen/docs/contributor-guide/pre-commit,/autogen/0.2/docs/contributor-guide/pre-commit
+/autogen/docs/contributor-guide/tests,/autogen/0.2/docs/contributor-guide/tests
+/autogen/docs/notebooks/agentchat_auto_feedback_from_code_execution,/autogen/0.2/docs/notebooks/agentchat_auto_feedback_from_code_execution
+/autogen/docs/notebooks/agentchat_RetrieveChat,/autogen/0.2/docs/notebooks/agentchat_RetrieveChat
+/autogen/docs/notebooks/agentchat_RetrieveChat_qdrant,/autogen/0.2/docs/notebooks/agentchat_RetrieveChat_qdrant
+/autogen/docs/notebooks/agentchat_groupchat,/autogen/0.2/docs/notebooks/agentchat_groupchat
+/autogen/docs/notebooks/agentchat_groupchat_vis,/autogen/0.2/docs/notebooks/agentchat_groupchat_vis
+/autogen/docs/notebooks/agentchat_groupchat_research,/autogen/0.2/docs/notebooks/agentchat_groupchat_research
+/autogen/docs/notebooks/agentchat_groupchat_finite_state_machine,/autogen/0.2/docs/notebooks/agentchat_groupchat_finite_state_machine
+/autogen/docs/notebooks/agentchat_society_of_mind,/autogen/0.2/docs/notebooks/agentchat_society_of_mind
+/autogen/docs/notebooks/agentchat_groupchat_customized,/autogen/0.2/docs/notebooks/agentchat_groupchat_customized
+/autogen/docs/notebooks/agentchat_multi_task_chats,/autogen/0.2/docs/notebooks/agentchat_multi_task_chats
+/autogen/docs/notebooks/agentchat_multi_task_async_chats,/autogen/0.2/docs/notebooks/agentchat_multi_task_async_chats
+/autogen/docs/notebooks/agentchats_sequential_chats,/autogen/0.2/docs/notebooks/agentchats_sequential_chats
+/autogen/docs/notebooks/agentchat_nestedchat,/autogen/0.2/docs/notebooks/agentchat_nestedchat
+/autogen/docs/notebooks/agentchat_nested_sequential_chats,/autogen/0.2/docs/notebooks/agentchat_nested_sequential_chats
+/autogen/docs/notebooks/agentchat_nestedchat_optiguide,/autogen/0.2/docs/notebooks/agentchat_nestedchat_optiguide
+/autogen/docs/notebooks/agentchat_nested_chats_chess,/autogen/0.2/docs/notebooks/agentchat_nested_chats_chess
+/autogen/docs/notebooks/agentchat_function_call_currency_calculator,/autogen/0.2/docs/notebooks/agentchat_function_call_currency_calculator
+/autogen/docs/notebooks/agentchat_function_call_async,/autogen/0.2/docs/notebooks/agentchat_function_call_async
+/autogen/docs/notebooks/agentchat_groupchat_RAG,/autogen/0.2/docs/notebooks/agentchat_groupchat_RAG
+/autogen/docs/notebooks/agentchat_video_transcript_translate_with_whisper,/autogen/0.2/docs/notebooks/agentchat_video_transcript_translate_with_whisper
+/autogen/docs/notebooks/agentchat_webscraping_with_apify,/autogen/0.2/docs/notebooks/agentchat_webscraping_with_apify
+/autogen/docs/notebooks/agentchat_teaching,/autogen/0.2/docs/notebooks/agentchat_teaching
+/autogen/docs/notebooks/agentchat_teachability,/autogen/0.2/docs/notebooks/agentchat_teachability
+/autogen/docs/notebooks/agentchat_nested_chats_chess_altmodels,/autogen/0.2/docs/notebooks/agentchat_nested_chats_chess_altmodels
+/autogen/docs/notebooks/agentchat_transform_messages,/autogen/0.2/docs/notebooks/agentchat_transform_messages
+/autogen/docs/Use-Cases/enhanced_inference/,/autogen/0.2/docs/Use-Cases/enhanced_inference/
+/autogen/docs/notebooks/JSON_mode_example,/autogen/0.2/docs/notebooks/JSON_mode_example
+/autogen/docs/notebooks/agentchat_RetrieveChat_mongodb,/autogen/0.2/docs/notebooks/agentchat_RetrieveChat_mongodb
+/autogen/docs/notebooks/agentchat_RetrieveChat_pgvector,/autogen/0.2/docs/notebooks/agentchat_RetrieveChat_pgvector
+/autogen/docs/notebooks/agentchat_agentops,/autogen/0.2/docs/notebooks/agentchat_agentops
+/autogen/docs/notebooks/agentchat_agentoptimizer,/autogen/0.2/docs/notebooks/agentchat_agentoptimizer
+/autogen/docs/notebooks/agentchat_azr_ai_search,/autogen/0.2/docs/notebooks/agentchat_azr_ai_search
+/autogen/docs/notebooks/agentchat_custom_model,/autogen/0.2/docs/notebooks/agentchat_custom_model
+/autogen/docs/notebooks/agentchat_databricks_dbrx,/autogen/0.2/docs/notebooks/agentchat_databricks_dbrx
+/autogen/docs/notebooks/agentchat_function_call_code_writing,/autogen/0.2/docs/notebooks/agentchat_function_call_code_writing
+/autogen/docs/notebooks/agentchat_function_call_with_composio,/autogen/0.2/docs/notebooks/agentchat_function_call_with_composio
+/autogen/docs/notebooks/agentchat_group_chat_with_llamaindex_agents,/autogen/0.2/docs/notebooks/agentchat_group_chat_with_llamaindex_agents
+/autogen/docs/notebooks/agentchat_groupchat_stateflow,/autogen/0.2/docs/notebooks/agentchat_groupchat_stateflow
+/autogen/docs/notebooks/agentchat_image_generation_capability,/autogen/0.2/docs/notebooks/agentchat_image_generation_capability
+/autogen/docs/notebooks/agentchat_lmm_gpt-4v,/autogen/0.2/docs/notebooks/agentchat_lmm_gpt-4v
+/autogen/docs/notebooks/agentchat_logging,/autogen/0.2/docs/notebooks/agentchat_logging
+/autogen/docs/notebooks/agentchat_memory_using_mem0,/autogen/0.2/docs/notebooks/agentchat_memory_using_mem0
+/autogen/docs/notebooks/agentchat_oai_assistant_function_call,/autogen/0.2/docs/notebooks/agentchat_oai_assistant_function_call
+/autogen/docs/notebooks/agentchat_oai_assistant_groupchat,/autogen/0.2/docs/notebooks/agentchat_oai_assistant_groupchat
+/autogen/docs/notebooks/agentchat_oai_code_interpreter,/autogen/0.2/docs/notebooks/agentchat_oai_code_interpreter
+/autogen/docs/notebooks/agentchat_websockets,/autogen/0.2/docs/notebooks/agentchat_websockets
+/autogen/docs/notebooks/gpt_assistant_agent_function_call,/autogen/0.2/docs/notebooks/gpt_assistant_agent_function_call
+/autogen/blog/2024/10/02/new-autogen-architecture-preview,/autogen/0.2/blog/2024/10/02/new-autogen-architecture-preview
+/autogen/blog/2024/07/25/AgentOps,/autogen/0.2/blog/2024/07/25/AgentOps
+/autogen/blog/2024/06/24/AltModels-Classes,/autogen/0.2/blog/2024/06/24/AltModels-Classes
+/autogen/blog/2024/06/21/AgentEval,/autogen/0.2/blog/2024/06/21/AgentEval
+/autogen/blog/2024/05/24/Agent,/autogen/0.2/blog/2024/05/24/Agent
+/autogen/blog/2024/03/11/AutoDefense/Defending%20LLMs%20Against%20Jailbreak%20Attacks%20with%20AutoDefense,/autogen/0.2/blog/2024/03/11/AutoDefense/Defending%20LLMs%20Against%20Jailbreak%20Attacks%20with%20AutoDefense
+/autogen/blog/2024/03/03/AutoGen-Update,/autogen/0.2/blog/2024/03/03/AutoGen-Update
+/autogen/blog/2024/02/29/StateFlow,/autogen/0.2/blog/2024/02/29/StateFlow
+/autogen/blog/2024/02/11/FSM-GroupChat,/autogen/0.2/blog/2024/02/11/FSM-GroupChat
+/autogen/blog/2024/02/02/AutoAnny,/autogen/0.2/blog/2024/02/02/AutoAnny
+/autogen/blog/2024/01/25/AutoGenBench,/autogen/0.2/blog/2024/01/25/AutoGenBench
+/autogen/blog/2024/01/23/Code-execution-in-docker,/autogen/0.2/blog/2024/01/23/Code-execution-in-docker
+/autogen/blog/2023/12/29/AgentDescriptions,/autogen/0.2/blog/2023/12/29/AgentDescriptions
+/autogen/blog/2023/12/23/AgentOptimizer,/autogen/0.2/blog/2023/12/23/AgentOptimizer
+/autogen/blog/2023/12/01/AutoGenStudio,/autogen/0.2/blog/2023/12/01/AutoGenStudio
+/autogen/blog/2023/11/26/Agent-AutoBuild,/autogen/0.2/blog/2023/11/26/Agent-AutoBuild
+/autogen/blog/2023/11/20/AgentEval,/autogen/0.2/blog/2023/11/20/AgentEval
+/autogen/blog/2023/11/13/OAI-assistants,/autogen/0.2/blog/2023/11/13/OAI-assistants
+/autogen/blog/2023/11/09/EcoAssistant,/autogen/0.2/blog/2023/11/09/EcoAssistant
+/autogen/blog/2023/11/06/LMM-Agent,/autogen/0.2/blog/2023/11/06/LMM-Agent
+/autogen/blog/2023/10/26/TeachableAgent,/autogen/0.2/blog/2023/10/26/TeachableAgent
+/autogen/blog/2023/10/18/RetrieveChat,/autogen/0.2/blog/2023/10/18/RetrieveChat
+/autogen/blog/2023/06/28/MathChat,/autogen/0.2/blog/2023/06/28/MathChat
+/autogen/blog/2023/05/18/GPT-adaptive-humaneval,/autogen/0.2/blog/2023/05/18/GPT-adaptive-humaneval
+/autogen/blog/2023/04/21/LLM-tuning-math,/autogen/0.2/blog/2023/04/21/LLM-tuning-math
+/autogen/blog/tags/auto-gen,/autogen/0.2/blog/tags/auto-gen
+/autogen/docs/notebooks/agentchat_agentops/,/autogen/0.2/docs/notebooks/agentchat_agentops/
+/autogen/blog/tags/llm,/autogen/0.2/blog/tags/llm
+/autogen/blog/tags/agent,/autogen/0.2/blog/tags/agent
+/autogen/blog/tags/observability,/autogen/0.2/blog/tags/observability
+/autogen/blog/tags/agent-ops,/autogen/0.2/blog/tags/agent-ops
+/autogen/docs/topics/non-openai-models/cloud-gemini,/autogen/0.2/docs/topics/non-openai-models/cloud-gemini
+/autogen/docs/topics/handling_long_contexts/intro_to_transform_messages,/autogen/0.2/docs/topics/handling_long_contexts/intro_to_transform_messages
+/autogen/docs/reference/oai/gemini,/autogen/0.2/docs/reference/oai/gemini
+/autogen/blog/tags/mistral-ai,/autogen/0.2/blog/tags/mistral-ai
+/autogen/blog/tags/anthropic,/autogen/0.2/blog/tags/anthropic
+/autogen/blog/tags/together-ai,/autogen/0.2/blog/tags/together-ai
+/autogen/blog/tags/gemini,/autogen/0.2/blog/tags/gemini
+/autogen/blog/2023/11/20/AgentEval/,/autogen/0.2/blog/2023/11/20/AgentEval/
+/autogen/blog/tags/gpt,/autogen/0.2/blog/tags/gpt
+/autogen/blog/tags/evaluation,/autogen/0.2/blog/tags/evaluation
+/autogen/blog/tags/task-utility,/autogen/0.2/blog/tags/task-utility
+/autogen/docs/topics/prompting-and-reasoning/reflection,/autogen/0.2/docs/topics/prompting-and-reasoning/reflection
+/autogen/docs/topics/code-execution/user-defined-functions,/autogen/0.2/docs/topics/code-execution/user-defined-functions
+/autogen/blog/2023/12/01/AutoGenStudio/,/autogen/0.2/blog/2023/12/01/AutoGenStudio/
+/autogen/blog/tags/thoughts,/autogen/0.2/blog/tags/thoughts
+/autogen/blog/tags/interview-notes,/autogen/0.2/blog/tags/interview-notes
+/autogen/blog/tags/research,/autogen/0.2/blog/tags/research
+/autogen/blog/tags/news,/autogen/0.2/blog/tags/news
+/autogen/blog/tags/summary,/autogen/0.2/blog/tags/summary
+/autogen/blog/tags/roadmap,/autogen/0.2/blog/tags/roadmap
+/autogen/blog/2024/02/11/FSM-GroupChat/,/autogen/0.2/blog/2024/02/11/FSM-GroupChat/
+/autogen/docs/notebooks/agentchat_groupchat_finite_state_machine/,/autogen/0.2/docs/notebooks/agentchat_groupchat_finite_state_machine/
+/autogen/blog/page/2,/autogen/0.2/blog/page/2
+/autogen/docs/reference/coding/local_commandline_code_executor,/autogen/0.2/docs/reference/coding/local_commandline_code_executor
+/autogen/docs/reference/coding/docker_commandline_code_executor,/autogen/0.2/docs/reference/coding/docker_commandline_code_executor
+/autogen/docs/reference/coding/jupyter/jupyter_code_executor,/autogen/0.2/docs/reference/coding/jupyter/jupyter_code_executor
+/autogen/docs/topics/code-execution/jupyter-code-executor,/autogen/0.2/docs/topics/code-execution/jupyter-code-executor
+/autogen/docs/topics/code-execution/custom-executor,/autogen/0.2/docs/topics/code-execution/custom-executor
+/autogen/docs/topics/groupchat/resuming_groupchat,/autogen/0.2/docs/topics/groupchat/resuming_groupchat
+/autogen/docs/topics/groupchat/transform_messages_speaker_selection,/autogen/0.2/docs/topics/groupchat/transform_messages_speaker_selection
+/autogen/docs/tags/orchestration,/autogen/0.2/docs/tags/orchestration
+/autogen/docs/tags/group-chat,/autogen/0.2/docs/tags/group-chat
+/autogen/docs/topics/non-openai-models/best-tips-for-nonopenai-models,/autogen/0.2/docs/topics/non-openai-models/best-tips-for-nonopenai-models
+/autogen/docs/topics/non-openai-models/cloud-anthropic,/autogen/0.2/docs/topics/non-openai-models/cloud-anthropic
+/autogen/docs/topics/non-openai-models/cloud-bedrock,/autogen/0.2/docs/topics/non-openai-models/cloud-bedrock
+/autogen/docs/topics/non-openai-models/cloud-cerebras,/autogen/0.2/docs/topics/non-openai-models/cloud-cerebras
+/autogen/docs/topics/non-openai-models/cloud-cohere,/autogen/0.2/docs/topics/non-openai-models/cloud-cohere
+/autogen/docs/topics/non-openai-models/cloud-gemini_vertexai,/autogen/0.2/docs/topics/non-openai-models/cloud-gemini_vertexai
+/autogen/docs/topics/non-openai-models/cloud-groq,/autogen/0.2/docs/topics/non-openai-models/cloud-groq
+/autogen/docs/topics/non-openai-models/cloud-mistralai,/autogen/0.2/docs/topics/non-openai-models/cloud-mistralai
+/autogen/docs/topics/non-openai-models/cloud-togetherai,/autogen/0.2/docs/topics/non-openai-models/cloud-togetherai
+/autogen/docs/topics/non-openai-models/local-litellm-ollama,/autogen/0.2/docs/topics/non-openai-models/local-litellm-ollama
+/autogen/docs/topics/non-openai-models/local-lm-studio,/autogen/0.2/docs/topics/non-openai-models/local-lm-studio
+/autogen/docs/topics/non-openai-models/local-ollama,/autogen/0.2/docs/topics/non-openai-models/local-ollama
+/autogen/docs/topics/non-openai-models/local-vllm,/autogen/0.2/docs/topics/non-openai-models/local-vllm
+/autogen/docs/topics/non-openai-models/transforms-for-nonopenai-models,/autogen/0.2/docs/topics/non-openai-models/transforms-for-nonopenai-models
+/autogen/docs/notebooks/agentchat_custom_model/,/autogen/0.2/docs/notebooks/agentchat_custom_model/
+/autogen/docs/reference/cache/disk_cache,/autogen/0.2/docs/reference/cache/disk_cache
+/autogen/docs/reference/cache/redis_cache,/autogen/0.2/docs/reference/cache/redis_cache
+/autogen/docs/reference/oai/openai_utils,/autogen/0.2/docs/reference/oai/openai_utils
+/autogen/docs/reference/cache/,/autogen/0.2/docs/reference/cache/
+/autogen/docs/reference/agentchat/contrib/retrieve_user_proxy_agent,/autogen/0.2/docs/reference/agentchat/contrib/retrieve_user_proxy_agent
+/autogen/docs/reference/agentchat/contrib/agent_eval/criterion,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/criterion
+/autogen/docs/reference/agentchat/contrib/agent_eval/critic_agent,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/critic_agent
+/autogen/docs/reference/agentchat/contrib/agent_eval/quantifier_agent,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/quantifier_agent
+/autogen/docs/reference/agentchat/contrib/agent_eval/subcritic_agent,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/subcritic_agent
+/autogen/docs/reference/agentchat/contrib/agent_eval/task,/autogen/0.2/docs/reference/agentchat/contrib/agent_eval/task
+/autogen/docs/reference/agentchat/contrib/capabilities/agent_capability,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/agent_capability
+/autogen/docs/reference/agentchat/contrib/graph_rag/document,/autogen/0.2/docs/reference/agentchat/contrib/graph_rag/document
+/autogen/docs/reference/agentchat/contrib/vectordb/base,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/base
+/autogen/docs/reference/agentchat/contrib/agent_builder,/autogen/0.2/docs/reference/agentchat/contrib/agent_builder
+/autogen/docs/reference/agentchat/contrib/agent_optimizer,/autogen/0.2/docs/reference/agentchat/contrib/agent_optimizer
+/autogen/docs/reference/agentchat/contrib/gpt_assistant_agent,/autogen/0.2/docs/reference/agentchat/contrib/gpt_assistant_agent
+/autogen/docs/reference/agentchat/contrib/img_utils,/autogen/0.2/docs/reference/agentchat/contrib/img_utils
+/autogen/docs/reference/agentchat/contrib/llamaindex_conversable_agent,/autogen/0.2/docs/reference/agentchat/contrib/llamaindex_conversable_agent
+/autogen/docs/reference/agentchat/contrib/llava_agent,/autogen/0.2/docs/reference/agentchat/contrib/llava_agent
+/autogen/docs/reference/agentchat/contrib/math_user_proxy_agent,/autogen/0.2/docs/reference/agentchat/contrib/math_user_proxy_agent
+/autogen/docs/reference/agentchat/contrib/multimodal_conversable_agent,/autogen/0.2/docs/reference/agentchat/contrib/multimodal_conversable_agent
+/autogen/docs/reference/agentchat/contrib/qdrant_retrieve_user_proxy_agent,/autogen/0.2/docs/reference/agentchat/contrib/qdrant_retrieve_user_proxy_agent
+/autogen/docs/reference/agentchat/contrib/retrieve_assistant_agent,/autogen/0.2/docs/reference/agentchat/contrib/retrieve_assistant_agent
+/autogen/docs/reference/agentchat/contrib/society_of_mind_agent,/autogen/0.2/docs/reference/agentchat/contrib/society_of_mind_agent
+/autogen/docs/reference/agentchat/contrib/text_analyzer_agent,/autogen/0.2/docs/reference/agentchat/contrib/text_analyzer_agent
+/autogen/docs/reference/agentchat/contrib/web_surfer,/autogen/0.2/docs/reference/agentchat/contrib/web_surfer
+/autogen/docs/reference/browser_utils/markdown_search,/autogen/0.2/docs/reference/browser_utils/markdown_search
+/autogen/docs/reference/browser_utils/mdconvert,/autogen/0.2/docs/reference/browser_utils/mdconvert
+/autogen/docs/reference/browser_utils/playwright_markdown_browser,/autogen/0.2/docs/reference/browser_utils/playwright_markdown_browser
+/autogen/docs/reference/browser_utils/requests_markdown_browser,/autogen/0.2/docs/reference/browser_utils/requests_markdown_browser
+/autogen/docs/reference/browser_utils/selenium_markdown_browser,/autogen/0.2/docs/reference/browser_utils/selenium_markdown_browser
+/autogen/docs/reference/cache/cache_factory,/autogen/0.2/docs/reference/cache/cache_factory
+/autogen/docs/reference/cache/cosmos_db_cache,/autogen/0.2/docs/reference/cache/cosmos_db_cache
+/autogen/docs/reference/cache/in_memory_cache,/autogen/0.2/docs/reference/cache/in_memory_cache
+/autogen/docs/reference/coding/jupyter/docker_jupyter_server,/autogen/0.2/docs/reference/coding/jupyter/docker_jupyter_server
+/autogen/docs/reference/coding/jupyter/embedded_ipython_code_executor,/autogen/0.2/docs/reference/coding/jupyter/embedded_ipython_code_executor
+/autogen/docs/reference/coding/jupyter/jupyter_client,/autogen/0.2/docs/reference/coding/jupyter/jupyter_client
+/autogen/docs/reference/coding/jupyter/local_jupyter_server,/autogen/0.2/docs/reference/coding/jupyter/local_jupyter_server
+/autogen/docs/reference/coding/base,/autogen/0.2/docs/reference/coding/base
+/autogen/docs/reference/coding/factory,/autogen/0.2/docs/reference/coding/factory
+/autogen/docs/reference/coding/func_with_reqs,/autogen/0.2/docs/reference/coding/func_with_reqs
+/autogen/docs/reference/coding/markdown_code_extractor,/autogen/0.2/docs/reference/coding/markdown_code_extractor
+/autogen/docs/reference/coding/utils,/autogen/0.2/docs/reference/coding/utils
+/autogen/docs/reference/io/console,/autogen/0.2/docs/reference/io/console
+/autogen/docs/reference/io/websockets,/autogen/0.2/docs/reference/io/websockets
+/autogen/docs/reference/logger/file_logger,/autogen/0.2/docs/reference/logger/file_logger
+/autogen/docs/reference/oai/bedrock,/autogen/0.2/docs/reference/oai/bedrock
+/autogen/docs/reference/oai/cerebras,/autogen/0.2/docs/reference/oai/cerebras
+/autogen/docs/reference/oai/client_utils,/autogen/0.2/docs/reference/oai/client_utils
+/autogen/docs/reference/oai/cohere,/autogen/0.2/docs/reference/oai/cohere
+/autogen/docs/reference/oai/completion,/autogen/0.2/docs/reference/oai/completion
+/autogen/docs/reference/oai/groq,/autogen/0.2/docs/reference/oai/groq
+/autogen/docs/reference/oai/mistral,/autogen/0.2/docs/reference/oai/mistral
+/autogen/docs/reference/oai/ollama,/autogen/0.2/docs/reference/oai/ollama
+/autogen/docs/reference/oai/rate_limiters,/autogen/0.2/docs/reference/oai/rate_limiters
+/autogen/docs/reference/oai/together,/autogen/0.2/docs/reference/oai/together
+/autogen/docs/Contribute,/autogen/0.2/docs/Contribute
+/autogen/docs/tags/code-generation,/autogen/0.2/docs/tags/code-generation
+/autogen/docs/tags/debugging,/autogen/0.2/docs/tags/debugging
+/autogen/docs/tags/rag,/autogen/0.2/docs/tags/rag
+/autogen/docs/tags/nested-chat,/autogen/0.2/docs/tags/nested-chat
+/autogen/docs/tags/sequential-chats,/autogen/0.2/docs/tags/sequential-chats
+/autogen/docs/tags/hierarchical-chat,/autogen/0.2/docs/tags/hierarchical-chat
+/autogen/docs/tags/tool-use,/autogen/0.2/docs/tags/tool-use
+/autogen/docs/tags/function-call,/autogen/0.2/docs/tags/function-call
+/autogen/docs/tags/async,/autogen/0.2/docs/tags/async
+/autogen/docs/tags/whisper,/autogen/0.2/docs/tags/whisper
+/autogen/docs/tags/web-scraping,/autogen/0.2/docs/tags/web-scraping
+/autogen/docs/tags/apify,/autogen/0.2/docs/tags/apify
+/autogen/docs/tags/teaching,/autogen/0.2/docs/tags/teaching
+/autogen/docs/tags/teachability,/autogen/0.2/docs/tags/teachability
+/autogen/docs/tags/capability,/autogen/0.2/docs/tags/capability
+/autogen/docs/tags/long-context-handling,/autogen/0.2/docs/tags/long-context-handling
+/autogen/blog/2023/12/29/AgentDescriptions/,/autogen/0.2/blog/2023/12/29/AgentDescriptions/
+/autogen/docs/tags/json,/autogen/0.2/docs/tags/json
+/autogen/docs/tags/description,/autogen/0.2/docs/tags/description
+/autogen/docs/tags/prompt-hacking,/autogen/0.2/docs/tags/prompt-hacking
+/autogen/docs/tags/monitoring,/autogen/0.2/docs/tags/monitoring
+/autogen/docs/tags/optimization,/autogen/0.2/docs/tags/optimization
+/autogen/docs/tags/tool-function,/autogen/0.2/docs/tags/tool-function
+/autogen/docs/tags/azure-identity,/autogen/0.2/docs/tags/azure-identity
+/autogen/docs/tags/azure-ai-search,/autogen/0.2/docs/tags/azure-ai-search
+/autogen/docs/tags/custom-model,/autogen/0.2/docs/tags/custom-model
+/autogen/docs/topics/non-openai-models/cloud-mistralai/,/autogen/0.2/docs/topics/non-openai-models/cloud-mistralai/
+/autogen/docs/tutorial/conversation-patterns/,/autogen/0.2/docs/tutorial/conversation-patterns/
+/autogen/docs/tags/dbrx,/autogen/0.2/docs/tags/dbrx
+/autogen/docs/tags/databricks,/autogen/0.2/docs/tags/databricks
+/autogen/docs/tags/open-source,/autogen/0.2/docs/tags/open-source
+/autogen/docs/tags/lakehouse,/autogen/0.2/docs/tags/lakehouse
+/autogen/docs/tags/data-intelligence,/autogen/0.2/docs/tags/data-intelligence
+/autogen/docs/tags/software-engineering,/autogen/0.2/docs/tags/software-engineering
+/autogen/docs/tags/agents,/autogen/0.2/docs/tags/agents
+/autogen/docs/tags/react,/autogen/0.2/docs/tags/react
+/autogen/docs/tags/llama-index,/autogen/0.2/docs/tags/llama-index
+/autogen/docs/tags/research,/autogen/0.2/docs/tags/research
+/autogen/docs/tags/multimodal,/autogen/0.2/docs/tags/multimodal
+/autogen/docs/tags/gpt-4-v,/autogen/0.2/docs/tags/gpt-4-v
+/autogen/docs/tags/logging,/autogen/0.2/docs/tags/logging
+/autogen/docs/tags/memory,/autogen/0.2/docs/tags/memory
+/autogen/docs/tags/open-ai-assistant,/autogen/0.2/docs/tags/open-ai-assistant
+/autogen/docs/tags/code-interpreter,/autogen/0.2/docs/tags/code-interpreter
+/autogen/docs/reference/io/base/IOStream,/autogen/0.2/docs/reference/io/base/IOStream
+/autogen/docs/reference/io/websockets/IOWebsockets,/autogen/0.2/docs/reference/io/websockets/IOWebsockets
+/autogen/docs/tags/websockets,/autogen/0.2/docs/tags/websockets
+/autogen/docs/tags/streaming,/autogen/0.2/docs/tags/streaming
+/autogen/docs/tags/gpt-assistant,/autogen/0.2/docs/tags/gpt-assistant
+/autogen/docs/Installation,/autogen/0.2/docs/Installation
+/autogen/docs/reference/agentchat/agentchat/,/autogen/0.2/docs/reference/agentchat/agentchat/
+/autogen/blog/tags/ui,/autogen/0.2/blog/tags/ui
+/autogen/blog/tags/web,/autogen/0.2/blog/tags/web
+/autogen/blog/tags/ux,/autogen/0.2/blog/tags/ux
+/autogen/blog/tags/openai-assistant,/autogen/0.2/blog/tags/openai-assistant
+/autogen/blog/tags/rag,/autogen/0.2/blog/tags/rag
+/autogen/blog/tags/cost-effectiveness,/autogen/0.2/blog/tags/cost-effectiveness
+/autogen/blog/tags/lmm,/autogen/0.2/blog/tags/lmm
+/autogen/blog/tags/multimodal,/autogen/0.2/blog/tags/multimodal
+/autogen/blog/tags/teach,/autogen/0.2/blog/tags/teach
+/autogen/blog/tags,/autogen/0.2/blog/tags
+/autogen/blog/tags/llm/page/2,/autogen/0.2/blog/tags/llm/page/2
+/autogen/docs/tags/gemini,/autogen/0.2/docs/tags/gemini
+/autogen/blog/page/3,/autogen/0.2/blog/page/3
+/autogen/docs/tags/resume,/autogen/0.2/docs/tags/resume
+/autogen/docs/reference/agentchat/contrib/capabilities/transform_messages,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/transform_messages
+/autogen/docs/tags,/autogen/0.2/docs/tags
+/autogen/docs/contributor-guide/contributing/,/autogen/0.2/docs/contributor-guide/contributing/
+/autogen/docs/tags/vertexai,/autogen/0.2/docs/tags/vertexai
+/autogen/docs/installation,/autogen/0.2/docs/installation
+/autogen/docs/reference/agentchat/contrib/capabilities/generate_images,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/generate_images
+/autogen/docs/reference/agentchat/contrib/capabilities/teachability,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/teachability
+/autogen/docs/reference/agentchat/contrib/capabilities/text_compressors,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/text_compressors
+/autogen/docs/reference/agentchat/contrib/capabilities/transforms,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/transforms
+/autogen/docs/reference/agentchat/contrib/capabilities/transforms_util,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/transforms_util
+/autogen/docs/reference/agentchat/contrib/capabilities/vision_capability,/autogen/0.2/docs/reference/agentchat/contrib/capabilities/vision_capability
+/autogen/docs/reference/agentchat/contrib/graph_rag/graph_query_engine,/autogen/0.2/docs/reference/agentchat/contrib/graph_rag/graph_query_engine
+/autogen/docs/reference/agentchat/contrib/graph_rag/graph_rag_capability,/autogen/0.2/docs/reference/agentchat/contrib/graph_rag/graph_rag_capability
+/autogen/docs/reference/agentchat/contrib/vectordb/chromadb,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/chromadb
+/autogen/docs/reference/agentchat/contrib/vectordb/couchbase,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/couchbase
+/autogen/docs/reference/agentchat/contrib/vectordb/mongodb,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/mongodb
+/autogen/docs/reference/agentchat/contrib/vectordb/pgvectordb,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/pgvectordb
+/autogen/docs/reference/agentchat/contrib/vectordb/qdrant,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/qdrant
+/autogen/docs/reference/agentchat/contrib/vectordb/utils,/autogen/0.2/docs/reference/agentchat/contrib/vectordb/utils
+/autogen/0.4.0dev0/,/autogen/0.4.0.dev0/
+/autogen/0.4.0dev1/,/autogen/0.4.0.dev1/
diff --git a/python/packages/autogen-core/docs/redirects/redirects.py b/python/packages/autogen-core/docs/redirects/redirects.py
index 6fcca87ed7d7..69cc942fdfd5 100644
--- a/python/packages/autogen-core/docs/redirects/redirects.py
+++ b/python/packages/autogen-core/docs/redirects/redirects.py
@@ -46,9 +46,8 @@ def main():
         lines = f.readlines()
 
     for line in lines:
-        # Replace /autogen/ with /autogen/0.2/ and generate redirect
-        old_url = line.strip()
-        new_url = old_url.replace("/autogen/", "/autogen/0.2/")
+        # Split line by comma, where old is left and new is right
+        old_url, new_url = line.strip().split(",")
         # Deal with pages base path of /autogen/
         file_to_write = old_url.replace("/autogen/", "/")
         generate_redirect(file_to_write, new_url, base_dir)
diff --git a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
index 5406cd07e4f3..eb3a4d41be54 100644
--- a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
+++ b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
@@ -2,7 +2,26 @@
 document.addEventListener('DOMContentLoaded', function() {
     // TODO: Please find a better way to override the button text in a better way...
     // Set a timer for 3 seconds to wait for the button to be rendered.
-    setTimeout(function() {
+    setTimeout(async function() {
+
+        // Fetch version list
+        // https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json
+        const response = await fetch('https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json');
+        const data = await response.json();
+
+        // Find the entry where preferred is true
+        const preferred = data.find(entry => entry.preferred);
+        if (preferred) {
+            // Get current rendered version
+            const currentVersion = DOCUMENTATION_OPTIONS.VERSION;
+            // The version compare library seems to not like the dev suffix without - so we're going to do an exact match and hide the banner if so
+            if (currentVersion === preferred.version) {
+                // Hide the banner with id bd-header-version-warning
+                document.getElementById('bd-header-version-warning').style.display = 'none';
+                return;
+            }
+        }
+
         // Get the button with class "pst-button-link-to-stable-version". There is only one.
         var button = document.querySelector('.pst-button-link-to-stable-version');
         if (!button) {
diff --git a/python/packages/autogen-core/docs/src/index.md b/python/packages/autogen-core/docs/src/index.md
index 1b23b2ba7954..4910721f53ab 100644
--- a/python/packages/autogen-core/docs/src/index.md
+++ b/python/packages/autogen-core/docs/src/index.md
@@ -61,7 +61,7 @@ AgentChat 
 High-level API that includes preset agents and teams for building multi-agent systems.
 
 ```sh
-pip install autogen-agentchat==0.4.0dev2
+pip install autogen-agentchat==0.4.0.dev2
 ```
 
 💡 *Start here if you are looking for an API similar to AutoGen 0.2*
@@ -82,7 +82,7 @@ Get Started
 Provides building blocks for creating asynchronous, event driven multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0dev2
+pip install autogen-core==0.4.0.dev2
 ```
 
 +++
diff --git a/python/packages/autogen-core/docs/src/packages/index.md b/python/packages/autogen-core/docs/src/packages/index.md
index 0046f50af9ef..f471d4e48a3a 100644
--- a/python/packages/autogen-core/docs/src/packages/index.md
+++ b/python/packages/autogen-core/docs/src/packages/index.md
@@ -29,7 +29,7 @@ myst:
 Library that is at a similar level of abstraction as AutoGen 0.2, including default agents and group chat.
 
 ```sh
-pip install autogen-agentchat==0.4.0dev2
+pip install autogen-agentchat==0.4.0.dev2
 ```
 
 [{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
@@ -44,7 +44,7 @@ pip install autogen-agentchat==0.4.0dev2
 Implements the core functionality of the AutoGen framework, providing basic building blocks for creating multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0dev2
+pip install autogen-core==0.4.0.dev2
 ```
 
 [{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
@@ -59,7 +59,7 @@ pip install autogen-core==0.4.0dev2
 Implementations of core components that interface with external services, or use extra dependencies. For example, Docker based code execution.
 
 ```sh
-pip install autogen-ext==0.4.0dev2
+pip install autogen-ext==0.4.0.dev2
 ```
 
 Extras:
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
index 52fe9f070ca1..528710a54e4f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
@@ -61,7 +61,7 @@ Install the `autogen-agentchat` package using pip:
 
 ```bash
 
-pip install autogen-agentchat==0.4.0dev2
+pip install autogen-agentchat==0.4.0.dev2
 ```
 
 ## Install Docker for Code Execution
diff --git a/python/packages/autogen-core/pyproject.toml b/python/packages/autogen-core/pyproject.toml
index dcd4fb0d784f..ea2a1b545e08 100644
--- a/python/packages/autogen-core/pyproject.toml
+++ b/python/packages/autogen-core/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-core"
-version = "0.4.0dev2"
+version = "0.4.0.dev2"
 license = {file = "LICENSE-CODE"}
 description = "Foundational interfaces and agent runtime implementation for AutoGen"
 readme = "README.md"
diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index 4e8da5a5aa49..f13843aabcf7 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-ext"
-version = "0.4.0dev2"
+version = "0.4.0.dev2"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen extensions library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0dev2",
+    "autogen-core==0.4.0.dev2",
 ]
 
 

From 551a1ee3aa294fd052f0d94d2871c883dc25a749 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 12:23:08 -0400
Subject: [PATCH 025/173] fix broken redirect (#3910)

---
 python/packages/autogen-core/docs/redirects/redirect_urls.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/docs/redirects/redirect_urls.txt b/python/packages/autogen-core/docs/redirects/redirect_urls.txt
index 79b5fbe99e34..779023764a1c 100644
--- a/python/packages/autogen-core/docs/redirects/redirect_urls.txt
+++ b/python/packages/autogen-core/docs/redirects/redirect_urls.txt
@@ -1,4 +1,4 @@
-/autogen/,/autogen/0.2/0.2/
+/autogen/,/autogen/0.2/
 /autogen/docs/Getting-Started,/autogen/0.2/docs/Getting-Started
 /autogen/docs/installation/,/autogen/0.2/docs/installation/
 /autogen/docs/tutorial/introduction,/autogen/0.2/docs/tutorial/introduction

From 8cbfb61252ed0f948fdaea664a2a42853deaf98d Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 12:51:43 -0400
Subject: [PATCH 026/173] Add special case for dev latest (#3912)

---
 .../autogen-core/docs/src/_static/override-switcher-button.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
index eb3a4d41be54..b9c9e6490a7e 100644
--- a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
+++ b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
@@ -14,8 +14,10 @@ document.addEventListener('DOMContentLoaded', function() {
         if (preferred) {
             // Get current rendered version
             const currentVersion = DOCUMENTATION_OPTIONS.VERSION;
+            const urlVersionPath = DOCUMENTATION_OPTIONS.theme_switcher_version_match;
             // The version compare library seems to not like the dev suffix without - so we're going to do an exact match and hide the banner if so
-            if (currentVersion === preferred.version) {
+            // For the "dev" version which is always latest we don't want to consider hiding the banner
+            if ((currentVersion === preferred.version) && (urlVersionPath !== "dev")) {
                 // Hide the banner with id bd-header-version-warning
                 document.getElementById('bd-header-version-warning').style.display = 'none';
                 return;

From 8f4d5ee5ec33aab52788972c939ea517f04bbb1f Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 14:13:24 -0400
Subject: [PATCH 027/173] add comment to explain await vs run (#3907)

* add comment to explain await vs run

* update output and import

---------

Co-authored-by: Eric Zhu 
---
 .../agentchat-user-guide/quickstart.ipynb       | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 5a2bc0d22df8..47ed61976d41 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -37,18 +37,18 @@
      "text": [
       "\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-20T09:01:32.381165]:\u001b[0m\n",
+      "\u001b[91m[2024-10-23T12:15:51.582079]:\u001b[0m\n",
       "\n",
       "What is the weather in New York?\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-20T09:01:33.698359], writing_agent:\u001b[0m\n",
+      "\u001b[91m[2024-10-23T12:15:52.745820], writing_agent:\u001b[0m\n",
       "\n",
       "The weather in New York is currently 73 degrees and sunny. TERMINATE\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-20T09:01:33.698749], Termination:\u001b[0m\n",
+      "\u001b[91m[2024-10-23T12:15:52.746210], Termination:\u001b[0m\n",
       "\n",
       "Maximal number of messages 1 reached, current message count: 1\n",
-      " TeamRunResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), StopMessage(source='writing_agent', content='The weather in New York is currently 73 degrees and sunny. TERMINATE')])\n"
+      " TaskResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), StopMessage(source='writing_agent', content='The weather in New York is currently 73 degrees and sunny. TERMINATE')])\n"
      ]
     }
    ],
@@ -56,11 +56,11 @@
     "import logging\n",
     "\n",
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
-    "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.agents import ToolUseAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
     "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat\n",
-    "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "from autogen_core.components.tools import FunctionTool\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
     "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
     "logger.addHandler(ConsoleLogHandler())\n",
@@ -84,6 +84,7 @@
     "\n",
     "# add the agent to a team\n",
     "agent_team = RoundRobinGroupChat([weather_agent])\n",
+    "# Note: if running in a Python file directly you'll need to use asyncio.run(agent_team.run(...)) instead of await agent_team.run(...)\n",
     "result = await agent_team.run(\n",
     "    task=\"What is the weather in New York?\",\n",
     "    termination_condition=MaxMessageTermination(max_messages=1),\n",
@@ -111,7 +112,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -125,7 +126,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.5"
   }
  },
  "nbformat": 4,

From fb494534b8876bec12f32392eced601997564b90 Mon Sep 17 00:00:00 2001
From: Rohan Thacker 
Date: Thu, 24 Oct 2024 02:12:40 +0530
Subject: [PATCH 028/173] Corrected framework guide docs (#3929)

* Corrected grammatical errors and typos

* Corrected formating issues
---
 .../framework/agent-and-agent-runtime.ipynb               | 6 +++---
 .../framework/command-line-code-executors.ipynb           | 2 +-
 .../framework/distributed-agent-runtime.ipynb             | 6 +++---
 .../src/user-guide/core-user-guide/framework/logging.md   | 4 ++--
 .../framework/message-and-communication.ipynb             | 4 ++--
 .../core-user-guide/framework/model-clients.ipynb         | 8 ++++----
 .../src/user-guide/core-user-guide/framework/tools.ipynb  | 2 +-
 7 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/agent-and-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/agent-and-agent-runtime.ipynb
index ae0fb097a05c..fdd7aed5644e 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/agent-and-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/agent-and-agent-runtime.ipynb
@@ -41,10 +41,10 @@
    "source": [
     "## Implementing an Agent\n",
     "\n",
-    "To implement an agent, developer must subclass the {py:class}`~autogen_core.base.BaseAgent` class\n",
+    "To implement an agent, the developer must subclass the {py:class}`~autogen_core.base.BaseAgent` class\n",
     "and implement the {py:meth}`~autogen_core.base.BaseAgent.on_message` method.\n",
     "This method is invoked when the agent receives a message. For example,\n",
-    "the following agent handles a simple message type and simply prints message it receives:"
+    "the following agent handles a simple message type and prints the message it receives:"
    ]
   },
   {
@@ -101,7 +101,7 @@
     "The factory function is expected to return an instance of the agent class \n",
     "on which the {py:meth}`~autogen_core.base.BaseAgent.register` class method is invoked.\n",
     "Read [Agent Identity and Lifecycles](../core-concepts/agent-identity-and-lifecycle.md)\n",
-    "about agent type an identity.\n",
+    "to learn more about agent type and identity.\n",
     "\n",
     "```{note}\n",
     "Different agent types can be registered with factory functions that return \n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
index 22244d97c8e9..a408cd09dd9c 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
@@ -71,7 +71,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Combining Application in Docker with a Docker based executor\n",
+    "### Combining an Application in Docker with a Docker based executor\n",
     "\n",
     "It is desirable to bundle your application into a Docker image. But then, how do you allow your containerised application to execute code in a different container?\n",
     "\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
index fabacded043d..fde32e69ca4f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
@@ -40,11 +40,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The above code starts the host service in the background and accepting\n",
-    "worker connections at port 50051.\n",
+    "The above code starts the host service in the background and accepts\n",
+    "worker connections on port 50051.\n",
     "\n",
     "Before running worker runtimes, let's define our agent.\n",
-    "The agent publishes a new message on every message it receives.\n",
+    "The agent will publish a new message on every message it receives.\n",
     "It also keeps track of how many messages it has published, and \n",
     "stops publishing new messages once it has published 5 messages."
    ]
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/logging.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/logging.md
index b93af546cf48..593affc0b535 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/logging.md
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/logging.md
@@ -6,10 +6,10 @@ There are two kinds of logging:
 
 - **Trace logging**: This is used for debugging and is human readable messages to indicate what is going on. This is intended for a developer to understand what is happening in the code. The content and format of these logs should not be depended on by other systems.
     - Name: {py:attr}`~autogen_core.application.logging.TRACE_LOGGER_NAME`.
-- **Structured logging**: This logger emits structured events that can be consumed by other systems. The content and format of these logs should be can be depended on by other systems.
+- **Structured logging**: This logger emits structured events that can be consumed by other systems. The content and format of these logs can be depended on by other systems.
     - Name: {py:attr}`~autogen_core.application.logging.EVENT_LOGGER_NAME`.
     - See the module {py:mod}`autogen_core.application.logging.events` to see the available events.
-- {py:attr}`~autogen_core.application.logging.ROOT_LOGGER` can be used to enable or disable all logs at the same time.
+- {py:attr}`~autogen_core.application.logging.ROOT_LOGGER` can be used to enable or disable all logs.
 
 ## Enabling logging output
 
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/message-and-communication.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/message-and-communication.ipynb
index 95c615d3e9f4..f51b31d9d332 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/message-and-communication.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/message-and-communication.ipynb
@@ -477,7 +477,7 @@
    "metadata": {},
    "source": [
     "Subscriptions are registered with the agent runtime, either as part of\n",
-    "agent type's registeration or through a separate API method.\n",
+    "agent type's registration or through a separate API method.\n",
     "Here is how we register {py:class}`~autogen_core.components.TypeSubscription`\n",
     "for the receiving agent with the {py:meth}`~autogen_core.components.type_subscription` decorator,\n",
     "and for the broadcasting agent without the decorator."
@@ -544,7 +544,7 @@
     "However, when there is a single scope of publishing, that is, \n",
     "all agents publish and subscribe to all broadcasted messages,\n",
     "we can use the convenience classes {py:class}`~autogen_core.components.DefaultTopicId`\n",
-    "and {py:meth}`~autogen_core.components.default_subscription` to simply our code.\n",
+    "and {py:meth}`~autogen_core.components.default_subscription` to simplify our code.\n",
     "\n",
     "{py:class}`~autogen_core.components.DefaultTopicId` is\n",
     "for creating a topic that uses `\"default\"` as the default value for the topic type\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
index b2b60be1458b..1e5f5c293ded 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
@@ -18,11 +18,11 @@
     "## Built-in Model Clients\n",
     "\n",
     "Currently there are two built-in model clients:\n",
-    "{py:class}~autogen_ext.models.OpenAIChatCompletionClient` and\n",
+    "{py:class}`~autogen_ext.models.OpenAIChatCompletionClient` and\n",
     "{py:class}`~autogen_ext.models.AzureOpenAIChatCompletionClient`.\n",
     "Both clients are asynchronous.\n",
     "\n",
-    "To use the {py:class}~autogen_ext.models.OpenAIChatCompletionClient`, you need to provide the API key\n",
+    "To use the {py:class}`~autogen_ext.models.OpenAIChatCompletionClient`, you need to provide the API key\n",
     "either through the environment variable `OPENAI_API_KEY` or through the `api_key` argument."
    ]
   },
@@ -45,7 +45,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can call the {py:meth}~autogen_ext.models.OpenAIChatCompletionClient.create` method to create a\n",
+    "You can call the {py:meth}`~autogen_ext.models.OpenAIChatCompletionClient.create` method to create a\n",
     "chat completion request, and await for an {py:class}`~autogen_core.components.models.CreateResult` object in return."
    ]
   },
@@ -79,7 +79,7 @@
    "source": [
     "### Streaming Response\n",
     "\n",
-    "You can use the {py:meth}~autogen_ext.models.OpenAIChatCompletionClient.create_streaming` method to create a\n",
+    "You can use the {py:meth}`~autogen_ext.models.OpenAIChatCompletionClient.create_streaming` method to create a\n",
     "chat completion request with streaming response."
    ]
   },
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
index c5d058189319..0214b0286896 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
@@ -8,7 +8,7 @@
     "\n",
     "Tools are code that can be executed by an agent to perform actions. A tool\n",
     "can be a simple function such as a calculator, or an API call to a third-party service\n",
-    "such as stock price lookup and weather forecast.\n",
+    "such as stock price lookup or weather forecast.\n",
     "In the context of AI agents, tools are designed to be executed by agents in\n",
     "response to model-generated function calls.\n",
     "\n",

From bf407d99b4cb829e51ead187b2fd376600650d2d Mon Sep 17 00:00:00 2001
From: Ryan Sweet 
Date: Wed, 23 Oct 2024 14:23:36 -0700
Subject: [PATCH 029/173] rysweet-adopt .NET Microsoft.Extensions.AI
 abstractions (#3790)

adopts the new Microsoft.Extensions.AI abstractions
adds a base InferenceAgent
fixes a lot of pain points in the runtime wrt startup/shutdown
fixes some uncaught exceptions in the grpc stream reading
adds an example for running the backend service in its own process
adds an example of an agent that connects to OpenAI/Ollama
adds an example of wrapping an agent app in .NET Aspire
upgrades some dependencies and removes some others
Known bugs: #3922
---
 dotnet/AutoGen.sln                            | 224 ++++++++++--------
 dotnet/Directory.Build.props                  |   2 +-
 dotnet/Directory.Packages.props               |  11 +-
 .../{Hello.csproj => Backend/Backend.csproj}  |   9 +-
 dotnet/samples/Hello/Backend/Program.cs       |   5 +
 dotnet/samples/Hello/Backend/README.md        |  12 +
 .../Hello/Hello.AppHost/Hello.AppHost.csproj  |  21 ++
 dotnet/samples/Hello/Hello.AppHost/Program.cs |   6 +
 .../appsettings.Development.json              |   8 +
 .../Hello/HelloAIAgents/HelloAIAgent.cs       |  33 +++
 .../Hello/HelloAIAgents/HelloAIAgents.csproj  |  21 ++
 dotnet/samples/Hello/HelloAIAgents/Program.cs |  81 +++++++
 .../Hello/HelloAgent/HelloAgent.csproj        |  21 ++
 .../samples/Hello/{ => HelloAgent}/Program.cs |  12 +-
 dotnet/samples/Hello/HelloAgent/README.md     | 121 ++++++++++
 dotnet/samples/Hello/README.md                | 121 +---------
 .../DevTeam.Agents/Developer/Developer.cs     |   2 +-
 .../DeveloperLead/DeveloperLead.cs            |   2 +-
 .../ProductManager/ProductManager.cs          |   2 +-
 .../DevTeam.Backend/Agents/AzureGenie.cs      |   2 +-
 .../dev-team/DevTeam.Backend/Agents/Hubber.cs |   2 +-
 .../src/AutoGen.WebAPI/AutoGen.WebAPI.csproj  |   2 +-
 .../Agents/AgentBaseExtensions.cs             |   4 +-
 .../Agents/AgentWorkerRuntime.cs              |   5 +
 .../Agents/Agents/AIAgent/InferenceAgent.cs   |  30 +++
 .../AIAgent/{AiAgent.cs => SKAiAgent.cs}      |   5 +-
 dotnet/src/Microsoft.AutoGen/Agents/App.cs    |  69 +++---
 .../Agents/Microsoft.AutoGen.Agents.csproj    |   1 +
 .../AIModelClientHostingExtensions.cs         |  33 +++
 .../AIModelClientHostingExtensions.csproj     |  18 ++
 .../Options/AIClientOptions.cs}               |   7 +-
 ...rviceCollectionChatCompletionExtensions.cs | 117 +++++++++
 ...t.AutoGen.Extensions.SemanticKernel.csproj |   1 +
 .../SemanticKernelHostingExtensions.cs        |   6 +-
 dotnet/src/Microsoft.AutoGen/Runtime/Host.cs  |   1 +
 .../Runtime/WorkerGatewayService.cs           |  13 +-
 36 files changed, 756 insertions(+), 274 deletions(-)
 rename dotnet/samples/Hello/{Hello.csproj => Backend/Backend.csproj} (56%)
 create mode 100644 dotnet/samples/Hello/Backend/Program.cs
 create mode 100644 dotnet/samples/Hello/Backend/README.md
 create mode 100644 dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
 create mode 100644 dotnet/samples/Hello/Hello.AppHost/Program.cs
 create mode 100644 dotnet/samples/Hello/Hello.AppHost/appsettings.Development.json
 create mode 100644 dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
 create mode 100644 dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
 create mode 100644 dotnet/samples/Hello/HelloAIAgents/Program.cs
 create mode 100644 dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
 rename dotnet/samples/Hello/{ => HelloAgent}/Program.cs (86%)
 create mode 100644 dotnet/samples/Hello/HelloAgent/README.md
 create mode 100644 dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
 rename dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/{AiAgent.cs => SKAiAgent.cs} (91%)
 create mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
 create mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
 rename dotnet/src/Microsoft.AutoGen/Extensions/{SemanticKernel/Options/OpenAIOptions.cs => AIModelClientHostingExtensions/Options/AIClientOptions.cs} (83%)
 create mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 317fc82ffd52..b93ba566156f 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -15,10 +15,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.SourceGenerator", "
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.SourceGenerator.Tests", "test\AutoGen.SourceGenerator.Tests\AutoGen.SourceGenerator.Tests.csproj", "{05A2FAD8-03B0-4B2F-82AF-2F6BF0F050E5}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.BasicSample", "samples\AutoGen.BasicSamples\AutoGen.BasicSample.csproj", "{7EBF916A-A7B1-4B74-AF10-D705B7A18F58}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{FBFEAD1F-29EB-4D99-A672-0CD8473E10B9}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.DotnetInteractive", "src\AutoGen.DotnetInteractive\AutoGen.DotnetInteractive.csproj", "{B61D8008-7FB7-4C0E-8044-3A74AA63A596}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.LMStudio", "src\AutoGen.LMStudio\AutoGen.LMStudio.csproj", "{F98BDA9B-8657-4BA8-9B03-BAEA454CAE60}"
@@ -47,28 +43,16 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Ollama", "src\AutoG
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Ollama.Tests", "test\AutoGen.Ollama.Tests\AutoGen.Ollama.Tests.csproj", "{03E31CAA-3728-48D3-B936-9F11CF6C18FE}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Ollama.Sample", "samples\AutoGen.Ollama.Sample\AutoGen.Ollama.Sample.csproj", "{93AA4D0D-6EE4-44D5-AD77-7F73A3934544}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.SemanticKernel.Sample", "samples\AutoGen.SemanticKernel.Sample\AutoGen.SemanticKernel.Sample.csproj", "{52958A60-3FF7-4243-9058-34A6E4F55C31}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Anthropic", "src\AutoGen.Anthropic\AutoGen.Anthropic.csproj", "{6A95E113-B824-4524-8F13-CD0C3E1C8804}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Anthropic.Tests", "test\AutoGen.Anthropic.Tests\AutoGen.Anthropic.Tests.csproj", "{815E937E-86D6-4476-9EC6-B7FBCBBB5DB6}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Anthropic.Samples", "samples\AutoGen.Anthropic.Samples\AutoGen.Anthropic.Samples.csproj", "{834B4E85-64E5-4382-8465-548F332E5298}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Gemini", "src\AutoGen.Gemini\AutoGen.Gemini.csproj", "{EFE0DC86-80FC-4D52-95B7-07654BA1A769}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Gemini.Tests", "test\AutoGen.Gemini.Tests\AutoGen.Gemini.Tests.csproj", "{8EA16BAB-465A-4C07-ABC4-1070D40067E9}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Gemini.Sample", "samples\AutoGen.Gemini.Sample\AutoGen.Gemini.Sample.csproj", "{19679B75-CE3A-4DF0-A3F0-CA369D2760A4}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.AotCompatibility.Tests", "test\AutoGen.AotCompatibility.Tests\AutoGen.AotCompatibility.Tests.csproj", "{6B82F26D-5040-4453-B21B-C8D1F913CE4C}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.OpenAI.Sample", "samples\AutoGen.OpenAI.Sample\AutoGen.OpenAI.Sample.csproj", "{0E635268-351C-4A6B-A28D-593D868C2CA4}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.WebAPI.Sample", "samples\AutoGen.WebAPI.Sample\AutoGen.WebAPI.Sample.csproj", "{12079C18-A519-403F-BBFD-200A36A0C083}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.AzureAIInference", "src\AutoGen.AzureAIInference\AutoGen.AzureAIInference.csproj", "{5C45981D-1319-4C25-935C-83D411CB28DF}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.AzureAIInference.Tests", "test\AutoGen.AzureAIInference.Tests\AutoGen.AzureAIInference.Tests.csproj", "{5970868F-831E-418F-89A9-4EC599563E16}"
@@ -81,28 +65,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.OpenAI.Tests", "tes
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AgentChat", "AgentChat", "{4BB66E06-37D8-45A0-9B97-DE590AFBA340}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AgentChat", "AgentChat", "{C7A2D42D-9277-47AC-862B-D86DF9D6AD48}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "dev-team", "dev-team", "{616F30DF-1F41-4047-BAA4-64BA03BF5AEA}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.AgentHost", "samples\dev-team\DevTeam.AgentHost\DevTeam.AgentHost.csproj", "{7228A701-C79D-4E15-BF45-48D11F721A84}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Agents", "samples\dev-team\DevTeam.Agents\DevTeam.Agents.csproj", "{EDECD35D-6EB1-4CA8-A175-A66588C3481E}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.AppHost", "samples\dev-team\DevTeam.AppHost\DevTeam.AppHost.csproj", "{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Backend", "samples\dev-team\DevTeam.Backend\DevTeam.Backend.csproj", "{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Shared", "samples\dev-team\DevTeam.Shared\DevTeam.Shared.csproj", "{D9F65DFD-368B-47DB-8BB5-0C74DED7F439}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{243E768F-EA7D-4AF1-B625-0398440BB1AB}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		spelling.dic = spelling.dic
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Hello", "samples\Hello\Hello.csproj", "{6C9135E6-9D15-4D86-B3F4-9666DB87060A}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Agents", "src\Microsoft.AutoGen\Agents\Microsoft.AutoGen.Agents.csproj", "{FD87BD33-4616-460B-AC85-A412BA08BB78}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Abstractions", "src\Microsoft.AutoGen\Abstractions\Microsoft.AutoGen.Abstractions.csproj", "{E0C991D9-0DB8-471C-ADC9-5FB16E2A0106}"
@@ -115,6 +83,46 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Runtime",
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.ServiceDefaults", "src\Microsoft.AutoGen\ServiceDefaults\Microsoft.AutoGen.ServiceDefaults.csproj", "{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AgentChat", "AgentChat", "{668726B9-77BC-45CF-B576-0F0773BF1615}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Anthropic.Samples", "samples\AutoGen.Anthropic.Samples\AutoGen.Anthropic.Samples.csproj", "{84020C4A-933A-4693-9889-1B99304A7D76}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.BasicSample", "samples\AutoGen.BasicSamples\AutoGen.BasicSample.csproj", "{5777515F-4053-42F9-AF2B-95D8D0F5384A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Gemini.Sample", "samples\AutoGen.Gemini.Sample\AutoGen.Gemini.Sample.csproj", "{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Ollama.Sample", "samples\AutoGen.Ollama.Sample\AutoGen.Ollama.Sample.csproj", "{20DA47F2-F6C4-4503-B9D4-420994E28EF0}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.OpenAI.Sample", "samples\AutoGen.OpenAI.Sample\AutoGen.OpenAI.Sample.csproj", "{1F86E48B-8674-4C20-A3BE-9431049A5BEC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.SemanticKernel.Sample", "samples\AutoGen.SemanticKernel.Sample\AutoGen.SemanticKernel.Sample.csproj", "{CB8824F5-9475-451F-87E8-F2AEF2490A12}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.WebAPI.Sample", "samples\AutoGen.WebAPI.Sample\AutoGen.WebAPI.Sample.csproj", "{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DevTeam", "DevTeam", "{05B9C173-6441-4DCA-9AC4-E897EF75F331}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.AgentHost", "samples\dev-team\DevTeam.AgentHost\DevTeam.AgentHost.csproj", "{462A357B-7BB9-4927-A9FD-4FB7675898E9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Agents", "samples\dev-team\DevTeam.Agents\DevTeam.Agents.csproj", "{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.AppHost", "samples\dev-team\DevTeam.AppHost\DevTeam.AppHost.csproj", "{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Backend", "samples\dev-team\DevTeam.Backend\DevTeam.Backend.csproj", "{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Shared", "samples\dev-team\DevTeam.Shared\DevTeam.Shared.csproj", "{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Hello", "Hello", "{7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Backend", "samples\Hello\Backend\Backend.csproj", "{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hello.AppHost", "samples\Hello\Hello.AppHost\Hello.AppHost.csproj", "{09A373A0-8169-409F-8C37-3FBC1654B122}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAIAgents", "samples\Hello\HelloAIAgents\HelloAIAgents.csproj", "{A20B9894-F352-4338-872A-F215A241D43D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAgent", "samples\Hello\HelloAgent\HelloAgent.csproj", "{8F7560CF-EEBB-4333-A69F-838CA40FD85D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AIModelClientHostingExtensions", "src\Microsoft.AutoGen\Extensions\AIModelClientHostingExtensions\AIModelClientHostingExtensions.csproj", "{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -137,10 +145,6 @@ Global
 		{05A2FAD8-03B0-4B2F-82AF-2F6BF0F050E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{05A2FAD8-03B0-4B2F-82AF-2F6BF0F050E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{05A2FAD8-03B0-4B2F-82AF-2F6BF0F050E5}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7EBF916A-A7B1-4B74-AF10-D705B7A18F58}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7EBF916A-A7B1-4B74-AF10-D705B7A18F58}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7EBF916A-A7B1-4B74-AF10-D705B7A18F58}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7EBF916A-A7B1-4B74-AF10-D705B7A18F58}.Release|Any CPU.Build.0 = Release|Any CPU
 		{B61D8008-7FB7-4C0E-8044-3A74AA63A596}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{B61D8008-7FB7-4C0E-8044-3A74AA63A596}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B61D8008-7FB7-4C0E-8044-3A74AA63A596}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -197,14 +201,6 @@ Global
 		{03E31CAA-3728-48D3-B936-9F11CF6C18FE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{03E31CAA-3728-48D3-B936-9F11CF6C18FE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{03E31CAA-3728-48D3-B936-9F11CF6C18FE}.Release|Any CPU.Build.0 = Release|Any CPU
-		{93AA4D0D-6EE4-44D5-AD77-7F73A3934544}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{93AA4D0D-6EE4-44D5-AD77-7F73A3934544}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{93AA4D0D-6EE4-44D5-AD77-7F73A3934544}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{93AA4D0D-6EE4-44D5-AD77-7F73A3934544}.Release|Any CPU.Build.0 = Release|Any CPU
-		{52958A60-3FF7-4243-9058-34A6E4F55C31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{52958A60-3FF7-4243-9058-34A6E4F55C31}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{52958A60-3FF7-4243-9058-34A6E4F55C31}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{52958A60-3FF7-4243-9058-34A6E4F55C31}.Release|Any CPU.Build.0 = Release|Any CPU
 		{6A95E113-B824-4524-8F13-CD0C3E1C8804}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{6A95E113-B824-4524-8F13-CD0C3E1C8804}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6A95E113-B824-4524-8F13-CD0C3E1C8804}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -213,10 +209,6 @@ Global
 		{815E937E-86D6-4476-9EC6-B7FBCBBB5DB6}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{815E937E-86D6-4476-9EC6-B7FBCBBB5DB6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{815E937E-86D6-4476-9EC6-B7FBCBBB5DB6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{834B4E85-64E5-4382-8465-548F332E5298}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{834B4E85-64E5-4382-8465-548F332E5298}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{834B4E85-64E5-4382-8465-548F332E5298}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{834B4E85-64E5-4382-8465-548F332E5298}.Release|Any CPU.Build.0 = Release|Any CPU
 		{EFE0DC86-80FC-4D52-95B7-07654BA1A769}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{EFE0DC86-80FC-4D52-95B7-07654BA1A769}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{EFE0DC86-80FC-4D52-95B7-07654BA1A769}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -225,22 +217,10 @@ Global
 		{8EA16BAB-465A-4C07-ABC4-1070D40067E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8EA16BAB-465A-4C07-ABC4-1070D40067E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8EA16BAB-465A-4C07-ABC4-1070D40067E9}.Release|Any CPU.Build.0 = Release|Any CPU
-		{19679B75-CE3A-4DF0-A3F0-CA369D2760A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{19679B75-CE3A-4DF0-A3F0-CA369D2760A4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{19679B75-CE3A-4DF0-A3F0-CA369D2760A4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{19679B75-CE3A-4DF0-A3F0-CA369D2760A4}.Release|Any CPU.Build.0 = Release|Any CPU
 		{6B82F26D-5040-4453-B21B-C8D1F913CE4C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{6B82F26D-5040-4453-B21B-C8D1F913CE4C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6B82F26D-5040-4453-B21B-C8D1F913CE4C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6B82F26D-5040-4453-B21B-C8D1F913CE4C}.Release|Any CPU.Build.0 = Release|Any CPU
-		{0E635268-351C-4A6B-A28D-593D868C2CA4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0E635268-351C-4A6B-A28D-593D868C2CA4}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0E635268-351C-4A6B-A28D-593D868C2CA4}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0E635268-351C-4A6B-A28D-593D868C2CA4}.Release|Any CPU.Build.0 = Release|Any CPU
-		{12079C18-A519-403F-BBFD-200A36A0C083}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{12079C18-A519-403F-BBFD-200A36A0C083}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{12079C18-A519-403F-BBFD-200A36A0C083}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{12079C18-A519-403F-BBFD-200A36A0C083}.Release|Any CPU.Build.0 = Release|Any CPU
 		{5C45981D-1319-4C25-935C-83D411CB28DF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{5C45981D-1319-4C25-935C-83D411CB28DF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{5C45981D-1319-4C25-935C-83D411CB28DF}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -261,30 +241,6 @@ Global
 		{42A8251C-E7B3-47BB-A82E-459952EBE132}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{42A8251C-E7B3-47BB-A82E-459952EBE132}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{42A8251C-E7B3-47BB-A82E-459952EBE132}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7228A701-C79D-4E15-BF45-48D11F721A84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7228A701-C79D-4E15-BF45-48D11F721A84}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7228A701-C79D-4E15-BF45-48D11F721A84}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7228A701-C79D-4E15-BF45-48D11F721A84}.Release|Any CPU.Build.0 = Release|Any CPU
-		{EDECD35D-6EB1-4CA8-A175-A66588C3481E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{EDECD35D-6EB1-4CA8-A175-A66588C3481E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{EDECD35D-6EB1-4CA8-A175-A66588C3481E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{EDECD35D-6EB1-4CA8-A175-A66588C3481E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D9F65DFD-368B-47DB-8BB5-0C74DED7F439}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D9F65DFD-368B-47DB-8BB5-0C74DED7F439}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D9F65DFD-368B-47DB-8BB5-0C74DED7F439}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D9F65DFD-368B-47DB-8BB5-0C74DED7F439}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6C9135E6-9D15-4D86-B3F4-9666DB87060A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6C9135E6-9D15-4D86-B3F4-9666DB87060A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6C9135E6-9D15-4D86-B3F4-9666DB87060A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6C9135E6-9D15-4D86-B3F4-9666DB87060A}.Release|Any CPU.Build.0 = Release|Any CPU
 		{FD87BD33-4616-460B-AC85-A412BA08BB78}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{FD87BD33-4616-460B-AC85-A412BA08BB78}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FD87BD33-4616-460B-AC85-A412BA08BB78}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -309,6 +265,74 @@ Global
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{84020C4A-933A-4693-9889-1B99304A7D76}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{84020C4A-933A-4693-9889-1B99304A7D76}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{84020C4A-933A-4693-9889-1B99304A7D76}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{84020C4A-933A-4693-9889-1B99304A7D76}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5777515F-4053-42F9-AF2B-95D8D0F5384A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5777515F-4053-42F9-AF2B-95D8D0F5384A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5777515F-4053-42F9-AF2B-95D8D0F5384A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5777515F-4053-42F9-AF2B-95D8D0F5384A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{20DA47F2-F6C4-4503-B9D4-420994E28EF0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{20DA47F2-F6C4-4503-B9D4-420994E28EF0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{20DA47F2-F6C4-4503-B9D4-420994E28EF0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{20DA47F2-F6C4-4503-B9D4-420994E28EF0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1F86E48B-8674-4C20-A3BE-9431049A5BEC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1F86E48B-8674-4C20-A3BE-9431049A5BEC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1F86E48B-8674-4C20-A3BE-9431049A5BEC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1F86E48B-8674-4C20-A3BE-9431049A5BEC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CB8824F5-9475-451F-87E8-F2AEF2490A12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CB8824F5-9475-451F-87E8-F2AEF2490A12}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CB8824F5-9475-451F-87E8-F2AEF2490A12}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CB8824F5-9475-451F-87E8-F2AEF2490A12}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{462A357B-7BB9-4927-A9FD-4FB7675898E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{462A357B-7BB9-4927-A9FD-4FB7675898E9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{462A357B-7BB9-4927-A9FD-4FB7675898E9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{462A357B-7BB9-4927-A9FD-4FB7675898E9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}.Release|Any CPU.Build.0 = Release|Any CPU
+		{09A373A0-8169-409F-8C37-3FBC1654B122}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{09A373A0-8169-409F-8C37-3FBC1654B122}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{09A373A0-8169-409F-8C37-3FBC1654B122}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{09A373A0-8169-409F-8C37-3FBC1654B122}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A20B9894-F352-4338-872A-F215A241D43D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A20B9894-F352-4338-872A-F215A241D43D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A20B9894-F352-4338-872A-F215A241D43D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A20B9894-F352-4338-872A-F215A241D43D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8F7560CF-EEBB-4333-A69F-838CA40FD85D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8F7560CF-EEBB-4333-A69F-838CA40FD85D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8F7560CF-EEBB-4333-A69F-838CA40FD85D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8F7560CF-EEBB-4333-A69F-838CA40FD85D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -318,7 +342,6 @@ Global
 		{FDD99AEC-4C57-4020-B23F-650612856102} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{3FFD14E3-D6BC-4EA7-97A2-D21733060FD6} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{05A2FAD8-03B0-4B2F-82AF-2F6BF0F050E5} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
-		{7EBF916A-A7B1-4B74-AF10-D705B7A18F58} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
 		{B61D8008-7FB7-4C0E-8044-3A74AA63A596} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{F98BDA9B-8657-4BA8-9B03-BAEA454CAE60} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{45D6FC80-36F3-4967-9663-E20B63824621} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
@@ -333,37 +356,40 @@ Global
 		{B61388CA-DC73-4B7F-A7B2-7B9A86C9229E} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{9F9E6DED-3D92-4970-909A-70FC11F1A665} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{03E31CAA-3728-48D3-B936-9F11CF6C18FE} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
-		{93AA4D0D-6EE4-44D5-AD77-7F73A3934544} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
-		{52958A60-3FF7-4243-9058-34A6E4F55C31} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
 		{6A95E113-B824-4524-8F13-CD0C3E1C8804} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{815E937E-86D6-4476-9EC6-B7FBCBBB5DB6} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
-		{834B4E85-64E5-4382-8465-548F332E5298} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
 		{EFE0DC86-80FC-4D52-95B7-07654BA1A769} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{8EA16BAB-465A-4C07-ABC4-1070D40067E9} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
-		{19679B75-CE3A-4DF0-A3F0-CA369D2760A4} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
 		{6B82F26D-5040-4453-B21B-C8D1F913CE4C} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
-		{0E635268-351C-4A6B-A28D-593D868C2CA4} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
-		{12079C18-A519-403F-BBFD-200A36A0C083} = {C7A2D42D-9277-47AC-862B-D86DF9D6AD48}
 		{5C45981D-1319-4C25-935C-83D411CB28DF} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{5970868F-831E-418F-89A9-4EC599563E16} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{143725E2-206C-4D37-93E4-9EDF699826B2} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{3AF1CBEC-2877-41E9-92AE-3A391B2AA9E8} = {4BB66E06-37D8-45A0-9B97-DE590AFBA340}
 		{42A8251C-E7B3-47BB-A82E-459952EBE132} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{4BB66E06-37D8-45A0-9B97-DE590AFBA340} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
-		{C7A2D42D-9277-47AC-862B-D86DF9D6AD48} = {FBFEAD1F-29EB-4D99-A672-0CD8473E10B9}
-		{616F30DF-1F41-4047-BAA4-64BA03BF5AEA} = {FBFEAD1F-29EB-4D99-A672-0CD8473E10B9}
-		{7228A701-C79D-4E15-BF45-48D11F721A84} = {616F30DF-1F41-4047-BAA4-64BA03BF5AEA}
-		{EDECD35D-6EB1-4CA8-A175-A66588C3481E} = {616F30DF-1F41-4047-BAA4-64BA03BF5AEA}
-		{F2F13EAF-05C6-4E90-B2E4-3FA0290D7F6E} = {616F30DF-1F41-4047-BAA4-64BA03BF5AEA}
-		{D826D5E4-31F4-4AB5-AC86-F7B4AD79314B} = {616F30DF-1F41-4047-BAA4-64BA03BF5AEA}
-		{D9F65DFD-368B-47DB-8BB5-0C74DED7F439} = {616F30DF-1F41-4047-BAA4-64BA03BF5AEA}
-		{6C9135E6-9D15-4D86-B3F4-9666DB87060A} = {FBFEAD1F-29EB-4D99-A672-0CD8473E10B9}
 		{FD87BD33-4616-460B-AC85-A412BA08BB78} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{E0C991D9-0DB8-471C-ADC9-5FB16E2A0106} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{952827D4-8D4C-4327-AE4D-E8D25811EF35} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{21C9EC49-E848-4EAE-932F-0862D44F7A80} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
+		{84020C4A-933A-4693-9889-1B99304A7D76} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{5777515F-4053-42F9-AF2B-95D8D0F5384A} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{20DA47F2-F6C4-4503-B9D4-420994E28EF0} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{1F86E48B-8674-4C20-A3BE-9431049A5BEC} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{CB8824F5-9475-451F-87E8-F2AEF2490A12} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{462A357B-7BB9-4927-A9FD-4FB7675898E9} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
+		{09A373A0-8169-409F-8C37-3FBC1654B122} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
+		{A20B9894-F352-4338-872A-F215A241D43D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
+		{8F7560CF-EEBB-4333-A69F-838CA40FD85D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
+		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {93384647-528D-46C8-922C-8DB36A382F0B}
diff --git a/dotnet/Directory.Build.props b/dotnet/Directory.Build.props
index d61d6f4c799a..bb78c84d14f4 100644
--- a/dotnet/Directory.Build.props
+++ b/dotnet/Directory.Build.props
@@ -3,7 +3,7 @@
   
   
   
-    netstandard2.0;net6.0;net8.0
+    netstandard2.0;net8.0
     net8.0
     preview
 	  enable
diff --git a/dotnet/Directory.Packages.props b/dotnet/Directory.Packages.props
index 74949f880b18..dd9df7161047 100644
--- a/dotnet/Directory.Packages.props
+++ b/dotnet/Directory.Packages.props
@@ -3,8 +3,10 @@
     true
     1.22.0
     1.22.0-alpha
+    9.0.0-preview.9.24507.7
   
   
+    
     
     
     
@@ -39,7 +41,12 @@
     
     
     
-    
+    
+    
+    
+    
+    
+    
     
     
     
@@ -104,6 +111,6 @@
     
     
     
-    
+    
   
 
\ No newline at end of file
diff --git a/dotnet/samples/Hello/Hello.csproj b/dotnet/samples/Hello/Backend/Backend.csproj
similarity index 56%
rename from dotnet/samples/Hello/Hello.csproj
rename to dotnet/samples/Hello/Backend/Backend.csproj
index bfd5d1a5cef0..60097b5d379d 100644
--- a/dotnet/samples/Hello/Hello.csproj
+++ b/dotnet/samples/Hello/Backend/Backend.csproj
@@ -1,19 +1,14 @@
-
-
+
   
-    
-    
+    
   
-
   
     
   
-
   
     Exe
     net8.0
     enable
     enable
   
-
 
diff --git a/dotnet/samples/Hello/Backend/Program.cs b/dotnet/samples/Hello/Backend/Program.cs
new file mode 100644
index 000000000000..747e0d860ab4
--- /dev/null
+++ b/dotnet/samples/Hello/Backend/Program.cs
@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft. All rights reserved.
+using Microsoft.Extensions.Hosting;
+
+var app = await Microsoft.AutoGen.Runtime.Host.StartAsync(local: true);
+await app.WaitForShutdownAsync();
diff --git a/dotnet/samples/Hello/Backend/README.md b/dotnet/samples/Hello/Backend/README.md
new file mode 100644
index 000000000000..45c7ddee1d05
--- /dev/null
+++ b/dotnet/samples/Hello/Backend/README.md
@@ -0,0 +1,12 @@
+# Backend Example
+
+This example demonstrates how to create a simple backend service for the agent runtime using ASP.NET Core.
+
+To Run it, simply run the following command in the terminal:
+
+```bash
+dotnet run
+```
+
+Or you can run it using Visual Studio Code by pressing `F5`.
+
diff --git a/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj b/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
new file mode 100644
index 000000000000..3ecd30dee13a
--- /dev/null
+++ b/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
@@ -0,0 +1,21 @@
+
+
+  
+    Exe
+    net8.0
+    enable
+    enable
+    true
+    ecb5cbe4-15d8-4120-8f18-d3ba4902915b
+  
+
+  
+    
+    
+  
+  
+    
+    
+  
+
+
diff --git a/dotnet/samples/Hello/Hello.AppHost/Program.cs b/dotnet/samples/Hello/Hello.AppHost/Program.cs
new file mode 100644
index 000000000000..d7c37df8ec13
--- /dev/null
+++ b/dotnet/samples/Hello/Hello.AppHost/Program.cs
@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+var builder = DistributedApplication.CreateBuilder(args);
+var backend = builder.AddProject("backend");
+builder.AddProject("client").WithReference(backend).WaitFor(backend);
+builder.Build().Run();
diff --git a/dotnet/samples/Hello/Hello.AppHost/appsettings.Development.json b/dotnet/samples/Hello/Hello.AppHost/appsettings.Development.json
new file mode 100644
index 000000000000..0c208ae9181e
--- /dev/null
+++ b/dotnet/samples/Hello/Hello.AppHost/appsettings.Development.json
@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
new file mode 100644
index 000000000000..935d1d50b7a8
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
@@ -0,0 +1,33 @@
+using Microsoft.AutoGen.Abstractions;
+using Microsoft.AutoGen.Agents;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Hello;
+[TopicSubscription("HelloAgents")]
+public class HelloAIAgent(
+    IAgentContext context,
+    [FromKeyedServices("EventTypes")] EventTypes typeRegistry,
+    IChatClient client) : HelloAgent(
+        context,
+        typeRegistry),
+        IHandle
+{
+    // This Handle supercedes the one in the base class
+    public new async Task Handle(NewMessageReceived item)
+    {
+        var prompt = "Please write a limerick greeting someone with the name " + item.Message;
+        var response = await client.CompleteAsync(prompt);
+        var evt = new Output
+        {
+            Message = response.Message.Text
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(evt).ConfigureAwait(false);
+        var goodbye = new ConversationClosed
+        {
+            UserId = this.AgentId.Key,
+            UserMessage = "Goodbye"
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(goodbye).ConfigureAwait(false);
+    }
+}
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
new file mode 100644
index 000000000000..73f1891b3f22
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
@@ -0,0 +1,21 @@
+
+
+  
+    
+    
+    
+    
+  
+
+  
+    
+  
+
+  
+    Exe
+    net8.0
+    enable
+    enable
+  
+
+
diff --git a/dotnet/samples/Hello/HelloAIAgents/Program.cs b/dotnet/samples/Hello/HelloAIAgents/Program.cs
new file mode 100644
index 000000000000..d2239f22b700
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAIAgents/Program.cs
@@ -0,0 +1,81 @@
+using Hello;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AutoGen.Abstractions;
+using Microsoft.AutoGen.Agents;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+// send a message to the agent
+var builder = WebApplication.CreateBuilder();
+// put these in your environment or appsettings.json
+builder.Configuration["HelloAIAgents:ModelType"] = "azureopenai";
+builder.Configuration["HelloAIAgents:LlmModelName"] = "gpt-3.5-turbo";
+Environment.SetEnvironmentVariable("AZURE_OPENAI_CONNECTION_STRING", "Endpoint=https://TODO.openai.azure.com/;Key=TODO;Deployment=TODO");
+if (Environment.GetEnvironmentVariable("AZURE_OPENAI_CONNECTION_STRING") == null)
+{
+    throw new InvalidOperationException("AZURE_OPENAI_CONNECTION_STRING not set, try something like AZURE_OPENAI_CONNECTION_STRING = \"Endpoint=https://TODO.openai.azure.com/;Key=TODO;Deployment=TODO\"");
+}
+builder.Configuration["ConectionStrings:HelloAIAgents"] = Environment.GetEnvironmentVariable("AZURE_OPENAI_CONNECTION_STRING");
+builder.AddChatCompletionService("HelloAIAgents");
+var agentTypes = new AgentTypes(new Dictionary
+{
+    { "HelloAIAgents", typeof(HelloAIAgent) }
+});
+var app = await AgentsApp.PublishMessageAsync("HelloAgents", new NewMessageReceived
+{
+    Message = "World"
+}, builder, agentTypes, local: true);
+
+await app.WaitForShutdownAsync();
+
+namespace Hello
+{
+    [TopicSubscription("HelloAgents")]
+    public class HelloAgent(
+        IAgentContext context,
+        [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
+            context,
+            typeRegistry),
+            ISayHello,
+            IHandle,
+            IHandle
+    {
+        public async Task Handle(NewMessageReceived item)
+        {
+            var response = await SayHello(item.Message).ConfigureAwait(false);
+            var evt = new Output
+            {
+                Message = response
+            }.ToCloudEvent(this.AgentId.Key);
+            await PublishEvent(evt).ConfigureAwait(false);
+            var goodbye = new ConversationClosed
+            {
+                UserId = this.AgentId.Key,
+                UserMessage = "Goodbye"
+            }.ToCloudEvent(this.AgentId.Key);
+            await PublishEvent(goodbye).ConfigureAwait(false);
+        }
+        public async Task Handle(ConversationClosed item)
+        {
+            var goodbye = $"*********************  {item.UserId} said {item.UserMessage}  ************************";
+            var evt = new Output
+            {
+                Message = goodbye
+            }.ToCloudEvent(this.AgentId.Key);
+            await PublishEvent(evt).ConfigureAwait(false);
+            //sleep30 seconds
+            await Task.Delay(30000).ConfigureAwait(false);
+            await AgentsApp.ShutdownAsync().ConfigureAwait(false);
+
+        }
+        public async Task SayHello(string ask)
+        {
+            var response = $"\n\n\n\n***************Hello {ask}**********************\n\n\n\n";
+            return response;
+        }
+    }
+    public interface ISayHello
+    {
+        public Task SayHello(string ask);
+    }
+}
diff --git a/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj b/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
new file mode 100644
index 000000000000..eb2ba96d6644
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
@@ -0,0 +1,21 @@
+
+
+  
+    
+    
+    
+  
+
+  
+    
+    
+  
+
+  
+    Exe
+    net8.0
+    enable
+    enable
+  
+
+
diff --git a/dotnet/samples/Hello/Program.cs b/dotnet/samples/Hello/HelloAgent/Program.cs
similarity index 86%
rename from dotnet/samples/Hello/Program.cs
rename to dotnet/samples/Hello/HelloAgent/Program.cs
index 3335ff96ccec..d378a5b4f781 100644
--- a/dotnet/samples/Hello/Program.cs
+++ b/dotnet/samples/Hello/HelloAgent/Program.cs
@@ -1,15 +1,16 @@
+// Copyright (c) Microsoft. All rights reserved.
+
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 // send a message to the agent
-var app = await App.PublishMessageAsync("HelloAgents", new NewMessageReceived
+var app = await AgentsApp.PublishMessageAsync("HelloAgents", new NewMessageReceived
 {
     Message = "World"
-}, local: true);
+}, local: false);
 
-await App.RuntimeApp!.WaitForShutdownAsync();
 await app.WaitForShutdownAsync();
 
 namespace Hello
@@ -47,7 +48,10 @@ public async Task Handle(ConversationClosed item)
                 Message = goodbye
             }.ToCloudEvent(this.AgentId.Key);
             await PublishEvent(evt).ConfigureAwait(false);
-            await App.ShutdownAsync();
+            //sleep
+            await Task.Delay(10000).ConfigureAwait(false);
+            await AgentsApp.ShutdownAsync().ConfigureAwait(false);
+
         }
         public async Task SayHello(string ask)
         {
diff --git a/dotnet/samples/Hello/HelloAgent/README.md b/dotnet/samples/Hello/HelloAgent/README.md
new file mode 100644
index 000000000000..795eed07281d
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgent/README.md
@@ -0,0 +1,121 @@
+# AutoGen 0.4 .NET Hello World Sample
+
+This [sample](Program.cs) demonstrates how to create a simple .NET console application that listens for an event and then orchestrates a series of actions in response.
+
+## Prerequisites
+
+To run this sample, you'll need: [.NET 8.0](https://dotnet.microsoft.com/en-us/) or later.
+Also recommended is the [GitHub CLI](https://cli.github.com/).
+
+## Instructions to run the sample
+
+```bash
+# Clone the repository
+gh repo clone microsoft/autogen
+cd dotnet/samples/Hello
+dotnet run
+```
+
+## Key Concepts
+
+This sample illustrates how to create your own agent that inherits from a base agent and listens for an event. It also shows how to use the SDK's App Runtime locally to start the agent and send messages.
+
+Flow Diagram:
+
+```mermaid
+%%{init: {'theme':'forest'}}%%
+graph LR;
+    A[Main] --> |"PublishEvent(NewMessage('World'))"| B{"Handle(NewMessageReceived item)"}
+    B --> |"PublishEvent(Output('***Hello, World***'))"| C[ConsoleAgent]
+    C --> D{"WriteConsole()"}
+    B --> |"PublishEvent(ConversationClosed('Goodbye'))"| E{"Handle(ConversationClosed item)"}
+    B --> |"PublishEvent(Output('***Goodbye***'))"| C
+    E --> F{"Shutdown()"}
+
+```
+
+### Writing Event Handlers
+
+The heart of an autogen application are the event handlers. Agents select a ```TopicSubscription``` to listen for events on a specific topic. When an event is received, the agent's event handler is called with the event data.
+
+Within that event handler you may optionally *emit* new events, which are then sent to the event bus for other agents to process. The EventTypes are declared gRPC ProtoBuf messages that are used to define the schema of the event.  The default protos are available via the ```Microsoft.AutoGen.Abstractions;``` namespace and are defined in [autogen/protos](/autogen/protos). The EventTypes are registered in the agent's constructor using the ```IHandle``` interface.
+
+```csharp
+TopicSubscription("HelloAgents")]
+public class HelloAgent(
+    IAgentContext context,
+    [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
+        context,
+        typeRegistry),
+        ISayHello,
+        IHandle,
+        IHandle
+{
+    public async Task Handle(NewMessageReceived item)
+    {
+        var response = await SayHello(item.Message).ConfigureAwait(false);
+        var evt = new Output
+        {
+            Message = response
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(evt).ConfigureAwait(false);
+        var goodbye = new ConversationClosed
+        {
+            UserId = this.AgentId.Key,
+            UserMessage = "Goodbye"
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(goodbye).ConfigureAwait(false);
+    }
+```
+
+### Inheritance and Composition
+
+This sample also illustrates inheritance in AutoGen. The `HelloAgent` class inherits from `ConsoleAgent`, which is a base class that provides a `WriteConsole` method.
+
+### Starting the Application Runtime
+
+AuotoGen provides a flexible runtime ```Microsoft.AutoGen.Agents.App``` that can be started in a variety of ways. The `Program.cs` file demonstrates how to start the runtime locally and send a message to the agent all in one go using the ```App.PublishMessageAsync``` method.
+
+```csharp
+// send a message to the agent
+var app = await App.PublishMessageAsync("HelloAgents", new NewMessageReceived
+{
+    Message = "World"
+}, local: true);
+
+await App.RuntimeApp!.WaitForShutdownAsync();
+await app.WaitForShutdownAsync();
+```
+
+### Sending Messages
+
+The set of possible Messages is defined in gRPC ProtoBuf specs. These are then turned into C# classes by the gRPC tools. You can define your own Message types by creating a new .proto file in your project and including the gRPC tools in your ```.csproj``` file:
+
+```proto
+syntax = "proto3";
+package devteam;
+option csharp_namespace = "DevTeam.Shared";
+message NewAsk {
+  string org = 1;
+  string repo = 2;
+  string ask = 3;
+  int64 issue_number = 4;
+}
+message ReadmeRequested {
+   string org = 1;
+   string repo = 2;
+   int64 issue_number = 3;
+   string ask = 4;
+}
+```
+
+
+```xml
+  
+    
+    
+    
+  
+```
+
+You can send messages using the [```Microsoft.AutoGen.Agents.AgentClient``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
diff --git a/dotnet/samples/Hello/README.md b/dotnet/samples/Hello/README.md
index 795eed07281d..fc92a2fe5daf 100644
--- a/dotnet/samples/Hello/README.md
+++ b/dotnet/samples/Hello/README.md
@@ -1,121 +1,10 @@
-# AutoGen 0.4 .NET Hello World Sample
+# Multiproject App Host for HelloAgent
 
-This [sample](Program.cs) demonstrates how to create a simple .NET console application that listens for an event and then orchestrates a series of actions in response.
+This is a [.NET Aspire](https://learn.microsoft.com/en-us/dotnet/aspire/get-started/aspire-overview) App Host that starts up the HelloAgent project and the agents backend. Once the project starts up you will be able to view the telemetry and logs in the [Aspire Dashboard](https://learn.microsoft.com/en-us/dotnet/aspire/get-started/aspire-dashboard) using the link provided in the console.
 
-## Prerequisites
-
-To run this sample, you'll need: [.NET 8.0](https://dotnet.microsoft.com/en-us/) or later.
-Also recommended is the [GitHub CLI](https://cli.github.com/).
-
-## Instructions to run the sample
-
-```bash
-# Clone the repository
-gh repo clone microsoft/autogen
-cd dotnet/samples/Hello
+```shell
+cd Hello.AppHost
 dotnet run
 ```
 
-## Key Concepts
-
-This sample illustrates how to create your own agent that inherits from a base agent and listens for an event. It also shows how to use the SDK's App Runtime locally to start the agent and send messages.
-
-Flow Diagram:
-
-```mermaid
-%%{init: {'theme':'forest'}}%%
-graph LR;
-    A[Main] --> |"PublishEvent(NewMessage('World'))"| B{"Handle(NewMessageReceived item)"}
-    B --> |"PublishEvent(Output('***Hello, World***'))"| C[ConsoleAgent]
-    C --> D{"WriteConsole()"}
-    B --> |"PublishEvent(ConversationClosed('Goodbye'))"| E{"Handle(ConversationClosed item)"}
-    B --> |"PublishEvent(Output('***Goodbye***'))"| C
-    E --> F{"Shutdown()"}
-
-```
-
-### Writing Event Handlers
-
-The heart of an autogen application are the event handlers. Agents select a ```TopicSubscription``` to listen for events on a specific topic. When an event is received, the agent's event handler is called with the event data.
-
-Within that event handler you may optionally *emit* new events, which are then sent to the event bus for other agents to process. The EventTypes are declared gRPC ProtoBuf messages that are used to define the schema of the event.  The default protos are available via the ```Microsoft.AutoGen.Abstractions;``` namespace and are defined in [autogen/protos](/autogen/protos). The EventTypes are registered in the agent's constructor using the ```IHandle``` interface.
-
-```csharp
-TopicSubscription("HelloAgents")]
-public class HelloAgent(
-    IAgentContext context,
-    [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
-        context,
-        typeRegistry),
-        ISayHello,
-        IHandle,
-        IHandle
-{
-    public async Task Handle(NewMessageReceived item)
-    {
-        var response = await SayHello(item.Message).ConfigureAwait(false);
-        var evt = new Output
-        {
-            Message = response
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt).ConfigureAwait(false);
-        var goodbye = new ConversationClosed
-        {
-            UserId = this.AgentId.Key,
-            UserMessage = "Goodbye"
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(goodbye).ConfigureAwait(false);
-    }
-```
-
-### Inheritance and Composition
-
-This sample also illustrates inheritance in AutoGen. The `HelloAgent` class inherits from `ConsoleAgent`, which is a base class that provides a `WriteConsole` method.
-
-### Starting the Application Runtime
-
-AuotoGen provides a flexible runtime ```Microsoft.AutoGen.Agents.App``` that can be started in a variety of ways. The `Program.cs` file demonstrates how to start the runtime locally and send a message to the agent all in one go using the ```App.PublishMessageAsync``` method.
-
-```csharp
-// send a message to the agent
-var app = await App.PublishMessageAsync("HelloAgents", new NewMessageReceived
-{
-    Message = "World"
-}, local: true);
-
-await App.RuntimeApp!.WaitForShutdownAsync();
-await app.WaitForShutdownAsync();
-```
-
-### Sending Messages
-
-The set of possible Messages is defined in gRPC ProtoBuf specs. These are then turned into C# classes by the gRPC tools. You can define your own Message types by creating a new .proto file in your project and including the gRPC tools in your ```.csproj``` file:
-
-```proto
-syntax = "proto3";
-package devteam;
-option csharp_namespace = "DevTeam.Shared";
-message NewAsk {
-  string org = 1;
-  string repo = 2;
-  string ask = 3;
-  int64 issue_number = 4;
-}
-message ReadmeRequested {
-   string org = 1;
-   string repo = 2;
-   int64 issue_number = 3;
-   string ask = 4;
-}
-```
-
-
-```xml
-  
-    
-    
-    
-  
-```
-
-You can send messages using the [```Microsoft.AutoGen.Agents.AgentClient``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
+For more info see the HelloAgent [README](../HelloAgent/README.md).
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
index 47a389ad7e3a..70632518271d 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
@@ -8,7 +8,7 @@ namespace DevTeam.Agents;
 
 [TopicSubscription("devteam")]
 public class Dev(IAgentContext context, Kernel kernel, ISemanticTextMemory memory, [FromKeyedServices("EventTypes")] EventTypes typeRegistry, ILogger logger)
-    : AiAgent(context, memory, kernel, typeRegistry), IDevelopApps,
+    : SKAiAgent(context, memory, kernel, typeRegistry), IDevelopApps,
     IHandle,
     IHandle
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
index c3e5e2feaf66..a0bd80497c80 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
@@ -9,7 +9,7 @@ namespace DevTeam.Agents;
 
 [TopicSubscription("devteam")]
 public class DeveloperLead(IAgentContext context, Kernel kernel, ISemanticTextMemory memory, [FromKeyedServices("EventTypes")] EventTypes typeRegistry, ILogger logger)
-    : AiAgent(context, memory, kernel, typeRegistry), ILeadDevelopers,
+    : SKAiAgent(context, memory, kernel, typeRegistry), ILeadDevelopers,
     IHandle,
     IHandle
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
index 36bb34c3a86f..a5bdca19d1bb 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
@@ -8,7 +8,7 @@ namespace DevTeam.Agents;
 
 [TopicSubscription("devteam")]
 public class ProductManager(IAgentContext context, Kernel kernel, ISemanticTextMemory memory, [FromKeyedServices("EventTypes")] EventTypes typeRegistry, ILogger logger)
-    : AiAgent(context, memory, kernel, typeRegistry), IManageProducts,
+    : SKAiAgent(context, memory, kernel, typeRegistry), IManageProducts,
     IHandle,
     IHandle
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
index 0c9aabe9b562..61c618acda72 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
@@ -7,7 +7,7 @@
 namespace Microsoft.AI.DevTeam;
 
 public class AzureGenie(IAgentContext context, Kernel kernel, ISemanticTextMemory memory, [FromKeyedServices("EventTypes")] EventTypes typeRegistry, IManageAzure azureService)
-    : AiAgent(context, memory, kernel, typeRegistry),
+    : SKAiAgent(context, memory, kernel, typeRegistry),
     IHandle,
     IHandle
 
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
index e0107c2eab5f..f42eb4763b45 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
@@ -10,7 +10,7 @@
 namespace Microsoft.AI.DevTeam;
 
 public class Hubber(IAgentContext context, Kernel kernel, ISemanticTextMemory memory, [FromKeyedServices("EventTypes")] EventTypes typeRegistry, IManageGithub ghService)
-    : AiAgent(context, memory, kernel, typeRegistry),
+    : SKAiAgent(context, memory, kernel, typeRegistry),
     IHandle,
     IHandle,
     IHandle,
diff --git a/dotnet/src/AutoGen.WebAPI/AutoGen.WebAPI.csproj b/dotnet/src/AutoGen.WebAPI/AutoGen.WebAPI.csproj
index 5467f66389a9..fe549d969b3a 100644
--- a/dotnet/src/AutoGen.WebAPI/AutoGen.WebAPI.csproj
+++ b/dotnet/src/AutoGen.WebAPI/AutoGen.WebAPI.csproj
@@ -1,7 +1,7 @@
 
 
   
-    net6.0;net8.0
+    net8.0
     true
     $(NoWarn);CS1591;CS1573;CA1852
   
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
index 19352ea69bec..0f815e3d2ecd 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
@@ -4,7 +4,6 @@ namespace Microsoft.AutoGen.Agents;
 
 public static class AgentBaseExtensions
 {
-
     public static Activity? ExtractActivity(this AgentBase agent, string activityName, IDictionary metadata)
     {
         Activity? activity = null;
@@ -61,10 +60,9 @@ public static class AgentBaseExtensions
 
         return activity;
     }
-
     public static async Task InvokeWithActivityAsync(this AgentBase agent, Func func, TState state, Activity? activity, string methodName)
     {
-        if (activity is not null)
+        if (activity is not null && activity.StartTimeUtc == default)
         {
             activity.Start();
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
index cefadf7b5a1e..d0df48f71bff 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
@@ -64,6 +64,11 @@ private async Task RunReadPump()
             {
                 await foreach (var message in channel.ResponseStream.ReadAllAsync(_shutdownCts.Token))
                 {
+                    // next if message is null
+                    if (message == null)
+                    {
+                        continue;
+                    }
                     switch (message.MessageCase)
                     {
                         case Message.MessageOneofCase.Request:
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
new file mode 100644
index 000000000000..e1f932fa6642
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
@@ -0,0 +1,30 @@
+using Microsoft.Extensions.AI;
+namespace Microsoft.AutoGen.Agents.Client;
+public abstract class InferenceAgent : AgentBase where T : class, new()
+{
+    protected IChatClient ChatClient { get; }
+    public InferenceAgent(
+        IAgentContext context,
+        EventTypes typeRegistry, IChatClient client
+        ) : base(context, typeRegistry)
+    {
+        ChatClient = client;
+    }
+
+    private Task CompleteAsync(
+        IList chatMessages,
+        ChatOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return ChatClient.CompleteAsync(chatMessages, options, cancellationToken);
+    }
+
+    private IAsyncEnumerable CompleteStreamingAsync(
+        IList chatMessages,
+        ChatOptions? options = null,
+        CancellationToken cancellationToken = default)
+    {
+        return ChatClient.CompleteStreamingAsync(chatMessages, options, cancellationToken);
+    }
+
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/AiAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
similarity index 91%
rename from dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/AiAgent.cs
rename to dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
index d5b4675e8945..84bd2f821906 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/AiAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
@@ -7,13 +7,13 @@
 using Microsoft.SemanticKernel.Memory;
 
 namespace Microsoft.AutoGen.Agents;
-public abstract class AiAgent : AgentBase where T : class, new()
+public abstract class SKAiAgent : AgentBase where T : class, new()
 {
     protected AgentState _state;
     protected Kernel _kernel;
     private readonly ISemanticTextMemory _memory;
 
-    public AiAgent(IAgentContext context, ISemanticTextMemory memory, Kernel kernel, EventTypes typeRegistry) : base(context, typeRegistry)
+    public SKAiAgent(IAgentContext context, ISemanticTextMemory memory, Kernel kernel, EventTypes typeRegistry) : base(context, typeRegistry)
     {
         _state = new();
         _memory = memory;
@@ -63,7 +63,6 @@ public async Task AddKnowledge(string instruction, string index
     }
 }
 
-// TODO Remove history when we introduce memory banks
 public class AgentState where T : class, new()
 {
     public List History { get; set; } = [];
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/App.cs b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
index 4a246f5ddbb5..00c487ede6fb 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/App.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
@@ -1,55 +1,70 @@
+using System.Diagnostics.CodeAnalysis;
 using Google.Protobuf;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AutoGen.Runtime;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
 namespace Microsoft.AutoGen.Agents;
 
-public static class App
+public static class AgentsApp
 {
     // need a variable to store the runtime instance
-    public static WebApplication? RuntimeApp { get; set; }
-    public static WebApplication? ClientApp { get; set; }
-    public static async ValueTask StartAsync(AgentTypes? agentTypes = null, bool local = false)
+    public static WebApplication? Host { get; private set; }
+    [MemberNotNull(nameof(Host))]
+    public static async ValueTask StartAsync(WebApplicationBuilder? builder = null, AgentTypes? agentTypes = null, bool local = false)
     {
-        // start the server runtime
-        RuntimeApp ??= await Runtime.Host.StartAsync(local);
-        var clientBuilder = WebApplication.CreateBuilder();
-        clientBuilder.AddServiceDefaults();
-        var appBuilder = clientBuilder.AddAgentWorker();
-        agentTypes ??= AgentTypes.GetAgentTypesFromAssembly()
-                   ?? throw new InvalidOperationException("No agent types found in the assembly");
-        foreach (var type in agentTypes.Types)
+        builder ??= WebApplication.CreateBuilder();
+        if (local)
+        {
+            // start the server runtime
+            builder.AddLocalAgentService();
+        }
+        builder.AddAgentWorker()
+            .AddAgents(agentTypes);
+        builder.AddServiceDefaults();
+        var app = builder.Build();
+        if (local)
         {
-            appBuilder.AddAgent(type.Key, type.Value);
+            app.MapAgentService();
         }
-        ClientApp = clientBuilder.Build();
-        await ClientApp.StartAsync().ConfigureAwait(false);
-        return ClientApp;
+        app.MapDefaultEndpoints();
+        Host = app;
+        await app.StartAsync().ConfigureAwait(false);
+        return Host;
     }
-
     public static async ValueTask PublishMessageAsync(
         string topic,
         IMessage message,
-        AgentTypes? agentTypes = null,
+        WebApplicationBuilder? builder = null,
+        AgentTypes? agents = null,
         bool local = false)
     {
-        if (ClientApp == null)
+        if (Host == null)
         {
-            ClientApp = await App.StartAsync(agentTypes, local);
+            await StartAsync(builder, agents, local);
         }
-        var client = ClientApp.Services.GetRequiredService() ?? throw new InvalidOperationException("Client not started");
+        var client = Host.Services.GetRequiredService() ?? throw new InvalidOperationException("Host not started");
         await client.PublishEventAsync(topic, message).ConfigureAwait(false);
-        return ClientApp;
+        return Host;
     }
-
     public static async ValueTask ShutdownAsync()
     {
-        if (ClientApp == null)
+        if (Host == null)
+        {
+            throw new InvalidOperationException("Host not started");
+        }
+        await Host.StopAsync();
+    }
+
+    private static AgentApplicationBuilder AddAgents(this AgentApplicationBuilder builder, AgentTypes? agentTypes)
+    {
+        agentTypes ??= AgentTypes.GetAgentTypesFromAssembly()
+                   ?? throw new InvalidOperationException("No agent types found in the assembly");
+        foreach (var type in agentTypes.Types)
         {
-            throw new InvalidOperationException("Client not started");
+            builder.AddAgent(type.Key, type.Value);
         }
-        await ClientApp.StopAsync();
-        await RuntimeApp!.StopAsync();
+        return builder;
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj b/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
index 60b0bd4a9dac..5c921fc2b0a8 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
@@ -17,6 +17,7 @@
 	
 
 	
+	  
 	  
 	  
 	
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
new file mode 100644
index 000000000000..41e91ef1dac1
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
@@ -0,0 +1,33 @@
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Extensions.Hosting
+{
+    public static class AIModelClient
+    {
+        public static IHostApplicationBuilder AddChatCompletionService(this IHostApplicationBuilder builder, string serviceName)
+        {
+            var pipeline = (ChatClientBuilder pipeline) => pipeline
+            .UseLogging()
+            .UseFunctionInvocation()
+            .UseOpenTelemetry(configure: c => c.EnableSensitiveData = true);
+
+            if (builder.Configuration[$"{serviceName}:ModelType"] == "ollama")
+            {
+                builder.AddOllamaChatClient(serviceName, pipeline);
+            }
+            else if (builder.Configuration[$"{serviceName}:ModelType"] == "openai" || builder.Configuration[$"{serviceName}:ModelType"] == "azureopenai")
+            {
+                builder.AddOpenAIChatClient(serviceName, pipeline);
+            }
+            else if (builder.Configuration[$"{serviceName}:ModelType"] == "azureaiinference")
+            {
+                builder.AddAzureChatClient(serviceName, pipeline);
+            }
+            else
+            {
+                throw new InvalidOperationException("Did not find a valid model implementation for the given service name ${serviceName}, valid supported implemenation types are ollama, openai, azureopenai, azureaiinference");
+            }
+            return builder;
+        }
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
new file mode 100644
index 000000000000..a94921946c09
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
@@ -0,0 +1,18 @@
+
+  
+    net8.0
+    enable
+    enable
+  
+  
+    
+    
+    
+    
+    
+    
+    
+    
+    
+  
+
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/OpenAIOptions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
similarity index 83%
rename from dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/OpenAIOptions.cs
rename to dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
index 2db5cb14bdb5..57d6e1a611af 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/OpenAIOptions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
@@ -1,9 +1,12 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace Microsoft.AutoGen.Extensions.SemanticKernel;
+namespace Microsoft.Extensions.Hosting;
 
-public class OpenAIOptions
+public class AIClientOptions
 {
+    // Model Classname
+    [Required]
+    public required string ModelType { get; set; }
     // Embeddings
     [Required]
     public required string EmbeddingsEndpoint { get; set; }
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs
new file mode 100644
index 000000000000..9511d7e737ec
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs
@@ -0,0 +1,117 @@
+using System.ClientModel;
+using System.Data.Common;
+using Azure;
+using Azure.AI.Inference;
+using Azure.AI.OpenAI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using OpenAI;
+
+namespace Microsoft.Extensions.Hosting;
+public static class ServiceCollectionChatClientExtensions
+{
+    public static IServiceCollection AddOllamaChatClient(
+        this IHostApplicationBuilder hostBuilder,
+        string serviceName,
+        Func? builder = null,
+        string? modelName = null)
+    {
+        if (modelName is null)
+        {
+            var configKey = $"{serviceName}:LlmModelName";
+            modelName = hostBuilder.Configuration[configKey];
+            if (string.IsNullOrEmpty(modelName))
+            {
+                throw new InvalidOperationException($"No {nameof(modelName)} was specified, and none could be found from configuration at '{configKey}'");
+            }
+        }
+        return hostBuilder.Services.AddOllamaChatClient(
+            modelName,
+            new Uri($"http://{serviceName}"),
+            builder);
+    }
+    public static IServiceCollection AddOllamaChatClient(
+        this IServiceCollection services,
+        string modelName,
+        Uri? uri = null,
+        Func? builder = null)
+    {
+        uri ??= new Uri("http://localhost:11434");
+        return services.AddChatClient(pipeline =>
+        {
+            builder?.Invoke(pipeline);
+            var httpClient = pipeline.Services.GetService() ?? new();
+            return pipeline.Use(new OllamaChatClient(uri, modelName, httpClient));
+        });
+    }
+    public static IServiceCollection AddOpenAIChatClient(
+        this IHostApplicationBuilder hostBuilder,
+        string serviceName,
+        Func? builder = null,
+        string? modelOrDeploymentName = null)
+    {
+        // TODO: We would prefer to use Aspire.AI.OpenAI here, 
+        var connectionString = hostBuilder.Configuration.GetConnectionString(serviceName);
+        if (string.IsNullOrWhiteSpace(connectionString))
+        {
+            throw new InvalidOperationException($"No connection string named '{serviceName}' was found. Ensure a corresponding Aspire service was registered.");
+        }
+        var connectionStringBuilder = new DbConnectionStringBuilder();
+        connectionStringBuilder.ConnectionString = connectionString;
+        var endpoint = (string?)connectionStringBuilder["endpoint"];
+        var apiKey = (string)connectionStringBuilder["key"] ?? throw new InvalidOperationException($"The connection string named '{serviceName}' does not specify a value for 'Key', but this is required.");
+
+        modelOrDeploymentName ??= (connectionStringBuilder["Deployment"] ?? connectionStringBuilder["Model"]) as string;
+        if (string.IsNullOrWhiteSpace(modelOrDeploymentName))
+        {
+            throw new InvalidOperationException($"The connection string named '{serviceName}' does not specify a value for 'Deployment' or 'Model', and no value was passed for {nameof(modelOrDeploymentName)}.");
+        }
+
+        var endpointUri = string.IsNullOrEmpty(endpoint) ? null : new Uri(endpoint);
+        return hostBuilder.Services.AddOpenAIChatClient(apiKey, modelOrDeploymentName, endpointUri, builder);
+    }
+    public static IServiceCollection AddOpenAIChatClient(
+        this IServiceCollection services,
+        string apiKey,
+        string modelOrDeploymentName,
+        Uri? endpoint = null,
+        Func? builder = null)
+    {
+        return services
+            .AddSingleton(_ => endpoint is null
+                ? new OpenAIClient(apiKey)
+                : new AzureOpenAIClient(endpoint, new ApiKeyCredential(apiKey)))
+            .AddChatClient(pipeline =>
+            {
+                builder?.Invoke(pipeline);
+                var openAiClient = pipeline.Services.GetRequiredService();
+                return pipeline.Use(openAiClient.AsChatClient(modelOrDeploymentName));
+            });
+    }
+    public static IServiceCollection AddAzureChatClient(
+        this IHostApplicationBuilder hostBuilder,
+        string serviceName,
+        Func? builder = null,
+        string? modelOrDeploymentName = null)
+    {
+        if (modelOrDeploymentName is null)
+        {
+            var configKey = $"{serviceName}:LlmModelName";
+            modelOrDeploymentName = hostBuilder.Configuration[configKey];
+            if (string.IsNullOrEmpty(modelOrDeploymentName))
+            {
+                throw new InvalidOperationException($"No {nameof(modelOrDeploymentName)} was specified, and none could be found from configuration at '{configKey}'");
+            }
+        }
+        var endpoint = $"{serviceName}:Endpoint" ?? throw new InvalidOperationException($"No endpoint was specified for the Azure Inference Chat Client");
+        var endpointUri = string.IsNullOrEmpty(endpoint) ? null : new Uri(endpoint);
+        return hostBuilder.Services.AddChatClient(pipeline =>
+        {
+            builder?.Invoke(pipeline);
+            var token = Environment.GetEnvironmentVariable("GH_TOKEN") ?? throw new InvalidOperationException("No model access token was found in the environment variable GH_TOKEN");
+            return pipeline.Use(new ChatCompletionsClient(
+            endpointUri, new AzureKeyCredential(token)).AsChatClient(modelOrDeploymentName));
+        });
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
index 9f3f44230e82..a976c007715c 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
@@ -2,6 +2,7 @@
 
   
     
+    
   
 
   
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
index f9e1db0de1e2..0c50b6e896ce 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
@@ -17,7 +17,7 @@ public static class SemanticKernelHostingExtensions
 {
     public static IHostApplicationBuilder ConfigureSemanticKernel(this IHostApplicationBuilder builder)
     {
-        builder.Services.Configure(o =>
+        builder.Services.Configure(o =>
         {
             o.EmbeddingsEndpoint = o.ImageEndpoint = o.ChatEndpoint = builder.Configuration["OpenAI:Endpoint"] ?? throw new InvalidOperationException("Ensure that OpenAI:Endpoint is set in configuration");
             o.EmbeddingsApiKey = o.ImageApiKey = o.ChatApiKey = builder.Configuration["OpenAI:Key"]!;
@@ -48,7 +48,7 @@ public static IHostApplicationBuilder ConfigureSemanticKernel(this IHostApplicat
     private static ISemanticTextMemory CreateMemory(IServiceProvider provider)
     {
         var qdrantConfig = provider.GetRequiredService>().Value;
-        var openAiConfig = provider.GetRequiredService>().Value;
+        var openAiConfig = provider.GetRequiredService>().Value;
         var qdrantHttpClient = new HttpClient();
         if (!string.IsNullOrEmpty(qdrantConfig.ApiKey))
         {
@@ -64,7 +64,7 @@ private static ISemanticTextMemory CreateMemory(IServiceProvider provider)
 
     private static Kernel CreateKernel(IServiceProvider provider)
     {
-        OpenAIOptions openAiConfig = provider.GetRequiredService>().Value;
+        AIClientOptions openAiConfig = provider.GetRequiredService>().Value;
         var builder = Kernel.CreateBuilder();
 
         // Chat
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs b/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
index b5faf367d6fa..f6e9326da734 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
@@ -19,6 +19,7 @@ public static async Task StartAsync(bool local = false)
         }
         var app = builder.Build();
         app.MapAgentService();
+        app.MapDefaultEndpoints();
         await app.StartAsync().ConfigureAwait(false);
         return app;
     }
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
index 19560b836e59..b817bc04925b 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
@@ -8,6 +8,17 @@ internal sealed class WorkerGatewayService(WorkerGateway agentWorker) : AgentRpc
 {
     public override async Task OpenChannel(IAsyncStreamReader requestStream, IServerStreamWriter responseStream, ServerCallContext context)
     {
-        await agentWorker.ConnectToWorkerProcess(requestStream, responseStream, context);
+        try
+        {
+            await agentWorker.ConnectToWorkerProcess(requestStream, responseStream, context).ConfigureAwait(true);
+        }
+        catch
+        {
+            if (context.CancellationToken.IsCancellationRequested)
+            {
+                return;
+            }
+            throw;
+        }
     }
 }

From e7729511466619edb6a3e32c131d9b73333a6cf3 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Wed, 23 Oct 2024 17:26:53 -0400
Subject: [PATCH 030/173] Add CSS override for banner (#3933)

* Add css override for banner

* remove merge conflict
---
 .../src/_static/override-switcher-button.js   | 49 +++++++++++--------
 1 file changed, 28 insertions(+), 21 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
index b9c9e6490a7e..3d74310b6d13 100644
--- a/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
+++ b/python/packages/autogen-core/docs/src/_static/override-switcher-button.js
@@ -1,29 +1,36 @@
 // When body is ready
-document.addEventListener('DOMContentLoaded', function() {
-    // TODO: Please find a better way to override the button text in a better way...
-    // Set a timer for 3 seconds to wait for the button to be rendered.
-    setTimeout(async function() {
+document.addEventListener('DOMContentLoaded', async function() {
+
+    const styles = `
+    #bd-header-version-warning {
+        display: none !important;
+    }
+    `;
 
-        // Fetch version list
-        // https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json
-        const response = await fetch('https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json');
-        const data = await response.json();
+    // Fetch version list
+    // https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json
+    const response = await fetch('https://raw.githubusercontent.com/microsoft/autogen/refs/heads/main/docs/switcher.json');
+    const data = await response.json();
 
-        // Find the entry where preferred is true
-        const preferred = data.find(entry => entry.preferred);
-        if (preferred) {
-            // Get current rendered version
-            const currentVersion = DOCUMENTATION_OPTIONS.VERSION;
-            const urlVersionPath = DOCUMENTATION_OPTIONS.theme_switcher_version_match;
-            // The version compare library seems to not like the dev suffix without - so we're going to do an exact match and hide the banner if so
-            // For the "dev" version which is always latest we don't want to consider hiding the banner
-            if ((currentVersion === preferred.version) && (urlVersionPath !== "dev")) {
-                // Hide the banner with id bd-header-version-warning
-                document.getElementById('bd-header-version-warning').style.display = 'none';
-                return;
-            }
+    // Find the entry where preferred is true
+    const preferred = data.find(entry => entry.preferred);
+    if (preferred) {
+        // Get current rendered version
+        const currentVersion = DOCUMENTATION_OPTIONS.VERSION;
+        const urlVersionPath = DOCUMENTATION_OPTIONS.theme_switcher_version_match;
+        // The version compare library seems to not like the dev suffix without - so we're going to do an exact match and hide the banner if so
+        // For the "dev" version which is always latest we don't want to consider hiding the banner
+        if ((currentVersion === preferred.version) && (urlVersionPath !== "dev")) {
+            // Hide the banner with id bd-header-version-warning
+            const styleSheet = document.createElement("style");
+            styleSheet.textContent = styles;
+            document.head.appendChild(styleSheet);
+            return;
         }
+    }
 
+    // TODO: Please find a better way to override the button text...
+    setTimeout(async function() {
         // Get the button with class "pst-button-link-to-stable-version". There is only one.
         var button = document.querySelector('.pst-button-link-to-stable-version');
         if (!button) {

From 8f6dc4e1dd53bc3435ec74cb1fdfbd2dc97e5e37 Mon Sep 17 00:00:00 2001
From: Ryan Sweet 
Date: Wed, 23 Oct 2024 21:57:37 -0700
Subject: [PATCH 031/173] removed unused code (#3940)

---
 dotnet/src/Microsoft.AutoGen/Abstractions/IAgent.cs |  7 -------
 .../src/Microsoft.AutoGen/Abstractions/IAiAgent.cs  | 13 -------------
 2 files changed, 20 deletions(-)
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Abstractions/IAgent.cs
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Abstractions/IAiAgent.cs

diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgent.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgent.cs
deleted file mode 100644
index 834e5678a218..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgent.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace Microsoft.AutoGen.Abstractions;
-
-public interface IAgent
-{
-    Task HandleEvent(CloudEvent item);
-    Task PublishEvent(CloudEvent item);
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAiAgent.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAiAgent.cs
deleted file mode 100644
index 47105eaca169..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IAiAgent.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-
-using Microsoft.SemanticKernel;
-using Microsoft.SemanticKernel.Connectors.OpenAI;
-
-namespace Microsoft.AutoGen.Abstractions;
-
-public interface IAiAgent : IAgent
-{
-    void AddToHistory(string message, ChatUserType userType);
-    string AppendChatHistory(string ask);
-    Task CallFunction(string template, KernelArguments arguments, OpenAIPromptExecutionSettings? settings = null);
-    Task AddKnowledge(string instruction, string index, KernelArguments arguments);
-}

From 1812cc068d823b17c65d55dd8cdeab6a152c115e Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Thu, 24 Oct 2024 05:36:33 -0700
Subject: [PATCH 032/173] Refactor agentchat +implement base chat agent run
 method (#3913)

---
 .../src/autogen_agentchat/agents/__init__.py  |  3 ++
 .../{base => agents}/_base_chat_agent.py      | 25 +++++++---
 .../agents/_code_executor_agent.py            |  2 +-
 .../agents/_coding_assistant_agent.py         |  2 +-
 .../agents/_tool_use_assistant_agent.py       |  2 +-
 .../src/autogen_agentchat/base/__init__.py    | 12 ++---
 .../src/autogen_agentchat/base/_base_team.py  | 10 ----
 .../src/autogen_agentchat/base/_chat_agent.py | 50 +++++++++++++++++++
 .../base/{_base_task.py => _task.py}          | 11 +++-
 .../src/autogen_agentchat/base/_team.py       | 18 +++++++
 .../{_base_termination.py => _termination.py} |  0
 .../src/autogen_agentchat/task/__init__.py    |  7 +++
 .../{teams => task}/_terminations.py          |  0
 .../src/autogen_agentchat/teams/__init__.py   |  4 --
 .../_group_chat/_base_chat_agent_container.py |  4 +-
 .../teams/_group_chat/_base_group_chat.py     | 28 ++++++++---
 .../_group_chat/_round_robin_group_chat.py    |  4 +-
 .../teams/_group_chat/_selector_group_chat.py |  4 +-
 .../tests/test_group_chat.py                  |  4 +-
 .../tests/test_termination_condition.py       |  2 +-
 .../tests/test_tool_use_assistant_agent.py    | 27 +++-------
 .../examples/company-research.ipynb           |  3 +-
 .../examples/literature-review.ipynb          |  3 +-
 .../examples/travel-planning.ipynb            |  3 +-
 .../agentchat-user-guide/quickstart.ipynb     |  5 +-
 .../tutorial/agents.ipynb                     |  7 ++-
 .../tutorial/introduction.ipynb               |  4 +-
 .../tutorial/selector-group-chat.ipynb        |  7 +--
 .../agentchat-user-guide/tutorial/teams.ipynb |  5 +-
 .../tutorial/termination.ipynb                |  5 +-
 30 files changed, 176 insertions(+), 85 deletions(-)
 rename python/packages/autogen-agentchat/src/autogen_agentchat/{base => agents}/_base_chat_agent.py (71%)
 delete mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
 rename python/packages/autogen-agentchat/src/autogen_agentchat/base/{_base_task.py => _task.py} (53%)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
 rename python/packages/autogen-agentchat/src/autogen_agentchat/base/{_base_termination.py => _termination.py} (100%)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
 rename python/packages/autogen-agentchat/src/autogen_agentchat/{teams => task}/_terminations.py (100%)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index e5f1bd8b691b..1c3078d01cf8 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -1,8 +1,11 @@
+from ._base_chat_agent import BaseChatAgent, BaseToolUseChatAgent
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
 from ._tool_use_assistant_agent import ToolUseAssistantAgent
 
 __all__ = [
+    "BaseChatAgent",
+    "BaseToolUseChatAgent",
     "CodeExecutorAgent",
     "CodingAssistantAgent",
     "ToolUseAssistantAgent",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
similarity index 71%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index 184e9061a35e..62bac59d5b08 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -4,12 +4,13 @@
 from autogen_core.base import CancellationToken
 from autogen_core.components.tools import Tool
 
+from ..base import ChatAgent, TaskResult, TerminationCondition, ToolUseChatAgent
 from ..messages import ChatMessage
-from ._base_task import TaskResult, TaskRunner
+from ..teams import RoundRobinGroupChat
 
 
-class BaseChatAgent(TaskRunner, ABC):
-    """Base class for a chat agent that can participant in a team."""
+class BaseChatAgent(ChatAgent, ABC):
+    """Base class for a chat agent."""
 
     def __init__(self, name: str, description: str) -> None:
         self._name = name
@@ -36,13 +37,23 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         ...
 
     async def run(
-        self, task: str, *, source: str = "user", cancellation_token: CancellationToken | None = None
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
-        # TODO: Implement this method.
-        raise NotImplementedError
+        """Run the agent with the given task and return the result."""
+        group_chat = RoundRobinGroupChat(participants=[self])
+        result = await group_chat.run(
+            task=task,
+            cancellation_token=cancellation_token,
+            termination_condition=termination_condition,
+        )
+        return result
 
 
-class BaseToolUseChatAgent(BaseChatAgent):
+class BaseToolUseChatAgent(BaseChatAgent, ToolUseChatAgent):
     """Base class for a chat agent that can use tools.
 
     Subclass this base class to create an agent class that uses tools by returning
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
index c38facbe5010..07cb45c4d84f 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
@@ -3,8 +3,8 @@
 from autogen_core.base import CancellationToken
 from autogen_core.components.code_executor import CodeBlock, CodeExecutor, extract_markdown_code_blocks
 
-from ..base import BaseChatAgent
 from ..messages import ChatMessage, TextMessage
+from ._base_chat_agent import BaseChatAgent
 
 
 class CodeExecutorAgent(BaseChatAgent):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
index b93621519764..070e2d491589 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
@@ -9,8 +9,8 @@
     UserMessage,
 )
 
-from ..base import BaseChatAgent
 from ..messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
+from ._base_chat_agent import BaseChatAgent
 
 
 class CodingAssistantAgent(BaseChatAgent):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
index d9cc57b040fc..37022acd0bd9 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
@@ -12,7 +12,6 @@
 )
 from autogen_core.components.tools import FunctionTool, Tool
 
-from ..base import BaseToolUseChatAgent
 from ..messages import (
     ChatMessage,
     MultiModalMessage,
@@ -21,6 +20,7 @@
     ToolCallMessage,
     ToolCallResultMessage,
 )
+from ._base_chat_agent import BaseToolUseChatAgent
 
 
 class ToolUseAssistantAgent(BaseToolUseChatAgent):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
index 3b942afbdbae..36845eb82182 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
@@ -1,11 +1,11 @@
-from ._base_chat_agent import BaseChatAgent, BaseToolUseChatAgent
-from ._base_task import TaskResult, TaskRunner
-from ._base_team import Team
-from ._base_termination import TerminatedException, TerminationCondition
+from ._chat_agent import ChatAgent, ToolUseChatAgent
+from ._task import TaskResult, TaskRunner
+from ._team import Team
+from ._termination import TerminatedException, TerminationCondition
 
 __all__ = [
-    "BaseChatAgent",
-    "BaseToolUseChatAgent",
+    "ChatAgent",
+    "ToolUseChatAgent",
     "Team",
     "TerminatedException",
     "TerminationCondition",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
deleted file mode 100644
index 5c3677fdc1ef..000000000000
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_team.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from typing import Protocol
-
-from ._base_task import TaskResult, TaskRunner
-from ._base_termination import TerminationCondition
-
-
-class Team(TaskRunner, Protocol):
-    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TaskResult:
-        """Run the team on a given task until the termination condition is met."""
-        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
new file mode 100644
index 000000000000..6200050d43d7
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -0,0 +1,50 @@
+from typing import List, Protocol, Sequence, runtime_checkable
+
+from autogen_core.base import CancellationToken
+from autogen_core.components.tools import Tool
+
+from ..messages import ChatMessage
+from ._task import TaskResult, TaskRunner
+from ._termination import TerminationCondition
+
+
+@runtime_checkable
+class ChatAgent(TaskRunner, Protocol):
+    """Protocol for a chat agent."""
+
+    @property
+    def name(self) -> str:
+        """The name of the agent. This is used by team to uniquely identify
+        the agent. It should be unique within the team."""
+        ...
+
+    @property
+    def description(self) -> str:
+        """The description of the agent. This is used by team to
+        make decisions about which agents to use. The description should
+        describe the agent's capabilities and how to interact with it."""
+        ...
+
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+        """Handle incoming messages and return a response message."""
+        ...
+
+    async def run(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
+    ) -> TaskResult:
+        """Run the agent with the given task and return the result."""
+        ...
+
+
+@runtime_checkable
+class ToolUseChatAgent(ChatAgent, Protocol):
+    """Protocol for a chat agent that can use tools."""
+
+    @property
+    def registered_tools(self) -> List[Tool]:
+        """The list of tools that the agent can use."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
similarity index 53%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 103721557796..1d9a768b90bb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -1,7 +1,10 @@
 from dataclasses import dataclass
 from typing import Protocol, Sequence
 
+from autogen_core.base import CancellationToken
+
 from ..messages import ChatMessage
+from ._termination import TerminationCondition
 
 
 @dataclass
@@ -15,6 +18,12 @@ class TaskResult:
 class TaskRunner(Protocol):
     """A task runner."""
 
-    async def run(self, task: str) -> TaskResult:
+    async def run(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
+    ) -> TaskResult:
         """Run the task."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
new file mode 100644
index 000000000000..b0a1dc3d2a38
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
@@ -0,0 +1,18 @@
+from typing import Protocol
+
+from autogen_core.base import CancellationToken
+
+from ._task import TaskResult, TaskRunner
+from ._termination import TerminationCondition
+
+
+class Team(TaskRunner, Protocol):
+    async def run(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
+    ) -> TaskResult:
+        """Run the team on a given task until the termination condition is met."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_termination.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
similarity index 100%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/base/_base_termination.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
new file mode 100644
index 000000000000..757edc043f38
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
@@ -0,0 +1,7 @@
+from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination
+
+__all__ = [
+    "MaxMessageTermination",
+    "TextMentionTermination",
+    "StopMessageTermination",
+]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
similarity index 100%
rename from python/packages/autogen-agentchat/src/autogen_agentchat/teams/_terminations.py
rename to python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
index e305a9e5c995..836f1501242b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
@@ -1,11 +1,7 @@
 from ._group_chat._round_robin_group_chat import RoundRobinGroupChat
 from ._group_chat._selector_group_chat import SelectorGroupChat
-from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination
 
 __all__ = [
-    "MaxMessageTermination",
-    "TextMentionTermination",
-    "StopMessageTermination",
     "RoundRobinGroupChat",
     "SelectorGroupChat",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
index 275e505d6d3a..4f3e902afbe0 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
@@ -8,7 +8,7 @@
 from autogen_core.components.tool_agent import ToolException
 
 from ... import EVENT_LOGGER_NAME
-from ...base import BaseChatAgent
+from ...base import ChatAgent
 from ...messages import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
 from .._events import ContentPublishEvent, ContentRequestEvent, ToolCallEvent, ToolCallResultEvent
 from ._sequential_routed_agent import SequentialRoutedAgent
@@ -27,7 +27,7 @@ class BaseChatAgentContainer(SequentialRoutedAgent):
         tool_agent_type (AgentType, optional): The agent type of the tool agent. Defaults to None.
     """
 
-    def __init__(self, parent_topic_type: str, agent: BaseChatAgent, tool_agent_type: AgentType | None = None) -> None:
+    def __init__(self, parent_topic_type: str, agent: ChatAgent, tool_agent_type: AgentType | None = None) -> None:
         super().__init__(description=agent.description)
         self._parent_topic_type = parent_topic_type
         self._agent = agent
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 08f44a1af665..c599d269b0e7 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -3,12 +3,20 @@
 from typing import Callable, List
 
 from autogen_core.application import SingleThreadedAgentRuntime
-from autogen_core.base import AgentId, AgentInstantiationContext, AgentRuntime, AgentType, MessageContext, TopicId
+from autogen_core.base import (
+    AgentId,
+    AgentInstantiationContext,
+    AgentRuntime,
+    AgentType,
+    CancellationToken,
+    MessageContext,
+    TopicId,
+)
 from autogen_core.components import ClosureAgent, TypeSubscription
 from autogen_core.components.tool_agent import ToolAgent
 from autogen_core.components.tools import Tool
 
-from ...base import BaseChatAgent, BaseToolUseChatAgent, TaskResult, Team, TerminationCondition
+from ...base import ChatAgent, TaskResult, Team, TerminationCondition, ToolUseChatAgent
 from ...messages import ChatMessage, TextMessage
 from .._events import ContentPublishEvent, ContentRequestEvent
 from ._base_chat_agent_container import BaseChatAgentContainer
@@ -22,13 +30,13 @@ class BaseGroupChat(Team, ABC):
     create a subclass of :class:`BaseGroupChat` that uses the group chat manager.
     """
 
-    def __init__(self, participants: List[BaseChatAgent], group_chat_manager_class: type[BaseGroupChatManager]):
+    def __init__(self, participants: List[ChatAgent], group_chat_manager_class: type[BaseGroupChatManager]):
         if len(participants) == 0:
             raise ValueError("At least one participant is required.")
         if len(participants) != len(set(participant.name for participant in participants)):
             raise ValueError("The participant names must be unique.")
         for participant in participants:
-            if isinstance(participant, BaseToolUseChatAgent) and not participant.registered_tools:
+            if isinstance(participant, ToolUseChatAgent) and not participant.registered_tools:
                 raise ValueError(
                     f"Participant '{participant.name}' is a tool use agent so it must have registered tools."
                 )
@@ -47,7 +55,7 @@ def _create_group_chat_manager_factory(
     ) -> Callable[[], BaseGroupChatManager]: ...
 
     def _create_participant_factory(
-        self, parent_topic_type: str, agent: BaseChatAgent, tool_agent_type: AgentType | None
+        self, parent_topic_type: str, agent: ChatAgent, tool_agent_type: AgentType | None
     ) -> Callable[[], BaseChatAgentContainer]:
         def _factory() -> BaseChatAgentContainer:
             id = AgentInstantiationContext.current_agent_id()
@@ -68,7 +76,13 @@ def _factory() -> ToolAgent:
 
         return _factory
 
-    async def run(self, task: str, *, termination_condition: TerminationCondition | None = None) -> TaskResult:
+    async def run(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
+    ) -> TaskResult:
         """Run the team and return the result."""
         # Create intervention handler for termination.
 
@@ -85,7 +99,7 @@ async def run(self, task: str, *, termination_condition: TerminationCondition |
         participant_topic_types: List[str] = []
         participant_descriptions: List[str] = []
         for participant in self._participants:
-            if isinstance(participant, BaseToolUseChatAgent):
+            if isinstance(participant, ToolUseChatAgent):
                 assert participant.registered_tools is not None and len(participant.registered_tools) > 0
                 # Register the tool agent.
                 tool_agent_type = await ToolAgent.register(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index daab986027ed..529314fece51 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -1,6 +1,6 @@
 from typing import Callable, List
 
-from ...base import BaseChatAgent, TerminationCondition
+from ...base import ChatAgent, TerminationCondition
 from .._events import ContentPublishEvent
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
@@ -73,7 +73,7 @@ class RoundRobinGroupChat(BaseGroupChat):
 
     """
 
-    def __init__(self, participants: List[BaseChatAgent]):
+    def __init__(self, participants: List[ChatAgent]):
         super().__init__(participants, group_chat_manager_class=RoundRobinGroupChatManager)
 
     def _create_group_chat_manager_factory(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index f000cbd69dc2..1eaf0ddd5609 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -5,7 +5,7 @@
 from autogen_core.components.models import ChatCompletionClient, SystemMessage
 
 from ... import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
-from ...base import BaseChatAgent, TerminationCondition
+from ...base import ChatAgent, TerminationCondition
 from ...messages import MultiModalMessage, StopMessage, TextMessage
 from .._events import ContentPublishEvent, SelectSpeakerEvent
 from ._base_group_chat import BaseGroupChat
@@ -178,7 +178,7 @@ class SelectorGroupChat(BaseGroupChat):
 
     def __init__(
         self,
-        participants: List[BaseChatAgent],
+        participants: List[ChatAgent],
         model_client: ChatCompletionClient,
         *,
         selector_prompt: str = """You are in a role play game. The following roles are available:
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 54e759663389..97cf65c2d88e 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -7,17 +7,17 @@
 import pytest
 from autogen_agentchat import EVENT_LOGGER_NAME
 from autogen_agentchat.agents import (
+    BaseChatAgent,
     CodeExecutorAgent,
     CodingAssistantAgent,
     ToolUseAssistantAgent,
 )
-from autogen_agentchat.base import BaseChatAgent
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage
+from autogen_agentchat.task import StopMessageTermination
 from autogen_agentchat.teams import (
     RoundRobinGroupChat,
     SelectorGroupChat,
-    StopMessageTermination,
 )
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
diff --git a/python/packages/autogen-agentchat/tests/test_termination_condition.py b/python/packages/autogen-agentchat/tests/test_termination_condition.py
index c3f575d34adb..7d504dce3a03 100644
--- a/python/packages/autogen-agentchat/tests/test_termination_condition.py
+++ b/python/packages/autogen-agentchat/tests/test_termination_condition.py
@@ -1,6 +1,6 @@
 import pytest
 from autogen_agentchat.messages import StopMessage, TextMessage
-from autogen_agentchat.teams import MaxMessageTermination, StopMessageTermination, TextMentionTermination
+from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination, TextMentionTermination
 
 
 @pytest.mark.asyncio
diff --git a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
index 6243152272dd..3a1734b3f71a 100644
--- a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
@@ -4,13 +4,7 @@
 
 import pytest
 from autogen_agentchat.agents import ToolUseAssistantAgent
-from autogen_agentchat.messages import (
-    TextMessage,
-    ToolCallMessage,
-    ToolCallResultMessage,
-)
-from autogen_core.base import CancellationToken
-from autogen_core.components.models import FunctionExecutionResult, OpenAIChatCompletionClient
+from autogen_core.components.models import OpenAIChatCompletionClient
 from autogen_core.components.tools import FunctionTool
 from openai.resources.chat.completions import AsyncCompletions
 from openai.types.chat.chat_completion import ChatCompletion, Choice
@@ -63,8 +57,8 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
                                 id="1",
                                 type="function",
                                 function=Function(
-                                    name="pass",
-                                    arguments=json.dumps({"input": "pass"}),
+                                    name="_pass_function",
+                                    arguments=json.dumps({"input": "task"}),
                                 ),
                             )
                         ],
@@ -107,14 +101,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
         registered_tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
     )
-    response = await tool_use_agent.on_messages(
-        messages=[TextMessage(content="Test", source="user")], cancellation_token=CancellationToken()
-    )
-    assert isinstance(response, ToolCallMessage)
-    tool_call_results = [FunctionExecutionResult(content="", call_id=call.id) for call in response.content]
-
-    response = await tool_use_agent.on_messages(
-        messages=[ToolCallResultMessage(content=tool_call_results, source="test")],
-        cancellation_token=CancellationToken(),
-    )
-    assert isinstance(response, TextMessage)
+    result = await tool_use_agent.run("task")
+    assert len(result.messages) == 3
+    # assert isinstance(result.messages[1], ToolCallMessage)
+    # assert isinstance(result.messages[2], TextMessage)
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
index a627f877ce41..15a641b7e973 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
@@ -23,7 +23,8 @@
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
-    "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
+    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
index 8857d9d32145..a8b933585995 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
@@ -23,7 +23,8 @@
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
-    "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
+    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
index 2683eb8a40ed..e42c569b4081 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
@@ -18,7 +18,8 @@
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent\n",
-    "from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination\n",
+    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
   },
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 47ed61976d41..be69005d7a05 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -58,7 +58,8 @@
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
     "from autogen_agentchat.agents import ToolUseAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
-    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat\n",
+    "from autogen_agentchat.task import MaxMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
@@ -126,7 +127,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index 55fc8c203cab..f905d7618678 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -45,10 +45,9 @@
     "import logging\n",
     "\n",
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
-    "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
+    "from autogen_agentchat.agents import ToolUseAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
     "from autogen_agentchat.messages import TextMessage\n",
-    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, SelectorGroupChat\n",
     "from autogen_core.base import CancellationToken\n",
     "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "from autogen_core.components.tools import FunctionTool\n",
@@ -251,7 +250,7 @@
     "import asyncio\n",
     "from typing import Sequence\n",
     "\n",
-    "from autogen_agentchat.base import BaseChatAgent\n",
+    "from autogen_agentchat.agents import BaseChatAgent\n",
     "from autogen_agentchat.messages import (\n",
     "    ChatMessage,\n",
     "    StopMessage,\n",
@@ -313,7 +312,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
index d75ffc4b2169..d4b57c79fe0f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/introduction.ipynb
@@ -98,7 +98,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -112,7 +112,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index 399fb5a4de2a..e85715d2baea 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -41,12 +41,13 @@
     "from typing import Sequence\n",
     "\n",
     "from autogen_agentchat.agents import (\n",
+    "    BaseChatAgent,\n",
     "    CodingAssistantAgent,\n",
     "    ToolUseAssistantAgent,\n",
     ")\n",
-    "from autogen_agentchat.base import BaseChatAgent\n",
     "from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage\n",
-    "from autogen_agentchat.teams import SelectorGroupChat, StopMessageTermination\n",
+    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.teams import SelectorGroupChat\n",
     "from autogen_core.base import CancellationToken\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
@@ -268,7 +269,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
index d957a90c52f2..acc3d239b390 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -28,7 +28,8 @@
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
-    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, SelectorGroupChat\n",
+    "from autogen_agentchat.task import MaxMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat\n",
     "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "\n",
@@ -208,7 +209,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
index 444e56b2b695..ef09378635f9 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -37,7 +37,8 @@
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
     "from autogen_agentchat.agents import CodingAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
-    "from autogen_agentchat.teams import MaxMessageTermination, RoundRobinGroupChat, StopMessageTermination\n",
+    "from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination\n",
+    "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "\n",
     "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
@@ -198,7 +199,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,

From 388e4d957cd968be9ba2161bad4421a946cbdcd2 Mon Sep 17 00:00:00 2001
From: Jack Gerrits 
Date: Thu, 24 Oct 2024 17:37:12 -0400
Subject: [PATCH 033/173] Update issue templates for types (#3945)

* Update issue templates for types

* Update feature_request.yml
---
 .github/ISSUE_TEMPLATE/bug_report.yml      | 2 +-
 .github/ISSUE_TEMPLATE/feature_request.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 090fa6cc5939..967fd7049534 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,6 +1,6 @@
 name: Bug Report
 description: Report a bug
-labels: ["bug"]
+type: "bug"
 
 body:
   - type: textarea
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
index 4b7bd8f4824e..1b1de6faf85e 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,6 +1,6 @@
 name: Feature Request
 description: Request a new feature or enhancement
-labels: ["feature"]
+type: "feature"
 
 body:
   - type: textarea

From 0756ebd63d471bee39cfcfc7dabd004c284a172c Mon Sep 17 00:00:00 2001
From: Victor Dibia 
Date: Fri, 25 Oct 2024 09:51:43 -0700
Subject: [PATCH 034/173] Update Magentic-one readme with images (#3958)

---
 .../imgs/autogen-magentic-one-agents.png      |  3 +
 .../imgs/autogen-magentic-one-arch.png        |  4 +-
 .../imgs/autogen-magentic-one-example.png     |  3 +
 .../imgs/autogen-magentic-one-landing.png     |  3 -
 .../packages/autogen-magentic-one/readme.md   | 79 +++++++++----------
 5 files changed, 46 insertions(+), 46 deletions(-)
 create mode 100644 python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
 create mode 100644 python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
 delete mode 100644 python/packages/autogen-magentic-one/imgs/autogen-magentic-one-landing.png

diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
new file mode 100644
index 000000000000..b8d44327ee80
--- /dev/null
+++ b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e89c451d86c7e693127707e696443b77ddad2d9c596936f5fc2f6225cf4b431d
+size 97407
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
index afcdb7ce8442..4d061bdfde41 100644
--- a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
+++ b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e6692d60a5ceaf08e087dd6af792bfb155001822f20a42166ec2c04ccc015fc3
-size 523566
+oid sha256:a3aa615fa321b54e09efcd9dbb2e4d25a392232fd4e065f85b5a58ed58a7768c
+size 298340
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
new file mode 100644
index 000000000000..633729e794c1
--- /dev/null
+++ b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6d0c57dc734747319fd4f847748fd2400cfb73ea01e87ac85dc8c28c738d21f
+size 206468
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-landing.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-landing.png
deleted file mode 100644
index abc191a0ee17..000000000000
--- a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-landing.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ddd290ad79e9c000150f1428a9ed0be726ca4d9da403819e3310a976bfe5edd7
-size 256266
diff --git a/python/packages/autogen-magentic-one/readme.md b/python/packages/autogen-magentic-one/readme.md
index 3a092cd4fb7d..1f14ffec15a7 100644
--- a/python/packages/autogen-magentic-one/readme.md
+++ b/python/packages/autogen-magentic-one/readme.md
@@ -1,17 +1,18 @@
 # Magentic-One
-Magentic-One is a generalist multi-agent softbot that utilizes a combination of five agents, including LLM and tool-based agents, to tackle intricate tasks. For example, it can be used to solve general tasks that involve multi-step planning and action in the real-world.
 
-> *Example*: Suppose a user requests to conduct a survey of AI safety papers published in the last month and create a concise presentation on the findings. Magentic-One will use the following process to handle this task. The orchestrator agent will break down the task into subtasks and assign them to the appropriate agents. Such as the web surfer agent to search for AI safety papers, the file surfer agent to extract information from the papers, the coder agent to create the presentation, and the computer terminal agent to execute the code. The orchestrator agent will coordinate the agents, monitor progress, and ensure the task is completed successfully.
+Magentic-One is a generalist multi-agent softbot that utilizes a combination of five agents, including LLM and tool-based agents, to tackle intricate tasks. For example, it can be used to solve general tasks that involve multi-step planning and action in the real-world.
 
+![](./imgs/autogen-magentic-one-example.png)
 
+> _Example_: Suppose a user requests the following: _Can you rewrite the readme of the autogen GitHub repository to be more clear_. Magentic-One will use the following process to handle this task. The Orchestrator agent will break down the task into subtasks and assign them to the appropriate agents. In this case, the WebSurfer will navigate to GiHub, search for the autogen repository, and extract the readme file. Next the Coder agent will rewrite the readme file for clarity and return the updated content to the Orchestrator. At each point, the Orchestrator will monitor progress via a ledger, and terminate when the task is completed successfully.
 
 ## Architecture
 
-

-drawing
-

-
+
 
+![](./imgs/autogen-magentic-one-agents.png)
 
 Magentic-One uses agents with the following personas and capabilities:
 
@@ -27,10 +28,10 @@ Magentic-One uses agents with the following personas and capabilities:
 
 We created Magentic-One with one agent of each type because their combined abilities help tackle tough benchmarks. By splitting tasks among different agents, we keep the code simple and modular, like in object-oriented programming. This also makes each agent's job easier since they only need to focus on specific tasks. For example, the websurfer agent only needs to navigate webpages and doesn't worry about writing code, making the team more efficient and effective.
 
-
 ### Planning and Tracking Task Progress
+
 

-drawing
+drawing
 

 
 The figure illustrates the workflow of an orchestrator managing a multi-agent setup, starting with an initial prompt or task. The orchestrator creates or updates a ledger with gathered information, including verified facts, facts to look up, derived facts, and educated guesses. Using this ledger, a plan is derived, which consists of a sequence of steps and task assignments for the agents. Before execution, the orchestrator clears the agents' contexts to ensure they start fresh. The orchestrator then evaluates if the request is fully satisfied. If so, it reports the final answer or an educated guess.
@@ -39,21 +40,19 @@ If the request is not fully satisfied, the orchestrator assesses whether the wor
 
 Note that many parameters such as terminal logic and maximum number of stalled iterations are configurable. Also note that the orchestrator cannot instantiate new agents. This is possible but not implemented in Magentic-One.
 
-
 ## Table of Definitions:
 
-| Term          | Definition                                      |
-|---------------|-------------------------------------------------|
-| Agent         | A component that can (autonomously) act based on observations. Different agents may have different functions and actions. |
-| Planning      | The process of determining actions to achieve goals, performed by the Orchestrator agent in Magentic-One. |
-| Ledger        | A record-keeping component used by the Orchestrator agent to track the progress and manage subgoals in Magentic-One. |
-| Stateful Tools | Tools that maintain state or data, such as the web browser and markdown-based file browser used by Magentic-One. |
-| Tools         | Resources used by Magentic-One for various purposes, including stateful and stateless tools. |
-| Stateless Tools | Tools that do not maintain state or data, like the commandline executor used by Magentic-One. |
-
-
+| Term            | Definition                                                                                                                |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Agent           | A component that can (autonomously) act based on observations. Different agents may have different functions and actions. |
+| Planning        | The process of determining actions to achieve goals, performed by the Orchestrator agent in Magentic-One.                 |
+| Ledger          | A record-keeping component used by the Orchestrator agent to track the progress and manage subgoals in Magentic-One.      |
+| Stateful Tools  | Tools that maintain state or data, such as the web browser and markdown-based file browser used by Magentic-One.          |
+| Tools           | Resources used by Magentic-One for various purposes, including stateful and stateless tools.                              |
+| Stateless Tools | Tools that do not maintain state or data, like the commandline executor used by Magentic-One.                             |
 
 ## Capabilities and Performance
+
 ### Capabilities
 
 - Planning: The Orchestrator agent in Magentic-One excels at performing planning tasks. Planning involves determining actions to achieve goals. The Orchestrator agent breaks down complex tasks into smaller subtasks and assigns them to the appropriate agents.
@@ -76,7 +75,6 @@ Note that many parameters such as terminal logic and maximum number of stalled i
 
 - Web Interaction: The Web Surfer agent in Magentic-One is proficient in web-related tasks. It can browse the internet, retrieve information from websites, and interact with web-based applications. This capability allows Magentic-One to handle interactive web pages, forms, and other web elements.
 
-
 ### What Magentic-One Cannot Do
 
 - **Video Scrubbing:** The agents are unable to navigate and process video content.
@@ -87,37 +85,38 @@ Note that many parameters such as terminal logic and maximum number of stalled i
 - **Limited LLM Capacity:** The agents' abilities are constrained by the limitations of the underlying language model.
 - **Web Surfer Limitations:** The web surfer agent may struggle with certain types of web pages, such as those requiring complex interactions or extensive JavaScript handling.
 
-
 ### Safety and Risks
 
 **Code Execution:**
+
 - **Risks:** Code execution carries inherent risks as it happens in the environment where the agents run using the command line executor. This means that the agents can execute arbitrary Python code.
 - **Mitigation:** Users are advised to run the system in isolated environments, such as Docker containers, to mitigate the risks associated with executing arbitrary code.
 
 **Web Browsing:**
+
 - **Capabilities:** The web surfer agent can operate on most websites, including performing tasks like booking flights.
 - **Risks:** Since the requests are sent online using GPT-4-based models, there are potential privacy and security concerns. It is crucial not to provide sensitive information such as keys or credit card data to the agents.
 
 **Safeguards:**
+
 - **Guardrails from LLM:** The agents inherit the guardrails from the underlying language model (e.g., GPT-4). This means they will refuse to generate toxic or stereotyping content, providing a layer of protection against generating harmful outputs.
 - **Limitations:** The agents' behavior is directly influenced by the capabilities and limitations of the underlying LLM. Consequently, any lack of guardrails in the language model will also affect the behavior of the agents.
 
 **General Recommendations:**
+
 - Always use isolated or controlled environments for running the agents to prevent unauthorized or harmful code execution.
 - Avoid sharing sensitive information with the agents to protect your privacy and security.
 - Regularly update and review the underlying LLM and system configurations to ensure they adhere to the latest safety and security standards.
 
-
 ### Performance
-Magentic-One currently achieves the following performance on complex agent benchmarks.
 
+Magentic-One currently achieves the following performance on complex agent benchmarks.
 
 #### GAIA
 
+GAIA is a benchmark from Meta that contains complex tasks that require multi-step reasoning and tool use. For example,
 
- GAIA is a benchmark from Meta that contains complex tasks that require multi-step reasoning and tool use. For example,
-
-> *Example*: If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.
+> _Example_: If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.
 
 In order to solve this task, the orchestrator begins by outlining the steps needed to solve the task of calculating how many thousand hours it would take Eliud Kipchoge to run the distance between the Earth and the Moon at its closest approach. The orchestrator instructs the web surfer agent to gather Eliud Kipchoge's marathon world record time (2:01:39) and the minimum perigee distance of the Moon from Wikipedia (356,400 kilometers).
 
@@ -125,14 +124,14 @@ Next, the orchestrator assigns the assistant agent to use this data to perform t
 
 Here is the performance of Magentic-One on a GAIA development set.
 
-| Level   | Task Completion Rate* |
-|---------|-----------------------|
-| Level 1 | 55% (29/53)           |
-| Level 2 | 34% (29/86)           |
-| Level 3 | 12% (3/26)            |
-| Total   | 37% (61/165)          |
+| Level   | Task Completion Rate\* |
+| ------- | ---------------------- |
+| Level 1 | 55% (29/53)            |
+| Level 2 | 34% (29/86)            |
+| Level 3 | 12% (3/26)             |
+| Total   | 37% (61/165)           |
 
-*Indicates the percentage of tasks completed successfully on the *validation* set.
+*Indicates the percentage of tasks completed successfully on the *validation\* set.
 
 #### WebArena
 
@@ -140,10 +139,10 @@ Here is the performance of Magentic-One on a GAIA development set.
 
 To solve this task, the agents began by logging into the Postmill platform using provided credentials and navigating to the Showerthoughts forum. They identified the latest post in this forum, which was made by a user named Waoonet. To proceed with the task, they then accessed Waoonet's profile to examine the comments section, where they could find all comments made by this user.
 
-Once on Waoonet's profile, the agents focused on counting the comments that had received more downvotes than upvotes. The web\_surfer agent analyzed the available comments and found that Waoonet had made two comments, both of which had more upvotes than downvotes. Consequently, they concluded that none of Waoonet's comments had received more downvotes than upvotes. This information was summarized and reported back, completing the task successfully.
+Once on Waoonet's profile, the agents focused on counting the comments that had received more downvotes than upvotes. The web_surfer agent analyzed the available comments and found that Waoonet had made two comments, both of which had more upvotes than downvotes. Consequently, they concluded that none of Waoonet's comments had received more downvotes than upvotes. This information was summarized and reported back, completing the task successfully.
 
 | Site           | Task Completion Rate |
-|----------------|----------------------|
+| -------------- | -------------------- |
 | Reddit         | 54%  (57/106)        |
 | Shopping       | 33%  (62/187)        |
 | CMS            | 29%  (53/182)        |
@@ -152,7 +151,6 @@ Once on Waoonet's profile, the agents focused on counting the comments that had
 | Multiple Sites | 15%  (7/48)          |
 | Total          | 33%  (267/812)       |
 
-
 ### Logging in Team One Agents
 
 Team One agents can emit several log events that can be consumed by a log handler (see the example log handler in [utils.py](src/autogen_magentic_one/utils.py)). A list of currently emitted events are:
@@ -160,12 +158,10 @@ Team One agents can emit several log events that can be consumed by a log handle
 - OrchestrationEvent : emitted by a an [Orchestrator](src/autogen_magentic_one/agents/base_orchestrator.py) agent.
 - WebSurferEvent : emitted by a [WebSurfer](src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py) agent.
 
-In addition, developers can also handle and process logs generated from the AutoGen core library (e.g., LLMCallEvent etc). See  the example log handler in [utils.py](src/autogen_magentic_one/utils.py) on how this can be implemented. By default, the logs are written to a file named `log.jsonl` which can be configured as a parameter to the defined log handler. These logs can be parsed to retrieved data agent actions.
-
+In addition, developers can also handle and process logs generated from the AutoGen core library (e.g., LLMCallEvent etc). See the example log handler in [utils.py](src/autogen_magentic_one/utils.py) on how this can be implemented. By default, the logs are written to a file named `log.jsonl` which can be configured as a parameter to the defined log handler. These logs can be parsed to retrieved data agent actions.
 
 # Setup
 
-
 You can install the Magentic-One package using pip and then run the example code to see how the agents work together to accomplish a task.
 
 1. Clone the code.
@@ -185,7 +181,6 @@ pip install -e .
 python examples/example.py
 ```
 
-
 ## Environment Configuration for Chat Completion Client
 
 This guide outlines how to configure your environment to use the `create_completion_client_from_env` function, which reads environment variables to return an appropriate `ChatCompletionClient`.
@@ -226,8 +221,10 @@ To configure for OpenAI, set the following environment variables:
 ```
 
 ### Other Keys
+
 Some functionalities, such as using web-search requires an API key for Bing.
 You can set it using:
+
 ```bash
 export BING_API_KEY=xxxxxxx
-```
\ No newline at end of file
+```

From f31ff663685a37f7960c4911b1837d36f1f32a13 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 25 Oct 2024 10:57:04 -0700
Subject: [PATCH 035/173] Refactor agent chat to prepare for handoff/swarm
 (#3949)

Add handoff message type to chat message types
Add Swarm group chat that uses handoff message to select next speaker
Remove tool call and tool call result message types from chat message types
Remove BaseToolUseChatAgent, move tool call handling from group chat's chat agent container upward to the ToolUseAssistantAgent implementation, which subclasses BaseChatAgent directly.
Renaming for better clarity

---------

Co-authored-by: Victor Dibia 
---
 .../src/autogen_agentchat/agents/__init__.py  |  3 +-
 .../agents/_base_chat_agent.py                | 23 +----
 .../agents/_tool_use_assistant_agent.py       | 92 ++++++++++++++-----
 .../src/autogen_agentchat/base/__init__.py    |  3 +-
 .../src/autogen_agentchat/base/_chat_agent.py | 13 +--
 .../logging/_console_log_handler.py           | 19 ++--
 .../logging/_file_log_handler.py              | 29 ++++--
 .../src/autogen_agentchat/messages.py         | 29 ++----
 .../src/autogen_agentchat/teams/__init__.py   |  2 +
 .../src/autogen_agentchat/teams/_events.py    | 40 ++------
 .../_group_chat/_base_chat_agent_container.py | 92 -------------------
 .../teams/_group_chat/_base_group_chat.py     | 59 ++++--------
 .../_group_chat/_base_group_chat_manager.py   | 53 +++++++----
 .../_group_chat/_chat_agent_container.py      | 48 ++++++++++
 .../_group_chat/_round_robin_group_chat.py    | 15 ++-
 .../teams/_group_chat/_selector_group_chat.py | 11 ++-
 .../teams/_group_chat/_swarm_group_chat.py    | 72 +++++++++++++++
 .../tests/test_group_chat.py                  | 47 +++++++++-
 .../tests/test_tool_use_assistant_agent.py    |  6 +-
 19 files changed, 363 insertions(+), 293 deletions(-)
 delete mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index 1c3078d01cf8..19cdec548f73 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -1,11 +1,10 @@
-from ._base_chat_agent import BaseChatAgent, BaseToolUseChatAgent
+from ._base_chat_agent import BaseChatAgent
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
 from ._tool_use_assistant_agent import ToolUseAssistantAgent
 
 __all__ = [
     "BaseChatAgent",
-    "BaseToolUseChatAgent",
     "CodeExecutorAgent",
     "CodingAssistantAgent",
     "ToolUseAssistantAgent",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index 62bac59d5b08..77bf4c02c470 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -1,10 +1,9 @@
 from abc import ABC, abstractmethod
-from typing import List, Sequence
+from typing import Sequence
 
 from autogen_core.base import CancellationToken
-from autogen_core.components.tools import Tool
 
-from ..base import ChatAgent, TaskResult, TerminationCondition, ToolUseChatAgent
+from ..base import ChatAgent, TaskResult, TerminationCondition
 from ..messages import ChatMessage
 from ..teams import RoundRobinGroupChat
 
@@ -51,21 +50,3 @@ async def run(
             termination_condition=termination_condition,
         )
         return result
-
-
-class BaseToolUseChatAgent(BaseChatAgent, ToolUseChatAgent):
-    """Base class for a chat agent that can use tools.
-
-    Subclass this base class to create an agent class that uses tools by returning
-    ToolCallMessage message from the :meth:`on_messages` method and receiving
-    ToolCallResultMessage message from the input to the :meth:`on_messages` method.
-    """
-
-    def __init__(self, name: str, description: str, registered_tools: List[Tool]) -> None:
-        super().__init__(name, description)
-        self._registered_tools = registered_tools
-
-    @property
-    def registered_tools(self) -> List[Tool]:
-        """The list of tools that the agent can use."""
-        return self._registered_tools
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
index 37022acd0bd9..fde1a3e49890 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
@@ -1,3 +1,6 @@
+import asyncio
+import json
+import logging
 from typing import Any, Awaitable, Callable, List, Sequence
 
 from autogen_core.base import CancellationToken
@@ -5,25 +8,45 @@
 from autogen_core.components.models import (
     AssistantMessage,
     ChatCompletionClient,
+    FunctionExecutionResult,
     FunctionExecutionResultMessage,
     LLMMessage,
     SystemMessage,
     UserMessage,
 )
 from autogen_core.components.tools import FunctionTool, Tool
+from pydantic import BaseModel, ConfigDict
 
+from .. import EVENT_LOGGER_NAME
 from ..messages import (
     ChatMessage,
-    MultiModalMessage,
     StopMessage,
     TextMessage,
-    ToolCallMessage,
-    ToolCallResultMessage,
 )
-from ._base_chat_agent import BaseToolUseChatAgent
+from ._base_chat_agent import BaseChatAgent
 
+event_logger = logging.getLogger(EVENT_LOGGER_NAME)
 
-class ToolUseAssistantAgent(BaseToolUseChatAgent):
+
+class ToolCallEvent(BaseModel):
+    """A tool call event."""
+
+    tool_calls: List[FunctionCall]
+    """The tool call message."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ToolCallResultEvent(BaseModel):
+    """A tool call result event."""
+
+    tool_call_results: List[FunctionExecutionResult]
+    """The tool call result message."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ToolUseAssistantAgent(BaseChatAgent):
     """An agent that provides assistance with tool use.
 
     It responds with a StopMessage when 'terminate' is detected in the response.
@@ -45,46 +68,50 @@ def __init__(
         description: str = "An agent that provides assistance with ability to use tools.",
         system_message: str = "You are a helpful AI assistant. Solve tasks using your tools. Reply with 'TERMINATE' when the task has been completed.",
     ):
-        tools: List[Tool] = []
+        super().__init__(name=name, description=description)
+        self._model_client = model_client
+        self._system_messages = [SystemMessage(content=system_message)]
+        self._tools: List[Tool] = []
         for tool in registered_tools:
             if isinstance(tool, Tool):
-                tools.append(tool)
+                self._tools.append(tool)
             elif callable(tool):
                 if hasattr(tool, "__doc__") and tool.__doc__ is not None:
                     description = tool.__doc__
                 else:
                     description = ""
-                tools.append(FunctionTool(tool, description=description))
+                self._tools.append(FunctionTool(tool, description=description))
             else:
                 raise ValueError(f"Unsupported tool type: {type(tool)}")
-        super().__init__(name=name, description=description, registered_tools=tools)
-        self._model_client = model_client
-        self._system_messages = [SystemMessage(content=system_message)]
-        self._tool_schema = [tool.schema for tool in tools]
         self._model_context: List[LLMMessage] = []
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         # Add messages to the model context.
         for msg in messages:
-            if isinstance(msg, ToolCallResultMessage):
-                self._model_context.append(FunctionExecutionResultMessage(content=msg.content))
-            elif not isinstance(msg, TextMessage | MultiModalMessage | StopMessage):
-                raise ValueError(f"Unsupported message type: {type(msg)}")
-            else:
-                self._model_context.append(UserMessage(content=msg.content, source=msg.source))
+            # TODO: add special handling for handoff messages
+            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
         # Generate an inference result based on the current model context.
         llm_messages = self._system_messages + self._model_context
-        result = await self._model_client.create(
-            llm_messages, tools=self._tool_schema, cancellation_token=cancellation_token
-        )
+        result = await self._model_client.create(llm_messages, tools=self._tools, cancellation_token=cancellation_token)
 
         # Add the response to the model context.
         self._model_context.append(AssistantMessage(content=result.content, source=self.name))
 
-        # Detect tool calls.
-        if isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
-            return ToolCallMessage(content=result.content, source=self.name)
+        # Run tool calls until the model produces a string response.
+        while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
+            event_logger.debug(ToolCallEvent(tool_calls=result.content))
+            # Execute the tool calls.
+            results = await asyncio.gather(
+                *[self._execute_tool_call(call, cancellation_token) for call in result.content]
+            )
+            event_logger.debug(ToolCallResultEvent(tool_call_results=results))
+            self._model_context.append(FunctionExecutionResultMessage(content=results))
+            # Generate an inference result based on the current model context.
+            result = await self._model_client.create(
+                self._model_context, tools=self._tools, cancellation_token=cancellation_token
+            )
+            self._model_context.append(AssistantMessage(content=result.content, source=self.name))
 
         assert isinstance(result.content, str)
         # Detect stop request.
@@ -93,3 +120,20 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             return StopMessage(content=result.content, source=self.name)
 
         return TextMessage(content=result.content, source=self.name)
+
+    async def _execute_tool_call(
+        self, tool_call: FunctionCall, cancellation_token: CancellationToken
+    ) -> FunctionExecutionResult:
+        """Execute a tool call and return the result."""
+        try:
+            if not self._tools:
+                raise ValueError("No tools are available.")
+            tool = next((t for t in self._tools if t.name == tool_call.name), None)
+            if tool is None:
+                raise ValueError(f"The tool '{tool_call.name}' is not available.")
+            arguments = json.loads(tool_call.arguments)
+            result = await tool.run_json(arguments, cancellation_token)
+            result_as_str = tool.return_value_as_string(result)
+            return FunctionExecutionResult(content=result_as_str, call_id=tool_call.id)
+        except Exception as e:
+            return FunctionExecutionResult(content=f"Error: {e}", call_id=tool_call.id)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
index 36845eb82182..436d69fb0440 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
@@ -1,11 +1,10 @@
-from ._chat_agent import ChatAgent, ToolUseChatAgent
+from ._chat_agent import ChatAgent
 from ._task import TaskResult, TaskRunner
 from ._team import Team
 from ._termination import TerminatedException, TerminationCondition
 
 __all__ = [
     "ChatAgent",
-    "ToolUseChatAgent",
     "Team",
     "TerminatedException",
     "TerminationCondition",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index 6200050d43d7..d82539540628 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -1,7 +1,6 @@
-from typing import List, Protocol, Sequence, runtime_checkable
+from typing import Protocol, Sequence, runtime_checkable
 
 from autogen_core.base import CancellationToken
-from autogen_core.components.tools import Tool
 
 from ..messages import ChatMessage
 from ._task import TaskResult, TaskRunner
@@ -38,13 +37,3 @@ async def run(
     ) -> TaskResult:
         """Run the agent with the given task and return the result."""
         ...
-
-
-@runtime_checkable
-class ToolUseChatAgent(ChatAgent, Protocol):
-    """Protocol for a chat agent that can use tools."""
-
-    @property
-    def registered_tools(self) -> List[Tool]:
-        """The list of tools that the agent can use."""
-        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
index d0fb4ab08a11..95200e2841be 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
@@ -3,13 +3,12 @@
 import sys
 from datetime import datetime
 
+from ..agents._tool_use_assistant_agent import ToolCallEvent, ToolCallResultEvent
 from ..messages import ChatMessage, StopMessage, TextMessage
 from ..teams._events import (
-    ContentPublishEvent,
-    SelectSpeakerEvent,
+    GroupChatPublishEvent,
+    GroupChatSelectSpeakerEvent,
     TerminationEvent,
-    ToolCallEvent,
-    ToolCallResultEvent,
 )
 
 
@@ -25,7 +24,7 @@ def serialize_chat_message(message: ChatMessage) -> str:
 
     def emit(self, record: logging.LogRecord) -> None:
         ts = datetime.fromtimestamp(record.created).isoformat()
-        if isinstance(record.msg, ContentPublishEvent):
+        if isinstance(record.msg, GroupChatPublishEvent):
             if record.msg.source is None:
                 sys.stdout.write(
                     f"\n{'-'*75} \n"
@@ -41,19 +40,15 @@ def emit(self, record: logging.LogRecord) -> None:
             sys.stdout.flush()
         elif isinstance(record.msg, ToolCallEvent):
             sys.stdout.write(
-                f"\n{'-'*75} \n"
-                f"\033[91m[{ts}], Tool Call:\033[0m\n"
-                f"\n{self.serialize_chat_message(record.msg.agent_message)}"
+                f"\n{'-'*75} \n" f"\033[91m[{ts}], Tool Call:\033[0m\n" f"\n{str(record.msg.model_dump())}"
             )
             sys.stdout.flush()
         elif isinstance(record.msg, ToolCallResultEvent):
             sys.stdout.write(
-                f"\n{'-'*75} \n"
-                f"\033[91m[{ts}], Tool Call Result:\033[0m\n"
-                f"\n{self.serialize_chat_message(record.msg.agent_message)}"
+                f"\n{'-'*75} \n" f"\033[91m[{ts}], Tool Call Result:\033[0m\n" f"\n{str(record.msg.model_dump())}"
             )
             sys.stdout.flush()
-        elif isinstance(record.msg, SelectSpeakerEvent):
+        elif isinstance(record.msg, GroupChatSelectSpeakerEvent):
             sys.stdout.write(
                 f"\n{'-'*75} \n" f"\033[91m[{ts}], Selected Next Speaker:\033[0m\n" f"\n{record.msg.selected_speaker}"
             )
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
index ca64b0d68dc0..24fd09418094 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
@@ -4,12 +4,11 @@
 from datetime import datetime
 from typing import Any
 
+from ..agents._tool_use_assistant_agent import ToolCallEvent, ToolCallResultEvent
 from ..teams._events import (
-    ContentPublishEvent,
-    SelectSpeakerEvent,
+    GroupChatPublishEvent,
+    GroupChatSelectSpeakerEvent,
     TerminationEvent,
-    ToolCallEvent,
-    ToolCallResultEvent,
 )
 
 
@@ -21,7 +20,7 @@ def __init__(self, filename: str) -> None:
 
     def emit(self, record: logging.LogRecord) -> None:
         ts = datetime.fromtimestamp(record.created).isoformat()
-        if isinstance(record.msg, ContentPublishEvent | ToolCallEvent | ToolCallResultEvent | TerminationEvent):
+        if isinstance(record.msg, GroupChatPublishEvent | TerminationEvent):
             log_entry = json.dumps(
                 {
                     "timestamp": ts,
@@ -31,7 +30,7 @@ def emit(self, record: logging.LogRecord) -> None:
                 },
                 default=self.json_serializer,
             )
-        elif isinstance(record.msg, SelectSpeakerEvent):
+        elif isinstance(record.msg, GroupChatSelectSpeakerEvent):
             log_entry = json.dumps(
                 {
                     "timestamp": ts,
@@ -41,6 +40,24 @@ def emit(self, record: logging.LogRecord) -> None:
                 },
                 default=self.json_serializer,
             )
+        elif isinstance(record.msg, ToolCallEvent):
+            log_entry = json.dumps(
+                {
+                    "timestamp": ts,
+                    "tool_calls": record.msg.model_dump(),
+                    "type": "ToolCallEvent",
+                },
+                default=self.json_serializer,
+            )
+        elif isinstance(record.msg, ToolCallResultEvent):
+            log_entry = json.dumps(
+                {
+                    "timestamp": ts,
+                    "tool_call_results": record.msg.model_dump(),
+                    "type": "ToolCallResultEvent",
+                },
+                default=self.json_serializer,
+            )
         else:
             raise ValueError(f"Unexpected log record: {record.msg}")
         file_record = logging.LogRecord(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 6aac22248d50..99bd0c888f0f 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -1,7 +1,6 @@
 from typing import List
 
-from autogen_core.components import FunctionCall, Image
-from autogen_core.components.models import FunctionExecutionResult
+from autogen_core.components import Image
 from pydantic import BaseModel
 
 
@@ -26,20 +25,6 @@ class MultiModalMessage(BaseMessage):
     """The content of the message."""
 
 
-class ToolCallMessage(BaseMessage):
-    """A message containing a list of function calls."""
-
-    content: List[FunctionCall]
-    """The list of function calls."""
-
-
-class ToolCallResultMessage(BaseMessage):
-    """A message containing the results of function calls."""
-
-    content: List[FunctionExecutionResult]
-    """The list of function execution results."""
-
-
 class StopMessage(BaseMessage):
     """A message requesting stop of a conversation."""
 
@@ -47,7 +32,14 @@ class StopMessage(BaseMessage):
     """The content for the stop message."""
 
 
-ChatMessage = TextMessage | MultiModalMessage | StopMessage | ToolCallMessage | ToolCallResultMessage
+class HandoffMessage(BaseMessage):
+    """A message requesting handoff of a conversation to another agent."""
+
+    content: str
+    """The agent name to handoff the conversation to."""
+
+
+ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage
 """A message used by agents in a team."""
 
 
@@ -55,8 +47,7 @@ class StopMessage(BaseMessage):
     "BaseMessage",
     "TextMessage",
     "MultiModalMessage",
-    "ToolCallMessage",
-    "ToolCallResultMessage",
     "StopMessage",
+    "HandoffMessage",
     "ChatMessage",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
index 836f1501242b..a2dd74d61b32 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
@@ -1,7 +1,9 @@
 from ._group_chat._round_robin_group_chat import RoundRobinGroupChat
 from ._group_chat._selector_group_chat import SelectorGroupChat
+from ._group_chat._swarm_group_chat import Swarm
 
 __all__ = [
     "RoundRobinGroupChat",
     "SelectorGroupChat",
+    "Swarm",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
index 5bfeff417841..3442b35ce87a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
@@ -1,16 +1,16 @@
 from autogen_core.base import AgentId
 from pydantic import BaseModel, ConfigDict
 
-from ..messages import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
+from ..messages import ChatMessage, StopMessage
 
 
-class ContentPublishEvent(BaseModel):
-    """An event for sharing some data. Agents receive this event should
+class GroupChatPublishEvent(BaseModel):
+    """An group chat event for sharing some data. Agents receive this event should
     update their internal state (e.g., append to message history) with the
     content of the event.
     """
 
-    agent_message: TextMessage | MultiModalMessage | StopMessage
+    agent_message: ChatMessage
     """The message published by the agent."""
 
     source: AgentId | None = None
@@ -19,39 +19,15 @@ class ContentPublishEvent(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
-class ContentRequestEvent(BaseModel):
-    """An event for requesting to publish a content event.
-    Upon receiving this event, the agent should publish a ContentPublishEvent.
+class GroupChatRequestPublishEvent(BaseModel):
+    """An event for requesting to publish a group chat publish event.
+    Upon receiving this event, the agent should publish a group chat publish event.
     """
 
     ...
 
 
-class ToolCallEvent(BaseModel):
-    """An event produced when requesting a tool call."""
-
-    agent_message: ToolCallMessage
-    """The tool call message."""
-
-    source: AgentId
-    """The sender of the tool call message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class ToolCallResultEvent(BaseModel):
-    """An event produced when a tool call is completed."""
-
-    agent_message: ToolCallResultMessage
-    """The tool call result message."""
-
-    source: AgentId
-    """The sender of the tool call result message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class SelectSpeakerEvent(BaseModel):
+class GroupChatSelectSpeakerEvent(BaseModel):
     """An event for selecting the next speaker in a group chat."""
 
     selected_speaker: str
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
deleted file mode 100644
index 4f3e902afbe0..000000000000
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_chat_agent_container.py
+++ /dev/null
@@ -1,92 +0,0 @@
-import asyncio
-import logging
-from typing import List
-
-from autogen_core.base import AgentId, AgentType, MessageContext
-from autogen_core.components import DefaultTopicId, event
-from autogen_core.components.models import FunctionExecutionResult
-from autogen_core.components.tool_agent import ToolException
-
-from ... import EVENT_LOGGER_NAME
-from ...base import ChatAgent
-from ...messages import MultiModalMessage, StopMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
-from .._events import ContentPublishEvent, ContentRequestEvent, ToolCallEvent, ToolCallResultEvent
-from ._sequential_routed_agent import SequentialRoutedAgent
-
-event_logger = logging.getLogger(EVENT_LOGGER_NAME)
-
-
-class BaseChatAgentContainer(SequentialRoutedAgent):
-    """A core agent class that delegates message handling to an
-    :class:`autogen_agentchat.agents.BaseChatAgent` so that it can be used in a
-    group chat team.
-
-    Args:
-        parent_topic_type (str): The topic type of the parent orchestrator.
-        agent (BaseChatAgent): The agent to delegate message handling to.
-        tool_agent_type (AgentType, optional): The agent type of the tool agent. Defaults to None.
-    """
-
-    def __init__(self, parent_topic_type: str, agent: ChatAgent, tool_agent_type: AgentType | None = None) -> None:
-        super().__init__(description=agent.description)
-        self._parent_topic_type = parent_topic_type
-        self._agent = agent
-        self._message_buffer: List[TextMessage | MultiModalMessage | StopMessage] = []
-        self._tool_agent_id = AgentId(type=tool_agent_type, key=self.id.key) if tool_agent_type else None
-
-    @event
-    async def handle_content_publish(self, message: ContentPublishEvent, ctx: MessageContext) -> None:
-        """Handle a content publish event by appending the content to the buffer."""
-        if not isinstance(message.agent_message, TextMessage | MultiModalMessage | StopMessage):
-            raise ValueError(
-                f"Unexpected message type: {type(message.agent_message)}. "
-                "The message must be a text, multimodal, or stop message."
-            )
-        self._message_buffer.append(message.agent_message)
-
-    @event
-    async def handle_content_request(self, message: ContentRequestEvent, ctx: MessageContext) -> None:
-        """Handle a content request event by passing the messages in the buffer
-        to the delegate agent and publish the response."""
-        response = await self._agent.on_messages(self._message_buffer, ctx.cancellation_token)
-
-        if self._tool_agent_id is not None:
-            # Handle tool calls.
-            while isinstance(response, ToolCallMessage):
-                # Log the tool call.
-                event_logger.debug(ToolCallEvent(agent_message=response, source=self.id))
-
-                results: List[FunctionExecutionResult | BaseException] = await asyncio.gather(
-                    *[
-                        self.send_message(
-                            message=call,
-                            recipient=self._tool_agent_id,
-                            cancellation_token=ctx.cancellation_token,
-                        )
-                        for call in response.content
-                    ]
-                )
-                # Combine the results in to a single response and handle exceptions.
-                function_results: List[FunctionExecutionResult] = []
-                for result in results:
-                    if isinstance(result, FunctionExecutionResult):
-                        function_results.append(result)
-                    elif isinstance(result, ToolException):
-                        function_results.append(
-                            FunctionExecutionResult(content=f"Error: {result}", call_id=result.call_id)
-                        )
-                    elif isinstance(result, BaseException):
-                        raise result  # Unexpected exception.
-                # Create a new tool call result message.
-                feedback = ToolCallResultMessage(content=function_results, source=self._tool_agent_id.type)
-                # Log the feedback.
-                event_logger.debug(ToolCallResultEvent(agent_message=feedback, source=self._tool_agent_id))
-                response = await self._agent.on_messages([feedback], ctx.cancellation_token)
-
-        # Publish the response.
-        assert isinstance(response, TextMessage | MultiModalMessage | StopMessage)
-        self._message_buffer.clear()
-        await self.publish_message(
-            ContentPublishEvent(agent_message=response, source=self.id),
-            topic_id=DefaultTopicId(type=self._parent_topic_type),
-        )
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index c599d269b0e7..6ee79d4ded0a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -13,14 +13,12 @@
     TopicId,
 )
 from autogen_core.components import ClosureAgent, TypeSubscription
-from autogen_core.components.tool_agent import ToolAgent
-from autogen_core.components.tools import Tool
 
-from ...base import ChatAgent, TaskResult, Team, TerminationCondition, ToolUseChatAgent
+from ...base import ChatAgent, TaskResult, Team, TerminationCondition
 from ...messages import ChatMessage, TextMessage
-from .._events import ContentPublishEvent, ContentRequestEvent
-from ._base_chat_agent_container import BaseChatAgentContainer
+from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
 from ._base_group_chat_manager import BaseGroupChatManager
+from ._chat_agent_container import ChatAgentContainer
 
 
 class BaseGroupChat(Team, ABC):
@@ -35,11 +33,6 @@ def __init__(self, participants: List[ChatAgent], group_chat_manager_class: type
             raise ValueError("At least one participant is required.")
         if len(participants) != len(set(participant.name for participant in participants)):
             raise ValueError("The participant names must be unique.")
-        for participant in participants:
-            if isinstance(participant, ToolUseChatAgent) and not participant.registered_tools:
-                raise ValueError(
-                    f"Participant '{participant.name}' is a tool use agent so it must have registered tools."
-                )
         self._participants = participants
         self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
@@ -55,27 +48,19 @@ def _create_group_chat_manager_factory(
     ) -> Callable[[], BaseGroupChatManager]: ...
 
     def _create_participant_factory(
-        self, parent_topic_type: str, agent: ChatAgent, tool_agent_type: AgentType | None
-    ) -> Callable[[], BaseChatAgentContainer]:
-        def _factory() -> BaseChatAgentContainer:
+        self,
+        parent_topic_type: str,
+        agent: ChatAgent,
+    ) -> Callable[[], ChatAgentContainer]:
+        def _factory() -> ChatAgentContainer:
             id = AgentInstantiationContext.current_agent_id()
             assert id == AgentId(type=agent.name, key=self._team_id)
-            container = BaseChatAgentContainer(parent_topic_type, agent, tool_agent_type)
+            container = ChatAgentContainer(parent_topic_type, agent)
             assert container.id == id
             return container
 
         return _factory
 
-    def _create_tool_agent_factory(
-        self,
-        caller_name: str,
-        tools: List[Tool],
-    ) -> Callable[[], ToolAgent]:
-        def _factory() -> ToolAgent:
-            return ToolAgent(f"Tool agent for {caller_name}", tools)
-
-        return _factory
-
     async def run(
         self,
         task: str,
@@ -99,27 +84,14 @@ async def run(
         participant_topic_types: List[str] = []
         participant_descriptions: List[str] = []
         for participant in self._participants:
-            if isinstance(participant, ToolUseChatAgent):
-                assert participant.registered_tools is not None and len(participant.registered_tools) > 0
-                # Register the tool agent.
-                tool_agent_type = await ToolAgent.register(
-                    runtime,
-                    f"tool_agent_for_{participant.name}",
-                    self._create_tool_agent_factory(participant.name, participant.registered_tools),
-                )
-                # No subscriptions are needed for the tool agent, which will be called via direct messages.
-            else:
-                # No tool agent is needed.
-                tool_agent_type = None
-
             # Use the participant name as the agent type and topic type.
             agent_type = participant.name
             topic_type = participant.name
             # Register the participant factory.
-            await BaseChatAgentContainer.register(
+            await ChatAgentContainer.register(
                 runtime,
                 type=agent_type,
-                factory=self._create_participant_factory(group_topic_type, participant, tool_agent_type),
+                factory=self._create_participant_factory(group_topic_type, participant),
             )
             # Add subscriptions for the participant.
             await runtime.add_subscription(TypeSubscription(topic_type=topic_type, agent_type=agent_type))
@@ -154,7 +126,10 @@ async def run(
         group_chat_messages: List[ChatMessage] = []
 
         async def collect_group_chat_messages(
-            _runtime: AgentRuntime, id: AgentId, message: ContentPublishEvent, ctx: MessageContext
+            _runtime: AgentRuntime,
+            id: AgentId,
+            message: GroupChatPublishEvent,
+            ctx: MessageContext,
         ) -> None:
             group_chat_messages.append(message.agent_message)
 
@@ -174,10 +149,10 @@ async def collect_group_chat_messages(
         team_topic_id = TopicId(type=team_topic_type, source=self._team_id)
         group_chat_manager_topic_id = TopicId(type=group_chat_manager_topic_type, source=self._team_id)
         await runtime.publish_message(
-            ContentPublishEvent(agent_message=TextMessage(content=task, source="user")),
+            GroupChatPublishEvent(agent_message=TextMessage(content=task, source="user")),
             topic_id=team_topic_id,
         )
-        await runtime.publish_message(ContentRequestEvent(), topic_id=group_chat_manager_topic_id)
+        await runtime.publish_message(GroupChatRequestPublishEvent(), topic_id=group_chat_manager_topic_id)
 
         # Wait for the runtime to stop.
         await runtime.stop_when_idle()
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
index 5f59e9e631d7..68eb76c06e81 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
@@ -1,13 +1,17 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import List
+from typing import Any, List
 
-from autogen_core.base import MessageContext, TopicId
-from autogen_core.components import event
+from autogen_core.base import MessageContext
+from autogen_core.components import DefaultTopicId, event
 
 from ... import EVENT_LOGGER_NAME
 from ...base import TerminationCondition
-from .._events import ContentPublishEvent, ContentRequestEvent, TerminationEvent
+from .._events import (
+    GroupChatPublishEvent,
+    GroupChatRequestPublishEvent,
+    TerminationEvent,
+)
 from ._sequential_routed_agent import SequentialRoutedAgent
 
 event_logger = logging.getLogger(EVENT_LOGGER_NAME)
@@ -33,6 +37,10 @@ class BaseGroupChatManager(SequentialRoutedAgent, ABC):
 
     Raises:
         ValueError: If the number of participant topic types, agent types, and descriptions are not the same.
+        ValueError: If the participant topic types are not unique.
+        ValueError: If the group topic type is in the participant topic types.
+        ValueError: If the parent topic type is in the participant topic types.
+        ValueError: If the group topic type is the same as the parent topic type.
     """
 
     def __init__(
@@ -58,11 +66,11 @@ def __init__(
             raise ValueError("The group topic type must not be the same as the parent topic type.")
         self._participant_topic_types = participant_topic_types
         self._participant_descriptions = participant_descriptions
-        self._message_thread: List[ContentPublishEvent] = []
+        self._message_thread: List[GroupChatPublishEvent] = []
         self._termination_condition = termination_condition
 
     @event
-    async def handle_content_publish(self, message: ContentPublishEvent, ctx: MessageContext) -> None:
+    async def handle_content_publish(self, message: GroupChatPublishEvent, ctx: MessageContext) -> None:
         """Handle a content publish event.
 
         If the event is from the parent topic, add the message to the thread.
@@ -70,16 +78,25 @@ async def handle_content_publish(self, message: ContentPublishEvent, ctx: Messag
         If the event is from the group chat topic, add the message to the thread and select a speaker to continue the conversation.
         If the event from the group chat session requests a pause, publish the last message to the parent topic."""
         assert ctx.topic_id is not None
-        group_chat_topic_id = TopicId(type=self._group_topic_type, source=ctx.topic_id.source)
 
         event_logger.info(message)
 
+        if self._termination_condition is not None and self._termination_condition.terminated:
+            # The group chat has been terminated.
+            return
+
         # Process event from parent.
         if ctx.topic_id.type == self._parent_topic_type:
             self._message_thread.append(message)
             await self.publish_message(
-                ContentPublishEvent(agent_message=message.agent_message, source=self.id), topic_id=group_chat_topic_id
+                GroupChatPublishEvent(agent_message=message.agent_message, source=self.id),
+                topic_id=DefaultTopicId(type=self._group_topic_type),
             )
+            if self._termination_condition is not None:
+                stop_message = await self._termination_condition([message.agent_message])
+                if stop_message is not None:
+                    event_logger.info(TerminationEvent(agent_message=stop_message, source=self.id))
+                    # Stop the group chat.
             return
 
         # Process event from the group chat this agent manages.
@@ -91,8 +108,6 @@ async def handle_content_publish(self, message: ContentPublishEvent, ctx: Messag
             stop_message = await self._termination_condition([message.agent_message])
             if stop_message is not None:
                 event_logger.info(TerminationEvent(agent_message=stop_message, source=self.id))
-                # Reset the termination condition.
-                await self._termination_condition.reset()
                 # Stop the group chat.
                 # TODO: this should be different if the group chat is nested.
                 return
@@ -100,24 +115,28 @@ async def handle_content_publish(self, message: ContentPublishEvent, ctx: Messag
         # Select a speaker to continue the conversation.
         speaker_topic_type = await self.select_speaker(self._message_thread)
 
-        participant_topic_id = TopicId(type=speaker_topic_type, source=ctx.topic_id.source)
-        group_chat_topic_id = TopicId(type=self._group_topic_type, source=ctx.topic_id.source)
-        await self.publish_message(ContentRequestEvent(), topic_id=participant_topic_id)
+        await self.publish_message(GroupChatRequestPublishEvent(), topic_id=DefaultTopicId(type=speaker_topic_type))
 
     @event
-    async def handle_content_request(self, message: ContentRequestEvent, ctx: MessageContext) -> None:
+    async def handle_content_request(self, message: GroupChatRequestPublishEvent, ctx: MessageContext) -> None:
         """Handle a content request by selecting a speaker to start the conversation."""
         assert ctx.topic_id is not None
         if ctx.topic_id.type == self._group_topic_type:
             raise RuntimeError("Content request event from the group chat topic is not allowed.")
 
+        if self._termination_condition is not None and self._termination_condition.terminated:
+            # The group chat has been terminated.
+            return
+
         speaker_topic_type = await self.select_speaker(self._message_thread)
 
-        participant_topic_id = TopicId(type=speaker_topic_type, source=ctx.topic_id.source)
-        await self.publish_message(ContentRequestEvent(), topic_id=participant_topic_id)
+        await self.publish_message(GroupChatRequestPublishEvent(), topic_id=DefaultTopicId(type=speaker_topic_type))
 
     @abstractmethod
-    async def select_speaker(self, thread: List[ContentPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
         """Select a speaker from the participants and return the
         topic type of the selected speaker."""
         ...
+
+    async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> None:
+        raise ValueError(f"Unhandled message in group chat manager: {type(message)}")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
new file mode 100644
index 000000000000..acf5e9d2f467
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -0,0 +1,48 @@
+from typing import Any, List
+
+from autogen_core.base import MessageContext
+from autogen_core.components import DefaultTopicId, event
+
+from ...base import ChatAgent
+from ...messages import ChatMessage
+from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
+from ._sequential_routed_agent import SequentialRoutedAgent
+
+
+class ChatAgentContainer(SequentialRoutedAgent):
+    """A core agent class that delegates message handling to an
+    :class:`autogen_agentchat.base.ChatAgent` so that it can be used in a
+    group chat team.
+
+    Args:
+        parent_topic_type (str): The topic type of the parent orchestrator.
+        agent (ChatAgent): The agent to delegate message handling to.
+    """
+
+    def __init__(self, parent_topic_type: str, agent: ChatAgent) -> None:
+        super().__init__(description=agent.description)
+        self._parent_topic_type = parent_topic_type
+        self._agent = agent
+        self._message_buffer: List[ChatMessage] = []
+
+    @event
+    async def handle_message(self, message: GroupChatPublishEvent, ctx: MessageContext) -> None:
+        """Handle an event by appending the content to the buffer."""
+        self._message_buffer.append(message.agent_message)
+
+    @event
+    async def handle_content_request(self, message: GroupChatRequestPublishEvent, ctx: MessageContext) -> None:
+        """Handle a content request event by passing the messages in the buffer
+        to the delegate agent and publish the response."""
+        # Pass the messages in the buffer to the delegate agent.
+        response = await self._agent.on_messages(self._message_buffer, ctx.cancellation_token)
+
+        # Publish the response.
+        self._message_buffer.clear()
+        await self.publish_message(
+            GroupChatPublishEvent(agent_message=response, source=self.id),
+            topic_id=DefaultTopicId(type=self._parent_topic_type),
+        )
+
+    async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> None:
+        raise ValueError(f"Unhandled message in agent container: {type(message)}")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index 529314fece51..fff872dd84b6 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -1,10 +1,17 @@
+import logging
 from typing import Callable, List
 
+from ... import EVENT_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
-from .._events import ContentPublishEvent
+from .._events import (
+    GroupChatPublishEvent,
+    GroupChatSelectSpeakerEvent,
+)
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
+event_logger = logging.getLogger(EVENT_LOGGER_NAME)
+
 
 class RoundRobinGroupChatManager(BaseGroupChatManager):
     """A group chat manager that selects the next speaker in a round-robin fashion."""
@@ -26,11 +33,13 @@ def __init__(
         )
         self._next_speaker_index = 0
 
-    async def select_speaker(self, thread: List[ContentPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
         """Select a speaker from the participants in a round-robin fashion."""
         current_speaker_index = self._next_speaker_index
         self._next_speaker_index = (current_speaker_index + 1) % len(self._participant_topic_types)
-        return self._participant_topic_types[current_speaker_index]
+        current_speaker = self._participant_topic_types[current_speaker_index]
+        event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=current_speaker, source=self.id))
+        return current_speaker
 
 
 class RoundRobinGroupChat(BaseGroupChat):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 1eaf0ddd5609..79f8b60decf4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -7,7 +7,10 @@
 from ... import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
 from ...messages import MultiModalMessage, StopMessage, TextMessage
-from .._events import ContentPublishEvent, SelectSpeakerEvent
+from .._events import (
+    GroupChatPublishEvent,
+    GroupChatSelectSpeakerEvent,
+)
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
@@ -42,7 +45,7 @@ def __init__(
         self._previous_speaker: str | None = None
         self._allow_repeated_speaker = allow_repeated_speaker
 
-    async def select_speaker(self, thread: List[ContentPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
         """Selects the next speaker in a group chat using a ChatCompletion client.
 
         A key assumption is that the agent type is the same as the topic type, which we use as the agent name.
@@ -107,7 +110,7 @@ async def select_speaker(self, thread: List[ContentPublishEvent]) -> str:
         else:
             agent_name = participants[0]
         self._previous_speaker = agent_name
-        event_logger.debug(SelectSpeakerEvent(selected_speaker=agent_name, source=self.id))
+        event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=agent_name, source=self.id))
         return agent_name
 
     def _mentioned_agents(self, message_content: str, agent_names: List[str]) -> Dict[str, int]:
@@ -148,7 +151,7 @@ class SelectorGroupChat(BaseGroupChat):
     to all, using a ChatCompletion model to select the next speaker after each message.
 
     Args:
-        participants (List[BaseChatAgent]): The participants in the group chat,
+        participants (List[ChatAgent]): The participants in the group chat,
             must have unique names and at least two participants.
         model_client (ChatCompletionClient): The ChatCompletion model client used
             to select the next speaker.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
new file mode 100644
index 000000000000..4f2d08afc1bf
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -0,0 +1,72 @@
+import logging
+from typing import Callable, List
+
+from ... import EVENT_LOGGER_NAME
+from ...base import ChatAgent, TerminationCondition
+from ...messages import HandoffMessage
+from .._events import (
+    GroupChatPublishEvent,
+    GroupChatSelectSpeakerEvent,
+)
+from ._base_group_chat import BaseGroupChat
+from ._base_group_chat_manager import BaseGroupChatManager
+
+event_logger = logging.getLogger(EVENT_LOGGER_NAME)
+
+
+class SwarmGroupChatManager(BaseGroupChatManager):
+    """A group chat manager that selects the next speaker based on handoff message only."""
+
+    def __init__(
+        self,
+        parent_topic_type: str,
+        group_topic_type: str,
+        participant_topic_types: List[str],
+        participant_descriptions: List[str],
+        termination_condition: TerminationCondition | None,
+    ) -> None:
+        super().__init__(
+            parent_topic_type,
+            group_topic_type,
+            participant_topic_types,
+            participant_descriptions,
+            termination_condition,
+        )
+        self._current_speaker = participant_topic_types[0]
+
+    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
+        """Select a speaker from the participants based on handoff message."""
+        if len(thread) > 0 and isinstance(thread[-1].agent_message, HandoffMessage):
+            self._current_speaker = thread[-1].agent_message.content
+            if self._current_speaker not in self._participant_topic_types:
+                raise ValueError("The selected speaker in the handoff message is not a participant.")
+            event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=self._current_speaker, source=self.id))
+            return self._current_speaker
+        else:
+            return self._current_speaker
+
+
+class Swarm(BaseGroupChat):
+    """(Experimental) A group chat that selects the next speaker based on handoff message only."""
+
+    def __init__(self, participants: List[ChatAgent]):
+        super().__init__(participants, group_chat_manager_class=SwarmGroupChatManager)
+
+    def _create_group_chat_manager_factory(
+        self,
+        parent_topic_type: str,
+        group_topic_type: str,
+        participant_topic_types: List[str],
+        participant_descriptions: List[str],
+        termination_condition: TerminationCondition | None,
+    ) -> Callable[[], SwarmGroupChatManager]:
+        def _factory() -> SwarmGroupChatManager:
+            return SwarmGroupChatManager(
+                parent_topic_type,
+                group_topic_type,
+                participant_topic_types,
+                participant_descriptions,
+                termination_condition,
+            )
+
+        return _factory
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 97cf65c2d88e..9f740eb6439c 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -13,11 +13,17 @@
     ToolUseAssistantAgent,
 )
 from autogen_agentchat.logging import FileLogHandler
-from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage
-from autogen_agentchat.task import StopMessageTermination
+from autogen_agentchat.messages import (
+    ChatMessage,
+    HandoffMessage,
+    StopMessage,
+    TextMessage,
+)
+from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination
 from autogen_agentchat.teams import (
     RoundRobinGroupChat,
     SelectorGroupChat,
+    Swarm,
 )
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
@@ -212,7 +218,16 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     )
     echo_agent = _EchoAgent("echo_agent", description="echo agent")
     team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent])
-    await team.run("Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination())
+    result = await team.run(
+        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+    )
+
+    assert len(result.messages) == 4
+    assert isinstance(result.messages[0], TextMessage)  # task
+    assert isinstance(result.messages[1], TextMessage)  # tool use agent response
+    assert isinstance(result.messages[2], TextMessage)  # echo agent response
+    assert isinstance(result.messages[3], StopMessage)  # tool use agent response
+
     context = tool_use_agent._model_context  # pyright: ignore
     assert context[0].content == "Write a program that prints 'Hello, world!'"
     assert isinstance(context[1].content, list)
@@ -393,3 +408,29 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     assert result.messages[1].source == "agent2"
     assert result.messages[2].source == "agent2"
     assert result.messages[3].source == "agent1"
+
+
+class _HandOffAgent(BaseChatAgent):
+    def __init__(self, name: str, description: str, next_agent: str) -> None:
+        super().__init__(name, description)
+        self._next_agent = next_agent
+
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+        return HandoffMessage(content=self._next_agent, source=self.name)
+
+
+@pytest.mark.asyncio
+async def test_swarm() -> None:
+    first_agent = _HandOffAgent("first_agent", description="first agent", next_agent="second_agent")
+    second_agent = _HandOffAgent("second_agent", description="second agent", next_agent="third_agent")
+    third_agent = _HandOffAgent("third_agent", description="third agent", next_agent="first_agent")
+
+    team = Swarm([second_agent, first_agent, third_agent])
+    result = await team.run("task", termination_condition=MaxMessageTermination(6))
+    assert len(result.messages) == 6
+    assert result.messages[0].content == "task"
+    assert result.messages[1].content == "third_agent"
+    assert result.messages[2].content == "first_agent"
+    assert result.messages[3].content == "second_agent"
+    assert result.messages[4].content == "third_agent"
+    assert result.messages[5].content == "first_agent"
diff --git a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
index 3a1734b3f71a..d5ec31a12b04 100644
--- a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
@@ -4,6 +4,7 @@
 
 import pytest
 from autogen_agentchat.agents import ToolUseAssistantAgent
+from autogen_agentchat.messages import StopMessage, TextMessage
 from autogen_core.components.models import OpenAIChatCompletionClient
 from autogen_core.components.tools import FunctionTool
 from openai.resources.chat.completions import AsyncCompletions
@@ -103,5 +104,6 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     )
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 3
-    # assert isinstance(result.messages[1], ToolCallMessage)
-    # assert isinstance(result.messages[2], TextMessage)
+    assert isinstance(result.messages[0], TextMessage)
+    assert isinstance(result.messages[1], TextMessage)
+    assert isinstance(result.messages[2], StopMessage)

From 69fc7425379956e94f058e130d6faaefdb2a18a3 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 25 Oct 2024 22:23:40 -0700
Subject: [PATCH 036/173] Pin uv version to 0.4.26 (#3964)

---
 .github/workflows/checks.yml                | 7 +++++++
 .github/workflows/docs.yml                  | 1 +
 .github/workflows/single-python-package.yml | 1 +
 3 files changed, 9 insertions(+)

diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 944e7e4f9ccb..667317870b94 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -18,6 +18,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -36,6 +37,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -64,6 +66,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -92,6 +95,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -118,6 +122,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -142,6 +147,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
@@ -160,6 +166,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 84e4d2c69337..d2219e6c7ed2 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -45,6 +45,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - uses: actions/setup-python@v5
         with:
           python-version: "3.11"
diff --git a/.github/workflows/single-python-package.yml b/.github/workflows/single-python-package.yml
index db761e2c2563..9c151129bec7 100644
--- a/.github/workflows/single-python-package.yml
+++ b/.github/workflows/single-python-package.yml
@@ -35,6 +35,7 @@ jobs:
       - uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
+          version: "0.4.26"
       - run: uv build --package ${{ github.event.inputs.package }} --out-dir dist/
         working-directory: python
       - name: Publish package to PyPI

From 3fe0f9e97d67a67f4027a92f458cb4842b3db43f Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 25 Oct 2024 23:17:06 -0700
Subject: [PATCH 037/173] Add AssistantAgent, deprecate CodingAssistantAgent
 and ToolUseAssistantAgent (#3960)

* Add AssistantAgent, deprecate CodingAssistantAgent and ToolUseAssistantAgent

* Rename

* Add note

* Update uv

* uf lock

* Merge branch 'main' into assistant-agent

* Update uv
---
 .../src/autogen_agentchat/agents/__init__.py  |    2 +
 .../agents/_assistant_agent.py                |  140 +
 .../agents/_coding_assistant_agent.py         |   47 +-
 .../agents/_tool_use_assistant_agent.py       |  123 +-
 .../logging/_console_log_handler.py           |    2 +-
 .../logging/_file_log_handler.py              |    2 +-
 ...stant_agent.py => test_assistant_agent.py} |   10 +-
 .../tests/test_group_chat.py                  |    9 +-
 python/uv.lock                                | 2613 +++++++++--------
 9 files changed, 1639 insertions(+), 1309 deletions(-)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
 rename python/packages/autogen-agentchat/tests/{test_tool_use_assistant_agent.py => test_assistant_agent.py} (90%)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index 19cdec548f73..2f32588604e9 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -1,3 +1,4 @@
+from ._assistant_agent import AssistantAgent
 from ._base_chat_agent import BaseChatAgent
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
@@ -5,6 +6,7 @@
 
 __all__ = [
     "BaseChatAgent",
+    "AssistantAgent",
     "CodeExecutorAgent",
     "CodingAssistantAgent",
     "ToolUseAssistantAgent",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
new file mode 100644
index 000000000000..6523b6d4260f
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -0,0 +1,140 @@
+import asyncio
+import json
+import logging
+from typing import Any, Awaitable, Callable, List, Sequence
+
+from autogen_core.base import CancellationToken
+from autogen_core.components import FunctionCall
+from autogen_core.components.models import (
+    AssistantMessage,
+    ChatCompletionClient,
+    FunctionExecutionResult,
+    FunctionExecutionResultMessage,
+    LLMMessage,
+    SystemMessage,
+    UserMessage,
+)
+from autogen_core.components.tools import FunctionTool, Tool
+from pydantic import BaseModel, ConfigDict
+
+from .. import EVENT_LOGGER_NAME
+from ..messages import (
+    ChatMessage,
+    StopMessage,
+    TextMessage,
+)
+from ._base_chat_agent import BaseChatAgent
+
+event_logger = logging.getLogger(EVENT_LOGGER_NAME)
+
+
+class ToolCallEvent(BaseModel):
+    """A tool call event."""
+
+    tool_calls: List[FunctionCall]
+    """The tool call message."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ToolCallResultEvent(BaseModel):
+    """A tool call result event."""
+
+    tool_call_results: List[FunctionExecutionResult]
+    """The tool call result message."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class AssistantAgent(BaseChatAgent):
+    """An agent that provides assistance with tool use.
+
+    It responds with a StopMessage when 'terminate' is detected in the response.
+
+    Args:
+        name (str): The name of the agent.
+        model_client (ChatCompletionClient): The model client to use for inference.
+        tools (List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]] | None, optional): The tools to register with the agent.
+        description (str, optional): The description of the agent.
+        system_message (str, optional): The system message for the model.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        model_client: ChatCompletionClient,
+        *,
+        tools: List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]] | None = None,
+        description: str = "An agent that provides assistance with ability to use tools.",
+        system_message: str = "You are a helpful AI assistant. Solve tasks using your tools. Reply with 'TERMINATE' when the task has been completed.",
+    ):
+        super().__init__(name=name, description=description)
+        self._model_client = model_client
+        self._system_messages = [SystemMessage(content=system_message)]
+        self._tools: List[Tool] = []
+        if tools is not None:
+            for tool in tools:
+                if isinstance(tool, Tool):
+                    self._tools.append(tool)
+                elif callable(tool):
+                    if hasattr(tool, "__doc__") and tool.__doc__ is not None:
+                        description = tool.__doc__
+                    else:
+                        description = ""
+                    self._tools.append(FunctionTool(tool, description=description))
+                else:
+                    raise ValueError(f"Unsupported tool type: {type(tool)}")
+        self._model_context: List[LLMMessage] = []
+
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+        # Add messages to the model context.
+        for msg in messages:
+            # TODO: add special handling for handoff messages
+            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
+
+        # Generate an inference result based on the current model context.
+        llm_messages = self._system_messages + self._model_context
+        result = await self._model_client.create(llm_messages, tools=self._tools, cancellation_token=cancellation_token)
+
+        # Add the response to the model context.
+        self._model_context.append(AssistantMessage(content=result.content, source=self.name))
+
+        # Run tool calls until the model produces a string response.
+        while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
+            event_logger.debug(ToolCallEvent(tool_calls=result.content))
+            # Execute the tool calls.
+            results = await asyncio.gather(
+                *[self._execute_tool_call(call, cancellation_token) for call in result.content]
+            )
+            event_logger.debug(ToolCallResultEvent(tool_call_results=results))
+            self._model_context.append(FunctionExecutionResultMessage(content=results))
+            # Generate an inference result based on the current model context.
+            result = await self._model_client.create(
+                self._model_context, tools=self._tools, cancellation_token=cancellation_token
+            )
+            self._model_context.append(AssistantMessage(content=result.content, source=self.name))
+
+        assert isinstance(result.content, str)
+        # Detect stop request.
+        request_stop = "terminate" in result.content.strip().lower()
+        if request_stop:
+            return StopMessage(content=result.content, source=self.name)
+
+        return TextMessage(content=result.content, source=self.name)
+
+    async def _execute_tool_call(
+        self, tool_call: FunctionCall, cancellation_token: CancellationToken
+    ) -> FunctionExecutionResult:
+        """Execute a tool call and return the result."""
+        try:
+            if not self._tools:
+                raise ValueError("No tools are available.")
+            tool = next((t for t in self._tools if t.name == tool_call.name), None)
+            if tool is None:
+                raise ValueError(f"The tool '{tool_call.name}' is not available.")
+            arguments = json.loads(tool_call.arguments)
+            result = await tool.run_json(arguments, cancellation_token)
+            result_as_str = tool.return_value_as_string(result)
+            return FunctionExecutionResult(content=result_as_str, call_id=tool_call.id)
+        except Exception as e:
+            return FunctionExecutionResult(content=f"Error: {e}", call_id=tool_call.id)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
index 070e2d491589..d7c5bfa97976 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_coding_assistant_agent.py
@@ -1,20 +1,14 @@
-from typing import List, Sequence
+import warnings
 
-from autogen_core.base import CancellationToken
 from autogen_core.components.models import (
-    AssistantMessage,
     ChatCompletionClient,
-    LLMMessage,
-    SystemMessage,
-    UserMessage,
 )
 
-from ..messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
-from ._base_chat_agent import BaseChatAgent
+from ._assistant_agent import AssistantAgent
 
 
-class CodingAssistantAgent(BaseChatAgent):
-    """An agent that provides coding assistance using an LLM model client.
+class CodingAssistantAgent(AssistantAgent):
+    """[DEPRECATED] An agent that provides coding assistance using an LLM model client.
 
     It responds with a StopMessage when 'terminate' is detected in the response.
     """
@@ -37,29 +31,10 @@ def __init__(
 When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible.
 Reply "TERMINATE" in the end when code has been executed and task is complete.""",
     ):
-        super().__init__(name=name, description=description)
-        self._model_client = model_client
-        self._system_messages = [SystemMessage(content=system_message)]
-        self._model_context: List[LLMMessage] = []
-
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        # Add messages to the model context and detect stopping.
-        for msg in messages:
-            if not isinstance(msg, TextMessage | MultiModalMessage | StopMessage):
-                raise ValueError(f"Unsupported message type: {type(msg)}")
-            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
-
-        # Generate an inference result based on the current model context.
-        llm_messages = self._system_messages + self._model_context
-        result = await self._model_client.create(llm_messages, cancellation_token=cancellation_token)
-        assert isinstance(result.content, str)
-
-        # Add the response to the model context.
-        self._model_context.append(AssistantMessage(content=result.content, source=self.name))
-
-        # Detect stop request.
-        request_stop = "terminate" in result.content.strip().lower()
-        if request_stop:
-            return StopMessage(content=result.content, source=self.name)
-
-        return TextMessage(content=result.content, source=self.name)
+        # Deprecation warning.
+        warnings.warn(
+            "CodingAssistantAgent is deprecated. Use AssistantAgent instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(name, model_client, description=description, system_message=system_message)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
index fde1a3e49890..0f59efb67778 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_tool_use_assistant_agent.py
@@ -1,53 +1,20 @@
-import asyncio
-import json
 import logging
-from typing import Any, Awaitable, Callable, List, Sequence
+import warnings
+from typing import Any, Awaitable, Callable, List
 
-from autogen_core.base import CancellationToken
-from autogen_core.components import FunctionCall
 from autogen_core.components.models import (
-    AssistantMessage,
     ChatCompletionClient,
-    FunctionExecutionResult,
-    FunctionExecutionResultMessage,
-    LLMMessage,
-    SystemMessage,
-    UserMessage,
 )
-from autogen_core.components.tools import FunctionTool, Tool
-from pydantic import BaseModel, ConfigDict
+from autogen_core.components.tools import Tool
 
 from .. import EVENT_LOGGER_NAME
-from ..messages import (
-    ChatMessage,
-    StopMessage,
-    TextMessage,
-)
-from ._base_chat_agent import BaseChatAgent
+from ._assistant_agent import AssistantAgent
 
 event_logger = logging.getLogger(EVENT_LOGGER_NAME)
 
 
-class ToolCallEvent(BaseModel):
-    """A tool call event."""
-
-    tool_calls: List[FunctionCall]
-    """The tool call message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class ToolCallResultEvent(BaseModel):
-    """A tool call result event."""
-
-    tool_call_results: List[FunctionExecutionResult]
-    """The tool call result message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class ToolUseAssistantAgent(BaseChatAgent):
-    """An agent that provides assistance with tool use.
+class ToolUseAssistantAgent(AssistantAgent):
+    """[DEPRECATED] An agent that provides assistance with tool use.
 
     It responds with a StopMessage when 'terminate' is detected in the response.
 
@@ -68,72 +35,12 @@ def __init__(
         description: str = "An agent that provides assistance with ability to use tools.",
         system_message: str = "You are a helpful AI assistant. Solve tasks using your tools. Reply with 'TERMINATE' when the task has been completed.",
     ):
-        super().__init__(name=name, description=description)
-        self._model_client = model_client
-        self._system_messages = [SystemMessage(content=system_message)]
-        self._tools: List[Tool] = []
-        for tool in registered_tools:
-            if isinstance(tool, Tool):
-                self._tools.append(tool)
-            elif callable(tool):
-                if hasattr(tool, "__doc__") and tool.__doc__ is not None:
-                    description = tool.__doc__
-                else:
-                    description = ""
-                self._tools.append(FunctionTool(tool, description=description))
-            else:
-                raise ValueError(f"Unsupported tool type: {type(tool)}")
-        self._model_context: List[LLMMessage] = []
-
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        # Add messages to the model context.
-        for msg in messages:
-            # TODO: add special handling for handoff messages
-            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
-
-        # Generate an inference result based on the current model context.
-        llm_messages = self._system_messages + self._model_context
-        result = await self._model_client.create(llm_messages, tools=self._tools, cancellation_token=cancellation_token)
-
-        # Add the response to the model context.
-        self._model_context.append(AssistantMessage(content=result.content, source=self.name))
-
-        # Run tool calls until the model produces a string response.
-        while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
-            event_logger.debug(ToolCallEvent(tool_calls=result.content))
-            # Execute the tool calls.
-            results = await asyncio.gather(
-                *[self._execute_tool_call(call, cancellation_token) for call in result.content]
-            )
-            event_logger.debug(ToolCallResultEvent(tool_call_results=results))
-            self._model_context.append(FunctionExecutionResultMessage(content=results))
-            # Generate an inference result based on the current model context.
-            result = await self._model_client.create(
-                self._model_context, tools=self._tools, cancellation_token=cancellation_token
-            )
-            self._model_context.append(AssistantMessage(content=result.content, source=self.name))
-
-        assert isinstance(result.content, str)
-        # Detect stop request.
-        request_stop = "terminate" in result.content.strip().lower()
-        if request_stop:
-            return StopMessage(content=result.content, source=self.name)
-
-        return TextMessage(content=result.content, source=self.name)
-
-    async def _execute_tool_call(
-        self, tool_call: FunctionCall, cancellation_token: CancellationToken
-    ) -> FunctionExecutionResult:
-        """Execute a tool call and return the result."""
-        try:
-            if not self._tools:
-                raise ValueError("No tools are available.")
-            tool = next((t for t in self._tools if t.name == tool_call.name), None)
-            if tool is None:
-                raise ValueError(f"The tool '{tool_call.name}' is not available.")
-            arguments = json.loads(tool_call.arguments)
-            result = await tool.run_json(arguments, cancellation_token)
-            result_as_str = tool.return_value_as_string(result)
-            return FunctionExecutionResult(content=result_as_str, call_id=tool_call.id)
-        except Exception as e:
-            return FunctionExecutionResult(content=f"Error: {e}", call_id=tool_call.id)
+        # Deprecation warning.
+        warnings.warn(
+            "ToolUseAssistantAgent is deprecated. Use AssistantAgent instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(
+            name, model_client, tools=registered_tools, description=description, system_message=system_message
+        )
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
index 95200e2841be..571cc875cec3 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
@@ -3,7 +3,7 @@
 import sys
 from datetime import datetime
 
-from ..agents._tool_use_assistant_agent import ToolCallEvent, ToolCallResultEvent
+from ..agents._assistant_agent import ToolCallEvent, ToolCallResultEvent
 from ..messages import ChatMessage, StopMessage, TextMessage
 from ..teams._events import (
     GroupChatPublishEvent,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
index 24fd09418094..9923f313d9e5 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
@@ -4,7 +4,7 @@
 from datetime import datetime
 from typing import Any
 
-from ..agents._tool_use_assistant_agent import ToolCallEvent, ToolCallResultEvent
+from ..agents._assistant_agent import ToolCallEvent, ToolCallResultEvent
 from ..teams._events import (
     GroupChatPublishEvent,
     GroupChatSelectSpeakerEvent,
diff --git a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
similarity index 90%
rename from python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
rename to python/packages/autogen-agentchat/tests/test_assistant_agent.py
index d5ec31a12b04..9a243a5a206e 100644
--- a/python/packages/autogen-agentchat/tests/test_tool_use_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -3,10 +3,10 @@
 from typing import Any, AsyncGenerator, List
 
 import pytest
-from autogen_agentchat.agents import ToolUseAssistantAgent
+from autogen_agentchat.agents import AssistantAgent
 from autogen_agentchat.messages import StopMessage, TextMessage
-from autogen_core.components.models import OpenAIChatCompletionClient
 from autogen_core.components.tools import FunctionTool
+from autogen_ext.models import OpenAIChatCompletionClient
 from openai.resources.chat.completions import AsyncCompletions
 from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -42,7 +42,7 @@ async def _echo_function(input: str) -> str:
 
 
 @pytest.mark.asyncio
-async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     model = "gpt-4o-2024-05-13"
     chat_completions = [
         ChatCompletion(
@@ -97,10 +97,10 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     ]
     mock = _MockChatCompletion(chat_completions)
     monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
-    tool_use_agent = ToolUseAssistantAgent(
+    tool_use_agent = AssistantAgent(
         "tool_use_agent",
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
-        registered_tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
+        tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
     )
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 3
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 9f740eb6439c..3f3c8a3b8a19 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -7,10 +7,9 @@
 import pytest
 from autogen_agentchat import EVENT_LOGGER_NAME
 from autogen_agentchat.agents import (
+    AssistantAgent,
     BaseChatAgent,
     CodeExecutorAgent,
-    CodingAssistantAgent,
-    ToolUseAssistantAgent,
 )
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import (
@@ -131,7 +130,7 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         code_executor_agent = CodeExecutorAgent(
             "code_executor", code_executor=LocalCommandLineCodeExecutor(work_dir=temp_dir)
         )
-        coding_assistant_agent = CodingAssistantAgent(
+        coding_assistant_agent = AssistantAgent(
             "coding_assistant", model_client=OpenAIChatCompletionClient(model=model, api_key="")
         )
         team = RoundRobinGroupChat(participants=[coding_assistant_agent, code_executor_agent])
@@ -211,10 +210,10 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     mock = _MockChatCompletion(chat_completions)
     monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
     tool = FunctionTool(_pass_function, name="pass", description="pass function")
-    tool_use_agent = ToolUseAssistantAgent(
+    tool_use_agent = AssistantAgent(
         "tool_use_agent",
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
-        registered_tools=[tool],
+        tools=[tool],
     )
     echo_agent = _EchoAgent("echo_agent", description="echo agent")
     team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent])
diff --git a/python/uv.lock b/python/uv.lock
index ed20c3784d79..d1c9d588c3eb 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -1,27 +1,11 @@
 version = 1
 requires-python = ">=3.10, <3.13"
 resolution-markers = [
-    "python_full_version < '3.11' and platform_system == 'Darwin'",
-    "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "python_full_version == '3.11.*' and platform_system == 'Darwin'",
-    "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "python_full_version < '3.11' and platform_system == 'Darwin'",
-    "python_full_version == '3.11.*' and platform_system == 'Darwin'",
-    "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system == 'Darwin'",
-    "python_full_version < '3.11' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "python_full_version == '3.11.*' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "(python_full_version < '3.11' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.11' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version == '3.11.*' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "(python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.12' and python_full_version < '3.12.4' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "python_full_version < '3.13' and platform_system == 'Darwin'",
-    "python_full_version >= '3.13' and platform_system == 'Darwin'",
-    "python_full_version < '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "python_full_version >= '3.13' and platform_machine == 'aarch64' and platform_system == 'Linux'",
-    "(python_full_version < '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version < '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",
-    "(python_full_version >= '3.13' and platform_machine != 'aarch64' and platform_system != 'Darwin') or (python_full_version >= '3.13' and platform_system != 'Darwin' and platform_system != 'Linux')",
+    "python_full_version < '3.11'",
+    "python_full_version == '3.11.*'",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4'",
+    "python_full_version < '3.13'",
+    "python_full_version >= '3.13'",
 ]
 
 [manifest]
@@ -112,16 +96,16 @@ wheels = [
 
 [[package]]
 name = "aiohappyeyeballs"
-version = "2.4.0"
+version = "2.4.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2d/f7/22bba300a16fd1cad99da1a23793fe43963ee326d012fdf852d0b4035955/aiohappyeyeballs-2.4.0.tar.gz", hash = "sha256:55a1714f084e63d49639800f95716da97a1f173d46a16dfcfda0016abb93b6b2", size = 16786 }
+sdist = { url = "https://files.pythonhosted.org/packages/bc/69/2f6d5a019bd02e920a3417689a89887b39ad1e350b562f9955693d900c40/aiohappyeyeballs-2.4.3.tar.gz", hash = "sha256:75cf88a15106a5002a8eb1dab212525c00d1f4c0fa96e551c9fbe6f09a621586", size = 21809 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/b6/58ea188899950d759a837f9a58b2aee1d1a380ea4d6211ce9b1823748851/aiohappyeyeballs-2.4.0-py3-none-any.whl", hash = "sha256:7ce92076e249169a13c2f49320d1967425eaf1f407522d707d59cac7628d62bd", size = 12155 },
+    { url = "https://files.pythonhosted.org/packages/f7/d8/120cd0fe3e8530df0539e71ba9683eade12cae103dd7543e50d15f737917/aiohappyeyeballs-2.4.3-py3-none-any.whl", hash = "sha256:8a7a83727b2756f394ab2895ea0765a0a8c475e3c71e98d43d76f22b4b435572", size = 14742 },
 ]
 
 [[package]]
 name = "aiohttp"
-version = "3.10.5"
+version = "3.10.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohappyeyeballs" },
@@ -132,68 +116,81 @@ dependencies = [
     { name = "multidict" },
     { name = "yarl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ca/28/ca549838018140b92a19001a8628578b0f2a3b38c16826212cc6f706e6d4/aiohttp-3.10.5.tar.gz", hash = "sha256:f071854b47d39591ce9a17981c46790acb30518e2f83dfca8db2dfa091178691", size = 7524360 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c0/4a/b27dd9b88fe22dde88742b341fd10251746a6ffcfe1c0b8b15b4a8cbd7c1/aiohttp-3.10.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:18a01eba2574fb9edd5f6e5fb25f66e6ce061da5dab5db75e13fe1558142e0a3", size = 587010 },
-    { url = "https://files.pythonhosted.org/packages/de/a9/0f7e2b71549c9d641086c423526ae7a10de3b88d03ba104a3df153574d0d/aiohttp-3.10.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:94fac7c6e77ccb1ca91e9eb4cb0ac0270b9fb9b289738654120ba8cebb1189c6", size = 397698 },
-    { url = "https://files.pythonhosted.org/packages/3b/52/26baa486e811c25b0cd16a494038260795459055568713f841e78f016481/aiohttp-3.10.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2f1f1c75c395991ce9c94d3e4aa96e5c59c8356a15b1c9231e783865e2772699", size = 389052 },
-    { url = "https://files.pythonhosted.org/packages/33/df/71ba374a3e925539cb2f6e6d4f5326e7b6b200fabbe1b3cc5e6368f07ce7/aiohttp-3.10.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f7acae3cf1a2a2361ec4c8e787eaaa86a94171d2417aae53c0cca6ca3118ff6", size = 1248615 },
-    { url = "https://files.pythonhosted.org/packages/67/02/bb89c1eba08a27fc844933bee505d63d480caf8e2816c06961d2941cd128/aiohttp-3.10.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:94c4381ffba9cc508b37d2e536b418d5ea9cfdc2848b9a7fea6aebad4ec6aac1", size = 1282930 },
-    { url = "https://files.pythonhosted.org/packages/db/36/07d8cfcc37f39c039f93a4210cc71dadacca003609946c63af23659ba656/aiohttp-3.10.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c31ad0c0c507894e3eaa843415841995bf8de4d6b2d24c6e33099f4bc9fc0d4f", size = 1317250 },
-    { url = "https://files.pythonhosted.org/packages/9a/44/cabeac994bef8ba521b552ae996928afc6ee1975a411385a07409811b01f/aiohttp-3.10.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0912b8a8fadeb32ff67a3ed44249448c20148397c1ed905d5dac185b4ca547bb", size = 1243212 },
-    { url = "https://files.pythonhosted.org/packages/5a/11/23f1e31f5885ac72be52fd205981951dd2e4c87c5b1487cf82fde5bbd46c/aiohttp-3.10.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d93400c18596b7dc4794d48a63fb361b01a0d8eb39f28800dc900c8fbdaca91", size = 1213401 },
-    { url = "https://files.pythonhosted.org/packages/3f/e7/6e69a0b0d896fbaf1192d492db4c21688e6c0d327486da610b0e8195bcc9/aiohttp-3.10.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d00f3c5e0d764a5c9aa5a62d99728c56d455310bcc288a79cab10157b3af426f", size = 1212450 },
-    { url = "https://files.pythonhosted.org/packages/a9/7f/a42f51074c723ea848254946aec118f1e59914a639dc8ba20b0c9247c195/aiohttp-3.10.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:d742c36ed44f2798c8d3f4bc511f479b9ceef2b93f348671184139e7d708042c", size = 1211324 },
-    { url = "https://files.pythonhosted.org/packages/d5/43/c2f9d2f588ccef8f028f0a0c999b5ceafecbda50b943313faee7e91f3e03/aiohttp-3.10.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:814375093edae5f1cb31e3407997cf3eacefb9010f96df10d64829362ae2df69", size = 1266838 },
-    { url = "https://files.pythonhosted.org/packages/c1/a7/ff9f067ecb06896d859e4f2661667aee4bd9c616689599ff034b63cbd9d7/aiohttp-3.10.5-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8224f98be68a84b19f48e0bdc14224b5a71339aff3a27df69989fa47d01296f3", size = 1285301 },
-    { url = "https://files.pythonhosted.org/packages/9a/e3/dd56bb4c67d216046ce61d98dec0f3023043f1de48f561df1bf93dd47aea/aiohttp-3.10.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d9a487ef090aea982d748b1b0d74fe7c3950b109df967630a20584f9a99c0683", size = 1235806 },
-    { url = "https://files.pythonhosted.org/packages/a7/64/90dcd42ac21927a49ba4140b2e4d50e1847379427ef6c43eb338ef9960e3/aiohttp-3.10.5-cp310-cp310-win32.whl", hash = "sha256:d9ef084e3dc690ad50137cc05831c52b6ca428096e6deb3c43e95827f531d5ef", size = 360162 },
-    { url = "https://files.pythonhosted.org/packages/f3/45/145d8b4853fc92c0c8509277642767e7726a085e390ce04353dc68b0f5b5/aiohttp-3.10.5-cp310-cp310-win_amd64.whl", hash = "sha256:66bf9234e08fe561dccd62083bf67400bdbf1c67ba9efdc3dac03650e97c6088", size = 379173 },
-    { url = "https://files.pythonhosted.org/packages/f1/90/54ccb1e4eadfb6c95deff695582453f6208584431d69bf572782e9ae542b/aiohttp-3.10.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8c6a4e5e40156d72a40241a25cc226051c0a8d816610097a8e8f517aeacd59a2", size = 586455 },
-    { url = "https://files.pythonhosted.org/packages/c3/7a/95e88c02756e7e718f054e1bb3ec6ad5d0ee4a2ca2bb1768c5844b3de30a/aiohttp-3.10.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2c634a3207a5445be65536d38c13791904fda0748b9eabf908d3fe86a52941cf", size = 397255 },
-    { url = "https://files.pythonhosted.org/packages/07/4f/767387b39990e1ee9aba8ce642abcc286d84d06e068dc167dab983898f18/aiohttp-3.10.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4aff049b5e629ef9b3e9e617fa6e2dfeda1bf87e01bcfecaf3949af9e210105e", size = 388973 },
-    { url = "https://files.pythonhosted.org/packages/61/46/0df41170a4d228c07b661b1ba9d87101d99a79339dc93b8b1183d8b20545/aiohttp-3.10.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1942244f00baaacaa8155eca94dbd9e8cc7017deb69b75ef67c78e89fdad3c77", size = 1326126 },
-    { url = "https://files.pythonhosted.org/packages/af/20/da0d65e07ce49d79173fed41598f487a0a722e87cfbaa8bb7e078a7c1d39/aiohttp-3.10.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e04a1f2a65ad2f93aa20f9ff9f1b672bf912413e5547f60749fa2ef8a644e061", size = 1364538 },
-    { url = "https://files.pythonhosted.org/packages/aa/20/b59728405114e57541ba9d5b96033e69d004e811ded299537f74237629ca/aiohttp-3.10.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7f2bfc0032a00405d4af2ba27f3c429e851d04fad1e5ceee4080a1c570476697", size = 1399896 },
-    { url = "https://files.pythonhosted.org/packages/2a/92/006690c31b830acbae09d2618e41308fe4c81c0679b3b33a3af859e0b7bf/aiohttp-3.10.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:424ae21498790e12eb759040bbb504e5e280cab64693d14775c54269fd1d2bb7", size = 1312914 },
-    { url = "https://files.pythonhosted.org/packages/d4/71/1a253ca215b6c867adbd503f1e142117527ea8775e65962bc09b2fad1d2c/aiohttp-3.10.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:975218eee0e6d24eb336d0328c768ebc5d617609affaca5dbbd6dd1984f16ed0", size = 1271301 },
-    { url = "https://files.pythonhosted.org/packages/0a/ab/5d1d9ff9ce6cce8fa54774d0364e64a0f3cd50e512ff09082ced8e5217a1/aiohttp-3.10.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4120d7fefa1e2d8fb6f650b11489710091788de554e2b6f8347c7a20ceb003f5", size = 1291652 },
-    { url = "https://files.pythonhosted.org/packages/75/5f/f90510ea954b9ae6e7a53d2995b97a3e5c181110fdcf469bc9238445871d/aiohttp-3.10.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b90078989ef3fc45cf9221d3859acd1108af7560c52397ff4ace8ad7052a132e", size = 1286289 },
-    { url = "https://files.pythonhosted.org/packages/be/9e/1f523414237798660921817c82b9225a363af436458caf584d2fa6a2eb4a/aiohttp-3.10.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:ba5a8b74c2a8af7d862399cdedce1533642fa727def0b8c3e3e02fcb52dca1b1", size = 1341848 },
-    { url = "https://files.pythonhosted.org/packages/f6/36/443472ddaa85d7d80321fda541d9535b23ecefe0bf5792cc3955ea635190/aiohttp-3.10.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:02594361128f780eecc2a29939d9dfc870e17b45178a867bf61a11b2a4367277", size = 1361619 },
-    { url = "https://files.pythonhosted.org/packages/19/f6/3ecbac0bc4359c7d7ba9e85c6b10f57e20edaf1f97751ad2f892db231ad0/aiohttp-3.10.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8fb4fc029e135859f533025bc82047334e24b0d489e75513144f25408ecaf058", size = 1320869 },
-    { url = "https://files.pythonhosted.org/packages/34/7e/ed74ffb36e3a0cdec1b05d8fbaa29cb532371d5a20058b3a8052fc90fe7c/aiohttp-3.10.5-cp311-cp311-win32.whl", hash = "sha256:e1ca1ef5ba129718a8fc827b0867f6aa4e893c56eb00003b7367f8a733a9b072", size = 359271 },
-    { url = "https://files.pythonhosted.org/packages/98/1b/718901f04bc8c886a742be9e83babb7b93facabf7c475cc95e2b3ab80b4d/aiohttp-3.10.5-cp311-cp311-win_amd64.whl", hash = "sha256:349ef8a73a7c5665cca65c88ab24abe75447e28aa3bc4c93ea5093474dfdf0ff", size = 379143 },
-    { url = "https://files.pythonhosted.org/packages/d9/1c/74f9dad4a2fc4107e73456896283d915937f48177b99867b63381fadac6e/aiohttp-3.10.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:305be5ff2081fa1d283a76113b8df7a14c10d75602a38d9f012935df20731487", size = 583468 },
-    { url = "https://files.pythonhosted.org/packages/12/29/68d090551f2b58ce76c2b436ced8dd2dfd32115d41299bf0b0c308a5483c/aiohttp-3.10.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3a1c32a19ee6bbde02f1cb189e13a71b321256cc1d431196a9f824050b160d5a", size = 394066 },
-    { url = "https://files.pythonhosted.org/packages/8f/f7/971f88b4cdcaaa4622925ba7d86de47b48ec02a9040a143514b382f78da4/aiohttp-3.10.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:61645818edd40cc6f455b851277a21bf420ce347baa0b86eaa41d51ef58ba23d", size = 389098 },
-    { url = "https://files.pythonhosted.org/packages/f1/5a/fe3742efdce551667b2ddf1158b27c5b8eb1edc13d5e14e996e52e301025/aiohttp-3.10.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c225286f2b13bab5987425558baa5cbdb2bc925b2998038fa028245ef421e75", size = 1332742 },
-    { url = "https://files.pythonhosted.org/packages/1a/52/a25c0334a1845eb4967dff279151b67ca32a948145a5812ed660ed900868/aiohttp-3.10.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8ba01ebc6175e1e6b7275c907a3a36be48a2d487549b656aa90c8a910d9f3178", size = 1372134 },
-    { url = "https://files.pythonhosted.org/packages/96/3d/33c1d8efc2d8ec36bff9a8eca2df9fdf8a45269c6e24a88e74f2aa4f16bd/aiohttp-3.10.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8eaf44ccbc4e35762683078b72bf293f476561d8b68ec8a64f98cf32811c323e", size = 1414413 },
-    { url = "https://files.pythonhosted.org/packages/64/74/0f1ddaa5f0caba1d946f0dd0c31f5744116e4a029beec454ec3726d3311f/aiohttp-3.10.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b1c43eb1ab7cbf411b8e387dc169acb31f0ca0d8c09ba63f9eac67829585b44f", size = 1328107 },
-    { url = "https://files.pythonhosted.org/packages/0a/32/c10118f0ad50e4093227234f71fd0abec6982c29367f65f32ee74ed652c4/aiohttp-3.10.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de7a5299827253023c55ea549444e058c0eb496931fa05d693b95140a947cb73", size = 1280126 },
-    { url = "https://files.pythonhosted.org/packages/c6/c9/77e3d648d97c03a42acfe843d03e97be3c5ef1b4d9de52e5bd2d28eed8e7/aiohttp-3.10.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4790f0e15f00058f7599dab2b206d3049d7ac464dc2e5eae0e93fa18aee9e7bf", size = 1292660 },
-    { url = "https://files.pythonhosted.org/packages/7e/5d/99c71f8e5c8b64295be421b4c42d472766b263a1fe32e91b64bf77005bf2/aiohttp-3.10.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:44b324a6b8376a23e6ba25d368726ee3bc281e6ab306db80b5819999c737d820", size = 1300988 },
-    { url = "https://files.pythonhosted.org/packages/8f/2c/76d2377dd947f52fbe8afb19b18a3b816d66c7966755c04030f93b1f7b2d/aiohttp-3.10.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:0d277cfb304118079e7044aad0b76685d30ecb86f83a0711fc5fb257ffe832ca", size = 1339268 },
-    { url = "https://files.pythonhosted.org/packages/fd/e6/3d9d935cc705d57ed524d82ec5d6b678a53ac1552720ae41282caa273584/aiohttp-3.10.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:54d9ddea424cd19d3ff6128601a4a4d23d54a421f9b4c0fff740505813739a91", size = 1366993 },
-    { url = "https://files.pythonhosted.org/packages/fe/c2/f7eed4d602f3f224600d03ab2e1a7734999b0901b1c49b94dc5891340433/aiohttp-3.10.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4f1c9866ccf48a6df2b06823e6ae80573529f2af3a0992ec4fe75b1a510df8a6", size = 1329459 },
-    { url = "https://files.pythonhosted.org/packages/ce/8f/27f205b76531fc592abe29e1ad265a16bf934a9f609509c02d765e6a8055/aiohttp-3.10.5-cp312-cp312-win32.whl", hash = "sha256:dc4826823121783dccc0871e3f405417ac116055bf184ac04c36f98b75aacd12", size = 356968 },
-    { url = "https://files.pythonhosted.org/packages/39/8c/4f6c0b2b3629f6be6c81ab84d9d577590f74f01d4412bfc4067958eaa1e1/aiohttp-3.10.5-cp312-cp312-win_amd64.whl", hash = "sha256:22c0a23a3b3138a6bf76fc553789cb1a703836da86b0f306b6f0dc1617398abc", size = 377650 },
-    { url = "https://files.pythonhosted.org/packages/7b/b9/03b4327897a5b5d29338fa9b514f1c2f66a3e4fc88a4e40fad478739314d/aiohttp-3.10.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7f6b639c36734eaa80a6c152a238242bedcee9b953f23bb887e9102976343092", size = 576994 },
-    { url = "https://files.pythonhosted.org/packages/67/1b/20c2e159cd07b8ed6dde71c2258233902fdf415b2fe6174bd2364ba63107/aiohttp-3.10.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f29930bc2921cef955ba39a3ff87d2c4398a0394ae217f41cb02d5c26c8b1b77", size = 390684 },
-    { url = "https://files.pythonhosted.org/packages/4d/6b/ff83b34f157e370431d8081c5d1741963f4fb12f9aaddb2cacbf50305225/aiohttp-3.10.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f489a2c9e6455d87eabf907ac0b7d230a9786be43fbe884ad184ddf9e9c1e385", size = 386176 },
-    { url = "https://files.pythonhosted.org/packages/4d/a1/6e92817eb657de287560962df4959b7ddd22859c4b23a0309e2d3de12538/aiohttp-3.10.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:123dd5b16b75b2962d0fff566effb7a065e33cd4538c1692fb31c3bda2bfb972", size = 1303310 },
-    { url = "https://files.pythonhosted.org/packages/04/29/200518dc7a39c30ae6d5bc232d7207446536e93d3d9299b8e95db6e79c54/aiohttp-3.10.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b98e698dc34966e5976e10bbca6d26d6724e6bdea853c7c10162a3235aba6e16", size = 1340445 },
-    { url = "https://files.pythonhosted.org/packages/8e/20/53f7bba841ba7b5bb5dea580fea01c65524879ba39cb917d08c845524717/aiohttp-3.10.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3b9162bab7e42f21243effc822652dc5bb5e8ff42a4eb62fe7782bcbcdfacf6", size = 1385121 },
-    { url = "https://files.pythonhosted.org/packages/f1/b4/d99354ad614c48dd38fb1ee880a1a54bd9ab2c3bcad3013048d4a1797d3a/aiohttp-3.10.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1923a5c44061bffd5eebeef58cecf68096e35003907d8201a4d0d6f6e387ccaa", size = 1299669 },
-    { url = "https://files.pythonhosted.org/packages/51/39/ca1de675f2a5729c71c327e52ac6344e63f036bd37281686ae5c3fb13bfb/aiohttp-3.10.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d55f011da0a843c3d3df2c2cf4e537b8070a419f891c930245f05d329c4b0689", size = 1252638 },
-    { url = "https://files.pythonhosted.org/packages/54/cf/a3ae7ff43138422d477348e309ef8275779701bf305ff6054831ef98b782/aiohttp-3.10.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:afe16a84498441d05e9189a15900640a2d2b5e76cf4efe8cbb088ab4f112ee57", size = 1266889 },
-    { url = "https://files.pythonhosted.org/packages/6e/7a/c6027ad70d9fb23cf254a26144de2723821dade1a624446aa22cd0b6d012/aiohttp-3.10.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f8112fb501b1e0567a1251a2fd0747baae60a4ab325a871e975b7bb67e59221f", size = 1266249 },
-    { url = "https://files.pythonhosted.org/packages/64/fd/ed136d46bc2c7e3342fed24662b4827771d55ceb5a7687847aae977bfc17/aiohttp-3.10.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1e72589da4c90337837fdfe2026ae1952c0f4a6e793adbbfbdd40efed7c63599", size = 1311036 },
-    { url = "https://files.pythonhosted.org/packages/76/9a/43eeb0166f1119256d6f43468f900db1aed7fbe32069d2a71c82f987db4d/aiohttp-3.10.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:4d46c7b4173415d8e583045fbc4daa48b40e31b19ce595b8d92cf639396c15d5", size = 1338756 },
-    { url = "https://files.pythonhosted.org/packages/d5/bc/d01ff0810b3f5e26896f76d44225ed78b088ddd33079b85cd1a23514318b/aiohttp-3.10.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:33e6bc4bab477c772a541f76cd91e11ccb6d2efa2b8d7d7883591dfb523e5987", size = 1299976 },
-    { url = "https://files.pythonhosted.org/packages/3e/c9/50a297c4f7ab57a949f4add2d3eafe5f3e68bb42f739e933f8b32a092bda/aiohttp-3.10.5-cp313-cp313-win32.whl", hash = "sha256:c58c6837a2c2a7cf3133983e64173aec11f9c2cd8e87ec2fdc16ce727bcf1a04", size = 355609 },
-    { url = "https://files.pythonhosted.org/packages/65/28/aee9d04fb0b3b1f90622c338a08e54af5198e704a910e20947c473298fd0/aiohttp-3.10.5-cp313-cp313-win_amd64.whl", hash = "sha256:38172a70005252b6893088c0f5e8a47d173df7cc2b2bd88650957eb84fcf5022", size = 375697 },
+sdist = { url = "https://files.pythonhosted.org/packages/17/7e/16e57e6cf20eb62481a2f9ce8674328407187950ccc602ad07c685279141/aiohttp-3.10.10.tar.gz", hash = "sha256:0631dd7c9f0822cc61c88586ca76d5b5ada26538097d0f1df510b082bad3411a", size = 7542993 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/dd/3d40c0e67e79c5c42671e3e268742f1ff96c6573ca43823563d01abd9475/aiohttp-3.10.10-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:be7443669ae9c016b71f402e43208e13ddf00912f47f623ee5994e12fc7d4b3f", size = 586969 },
+    { url = "https://files.pythonhosted.org/packages/75/64/8de41b5555e5b43ef6d4ed1261891d33fe45ecc6cb62875bfafb90b9ab93/aiohttp-3.10.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7b06b7843929e41a94ea09eb1ce3927865387e3e23ebe108e0d0d09b08d25be9", size = 399367 },
+    { url = "https://files.pythonhosted.org/packages/96/36/27bd62ea7ce43906d1443a73691823fc82ffb8fa03276b0e2f7e1037c286/aiohttp-3.10.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:333cf6cf8e65f6a1e06e9eb3e643a0c515bb850d470902274239fea02033e9a8", size = 390720 },
+    { url = "https://files.pythonhosted.org/packages/e8/4d/d516b050d811ce0dd26325c383013c104ffa8b58bd361b82e52833f68e78/aiohttp-3.10.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:274cfa632350225ce3fdeb318c23b4a10ec25c0e2c880eff951a3842cf358ac1", size = 1228820 },
+    { url = "https://files.pythonhosted.org/packages/53/94/964d9327a3e336d89aad52260836e4ec87fdfa1207176550fdf384eaffe7/aiohttp-3.10.10-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d9e5e4a85bdb56d224f412d9c98ae4cbd032cc4f3161818f692cd81766eee65a", size = 1264616 },
+    { url = "https://files.pythonhosted.org/packages/0c/20/70ce17764b685ca8f5bf4d568881b4e1f1f4ea5e8170f512fdb1a33859d2/aiohttp-3.10.10-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b606353da03edcc71130b52388d25f9a30a126e04caef1fd637e31683033abd", size = 1298402 },
+    { url = "https://files.pythonhosted.org/packages/d1/d1/5248225ccc687f498d06c3bca5af2647a361c3687a85eb3aedcc247ee1aa/aiohttp-3.10.10-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab5a5a0c7a7991d90446a198689c0535be89bbd6b410a1f9a66688f0880ec026", size = 1222205 },
+    { url = "https://files.pythonhosted.org/packages/f2/a3/9296b27cc5d4feadf970a14d0694902a49a985f3fae71b8322a5f77b0baa/aiohttp-3.10.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:578a4b875af3e0daaf1ac6fa983d93e0bbfec3ead753b6d6f33d467100cdc67b", size = 1193804 },
+    { url = "https://files.pythonhosted.org/packages/d9/07/f3760160feb12ac51a6168a6da251a4a8f2a70733d49e6ceb9b3e6ee2f03/aiohttp-3.10.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:8105fd8a890df77b76dd3054cddf01a879fc13e8af576805d667e0fa0224c35d", size = 1193544 },
+    { url = "https://files.pythonhosted.org/packages/7e/4c/93a70f9a4ba1c30183a6dd68bfa79cddbf9a674f162f9c62e823a74a5515/aiohttp-3.10.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3bcd391d083f636c06a68715e69467963d1f9600f85ef556ea82e9ef25f043f7", size = 1193047 },
+    { url = "https://files.pythonhosted.org/packages/ff/a3/36a1e23ff00c7a0cd696c5a28db05db25dc42bfc78c508bd78623ff62a4a/aiohttp-3.10.10-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fbc6264158392bad9df19537e872d476f7c57adf718944cc1e4495cbabf38e2a", size = 1247201 },
+    { url = "https://files.pythonhosted.org/packages/55/ae/95399848557b98bb2c402d640b2276ce3a542b94dba202de5a5a1fe29abe/aiohttp-3.10.10-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e48d5021a84d341bcaf95c8460b152cfbad770d28e5fe14a768988c461b821bc", size = 1264102 },
+    { url = "https://files.pythonhosted.org/packages/38/f5/02e5c72c1b60d7cceb30b982679a26167e84ac029fd35a93dd4da52c50a3/aiohttp-3.10.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2609e9ab08474702cc67b7702dbb8a80e392c54613ebe80db7e8dbdb79837c68", size = 1215760 },
+    { url = "https://files.pythonhosted.org/packages/30/17/1463840bad10d02d0439068f37ce5af0b383884b0d5838f46fb027e233bf/aiohttp-3.10.10-cp310-cp310-win32.whl", hash = "sha256:84afcdea18eda514c25bc68b9af2a2b1adea7c08899175a51fe7c4fb6d551257", size = 362678 },
+    { url = "https://files.pythonhosted.org/packages/dd/01/a0ef707d93e867a43abbffee3a2cdf30559910750b9176b891628c7ad074/aiohttp-3.10.10-cp310-cp310-win_amd64.whl", hash = "sha256:9c72109213eb9d3874f7ac8c0c5fa90e072d678e117d9061c06e30c85b4cf0e6", size = 381097 },
+    { url = "https://files.pythonhosted.org/packages/72/31/3c351d17596194e5a38ef169a4da76458952b2497b4b54645b9d483cbbb0/aiohttp-3.10.10-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c30a0eafc89d28e7f959281b58198a9fa5e99405f716c0289b7892ca345fe45f", size = 586501 },
+    { url = "https://files.pythonhosted.org/packages/a4/a8/a559d09eb08478cdead6b7ce05b0c4a133ba27fcdfa91e05d2e62867300d/aiohttp-3.10.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:258c5dd01afc10015866114e210fb7365f0d02d9d059c3c3415382ab633fcbcb", size = 398993 },
+    { url = "https://files.pythonhosted.org/packages/c5/47/7736d4174613feef61d25332c3bd1a4f8ff5591fbd7331988238a7299485/aiohttp-3.10.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:15ecd889a709b0080f02721255b3f80bb261c2293d3c748151274dfea93ac871", size = 390647 },
+    { url = "https://files.pythonhosted.org/packages/27/21/e9ba192a04b7160f5a8952c98a1de7cf8072ad150fa3abd454ead1ab1d7f/aiohttp-3.10.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3935f82f6f4a3820270842e90456ebad3af15810cf65932bd24da4463bc0a4c", size = 1306481 },
+    { url = "https://files.pythonhosted.org/packages/cf/50/f364c01c8d0def1dc34747b2470969e216f5a37c7ece00fe558810f37013/aiohttp-3.10.10-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:413251f6fcf552a33c981c4709a6bba37b12710982fec8e558ae944bfb2abd38", size = 1344652 },
+    { url = "https://files.pythonhosted.org/packages/1d/c2/74f608e984e9b585649e2e83883facad6fa3fc1d021de87b20cc67e8e5ae/aiohttp-3.10.10-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1720b4f14c78a3089562b8875b53e36b51c97c51adc53325a69b79b4b48ebcb", size = 1378498 },
+    { url = "https://files.pythonhosted.org/packages/9f/a7/05a48c7c0a7a80a5591b1203bf1b64ca2ed6a2050af918d09c05852dc42b/aiohttp-3.10.10-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:679abe5d3858b33c2cf74faec299fda60ea9de62916e8b67e625d65bf069a3b7", size = 1292718 },
+    { url = "https://files.pythonhosted.org/packages/7d/78/a925655018747e9790350180330032e27d6e0d7ed30bde545fae42f8c49c/aiohttp-3.10.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:79019094f87c9fb44f8d769e41dbb664d6e8fcfd62f665ccce36762deaa0e911", size = 1251776 },
+    { url = "https://files.pythonhosted.org/packages/47/9d/85c6b69f702351d1236594745a4fdc042fc43f494c247a98dac17e004026/aiohttp-3.10.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fe2fb38c2ed905a2582948e2de560675e9dfbee94c6d5ccdb1301c6d0a5bf092", size = 1271716 },
+    { url = "https://files.pythonhosted.org/packages/7f/a7/55fc805ff9b14af818903882ece08e2235b12b73b867b521b92994c52b14/aiohttp-3.10.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a3f00003de6eba42d6e94fabb4125600d6e484846dbf90ea8e48a800430cc142", size = 1266263 },
+    { url = "https://files.pythonhosted.org/packages/1f/ec/d2be2ca7b063e4f91519d550dbc9c1cb43040174a322470deed90b3d3333/aiohttp-3.10.10-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1bbb122c557a16fafc10354b9d99ebf2f2808a660d78202f10ba9d50786384b9", size = 1321617 },
+    { url = "https://files.pythonhosted.org/packages/c9/a3/b29f7920e1cd0a9a68a45dd3eb16140074d2efb1518d2e1f3e140357dc37/aiohttp-3.10.10-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:30ca7c3b94708a9d7ae76ff281b2f47d8eaf2579cd05971b5dc681db8caac6e1", size = 1339227 },
+    { url = "https://files.pythonhosted.org/packages/8a/81/34b67235c47e232d807b4bbc42ba9b927c7ce9476872372fddcfd1e41b3d/aiohttp-3.10.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:df9270660711670e68803107d55c2b5949c2e0f2e4896da176e1ecfc068b974a", size = 1299068 },
+    { url = "https://files.pythonhosted.org/packages/04/1f/26a7fe11b6ad3184f214733428353c89ae9fe3e4f605a657f5245c5e720c/aiohttp-3.10.10-cp311-cp311-win32.whl", hash = "sha256:aafc8ee9b742ce75044ae9a4d3e60e3d918d15a4c2e08a6c3c3e38fa59b92d94", size = 362223 },
+    { url = "https://files.pythonhosted.org/packages/10/91/85dcd93f64011434359ce2666bece981f08d31bc49df33261e625b28595d/aiohttp-3.10.10-cp311-cp311-win_amd64.whl", hash = "sha256:362f641f9071e5f3ee6f8e7d37d5ed0d95aae656adf4ef578313ee585b585959", size = 381576 },
+    { url = "https://files.pythonhosted.org/packages/ae/99/4c5aefe5ad06a1baf206aed6598c7cdcbc7c044c46801cd0d1ecb758cae3/aiohttp-3.10.10-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9294bbb581f92770e6ed5c19559e1e99255e4ca604a22c5c6397b2f9dd3ee42c", size = 583536 },
+    { url = "https://files.pythonhosted.org/packages/a9/36/8b3bc49b49cb6d2da40ee61ff15dbcc44fd345a3e6ab5bb20844df929821/aiohttp-3.10.10-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a8fa23fe62c436ccf23ff930149c047f060c7126eae3ccea005f0483f27b2e28", size = 395693 },
+    { url = "https://files.pythonhosted.org/packages/e1/77/0aa8660dcf11fa65d61712dbb458c4989de220a844bd69778dff25f2d50b/aiohttp-3.10.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5c6a5b8c7926ba5d8545c7dd22961a107526562da31a7a32fa2456baf040939f", size = 390898 },
+    { url = "https://files.pythonhosted.org/packages/38/d2/b833d95deb48c75db85bf6646de0a697e7fb5d87bd27cbade4f9746b48b1/aiohttp-3.10.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:007ec22fbc573e5eb2fb7dec4198ef8f6bf2fe4ce20020798b2eb5d0abda6138", size = 1312060 },
+    { url = "https://files.pythonhosted.org/packages/aa/5f/29fd5113165a0893de8efedf9b4737e0ba92dfcd791415a528f947d10299/aiohttp-3.10.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9627cc1a10c8c409b5822a92d57a77f383b554463d1884008e051c32ab1b3742", size = 1350553 },
+    { url = "https://files.pythonhosted.org/packages/ad/cc/f835f74b7d344428469200105236d44606cfa448be1e7c95ca52880d9bac/aiohttp-3.10.10-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:50edbcad60d8f0e3eccc68da67f37268b5144ecc34d59f27a02f9611c1d4eec7", size = 1392646 },
+    { url = "https://files.pythonhosted.org/packages/bf/fe/1332409d845ca601893bbf2d76935e0b93d41686e5f333841c7d7a4a770d/aiohttp-3.10.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a45d85cf20b5e0d0aa5a8dca27cce8eddef3292bc29d72dcad1641f4ed50aa16", size = 1306310 },
+    { url = "https://files.pythonhosted.org/packages/e4/a1/25a7633a5a513278a9892e333501e2e69c83e50be4b57a62285fb7a008c3/aiohttp-3.10.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0b00807e2605f16e1e198f33a53ce3c4523114059b0c09c337209ae55e3823a8", size = 1260255 },
+    { url = "https://files.pythonhosted.org/packages/f2/39/30eafe89e0e2a06c25e4762844c8214c0c0cd0fd9ffc3471694a7986f421/aiohttp-3.10.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f2d4324a98062be0525d16f768a03e0bbb3b9fe301ceee99611dc9a7953124e6", size = 1271141 },
+    { url = "https://files.pythonhosted.org/packages/5b/fc/33125df728b48391ef1fcb512dfb02072158cc10d041414fb79803463020/aiohttp-3.10.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:438cd072f75bb6612f2aca29f8bd7cdf6e35e8f160bc312e49fbecab77c99e3a", size = 1280244 },
+    { url = "https://files.pythonhosted.org/packages/3b/61/e42bf2c2934b5caa4e2ec0b5e5fd86989adb022b5ee60c2572a9d77cf6fe/aiohttp-3.10.10-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:baa42524a82f75303f714108fea528ccacf0386af429b69fff141ffef1c534f9", size = 1316805 },
+    { url = "https://files.pythonhosted.org/packages/18/32/f52a5e2ae9ad3bba10e026a63a7a23abfa37c7d97aeeb9004eaa98df3ce3/aiohttp-3.10.10-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a7d8d14fe962153fc681f6366bdec33d4356f98a3e3567782aac1b6e0e40109a", size = 1343930 },
+    { url = "https://files.pythonhosted.org/packages/05/be/6a403b464dcab3631fe8e27b0f1d906d9e45c5e92aca97ee007e5a895560/aiohttp-3.10.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1277cd707c465cd09572a774559a3cc7c7a28802eb3a2a9472588f062097205", size = 1306186 },
+    { url = "https://files.pythonhosted.org/packages/8e/fd/bb50fe781068a736a02bf5c7ad5f3ab53e39f1d1e63110da6d30f7605edc/aiohttp-3.10.10-cp312-cp312-win32.whl", hash = "sha256:59bb3c54aa420521dc4ce3cc2c3fe2ad82adf7b09403fa1f48ae45c0cbde6628", size = 359289 },
+    { url = "https://files.pythonhosted.org/packages/70/9e/5add7e240f77ef67c275c82cc1d08afbca57b77593118c1f6e920ae8ad3f/aiohttp-3.10.10-cp312-cp312-win_amd64.whl", hash = "sha256:0e1b370d8007c4ae31ee6db7f9a2fe801a42b146cec80a86766e7ad5c4a259cf", size = 379313 },
+    { url = "https://files.pythonhosted.org/packages/b1/eb/618b1b76c7fe8082a71c9d62e3fe84c5b9af6703078caa9ec57850a12080/aiohttp-3.10.10-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ad7593bb24b2ab09e65e8a1d385606f0f47c65b5a2ae6c551db67d6653e78c28", size = 576114 },
+    { url = "https://files.pythonhosted.org/packages/aa/37/3126995d7869f8b30d05381b81a2d4fb4ec6ad313db788e009bc6d39c211/aiohttp-3.10.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1eb89d3d29adaf533588f209768a9c02e44e4baf832b08118749c5fad191781d", size = 391901 },
+    { url = "https://files.pythonhosted.org/packages/3e/f2/8fdfc845be1f811c31ceb797968523813f8e1263ee3e9120d61253f6848f/aiohttp-3.10.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3fe407bf93533a6fa82dece0e74dbcaaf5d684e5a51862887f9eaebe6372cd79", size = 387418 },
+    { url = "https://files.pythonhosted.org/packages/60/d5/33d2061d36bf07e80286e04b7e0a4de37ce04b5ebfed72dba67659a05250/aiohttp-3.10.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50aed5155f819873d23520919e16703fc8925e509abbb1a1491b0087d1cd969e", size = 1287073 },
+    { url = "https://files.pythonhosted.org/packages/00/52/affb55be16a4747740bd630b4c002dac6c5eac42f9bb64202fc3cf3f1930/aiohttp-3.10.10-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4f05e9727ce409358baa615dbeb9b969db94324a79b5a5cea45d39bdb01d82e6", size = 1323612 },
+    { url = "https://files.pythonhosted.org/packages/94/f2/cddb69b975387daa2182a8442566971d6410b8a0179bb4540d81c97b1611/aiohttp-3.10.10-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dffb610a30d643983aeb185ce134f97f290f8935f0abccdd32c77bed9388b42", size = 1368406 },
+    { url = "https://files.pythonhosted.org/packages/c1/e4/afba7327da4d932da8c6e29aecaf855f9d52dace53ac15bfc8030a246f1b/aiohttp-3.10.10-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa6658732517ddabe22c9036479eabce6036655ba87a0224c612e1ae6af2087e", size = 1282761 },
+    { url = "https://files.pythonhosted.org/packages/9f/6b/364856faa0c9031ea76e24ef0f7fef79cddd9fa8e7dba9a1771c6acc56b5/aiohttp-3.10.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:741a46d58677d8c733175d7e5aa618d277cd9d880301a380fd296975a9cdd7bc", size = 1236518 },
+    { url = "https://files.pythonhosted.org/packages/46/af/c382846f8356fe64a7b5908bb9b477457aa23b71be7ed551013b7b7d4d87/aiohttp-3.10.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e00e3505cd80440f6c98c6d69269dcc2a119f86ad0a9fd70bccc59504bebd68a", size = 1250344 },
+    { url = "https://files.pythonhosted.org/packages/87/53/294f87fc086fd0772d0ab82497beb9df67f0f27a8b3dd5742a2656db2bc6/aiohttp-3.10.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ffe595f10566f8276b76dc3a11ae4bb7eba1aac8ddd75811736a15b0d5311414", size = 1248956 },
+    { url = "https://files.pythonhosted.org/packages/86/30/7d746717fe11bdfefb88bb6c09c5fc985d85c4632da8bb6018e273899254/aiohttp-3.10.10-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdfcf6443637c148c4e1a20c48c566aa694fa5e288d34b20fcdc58507882fed3", size = 1293379 },
+    { url = "https://files.pythonhosted.org/packages/48/b9/45d670a834458db67a24258e9139ba61fa3bd7d69b98ecf3650c22806f8f/aiohttp-3.10.10-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d183cf9c797a5291e8301790ed6d053480ed94070637bfaad914dd38b0981f67", size = 1320108 },
+    { url = "https://files.pythonhosted.org/packages/72/8c/804bb2e837a175635d2000a0659eafc15b2e9d92d3d81c8f69e141ecd0b0/aiohttp-3.10.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:77abf6665ae54000b98b3c742bc6ea1d1fb31c394bcabf8b5d2c1ac3ebfe7f3b", size = 1281546 },
+    { url = "https://files.pythonhosted.org/packages/89/c0/862e6a9de3d6eeb126cd9d9ea388243b70df9b871ce1a42b193b7a4a77fc/aiohttp-3.10.10-cp313-cp313-win32.whl", hash = "sha256:4470c73c12cd9109db8277287d11f9dd98f77fc54155fc71a7738a83ffcc8ea8", size = 357516 },
+    { url = "https://files.pythonhosted.org/packages/ae/63/3e1aee3e554263f3f1011cca50d78a4894ae16ce99bf78101ac3a2f0ef74/aiohttp-3.10.10-cp313-cp313-win_amd64.whl", hash = "sha256:486f7aabfa292719a2753c016cc3a8f8172965cabb3ea2e7f7436c7f5a22a151", size = 376785 },
+]
+
+[[package]]
+name = "aiohttp-jinja2"
+version = "1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "jinja2" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e6/39/da5a94dd89b1af7241fb7fc99ae4e73505b5f898b540b6aba6dc7afe600e/aiohttp-jinja2-1.6.tar.gz", hash = "sha256:a3a7ff5264e5bca52e8ae547bbfd0761b72495230d438d05b6c0915be619b0e2", size = 53057 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/90/65238d4246307195411b87a07d03539049819b022c01bcc773826f600138/aiohttp_jinja2-1.6-py3-none-any.whl", hash = "sha256:0df405ee6ad1b58e5a068a105407dc7dcc1704544c559f1938babde954f945c7", size = 11736 },
 ]
 
 [[package]]
@@ -242,7 +239,7 @@ wheels = [
 
 [[package]]
 name = "anthropic"
-version = "0.34.2"
+version = "0.37.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -254,14 +251,14 @@ dependencies = [
     { name = "tokenizers" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/a6/10efc0ca36712673a11ac90095bdb84a299cd6f591d5111bfa9acbb2e76e/anthropic-0.34.2.tar.gz", hash = "sha256:808ea19276f26646bfde9ee535669735519376e4eeb301a2974fc69892be1d6e", size = 902318 }
+sdist = { url = "https://files.pythonhosted.org/packages/bb/7c/4b4cc70a82b18ecbd69b13c4707281850bd9575b6c1fc74b06df231b17ca/anthropic-0.37.1.tar.gz", hash = "sha256:99f688265795daa7ba9256ee68eaf2f05d53cd99d7417f4a0c2dc292c106d00a", size = 931431 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/6d/c739c11fb3838cda8d4052d0ab3462b2b7d2499a726a7869e5d3e228cb74/anthropic-0.34.2-py3-none-any.whl", hash = "sha256:f50a628eb71e2c76858b106c8cbea278c45c6bd2077cb3aff716a112abddc9fc", size = 891945 },
+    { url = "https://files.pythonhosted.org/packages/4e/40/bbb252b77f7a0345aa8c759bab8280d97eab5a9acf4df49fa2251f4a3a58/anthropic-0.37.1-py3-none-any.whl", hash = "sha256:8f550f88906823752e2abf99fbe491fbc8d40bce4cb26b9663abdf7be990d721", size = 945950 },
 ]
 
 [[package]]
 name = "anyio"
-version = "4.4.0"
+version = "4.6.2.post1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
@@ -269,9 +266,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e6/e3/c4c8d473d6780ef1853d630d581f70d655b4f8d7553c6997958c283039a2/anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94", size = 163930 }
+sdist = { url = "https://files.pythonhosted.org/packages/9f/09/45b9b7a6d4e45c6bcb5bf61d19e3ab87df68e0601fa8c5293de3542546cc/anyio-4.6.2.post1.tar.gz", hash = "sha256:4c8bc31ccdb51c7f7bd251f51c609e038d63e34219b44aa86e47576389880b4c", size = 173422 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/a2/10639a79341f6c019dedc95bd48a4928eed9f1d1197f4c04f546fc7ae0ff/anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7", size = 86780 },
+    { url = "https://files.pythonhosted.org/packages/e4/f5/f2b75d2fc6f1a260f340f0e7c6a060f4dd2961cc16884ed851b0d18da06a/anyio-4.6.2.post1-py3-none-any.whl", hash = "sha256:6d170c36fba3bdd840c73d3868c1e777e33676a69c3a72cf0a0d5d6d8009b61d", size = 90377 },
 ]
 
 [[package]]
@@ -663,21 +660,21 @@ wheels = [
 
 [[package]]
 name = "azure-core"
-version = "1.30.2"
+version = "1.31.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "requests" },
     { name = "six" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/99/d4/1f469fa246f554b86fb5cebc30eef1b2a38b7af7a2c2791bce0a4c6e4604/azure-core-1.30.2.tar.gz", hash = "sha256:a14dc210efcd608821aa472d9fb8e8d035d29b68993819147bc290a8ac224472", size = 271104 }
+sdist = { url = "https://files.pythonhosted.org/packages/03/7a/f79ad135a276a37e61168495697c14ba1721a52c3eab4dae2941929c79f8/azure_core-1.31.0.tar.gz", hash = "sha256:656a0dd61e1869b1506b7c6a3b31d62f15984b1a573d6326f6aa2f3e4123284b", size = 277147 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/d7/69d53f37733f8cb844862781767aef432ff3152bc9b9864dc98c7e286ce9/azure_core-1.30.2-py3-none-any.whl", hash = "sha256:cf019c1ca832e96274ae85abd3d9f752397194d9fea3b41487290562ac8abe4a", size = 194253 },
+    { url = "https://files.pythonhosted.org/packages/01/8e/fcb6a77d3029d2a7356f38dbc77cf7daa113b81ddab76b5593d23321e44c/azure_core-1.31.0-py3-none-any.whl", hash = "sha256:22954de3777e0250029360ef31d80448ef1be13b80a459bff80ba7073379e2cd", size = 197399 },
 ]
 
 [[package]]
 name = "azure-identity"
-version = "1.17.1"
+version = "1.19.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "azure-core" },
@@ -686,9 +683,9 @@ dependencies = [
     { name = "msal-extensions" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/c9/f7e3926686a89670ce641b360bd2da9a2d7a12b3e532403462d99f81e9d5/azure-identity-1.17.1.tar.gz", hash = "sha256:32ecc67cc73f4bd0595e4f64b1ca65cd05186f4fe6f98ed2ae9f1aa32646efea", size = 246652 }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/91/cbaeff9eb0b838f0d35b4607ac1c6195c735c8eb17db235f8f60e622934c/azure_identity-1.19.0.tar.gz", hash = "sha256:500144dc18197d7019b81501165d4fa92225f03778f17d7ca8a2a180129a9c83", size = 263058 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/83/a777861351e7b99e7c84ff3b36bab35e87b6e5d36e50b6905e148c696515/azure_identity-1.17.1-py3-none-any.whl", hash = "sha256:db8d59c183b680e763722bfe8ebc45930e6c57df510620985939f7f3191e0382", size = 173229 },
+    { url = "https://files.pythonhosted.org/packages/f0/d5/3995ed12f941f4a41a273d9b1709282e825ef87ed8eab3833038fee54d59/azure_identity-1.19.0-py3-none-any.whl", hash = "sha256:e3f6558c181692d7509f09de10cca527c7dce426776454fb97df512a46527e81", size = 187587 },
 ]
 
 [[package]]
@@ -735,68 +732,68 @@ wheels = [
 
 [[package]]
 name = "certifi"
-version = "2024.7.4"
+version = "2024.8.30"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c2/02/a95f2b11e207f68bc64d7aae9666fed2e2b3f307748d5123dffb72a1bbea/certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b", size = 164065 }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/ee/9b19140fe824b367c04c5e1b369942dd754c4c5462d5674002f75c4dedc1/certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9", size = 168507 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/d5/c84e1a17bf61d4df64ca866a1c9a913874b4e9bdc131ec689a0ad013fb36/certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90", size = 162960 },
+    { url = "https://files.pythonhosted.org/packages/12/90/3c9ff0512038035f59d279fddeb79f5f1eccd8859f06d6163c58798b9487/certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8", size = 167321 },
 ]
 
 [[package]]
 name = "cffi"
-version = "1.17.0"
+version = "1.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pycparser" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1e/bf/82c351342972702867359cfeba5693927efe0a8dd568165490144f554b18/cffi-1.17.0.tar.gz", hash = "sha256:f3157624b7558b914cb039fd1af735e5e8049a87c817cc215109ad1c8779df76", size = 516073 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/2a/9071bf1e20bf9f695643b6c3e0f838f340b95ee29de0d1bb7968772409be/cffi-1.17.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f9338cc05451f1942d0d8203ec2c346c830f8e86469903d5126c1f0a13a2bcbb", size = 181841 },
-    { url = "https://files.pythonhosted.org/packages/4b/42/60116f10466d692b64aef32ac40fd79b11344ab6ef889ff8e3d047f2fcb2/cffi-1.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a0ce71725cacc9ebf839630772b07eeec220cbb5f03be1399e0457a1464f8e1a", size = 178242 },
-    { url = "https://files.pythonhosted.org/packages/26/8e/a53f844454595c6e9215e56cda123db3427f8592f2c7b5ef1be782f620d6/cffi-1.17.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c815270206f983309915a6844fe994b2fa47e5d05c4c4cef267c3b30e34dbe42", size = 425676 },
-    { url = "https://files.pythonhosted.org/packages/60/ac/6402563fb40b64c7ccbea87836d9c9498b374629af3449f3d8ff34df187d/cffi-1.17.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6bdcd415ba87846fd317bee0774e412e8792832e7805938987e4ede1d13046d", size = 447842 },
-    { url = "https://files.pythonhosted.org/packages/b2/e7/e2ffdb8de59f48f17b196813e9c717fbed2364e39b10bdb3836504e89486/cffi-1.17.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a98748ed1a1df4ee1d6f927e151ed6c1a09d5ec21684de879c7ea6aa96f58f2", size = 455224 },
-    { url = "https://files.pythonhosted.org/packages/59/55/3e8968e92fe35c1c368959a070a1276c10cae29cdad0fd0daa36c69e237e/cffi-1.17.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0a048d4f6630113e54bb4b77e315e1ba32a5a31512c31a273807d0027a7e69ab", size = 436341 },
-    { url = "https://files.pythonhosted.org/packages/7f/df/700aaf009dfbfa04acb1ed487586c03c788c6a312f0361ad5f298c5f5a7d/cffi-1.17.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24aa705a5f5bd3a8bcfa4d123f03413de5d86e497435693b638cbffb7d5d8a1b", size = 445861 },
-    { url = "https://files.pythonhosted.org/packages/5a/70/637f070aae533ea11ab77708a820f3935c0edb4fbcef9393b788e6f426a5/cffi-1.17.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:856bf0924d24e7f93b8aee12a3a1095c34085600aa805693fb7f5d1962393206", size = 460982 },
-    { url = "https://files.pythonhosted.org/packages/f7/1a/7d4740fa1ccc4fcc888963fc3165d69ef1a2c8d42c8911c946703ff5d4a5/cffi-1.17.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:4304d4416ff032ed50ad6bb87416d802e67139e31c0bde4628f36a47a3164bfa", size = 438434 },
-    { url = "https://files.pythonhosted.org/packages/d0/d9/c48cc38aaf6f53a8b5d2dbf6fe788410fcbab33b15a69c56c01d2b08f6a2/cffi-1.17.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:331ad15c39c9fe9186ceaf87203a9ecf5ae0ba2538c9e898e3a6967e8ad3db6f", size = 461219 },
-    { url = "https://files.pythonhosted.org/packages/26/ec/b6a7f660a7f27bd2bb53fe99a2ccafa279088395ec8639b25b8950985b2d/cffi-1.17.0-cp310-cp310-win32.whl", hash = "sha256:669b29a9eca6146465cc574659058ed949748f0809a2582d1f1a324eb91054dc", size = 171406 },
-    { url = "https://files.pythonhosted.org/packages/08/42/8c00824787e6f5ec55194f5cd30c4ba4b9d9d5bb0d4d0007b1bb948d4ad4/cffi-1.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:48b389b1fd5144603d61d752afd7167dfd205973a43151ae5045b35793232aa2", size = 180809 },
-    { url = "https://files.pythonhosted.org/packages/53/cc/9298fb6235522e00e47d78d6aa7f395332ef4e5f6fe124f9a03aa60600f7/cffi-1.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c5d97162c196ce54af6700949ddf9409e9833ef1003b4741c2b39ef46f1d9720", size = 181912 },
-    { url = "https://files.pythonhosted.org/packages/e7/79/dc5334fbe60635d0846c56597a8d2af078a543ff22bc48d36551a0de62c2/cffi-1.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ba5c243f4004c750836f81606a9fcb7841f8874ad8f3bf204ff5e56332b72b9", size = 178297 },
-    { url = "https://files.pythonhosted.org/packages/39/d7/ef1b6b16b51ccbabaced90ff0d821c6c23567fc4b2e4a445aea25d3ceb92/cffi-1.17.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bb9333f58fc3a2296fb1d54576138d4cf5d496a2cc118422bd77835e6ae0b9cb", size = 444909 },
-    { url = "https://files.pythonhosted.org/packages/29/b8/6e3c61885537d985c78ef7dd779b68109ba256263d74a2f615c40f44548d/cffi-1.17.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:435a22d00ec7d7ea533db494da8581b05977f9c37338c80bc86314bec2619424", size = 468854 },
-    { url = "https://files.pythonhosted.org/packages/0b/49/adad1228e19b931e523c2731e6984717d5f9e33a2f9971794ab42815b29b/cffi-1.17.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d1df34588123fcc88c872f5acb6f74ae59e9d182a2707097f9e28275ec26a12d", size = 476890 },
-    { url = "https://files.pythonhosted.org/packages/76/54/c00f075c3e7fd14d9011713bcdb5b4f105ad044c5ad948db7b1a0a7e4e78/cffi-1.17.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df8bb0010fdd0a743b7542589223a2816bdde4d94bb5ad67884348fa2c1c67e8", size = 459374 },
-    { url = "https://files.pythonhosted.org/packages/f3/b9/f163bb3fa4fbc636ee1f2a6a4598c096cdef279823ddfaa5734e556dd206/cffi-1.17.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8b5b9712783415695663bd463990e2f00c6750562e6ad1d28e072a611c5f2a6", size = 466891 },
-    { url = "https://files.pythonhosted.org/packages/31/52/72bbc95f6d06ff2e88a6fa13786be4043e542cb24748e1351aba864cb0a7/cffi-1.17.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ffef8fd58a36fb5f1196919638f73dd3ae0db1a878982b27a9a5a176ede4ba91", size = 477658 },
-    { url = "https://files.pythonhosted.org/packages/67/20/d694811457eeae0c7663fa1a7ca201ce495533b646c1180d4ac25684c69c/cffi-1.17.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4e67d26532bfd8b7f7c05d5a766d6f437b362c1bf203a3a5ce3593a645e870b8", size = 453890 },
-    { url = "https://files.pythonhosted.org/packages/dc/79/40cbf5739eb4f694833db5a27ce7f63e30a9b25b4a836c4f25fb7272aacc/cffi-1.17.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:45f7cd36186db767d803b1473b3c659d57a23b5fa491ad83c6d40f2af58e4dbb", size = 478254 },
-    { url = "https://files.pythonhosted.org/packages/e9/eb/2c384c385cca5cae67ca10ac4ef685277680b8c552b99aedecf4ea23ff7e/cffi-1.17.0-cp311-cp311-win32.whl", hash = "sha256:a9015f5b8af1bb6837a3fcb0cdf3b874fe3385ff6274e8b7925d81ccaec3c5c9", size = 171285 },
-    { url = "https://files.pythonhosted.org/packages/ca/42/74cb1e0f1b79cb64672f3cb46245b506239c1297a20c0d9c3aeb3929cb0c/cffi-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:b50aaac7d05c2c26dfd50c3321199f019ba76bb650e346a6ef3616306eed67b0", size = 180842 },
-    { url = "https://files.pythonhosted.org/packages/1a/1f/7862231350cc959a3138889d2c8d33da7042b22e923457dfd4cd487d772a/cffi-1.17.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:aec510255ce690d240f7cb23d7114f6b351c733a74c279a84def763660a2c3bc", size = 182826 },
-    { url = "https://files.pythonhosted.org/packages/8b/8c/26119bf8b79e05a1c39812064e1ee7981e1f8a5372205ba5698ea4dd958d/cffi-1.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2770bb0d5e3cc0e31e7318db06efcbcdb7b31bcb1a70086d3177692a02256f59", size = 178494 },
-    { url = "https://files.pythonhosted.org/packages/61/94/4882c47d3ad396d91f0eda6ef16d45be3d752a332663b7361933039ed66a/cffi-1.17.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db9a30ec064129d605d0f1aedc93e00894b9334ec74ba9c6bdd08147434b33eb", size = 454459 },
-    { url = "https://files.pythonhosted.org/packages/0f/7c/a6beb119ad515058c5ee1829742d96b25b2b9204ff920746f6e13bf574eb/cffi-1.17.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a47eef975d2b8b721775a0fa286f50eab535b9d56c70a6e62842134cf7841195", size = 478502 },
-    { url = "https://files.pythonhosted.org/packages/61/8a/2575cd01a90e1eca96a30aec4b1ac101a6fae06c49d490ac2704fa9bc8ba/cffi-1.17.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f3e0992f23bbb0be00a921eae5363329253c3b86287db27092461c887b791e5e", size = 485381 },
-    { url = "https://files.pythonhosted.org/packages/cd/66/85899f5a9f152db49646e0c77427173e1b77a1046de0191ab3b0b9a5e6e3/cffi-1.17.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6107e445faf057c118d5050560695e46d272e5301feffda3c41849641222a828", size = 470907 },
-    { url = "https://files.pythonhosted.org/packages/00/13/150924609bf377140abe6e934ce0a57f3fc48f1fd956ec1f578ce97a4624/cffi-1.17.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb862356ee9391dc5a0b3cbc00f416b48c1b9a52d252d898e5b7696a5f9fe150", size = 479074 },
-    { url = "https://files.pythonhosted.org/packages/17/fd/7d73d7110155c036303b0a6462c56250e9bc2f4119d7591d27417329b4d1/cffi-1.17.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c1c13185b90bbd3f8b5963cd8ce7ad4ff441924c31e23c975cb150e27c2bf67a", size = 484225 },
-    { url = "https://files.pythonhosted.org/packages/fc/83/8353e5c9b01bb46332dac3dfb18e6c597a04ceb085c19c814c2f78a8c0d0/cffi-1.17.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:17c6d6d3260c7f2d94f657e6872591fe8733872a86ed1345bda872cfc8c74885", size = 488388 },
-    { url = "https://files.pythonhosted.org/packages/73/0c/f9d5ca9a095b1fc88ef77d1f8b85d11151c374144e4606da33874e17b65b/cffi-1.17.0-cp312-cp312-win32.whl", hash = "sha256:c3b8bd3133cd50f6b637bb4322822c94c5ce4bf0d724ed5ae70afce62187c492", size = 172096 },
-    { url = "https://files.pythonhosted.org/packages/72/21/8c5d285fe20a6e31d29325f1287bb0e55f7d93630a5a44cafdafb5922495/cffi-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:dca802c8db0720ce1c49cce1149ff7b06e91ba15fa84b1d59144fef1a1bc7ac2", size = 181478 },
-    { url = "https://files.pythonhosted.org/packages/17/8f/581f2f3c3464d5f7cf87c2f7a5ba9acc6976253e02d73804240964243ec2/cffi-1.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6ce01337d23884b21c03869d2f68c5523d43174d4fc405490eb0091057943118", size = 182638 },
-    { url = "https://files.pythonhosted.org/packages/8d/1c/c9afa66684b7039f48018eb11b229b659dfb32b7a16b88251bac106dd1ff/cffi-1.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cab2eba3830bf4f6d91e2d6718e0e1c14a2f5ad1af68a89d24ace0c6b17cced7", size = 178453 },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/1a134d479d3a5a1ff2fabbee551d1d3f1dd70f453e081b5f70d604aae4c0/cffi-1.17.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:14b9cbc8f7ac98a739558eb86fabc283d4d564dafed50216e7f7ee62d0d25377", size = 454441 },
-    { url = "https://files.pythonhosted.org/packages/b1/b4/e1569475d63aad8042b0935dbf62ae2a54d1e9142424e2b0e924d2d4a529/cffi-1.17.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b00e7bcd71caa0282cbe3c90966f738e2db91e64092a877c3ff7f19a1628fdcb", size = 478543 },
-    { url = "https://files.pythonhosted.org/packages/d2/40/a9ad03fbd64309dec5bb70bc803a9a6772602de0ee164d7b9a6ca5a89249/cffi-1.17.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41f4915e09218744d8bae14759f983e466ab69b178de38066f7579892ff2a555", size = 485463 },
-    { url = "https://files.pythonhosted.org/packages/a6/1a/f10be60e006dd9242a24bcc2b1cd55c34c578380100f742d8c610f7a5d26/cffi-1.17.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4760a68cab57bfaa628938e9c2971137e05ce48e762a9cb53b76c9b569f1204", size = 470854 },
-    { url = "https://files.pythonhosted.org/packages/cc/b3/c035ed21aa3d39432bd749fe331ee90e4bc83ea2dbed1f71c4bc26c41084/cffi-1.17.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:011aff3524d578a9412c8b3cfaa50f2c0bd78e03eb7af7aa5e0df59b158efb2f", size = 479096 },
-    { url = "https://files.pythonhosted.org/packages/00/cb/6f7edde01131de9382c89430b8e253b8c8754d66b63a62059663ceafeab2/cffi-1.17.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a003ac9edc22d99ae1286b0875c460351f4e101f8c9d9d2576e78d7e048f64e0", size = 484013 },
-    { url = "https://files.pythonhosted.org/packages/b9/83/8e4e8c211ea940210d293e951bf06b1bfb90f2eeee590e9778e99b4a8676/cffi-1.17.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ef9528915df81b8f4c7612b19b8628214c65c9b7f74db2e34a646a0a2a0da2d4", size = 488119 },
-    { url = "https://files.pythonhosted.org/packages/5e/52/3f7cfbc4f444cb4f73ff17b28690d12436dde665f67d68f1e1687908ab6c/cffi-1.17.0-cp313-cp313-win32.whl", hash = "sha256:70d2aa9fb00cf52034feac4b913181a6e10356019b18ef89bc7c12a283bf5f5a", size = 172122 },
-    { url = "https://files.pythonhosted.org/packages/94/19/cf5baa07ee0f0e55eab7382459fbddaba0fdb0ba45973dd92556ae0d02db/cffi-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:b7b6ea9e36d32582cda3465f54c4b454f62f23cb083ebc7a94e2ca6ef011c3a7", size = 181504 },
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 },
+    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 },
+    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 },
+    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 },
+    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 },
+    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 },
+    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 },
+    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 },
+    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 },
+    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 },
+    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 },
+    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 },
+    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 },
+    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 },
+    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 },
+    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 },
+    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 },
+    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 },
+    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 },
+    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 },
+    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 },
+    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 },
+    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 },
+    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
+    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
+    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
+    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
+    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
+    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
+    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
+    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
+    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
+    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
+    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
+    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
+    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
+    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
+    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
 ]
 
 [[package]]
@@ -810,66 +807,78 @@ wheels = [
 
 [[package]]
 name = "charset-normalizer"
-version = "3.3.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/63/09/c1bc53dab74b1816a00d8d030de5bf98f724c52c1635e07681d312f20be8/charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5", size = 104809 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/61/095a0aa1a84d1481998b534177c8566fdc50bb1233ea9a0478cd3cc075bd/charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3", size = 194219 },
-    { url = "https://files.pythonhosted.org/packages/cc/94/f7cf5e5134175de79ad2059edf2adce18e0685ebdb9227ff0139975d0e93/charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027", size = 122521 },
-    { url = "https://files.pythonhosted.org/packages/46/6a/d5c26c41c49b546860cc1acabdddf48b0b3fb2685f4f5617ac59261b44ae/charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03", size = 120383 },
-    { url = "https://files.pythonhosted.org/packages/b8/60/e2f67915a51be59d4539ed189eb0a2b0d292bf79270410746becb32bc2c3/charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d", size = 138223 },
-    { url = "https://files.pythonhosted.org/packages/05/8c/eb854996d5fef5e4f33ad56927ad053d04dc820e4a3d39023f35cad72617/charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e", size = 148101 },
-    { url = "https://files.pythonhosted.org/packages/f6/93/bb6cbeec3bf9da9b2eba458c15966658d1daa8b982c642f81c93ad9b40e1/charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6", size = 140699 },
-    { url = "https://files.pythonhosted.org/packages/da/f1/3702ba2a7470666a62fd81c58a4c40be00670e5006a67f4d626e57f013ae/charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5", size = 142065 },
-    { url = "https://files.pythonhosted.org/packages/3f/ba/3f5e7be00b215fa10e13d64b1f6237eb6ebea66676a41b2bcdd09fe74323/charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537", size = 144505 },
-    { url = "https://files.pythonhosted.org/packages/33/c3/3b96a435c5109dd5b6adc8a59ba1d678b302a97938f032e3770cc84cd354/charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c", size = 139425 },
-    { url = "https://files.pythonhosted.org/packages/43/05/3bf613e719efe68fb3a77f9c536a389f35b95d75424b96b426a47a45ef1d/charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12", size = 145287 },
-    { url = "https://files.pythonhosted.org/packages/58/78/a0bc646900994df12e07b4ae5c713f2b3e5998f58b9d3720cce2aa45652f/charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f", size = 149929 },
-    { url = "https://files.pythonhosted.org/packages/eb/5c/97d97248af4920bc68687d9c3b3c0f47c910e21a8ff80af4565a576bd2f0/charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269", size = 141605 },
-    { url = "https://files.pythonhosted.org/packages/a8/31/47d018ef89f95b8aded95c589a77c072c55e94b50a41aa99c0a2008a45a4/charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519", size = 142646 },
-    { url = "https://files.pythonhosted.org/packages/ae/d5/4fecf1d58bedb1340a50f165ba1c7ddc0400252d6832ff619c4568b36cc0/charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73", size = 92846 },
-    { url = "https://files.pythonhosted.org/packages/a2/a0/4af29e22cb5942488cf45630cbdd7cefd908768e69bdd90280842e4e8529/charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09", size = 100343 },
-    { url = "https://files.pythonhosted.org/packages/68/77/02839016f6fbbf808e8b38601df6e0e66c17bbab76dff4613f7511413597/charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db", size = 191647 },
-    { url = "https://files.pythonhosted.org/packages/3e/33/21a875a61057165e92227466e54ee076b73af1e21fe1b31f1e292251aa1e/charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96", size = 121434 },
-    { url = "https://files.pythonhosted.org/packages/dd/51/68b61b90b24ca35495956b718f35a9756ef7d3dd4b3c1508056fa98d1a1b/charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e", size = 118979 },
-    { url = "https://files.pythonhosted.org/packages/e4/a6/7ee57823d46331ddc37dd00749c95b0edec2c79b15fc0d6e6efb532e89ac/charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f", size = 136582 },
-    { url = "https://files.pythonhosted.org/packages/74/f1/0d9fe69ac441467b737ba7f48c68241487df2f4522dd7246d9426e7c690e/charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574", size = 146645 },
-    { url = "https://files.pythonhosted.org/packages/05/31/e1f51c76db7be1d4aef220d29fbfa5dbb4a99165d9833dcbf166753b6dc0/charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4", size = 139398 },
-    { url = "https://files.pythonhosted.org/packages/40/26/f35951c45070edc957ba40a5b1db3cf60a9dbb1b350c2d5bef03e01e61de/charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8", size = 140273 },
-    { url = "https://files.pythonhosted.org/packages/07/07/7e554f2bbce3295e191f7e653ff15d55309a9ca40d0362fcdab36f01063c/charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc", size = 142577 },
-    { url = "https://files.pythonhosted.org/packages/d8/b5/eb705c313100defa57da79277d9207dc8d8e45931035862fa64b625bfead/charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae", size = 137747 },
-    { url = "https://files.pythonhosted.org/packages/19/28/573147271fd041d351b438a5665be8223f1dd92f273713cb882ddafe214c/charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887", size = 143375 },
-    { url = "https://files.pythonhosted.org/packages/cf/7c/f3b682fa053cc21373c9a839e6beba7705857075686a05c72e0f8c4980ca/charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae", size = 148474 },
-    { url = "https://files.pythonhosted.org/packages/1e/49/7ab74d4ac537ece3bc3334ee08645e231f39f7d6df6347b29a74b0537103/charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce", size = 140232 },
-    { url = "https://files.pythonhosted.org/packages/2d/dc/9dacba68c9ac0ae781d40e1a0c0058e26302ea0660e574ddf6797a0347f7/charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f", size = 140859 },
-    { url = "https://files.pythonhosted.org/packages/6c/c2/4a583f800c0708dd22096298e49f887b49d9746d0e78bfc1d7e29816614c/charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab", size = 92509 },
-    { url = "https://files.pythonhosted.org/packages/57/ec/80c8d48ac8b1741d5b963797b7c0c869335619e13d4744ca2f67fc11c6fc/charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77", size = 99870 },
-    { url = "https://files.pythonhosted.org/packages/d1/b2/fcedc8255ec42afee97f9e6f0145c734bbe104aac28300214593eb326f1d/charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8", size = 192892 },
-    { url = "https://files.pythonhosted.org/packages/2e/7d/2259318c202f3d17f3fe6438149b3b9e706d1070fe3fcbb28049730bb25c/charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b", size = 122213 },
-    { url = "https://files.pythonhosted.org/packages/3a/52/9f9d17c3b54dc238de384c4cb5a2ef0e27985b42a0e5cc8e8a31d918d48d/charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6", size = 119404 },
-    { url = "https://files.pythonhosted.org/packages/99/b0/9c365f6d79a9f0f3c379ddb40a256a67aa69c59609608fe7feb6235896e1/charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a", size = 137275 },
-    { url = "https://files.pythonhosted.org/packages/91/33/749df346e93d7a30cdcb90cbfdd41a06026317bfbfb62cd68307c1a3c543/charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389", size = 147518 },
-    { url = "https://files.pythonhosted.org/packages/72/1a/641d5c9f59e6af4c7b53da463d07600a695b9824e20849cb6eea8a627761/charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa", size = 140182 },
-    { url = "https://files.pythonhosted.org/packages/ee/fb/14d30eb4956408ee3ae09ad34299131fb383c47df355ddb428a7331cfa1e/charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b", size = 141869 },
-    { url = "https://files.pythonhosted.org/packages/df/3e/a06b18788ca2eb6695c9b22325b6fde7dde0f1d1838b1792a0076f58fe9d/charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed", size = 144042 },
-    { url = "https://files.pythonhosted.org/packages/45/59/3d27019d3b447a88fe7e7d004a1e04be220227760264cc41b405e863891b/charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26", size = 138275 },
-    { url = "https://files.pythonhosted.org/packages/7b/ef/5eb105530b4da8ae37d506ccfa25057961b7b63d581def6f99165ea89c7e/charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d", size = 144819 },
-    { url = "https://files.pythonhosted.org/packages/a2/51/e5023f937d7f307c948ed3e5c29c4b7a3e42ed2ee0b8cdf8f3a706089bf0/charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068", size = 149415 },
-    { url = "https://files.pythonhosted.org/packages/24/9d/2e3ef673dfd5be0154b20363c5cdcc5606f35666544381bee15af3778239/charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143", size = 141212 },
-    { url = "https://files.pythonhosted.org/packages/5b/ae/ce2c12fcac59cb3860b2e2d76dc405253a4475436b1861d95fe75bdea520/charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4", size = 142167 },
-    { url = "https://files.pythonhosted.org/packages/ed/3a/a448bf035dce5da359daf9ae8a16b8a39623cc395a2ffb1620aa1bce62b0/charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7", size = 93041 },
-    { url = "https://files.pythonhosted.org/packages/b6/7c/8debebb4f90174074b827c63242c23851bdf00a532489fba57fef3416e40/charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001", size = 100397 },
-    { url = "https://files.pythonhosted.org/packages/28/76/e6222113b83e3622caa4bb41032d0b1bf785250607392e1b778aca0b8a7d/charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc", size = 48543 },
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f2/4f/e1808dc01273379acc506d18f1504eb2d299bd4131743b9fc54d7be4df1e/charset_normalizer-3.4.0.tar.gz", hash = "sha256:223217c3d4f82c3ac5e29032b3f1c2eb0fb591b72161f86d93f5719079dae93e", size = 106620 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/8b/825cc84cf13a28bfbcba7c416ec22bf85a9584971be15b21dd8300c65b7f/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4f9fc98dad6c2eaa32fc3af1417d95b5e3d08aff968df0cd320066def971f9a6", size = 196363 },
+    { url = "https://files.pythonhosted.org/packages/23/81/d7eef6a99e42c77f444fdd7bc894b0ceca6c3a95c51239e74a722039521c/charset_normalizer-3.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0de7b687289d3c1b3e8660d0741874abe7888100efe14bd0f9fd7141bcbda92b", size = 125639 },
+    { url = "https://files.pythonhosted.org/packages/21/67/b4564d81f48042f520c948abac7079356e94b30cb8ffb22e747532cf469d/charset_normalizer-3.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5ed2e36c3e9b4f21dd9422f6893dec0abf2cca553af509b10cd630f878d3eb99", size = 120451 },
+    { url = "https://files.pythonhosted.org/packages/c2/72/12a7f0943dd71fb5b4e7b55c41327ac0a1663046a868ee4d0d8e9c369b85/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d3ff7fc90b98c637bda91c89d51264a3dcf210cade3a2c6f838c7268d7a4ca", size = 140041 },
+    { url = "https://files.pythonhosted.org/packages/67/56/fa28c2c3e31217c4c52158537a2cf5d98a6c1e89d31faf476c89391cd16b/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1110e22af8ca26b90bd6364fe4c763329b0ebf1ee213ba32b68c73de5752323d", size = 150333 },
+    { url = "https://files.pythonhosted.org/packages/f9/d2/466a9be1f32d89eb1554cf84073a5ed9262047acee1ab39cbaefc19635d2/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86f4e8cca779080f66ff4f191a685ced73d2f72d50216f7112185dc02b90b9b7", size = 142921 },
+    { url = "https://files.pythonhosted.org/packages/f8/01/344ec40cf5d85c1da3c1f57566c59e0c9b56bcc5566c08804a95a6cc8257/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f683ddc7eedd742e2889d2bfb96d69573fde1d92fcb811979cdb7165bb9c7d3", size = 144785 },
+    { url = "https://files.pythonhosted.org/packages/73/8b/2102692cb6d7e9f03b9a33a710e0164cadfce312872e3efc7cfe22ed26b4/charset_normalizer-3.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:27623ba66c183eca01bf9ff833875b459cad267aeeb044477fedac35e19ba907", size = 146631 },
+    { url = "https://files.pythonhosted.org/packages/d8/96/cc2c1b5d994119ce9f088a9a0c3ebd489d360a2eb058e2c8049f27092847/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f606a1881d2663630ea5b8ce2efe2111740df4b687bd78b34a8131baa007f79b", size = 140867 },
+    { url = "https://files.pythonhosted.org/packages/c9/27/cde291783715b8ec30a61c810d0120411844bc4c23b50189b81188b273db/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0b309d1747110feb25d7ed6b01afdec269c647d382c857ef4663bbe6ad95a912", size = 149273 },
+    { url = "https://files.pythonhosted.org/packages/3a/a4/8633b0fc1a2d1834d5393dafecce4a1cc56727bfd82b4dc18fc92f0d3cc3/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:136815f06a3ae311fae551c3df1f998a1ebd01ddd424aa5603a4336997629e95", size = 152437 },
+    { url = "https://files.pythonhosted.org/packages/64/ea/69af161062166b5975ccbb0961fd2384853190c70786f288684490913bf5/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:14215b71a762336254351b00ec720a8e85cada43b987da5a042e4ce3e82bd68e", size = 150087 },
+    { url = "https://files.pythonhosted.org/packages/3b/fd/e60a9d9fd967f4ad5a92810138192f825d77b4fa2a557990fd575a47695b/charset_normalizer-3.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79983512b108e4a164b9c8d34de3992f76d48cadc9554c9e60b43f308988aabe", size = 145142 },
+    { url = "https://files.pythonhosted.org/packages/6d/02/8cb0988a1e49ac9ce2eed1e07b77ff118f2923e9ebd0ede41ba85f2dcb04/charset_normalizer-3.4.0-cp310-cp310-win32.whl", hash = "sha256:c94057af19bc953643a33581844649a7fdab902624d2eb739738a30e2b3e60fc", size = 94701 },
+    { url = "https://files.pythonhosted.org/packages/d6/20/f1d4670a8a723c46be695dff449d86d6092916f9e99c53051954ee33a1bc/charset_normalizer-3.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:55f56e2ebd4e3bc50442fbc0888c9d8c94e4e06a933804e2af3e89e2f9c1c749", size = 102191 },
+    { url = "https://files.pythonhosted.org/packages/9c/61/73589dcc7a719582bf56aae309b6103d2762b526bffe189d635a7fcfd998/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0d99dd8ff461990f12d6e42c7347fd9ab2532fb70e9621ba520f9e8637161d7c", size = 193339 },
+    { url = "https://files.pythonhosted.org/packages/77/d5/8c982d58144de49f59571f940e329ad6e8615e1e82ef84584c5eeb5e1d72/charset_normalizer-3.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c57516e58fd17d03ebe67e181a4e4e2ccab1168f8c2976c6a334d4f819fe5944", size = 124366 },
+    { url = "https://files.pythonhosted.org/packages/bf/19/411a64f01ee971bed3231111b69eb56f9331a769072de479eae7de52296d/charset_normalizer-3.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6dba5d19c4dfab08e58d5b36304b3f92f3bd5d42c1a3fa37b5ba5cdf6dfcbcee", size = 118874 },
+    { url = "https://files.pythonhosted.org/packages/4c/92/97509850f0d00e9f14a46bc751daabd0ad7765cff29cdfb66c68b6dad57f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf4475b82be41b07cc5e5ff94810e6a01f276e37c2d55571e3fe175e467a1a1c", size = 138243 },
+    { url = "https://files.pythonhosted.org/packages/e2/29/d227805bff72ed6d6cb1ce08eec707f7cfbd9868044893617eb331f16295/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce031db0408e487fd2775d745ce30a7cd2923667cf3b69d48d219f1d8f5ddeb6", size = 148676 },
+    { url = "https://files.pythonhosted.org/packages/13/bc/87c2c9f2c144bedfa62f894c3007cd4530ba4b5351acb10dc786428a50f0/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ff4e7cdfdb1ab5698e675ca622e72d58a6fa2a8aa58195de0c0061288e6e3ea", size = 141289 },
+    { url = "https://files.pythonhosted.org/packages/eb/5b/6f10bad0f6461fa272bfbbdf5d0023b5fb9bc6217c92bf068fa5a99820f5/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3710a9751938947e6327ea9f3ea6332a09bf0ba0c09cae9cb1f250bd1f1549bc", size = 142585 },
+    { url = "https://files.pythonhosted.org/packages/3b/a0/a68980ab8a1f45a36d9745d35049c1af57d27255eff8c907e3add84cf68f/charset_normalizer-3.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82357d85de703176b5587dbe6ade8ff67f9f69a41c0733cf2425378b49954de5", size = 144408 },
+    { url = "https://files.pythonhosted.org/packages/d7/a1/493919799446464ed0299c8eef3c3fad0daf1c3cd48bff9263c731b0d9e2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47334db71978b23ebcf3c0f9f5ee98b8d65992b65c9c4f2d34c2eaf5bcaf0594", size = 139076 },
+    { url = "https://files.pythonhosted.org/packages/fb/9d/9c13753a5a6e0db4a0a6edb1cef7aee39859177b64e1a1e748a6e3ba62c2/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8ce7fd6767a1cc5a92a639b391891bf1c268b03ec7e021c7d6d902285259685c", size = 146874 },
+    { url = "https://files.pythonhosted.org/packages/75/d2/0ab54463d3410709c09266dfb416d032a08f97fd7d60e94b8c6ef54ae14b/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f1a2f519ae173b5b6a2c9d5fa3116ce16e48b3462c8b96dfdded11055e3d6365", size = 150871 },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/27e41d481557be53d51e60750b85aa40eaf52b841946b3cdeff363105737/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:63bc5c4ae26e4bc6be6469943b8253c0fd4e4186c43ad46e713ea61a0ba49129", size = 148546 },
+    { url = "https://files.pythonhosted.org/packages/ee/44/4f62042ca8cdc0cabf87c0fc00ae27cd8b53ab68be3605ba6d071f742ad3/charset_normalizer-3.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bcb4f8ea87d03bc51ad04add8ceaf9b0f085ac045ab4d74e73bbc2dc033f0236", size = 143048 },
+    { url = "https://files.pythonhosted.org/packages/01/f8/38842422988b795220eb8038745d27a675ce066e2ada79516c118f291f07/charset_normalizer-3.4.0-cp311-cp311-win32.whl", hash = "sha256:9ae4ef0b3f6b41bad6366fb0ea4fc1d7ed051528e113a60fa2a65a9abb5b1d99", size = 94389 },
+    { url = "https://files.pythonhosted.org/packages/0b/6e/b13bd47fa9023b3699e94abf565b5a2f0b0be6e9ddac9812182596ee62e4/charset_normalizer-3.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cee4373f4d3ad28f1ab6290684d8e2ebdb9e7a1b74fdc39e4c211995f77bec27", size = 101752 },
+    { url = "https://files.pythonhosted.org/packages/d3/0b/4b7a70987abf9b8196845806198975b6aab4ce016632f817ad758a5aa056/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0713f3adb9d03d49d365b70b84775d0a0d18e4ab08d12bc46baa6132ba78aaf6", size = 194445 },
+    { url = "https://files.pythonhosted.org/packages/50/89/354cc56cf4dd2449715bc9a0f54f3aef3dc700d2d62d1fa5bbea53b13426/charset_normalizer-3.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:de7376c29d95d6719048c194a9cf1a1b0393fbe8488a22008610b0361d834ecf", size = 125275 },
+    { url = "https://files.pythonhosted.org/packages/fa/44/b730e2a2580110ced837ac083d8ad222343c96bb6b66e9e4e706e4d0b6df/charset_normalizer-3.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a51b48f42d9358460b78725283f04bddaf44a9358197b889657deba38f329db", size = 119020 },
+    { url = "https://files.pythonhosted.org/packages/9d/e4/9263b8240ed9472a2ae7ddc3e516e71ef46617fe40eaa51221ccd4ad9a27/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b295729485b06c1a0683af02a9e42d2caa9db04a373dc38a6a58cdd1e8abddf1", size = 139128 },
+    { url = "https://files.pythonhosted.org/packages/6b/e3/9f73e779315a54334240353eaea75854a9a690f3f580e4bd85d977cb2204/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee803480535c44e7f5ad00788526da7d85525cfefaf8acf8ab9a310000be4b03", size = 149277 },
+    { url = "https://files.pythonhosted.org/packages/1a/cf/f1f50c2f295312edb8a548d3fa56a5c923b146cd3f24114d5adb7e7be558/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d59d125ffbd6d552765510e3f31ed75ebac2c7470c7274195b9161a32350284", size = 142174 },
+    { url = "https://files.pythonhosted.org/packages/16/92/92a76dc2ff3a12e69ba94e7e05168d37d0345fa08c87e1fe24d0c2a42223/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8cda06946eac330cbe6598f77bb54e690b4ca93f593dee1568ad22b04f347c15", size = 143838 },
+    { url = "https://files.pythonhosted.org/packages/a4/01/2117ff2b1dfc61695daf2babe4a874bca328489afa85952440b59819e9d7/charset_normalizer-3.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07afec21bbbbf8a5cc3651aa96b980afe2526e7f048fdfb7f1014d84acc8b6d8", size = 146149 },
+    { url = "https://files.pythonhosted.org/packages/f6/9b/93a332b8d25b347f6839ca0a61b7f0287b0930216994e8bf67a75d050255/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6b40e8d38afe634559e398cc32b1472f376a4099c75fe6299ae607e404c033b2", size = 140043 },
+    { url = "https://files.pythonhosted.org/packages/ab/f6/7ac4a01adcdecbc7a7587767c776d53d369b8b971382b91211489535acf0/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b8dcd239c743aa2f9c22ce674a145e0a25cb1566c495928440a181ca1ccf6719", size = 148229 },
+    { url = "https://files.pythonhosted.org/packages/9d/be/5708ad18161dee7dc6a0f7e6cf3a88ea6279c3e8484844c0590e50e803ef/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:84450ba661fb96e9fd67629b93d2941c871ca86fc38d835d19d4225ff946a631", size = 151556 },
+    { url = "https://files.pythonhosted.org/packages/5a/bb/3d8bc22bacb9eb89785e83e6723f9888265f3a0de3b9ce724d66bd49884e/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:44aeb140295a2f0659e113b31cfe92c9061622cadbc9e2a2f7b8ef6b1e29ef4b", size = 149772 },
+    { url = "https://files.pythonhosted.org/packages/f7/fa/d3fc622de05a86f30beea5fc4e9ac46aead4731e73fd9055496732bcc0a4/charset_normalizer-3.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1db4e7fefefd0f548d73e2e2e041f9df5c59e178b4c72fbac4cc6f535cfb1565", size = 144800 },
+    { url = "https://files.pythonhosted.org/packages/9a/65/bdb9bc496d7d190d725e96816e20e2ae3a6fa42a5cac99c3c3d6ff884118/charset_normalizer-3.4.0-cp312-cp312-win32.whl", hash = "sha256:5726cf76c982532c1863fb64d8c6dd0e4c90b6ece9feb06c9f202417a31f7dd7", size = 94836 },
+    { url = "https://files.pythonhosted.org/packages/3e/67/7b72b69d25b89c0b3cea583ee372c43aa24df15f0e0f8d3982c57804984b/charset_normalizer-3.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:b197e7094f232959f8f20541ead1d9862ac5ebea1d58e9849c1bf979255dfac9", size = 102187 },
+    { url = "https://files.pythonhosted.org/packages/f3/89/68a4c86f1a0002810a27f12e9a7b22feb198c59b2f05231349fbce5c06f4/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dd4eda173a9fcccb5f2e2bd2a9f423d180194b1bf17cf59e3269899235b2a114", size = 194617 },
+    { url = "https://files.pythonhosted.org/packages/4f/cd/8947fe425e2ab0aa57aceb7807af13a0e4162cd21eee42ef5b053447edf5/charset_normalizer-3.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9e3c4c9e1ed40ea53acf11e2a386383c3304212c965773704e4603d589343ed", size = 125310 },
+    { url = "https://files.pythonhosted.org/packages/5b/f0/b5263e8668a4ee9becc2b451ed909e9c27058337fda5b8c49588183c267a/charset_normalizer-3.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92a7e36b000bf022ef3dbb9c46bfe2d52c047d5e3f3343f43204263c5addc250", size = 119126 },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/e445afe4f7fda27a533f3234b627b3e515a1b9429bc981c9a5e2aa5d97b6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54b6a92d009cbe2fb11054ba694bc9e284dad30a26757b1e372a1fdddaf21920", size = 139342 },
+    { url = "https://files.pythonhosted.org/packages/a1/b2/4af9993b532d93270538ad4926c8e37dc29f2111c36f9c629840c57cd9b3/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ffd9493de4c922f2a38c2bf62b831dcec90ac673ed1ca182fe11b4d8e9f2a64", size = 149383 },
+    { url = "https://files.pythonhosted.org/packages/fb/6f/4e78c3b97686b871db9be6f31d64e9264e889f8c9d7ab33c771f847f79b7/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35c404d74c2926d0287fbd63ed5d27eb911eb9e4a3bb2c6d294f3cfd4a9e0c23", size = 142214 },
+    { url = "https://files.pythonhosted.org/packages/2b/c9/1c8fe3ce05d30c87eff498592c89015b19fade13df42850aafae09e94f35/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4796efc4faf6b53a18e3d46343535caed491776a22af773f366534056c4e1fbc", size = 144104 },
+    { url = "https://files.pythonhosted.org/packages/ee/68/efad5dcb306bf37db7db338338e7bb8ebd8cf38ee5bbd5ceaaaa46f257e6/charset_normalizer-3.4.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e7fdd52961feb4c96507aa649550ec2a0d527c086d284749b2f582f2d40a2e0d", size = 146255 },
+    { url = "https://files.pythonhosted.org/packages/0c/75/1ed813c3ffd200b1f3e71121c95da3f79e6d2a96120163443b3ad1057505/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:92db3c28b5b2a273346bebb24857fda45601aef6ae1c011c0a997106581e8a88", size = 140251 },
+    { url = "https://files.pythonhosted.org/packages/7d/0d/6f32255c1979653b448d3c709583557a4d24ff97ac4f3a5be156b2e6a210/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ab973df98fc99ab39080bfb0eb3a925181454d7c3ac8a1e695fddfae696d9e90", size = 148474 },
+    { url = "https://files.pythonhosted.org/packages/ac/a0/c1b5298de4670d997101fef95b97ac440e8c8d8b4efa5a4d1ef44af82f0d/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4b67fdab07fdd3c10bb21edab3cbfe8cf5696f453afce75d815d9d7223fbe88b", size = 151849 },
+    { url = "https://files.pythonhosted.org/packages/04/4f/b3961ba0c664989ba63e30595a3ed0875d6790ff26671e2aae2fdc28a399/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aa41e526a5d4a9dfcfbab0716c7e8a1b215abd3f3df5a45cf18a12721d31cb5d", size = 149781 },
+    { url = "https://files.pythonhosted.org/packages/d8/90/6af4cd042066a4adad58ae25648a12c09c879efa4849c705719ba1b23d8c/charset_normalizer-3.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffc519621dce0c767e96b9c53f09c5d215578e10b02c285809f76509a3931482", size = 144970 },
+    { url = "https://files.pythonhosted.org/packages/cc/67/e5e7e0cbfefc4ca79025238b43cdf8a2037854195b37d6417f3d0895c4c2/charset_normalizer-3.4.0-cp313-cp313-win32.whl", hash = "sha256:f19c1585933c82098c2a520f8ec1227f20e339e33aca8fa6f956f6691b784e67", size = 94973 },
+    { url = "https://files.pythonhosted.org/packages/65/97/fc9bbc54ee13d33dc54a7fcf17b26368b18505500fc01e228c27b5222d80/charset_normalizer-3.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:707b82d19e65c9bd28b81dde95249b07bf9f5b90ebe1ef17d9b57473f8a64b7b", size = 102308 },
+    { url = "https://files.pythonhosted.org/packages/bf/9b/08c0432272d77b04803958a4598a51e2a4b51c06640af8b8f0f908c18bf2/charset_normalizer-3.4.0-py3-none-any.whl", hash = "sha256:fe9f97feb71aa9896b81973a7bbada8c49501dc73e58a10fcef6663af95e5079", size = 49446 },
 ]
 
 [[package]]
 name = "chess"
-version = "1.10.0"
+version = "1.11.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/03/7d/b9db31dbea86c8e7c1479edf5c6c2d0a719724c741e351e411eef2858880/chess-1.10.0.tar.gz", hash = "sha256:bccde105f54aa436e899f92b4ba953731c65012a863fd9235683d0e2863ccd54", size = 161136 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/d8/15cfcb738d2518daf04d34b23419bd359cbd8e09da50778ebac521774fc8/chess-1.10.0-py3-none-any.whl", hash = "sha256:48ff7c084a370811819cfc753c2ee159942356ada70824666bd01ee3fca170d0", size = 154405 },
-]
+sdist = { url = "https://files.pythonhosted.org/packages/74/16/53b895bb4fccede8e506de820fa94db03a2dc8bd2ca4bec0aac4a112fb65/chess-1.11.1.tar.gz", hash = "sha256:b7f66a32dc599ab260e2b688e6ac4e868dad840377a54b61357e2dec2a5fed00", size = 156529 }
 
 [[package]]
 name = "chromedriver-autoinstaller"
@@ -946,35 +955,35 @@ wheels = [
 
 [[package]]
 name = "cryptography"
-version = "43.0.0"
+version = "43.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/69/ec/9fb9dcf4f91f0e5e76de597256c43eedefd8423aa59be95c70c4c3db426a/cryptography-43.0.0.tar.gz", hash = "sha256:b88075ada2d51aa9f18283532c9f60e72170041bba88d7f37e49cbb10275299e", size = 686873 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d3/46/dcd2eb6840b9452e7fbc52720f3dc54a85eb41e68414733379e8f98e3275/cryptography-43.0.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:64c3f16e2a4fc51c0d06af28441881f98c5d91009b8caaff40cf3548089e9c74", size = 6239718 },
-    { url = "https://files.pythonhosted.org/packages/e8/23/b0713319edff1d8633775b354f8b34a476e4dd5f4cd4b91e488baec3361a/cryptography-43.0.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3dcdedae5c7710b9f97ac6bba7e1052b95c7083c9d0e9df96e02a1932e777895", size = 3808466 },
-    { url = "https://files.pythonhosted.org/packages/77/9d/0b98c73cebfd41e4fb0439fe9ce08022e8d059f51caa7afc8934fc1edcd9/cryptography-43.0.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d9a1eca329405219b605fac09ecfc09ac09e595d6def650a437523fcd08dd22", size = 3998060 },
-    { url = "https://files.pythonhosted.org/packages/ae/71/e073795d0d1624847f323481f7d84855f699172a632aa37646464b0e1712/cryptography-43.0.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ea9e57f8ea880eeea38ab5abf9fbe39f923544d7884228ec67d666abd60f5a47", size = 3792596 },
-    { url = "https://files.pythonhosted.org/packages/83/25/439a8ddd8058e7f898b7d27c36f94b66c8c8a2d60e1855d725845f4be0bc/cryptography-43.0.0-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9a8d6802e0825767476f62aafed40532bd435e8a5f7d23bd8b4f5fd04cc80ecf", size = 4008355 },
-    { url = "https://files.pythonhosted.org/packages/c7/a2/1607f1295eb2c30fcf2c07d7fd0c3772d21dcdb827de2b2730b02df0af51/cryptography-43.0.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cc70b4b581f28d0a254d006f26949245e3657d40d8857066c2ae22a61222ef55", size = 3899133 },
-    { url = "https://files.pythonhosted.org/packages/5e/64/f41f42ddc9c583737c9df0093affb92c61de7d5b0d299bf644524afe31c1/cryptography-43.0.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4a997df8c1c2aae1e1e5ac49c2e4f610ad037fc5a3aadc7b64e39dea42249431", size = 4096946 },
-    { url = "https://files.pythonhosted.org/packages/cd/cd/d165adcf3e707d6a049d44ade6ca89973549bed0ab3686fa49efdeefea53/cryptography-43.0.0-cp37-abi3-win32.whl", hash = "sha256:6e2b11c55d260d03a8cf29ac9b5e0608d35f08077d8c087be96287f43af3ccdc", size = 2616826 },
-    { url = "https://files.pythonhosted.org/packages/f9/b7/38924229e84c41b0e88d7a5eed8a29d05a44364f85fbb9ddb3984b746fd2/cryptography-43.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:31e44a986ceccec3d0498e16f3d27b2ee5fdf69ce2ab89b52eaad1d2f33d8778", size = 3078700 },
-    { url = "https://files.pythonhosted.org/packages/66/d7/397515233e6a861f921bd0365b162b38e0cc513fcf4f1bdd9cc7bc5a3384/cryptography-43.0.0-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:7b3f5fe74a5ca32d4d0f302ffe6680fcc5c28f8ef0dc0ae8f40c0f3a1b4fca66", size = 6242814 },
-    { url = "https://files.pythonhosted.org/packages/58/aa/99b2c00a4f54c60d210d6d1759c720ecf28305aa32d6fb1bb1853f415be6/cryptography-43.0.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac1955ce000cb29ab40def14fd1bbfa7af2017cca696ee696925615cafd0dce5", size = 3809467 },
-    { url = "https://files.pythonhosted.org/packages/76/eb/ab783b47b3b9b55371b4361c7ec695144bde1a3343ff2b7a8c1d8fe617bb/cryptography-43.0.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:299d3da8e00b7e2b54bb02ef58d73cd5f55fb31f33ebbf33bd00d9aa6807df7e", size = 3998617 },
-    { url = "https://files.pythonhosted.org/packages/a3/62/62770f34290ebb1b6542bd3f13b3b102875b90aed4804e296f8d2a5ac6d7/cryptography-43.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ee0c405832ade84d4de74b9029bedb7b31200600fa524d218fc29bfa371e97f5", size = 3794003 },
-    { url = "https://files.pythonhosted.org/packages/0f/6c/b42660b3075ff543065b2c1c5a3d9bedaadcff8ebce2ee981be2babc2934/cryptography-43.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:cb013933d4c127349b3948aa8aaf2f12c0353ad0eccd715ca789c8a0f671646f", size = 4008774 },
-    { url = "https://files.pythonhosted.org/packages/f7/74/028cea86db9315ba3f991e307adabf9f0aa15067011137c38b2fb2aa16eb/cryptography-43.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fdcb265de28585de5b859ae13e3846a8e805268a823a12a4da2597f1f5afc9f0", size = 3900098 },
-    { url = "https://files.pythonhosted.org/packages/bd/f6/e4387edb55563e2546028ba4c634522fe727693d3cdd9ec0ecacedc75411/cryptography-43.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2905ccf93a8a2a416f3ec01b1a7911c3fe4073ef35640e7ee5296754e30b762b", size = 4096867 },
-    { url = "https://files.pythonhosted.org/packages/ce/61/55560405e75432bdd9f6cf72fa516cab623b83a3f6d230791bc8fc4afeee/cryptography-43.0.0-cp39-abi3-win32.whl", hash = "sha256:47ca71115e545954e6c1d207dd13461ab81f4eccfcb1345eac874828b5e3eaaf", size = 2616481 },
-    { url = "https://files.pythonhosted.org/packages/e6/3d/696e7a0f04555c58a2813d47aaa78cb5ba863c1f453c74a4f45ae772b054/cryptography-43.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:0663585d02f76929792470451a5ba64424acc3cd5227b03921dab0e2f27b1709", size = 3081462 },
-    { url = "https://files.pythonhosted.org/packages/c6/3a/9c7d864bbcca2df77a601366a6ae3937cd78d0f21ad98441f3424592aea7/cryptography-43.0.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2c6d112bf61c5ef44042c253e4859b3cbbb50df2f78fa8fae6747a7814484a70", size = 3156882 },
-    { url = "https://files.pythonhosted.org/packages/17/cd/d43859b09d726a905d882b6e464ccf02aa2dca2c3e76c44a0c5b169f0144/cryptography-43.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:844b6d608374e7d08f4f6e6f9f7b951f9256db41421917dfb2d003dde4cd6b66", size = 3722095 },
-    { url = "https://files.pythonhosted.org/packages/2e/ce/c7b912d95f0ded80ad3b50a0a6b31de813c25d9ffadbe1b26bf22d2c4518/cryptography-43.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:51956cf8730665e2bdf8ddb8da0056f699c1a5715648c1b0144670c1ba00b48f", size = 3928750 },
-    { url = "https://files.pythonhosted.org/packages/ca/25/7b53082e4c373127c1fb190f70c5aca7bf7a03ac11f67ba15473bc6d9a0e/cryptography-43.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:aae4d918f6b180a8ab8bf6511a419473d107df4dbb4225c7b48c5c9602c38c7f", size = 3002487 },
+sdist = { url = "https://files.pythonhosted.org/packages/0d/05/07b55d1fa21ac18c3a8c79f764e2514e6f6a9698f1be44994f5adf0d29db/cryptography-43.0.3.tar.gz", hash = "sha256:315b9001266a492a6ff443b61238f956b214dbec9910a081ba5b6646a055a805", size = 686989 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1f/f3/01fdf26701a26f4b4dbc337a26883ad5bccaa6f1bbbdd29cd89e22f18a1c/cryptography-43.0.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:bf7a1932ac4176486eab36a19ed4c0492da5d97123f1406cf15e41b05e787d2e", size = 6225303 },
+    { url = "https://files.pythonhosted.org/packages/a3/01/4896f3d1b392025d4fcbecf40fdea92d3df8662123f6835d0af828d148fd/cryptography-43.0.3-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63efa177ff54aec6e1c0aefaa1a241232dcd37413835a9b674b6e3f0ae2bfd3e", size = 3760905 },
+    { url = "https://files.pythonhosted.org/packages/0a/be/f9a1f673f0ed4b7f6c643164e513dbad28dd4f2dcdf5715004f172ef24b6/cryptography-43.0.3-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e1ce50266f4f70bf41a2c6dc4358afadae90e2a1e5342d3c08883df1675374f", size = 3977271 },
+    { url = "https://files.pythonhosted.org/packages/4e/49/80c3a7b5514d1b416d7350830e8c422a4d667b6d9b16a9392ebfd4a5388a/cryptography-43.0.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:443c4a81bb10daed9a8f334365fe52542771f25aedaf889fd323a853ce7377d6", size = 3746606 },
+    { url = "https://files.pythonhosted.org/packages/0e/16/a28ddf78ac6e7e3f25ebcef69ab15c2c6be5ff9743dd0709a69a4f968472/cryptography-43.0.3-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:74f57f24754fe349223792466a709f8e0c093205ff0dca557af51072ff47ab18", size = 3986484 },
+    { url = "https://files.pythonhosted.org/packages/01/f5/69ae8da70c19864a32b0315049866c4d411cce423ec169993d0434218762/cryptography-43.0.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9762ea51a8fc2a88b70cf2995e5675b38d93bf36bd67d91721c309df184f49bd", size = 3852131 },
+    { url = "https://files.pythonhosted.org/packages/fd/db/e74911d95c040f9afd3612b1f732e52b3e517cb80de8bf183be0b7d413c6/cryptography-43.0.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:81ef806b1fef6b06dcebad789f988d3b37ccaee225695cf3e07648eee0fc6b73", size = 4075647 },
+    { url = "https://files.pythonhosted.org/packages/56/48/7b6b190f1462818b324e674fa20d1d5ef3e24f2328675b9b16189cbf0b3c/cryptography-43.0.3-cp37-abi3-win32.whl", hash = "sha256:cbeb489927bd7af4aa98d4b261af9a5bc025bd87f0e3547e11584be9e9427be2", size = 2623873 },
+    { url = "https://files.pythonhosted.org/packages/eb/b1/0ebff61a004f7f89e7b65ca95f2f2375679d43d0290672f7713ee3162aff/cryptography-43.0.3-cp37-abi3-win_amd64.whl", hash = "sha256:f46304d6f0c6ab8e52770addfa2fc41e6629495548862279641972b6215451cd", size = 3068039 },
+    { url = "https://files.pythonhosted.org/packages/30/d5/c8b32c047e2e81dd172138f772e81d852c51f0f2ad2ae8a24f1122e9e9a7/cryptography-43.0.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:8ac43ae87929a5982f5948ceda07001ee5e83227fd69cf55b109144938d96984", size = 6222984 },
+    { url = "https://files.pythonhosted.org/packages/2f/78/55356eb9075d0be6e81b59f45c7b48df87f76a20e73893872170471f3ee8/cryptography-43.0.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:846da004a5804145a5f441b8530b4bf35afbf7da70f82409f151695b127213d5", size = 3762968 },
+    { url = "https://files.pythonhosted.org/packages/2a/2c/488776a3dc843f95f86d2f957ca0fc3407d0242b50bede7fad1e339be03f/cryptography-43.0.3-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f996e7268af62598f2fc1204afa98a3b5712313a55c4c9d434aef49cadc91d4", size = 3977754 },
+    { url = "https://files.pythonhosted.org/packages/7c/04/2345ca92f7a22f601a9c62961741ef7dd0127c39f7310dffa0041c80f16f/cryptography-43.0.3-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f7b178f11ed3664fd0e995a47ed2b5ff0a12d893e41dd0494f406d1cf555cab7", size = 3749458 },
+    { url = "https://files.pythonhosted.org/packages/ac/25/e715fa0bc24ac2114ed69da33adf451a38abb6f3f24ec207908112e9ba53/cryptography-43.0.3-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:c2e6fc39c4ab499049df3bdf567f768a723a5e8464816e8f009f121a5a9f4405", size = 3988220 },
+    { url = "https://files.pythonhosted.org/packages/21/ce/b9c9ff56c7164d8e2edfb6c9305045fbc0df4508ccfdb13ee66eb8c95b0e/cryptography-43.0.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e1be4655c7ef6e1bbe6b5d0403526601323420bcf414598955968c9ef3eb7d16", size = 3853898 },
+    { url = "https://files.pythonhosted.org/packages/2a/33/b3682992ab2e9476b9c81fff22f02c8b0a1e6e1d49ee1750a67d85fd7ed2/cryptography-43.0.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:df6b6c6d742395dd77a23ea3728ab62f98379eff8fb61be2744d4679ab678f73", size = 4076592 },
+    { url = "https://files.pythonhosted.org/packages/81/1e/ffcc41b3cebd64ca90b28fd58141c5f68c83d48563c88333ab660e002cd3/cryptography-43.0.3-cp39-abi3-win32.whl", hash = "sha256:d56e96520b1020449bbace2b78b603442e7e378a9b3bd68de65c782db1507995", size = 2623145 },
+    { url = "https://files.pythonhosted.org/packages/87/5c/3dab83cc4aba1f4b0e733e3f0c3e7d4386440d660ba5b1e3ff995feb734d/cryptography-43.0.3-cp39-abi3-win_amd64.whl", hash = "sha256:0c580952eef9bf68c4747774cde7ec1d85a6e61de97281f2dba83c7d2c806362", size = 3068026 },
+    { url = "https://files.pythonhosted.org/packages/6f/db/d8b8a039483f25fc3b70c90bc8f3e1d4497a99358d610c5067bf3bd4f0af/cryptography-43.0.3-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d03b5621a135bffecad2c73e9f4deb1a0f977b9a8ffe6f8e002bf6c9d07b918c", size = 3144545 },
+    { url = "https://files.pythonhosted.org/packages/93/90/116edd5f8ec23b2dc879f7a42443e073cdad22950d3c8ee834e3b8124543/cryptography-43.0.3-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a2a431ee15799d6db9fe80c82b055bae5a752bef645bba795e8e52687c69efe3", size = 3679828 },
+    { url = "https://files.pythonhosted.org/packages/d8/32/1e1d78b316aa22c0ba6493cc271c1c309969e5aa5c22c830a1d7ce3471e6/cryptography-43.0.3-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:281c945d0e28c92ca5e5930664c1cefd85efe80e5c0d2bc58dd63383fda29f83", size = 3908132 },
+    { url = "https://files.pythonhosted.org/packages/91/bb/cd2c13be3332e7af3cdf16154147952d39075b9f61ea5e6b5241bf4bf436/cryptography-43.0.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f18c716be16bc1fea8e95def49edf46b82fccaa88587a45f8dc0ff6ab5d8e0a7", size = 2988811 },
 ]
 
 [[package]]
@@ -1001,23 +1010,27 @@ wheels = [
 
 [[package]]
 name = "debugpy"
-version = "1.8.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ea/f9/61c325a10ded8dc3ddc3e7cd2ed58c0b15b2ef4bf8b4bf2930ee98ed59ee/debugpy-1.8.5.zip", hash = "sha256:b2112cfeb34b4507399d298fe7023a16656fc553ed5246536060ca7bd0e668d0", size = 4612118 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f1/36/0b423f94097cc86555f9a2c8717511863b2a680c9b44b5419d8ac1ff7bf2/debugpy-1.8.5-cp310-cp310-macosx_12_0_x86_64.whl", hash = "sha256:7e4d594367d6407a120b76bdaa03886e9eb652c05ba7f87e37418426ad2079f7", size = 1711184 },
-    { url = "https://files.pythonhosted.org/packages/57/0c/c2ec581541923a4d36cee4fd2419c1211c986849fc61097f87aa81fc6ad3/debugpy-1.8.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4413b7a3ede757dc33a273a17d685ea2b0c09dbd312cc03f5534a0fd4d40750a", size = 2997629 },
-    { url = "https://files.pythonhosted.org/packages/a8/46/3072c2cd3b20f435968275d316f6aea7ddbb760386324e6578278bc2eb99/debugpy-1.8.5-cp310-cp310-win32.whl", hash = "sha256:dd3811bd63632bb25eda6bd73bea8e0521794cda02be41fa3160eb26fc29e7ed", size = 4764678 },
-    { url = "https://files.pythonhosted.org/packages/38/25/e738d6f782beba924c0e10dfde2061152f1ea3608dff0e5a5bfb30c311e9/debugpy-1.8.5-cp310-cp310-win_amd64.whl", hash = "sha256:b78c1250441ce893cb5035dd6f5fc12db968cc07f91cc06996b2087f7cefdd8e", size = 4788002 },
-    { url = "https://files.pythonhosted.org/packages/ad/72/fd138a10dda16775607316d60dd440fcd23e7560e9276da53c597b5917e9/debugpy-1.8.5-cp311-cp311-macosx_12_0_universal2.whl", hash = "sha256:606bccba19f7188b6ea9579c8a4f5a5364ecd0bf5a0659c8a5d0e10dcee3032a", size = 1786504 },
-    { url = "https://files.pythonhosted.org/packages/e2/0e/d0e6af2d7bbf5ace847e4d3bd41f8f9d4a0764fcd8058f07a1c51618cbf2/debugpy-1.8.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db9fb642938a7a609a6c865c32ecd0d795d56c1aaa7a7a5722d77855d5e77f2b", size = 2642077 },
-    { url = "https://files.pythonhosted.org/packages/f6/55/2a1dc192894ba9b368cdcce15315761a00f2d4cd7de4402179648840e480/debugpy-1.8.5-cp311-cp311-win32.whl", hash = "sha256:4fbb3b39ae1aa3e5ad578f37a48a7a303dad9a3d018d369bc9ec629c1cfa7408", size = 4702081 },
-    { url = "https://files.pythonhosted.org/packages/7f/7f/942b23d64f4896e9f8776cf306dfd00feadc950a38d56398610a079b28b1/debugpy-1.8.5-cp311-cp311-win_amd64.whl", hash = "sha256:345d6a0206e81eb68b1493ce2fbffd57c3088e2ce4b46592077a943d2b968ca3", size = 4715571 },
-    { url = "https://files.pythonhosted.org/packages/9a/82/7d9e1f75fb23c876ab379008c7cf484a1cfa5ed47ccaac8ba37c75e6814e/debugpy-1.8.5-cp312-cp312-macosx_12_0_universal2.whl", hash = "sha256:5b5c770977c8ec6c40c60d6f58cacc7f7fe5a45960363d6974ddb9b62dbee156", size = 1436398 },
-    { url = "https://files.pythonhosted.org/packages/fd/b6/ee71d5e73712daf8307a9e85f5e39301abc8b66d13acd04dfff1702e672e/debugpy-1.8.5-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0a65b00b7cdd2ee0c2cf4c7335fef31e15f1b7056c7fdbce9e90193e1a8c8cb", size = 1437465 },
-    { url = "https://files.pythonhosted.org/packages/6c/d8/8e32bf1f2e0142f7e8a2c354338b493e87f2c44e77e233b3a140fb5efa03/debugpy-1.8.5-cp312-cp312-win32.whl", hash = "sha256:c9f7c15ea1da18d2fcc2709e9f3d6de98b69a5b0fff1807fb80bc55f906691f7", size = 4581313 },
-    { url = "https://files.pythonhosted.org/packages/f7/be/2fbaffecb063de228b2b3b6a1750b0b745e5dc645eddd52be8b329933c0b/debugpy-1.8.5-cp312-cp312-win_amd64.whl", hash = "sha256:28ced650c974aaf179231668a293ecd5c63c0a671ae6d56b8795ecc5d2f48d3c", size = 4581209 },
-    { url = "https://files.pythonhosted.org/packages/02/49/b595c34d7bc690e8d225a6641618a5c111c7e13db5d9e2b756c15ce8f8c6/debugpy-1.8.5-py2.py3-none-any.whl", hash = "sha256:55919dce65b471eff25901acf82d328bbd5b833526b6c1364bd5133754777a44", size = 4824118 },
+version = "1.8.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6d/00/5a8b5dc8f52617c5e41845e26290ebea1ba06377cc08155b6d245c27b386/debugpy-1.8.7.zip", hash = "sha256:18b8f731ed3e2e1df8e9cdaa23fb1fc9c24e570cd0081625308ec51c82efe42e", size = 4957835 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/50/1850a5a0cab6f65a21e452166ec60bac5f8a995184d17e18bb9dc3789c72/debugpy-1.8.7-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:95fe04a573b8b22896c404365e03f4eda0ce0ba135b7667a1e57bd079793b96b", size = 2090182 },
+    { url = "https://files.pythonhosted.org/packages/87/51/ef4d5c55c06689b377678bdee870e3df8eb2a3d9cf0e618b4d7255413c8a/debugpy-1.8.7-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:628a11f4b295ffb4141d8242a9bb52b77ad4a63a2ad19217a93be0f77f2c28c9", size = 3547569 },
+    { url = "https://files.pythonhosted.org/packages/eb/df/a4ea1f95022f93522b59b71ec42d6703abe3e0bee753070118816555fee9/debugpy-1.8.7-cp310-cp310-win32.whl", hash = "sha256:85ce9c1d0eebf622f86cc68618ad64bf66c4fc3197d88f74bb695a416837dd55", size = 5153144 },
+    { url = "https://files.pythonhosted.org/packages/47/f7/912408b69e83659bd62fa29ebb7984efe81aed4f5e08bfe10e31a1dc3c3a/debugpy-1.8.7-cp310-cp310-win_amd64.whl", hash = "sha256:29e1571c276d643757ea126d014abda081eb5ea4c851628b33de0c2b6245b037", size = 5185605 },
+    { url = "https://files.pythonhosted.org/packages/f6/0a/4a4516ef4c07891542cb25620085507cab3c6b23a42b5630c17788fff83e/debugpy-1.8.7-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:caf528ff9e7308b74a1749c183d6808ffbedbb9fb6af78b033c28974d9b8831f", size = 2204794 },
+    { url = "https://files.pythonhosted.org/packages/46/6f/2bb0bba20b8b74b7c341379dd99275cf6aa7722c1948fa99728716aad1b9/debugpy-1.8.7-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cba1d078cf2e1e0b8402e6bda528bf8fda7ccd158c3dba6c012b7897747c41a0", size = 3122160 },
+    { url = "https://files.pythonhosted.org/packages/c0/ce/833351375cef971f0caa63fa82adf3f6949ad85410813026a4a436083a71/debugpy-1.8.7-cp311-cp311-win32.whl", hash = "sha256:171899588bcd412151e593bd40d9907133a7622cd6ecdbdb75f89d1551df13c2", size = 5078675 },
+    { url = "https://files.pythonhosted.org/packages/7d/e1/e9ac2d546143a4defbaa2e609e173c912fb989cdfb5385c9771770a6bf5c/debugpy-1.8.7-cp311-cp311-win_amd64.whl", hash = "sha256:6e1c4ffb0c79f66e89dfd97944f335880f0d50ad29525dc792785384923e2211", size = 5102927 },
+    { url = "https://files.pythonhosted.org/packages/59/4b/9f52ca1a799601a10cd2673503658bd8c8ecc4a7a43302ee29cf062474ec/debugpy-1.8.7-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:4d27d842311353ede0ad572600c62e4bcd74f458ee01ab0dd3a1a4457e7e3706", size = 2529803 },
+    { url = "https://files.pythonhosted.org/packages/80/79/8bba39190d2ea17840925d287f1c6c3a7c60b58f5090444e9ecf176c540f/debugpy-1.8.7-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:703c1fd62ae0356e194f3e7b7a92acd931f71fe81c4b3be2c17a7b8a4b546ec2", size = 4170911 },
+    { url = "https://files.pythonhosted.org/packages/3b/19/5b3d312936db8eb281310fa27903459328ed722d845d594ba5feaeb2f0b3/debugpy-1.8.7-cp312-cp312-win32.whl", hash = "sha256:2f729228430ef191c1e4df72a75ac94e9bf77413ce5f3f900018712c9da0aaca", size = 5195476 },
+    { url = "https://files.pythonhosted.org/packages/9f/49/ad20b29f8c921fd5124530d3d39b8f2077efd51b71339a2eff02bba693e9/debugpy-1.8.7-cp312-cp312-win_amd64.whl", hash = "sha256:45c30aaefb3e1975e8a0258f5bbd26cd40cde9bfe71e9e5a7ac82e79bad64e39", size = 5235031 },
+    { url = "https://files.pythonhosted.org/packages/41/95/29b247518d0a6afdb5249f5d05743c9c5bfaf4bd13a85b81cb5e1dc65837/debugpy-1.8.7-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:d050a1ec7e925f514f0f6594a1e522580317da31fbda1af71d1530d6ea1f2b40", size = 2517557 },
+    { url = "https://files.pythonhosted.org/packages/4d/93/026e2000a0740e2f54b198f8dc317accf3a70b6524b2b15fa8e6eca74414/debugpy-1.8.7-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2f4349a28e3228a42958f8ddaa6333d6f8282d5edaea456070e48609c5983b7", size = 4162703 },
+    { url = "https://files.pythonhosted.org/packages/c3/92/a48e653b19a171434290ecdc5935b7a292a65488139c5271d6d0eceeb0f1/debugpy-1.8.7-cp313-cp313-win32.whl", hash = "sha256:11ad72eb9ddb436afb8337891a986302e14944f0f755fd94e90d0d71e9100bba", size = 5195220 },
+    { url = "https://files.pythonhosted.org/packages/4e/b3/dc3c5527edafcd1a6d0f8c4ecc6c5c9bc431f77340cf4193328e98f0ac38/debugpy-1.8.7-cp313-cp313-win_amd64.whl", hash = "sha256:2efb84d6789352d7950b03d7f866e6d180284bc02c7e12cb37b489b7083d81aa", size = 5235333 },
+    { url = "https://files.pythonhosted.org/packages/51/b1/a0866521c71a6ae3d3ca320e74835163a4671b1367ba360a55a0a51e5a91/debugpy-1.8.7-py2.py3-none-any.whl", hash = "sha256:57b00de1c8d2c84a61b90880f7e5b6deaf4c312ecbde3a0e8912f2a56c4ac9ae", size = 5210683 },
 ]
 
 [[package]]
@@ -1102,11 +1115,20 @@ wheels = [
 
 [[package]]
 name = "et-xmlfile"
-version = "1.1.0"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059 },
+]
+
+[[package]]
+name = "eval-type-backport"
+version = "0.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3d/5d/0413a31d184a20c763ad741cc7852a659bf15094c24840c5bdd1754765cd/et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c", size = 3218 }
+sdist = { url = "https://files.pythonhosted.org/packages/23/ca/1601a9fa588867fe2ab6c19ed4c936929160d08a86597adf61bbd443fe57/eval_type_backport-0.2.0.tar.gz", hash = "sha256:68796cfbc7371ebf923f03bdf7bef415f3ec098aeced24e054b253a0e78f7b37", size = 8977 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/c2/3dd434b0108730014f1b96fd286040dc3bcb70066346f7e01ec2ac95865f/et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada", size = 4688 },
+    { url = "https://files.pythonhosted.org/packages/ac/ac/aa3d8e0acbcd71140420bc752d7c9779cf3a2a3bb1d7ef30944e38b2cd39/eval_type_backport-0.2.0-py3-none-any.whl", hash = "sha256:ac2f73d30d40c5a30a80b8739a789d6bb5e49fdffa66d7912667e2015d9c9933", size = 5855 },
 ]
 
 [[package]]
@@ -1129,25 +1151,25 @@ wheels = [
 
 [[package]]
 name = "executing"
-version = "2.0.1"
+version = "2.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/08/41/85d2d28466fca93737592b7f3cc456d1cfd6bcd401beceeba17e8e792b50/executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147", size = 836501 }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/80/03/6ea8b1b2a5ab40a7a60dc464d3daa7aa546e0a74d74a9f8ff551ea7905db/executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc", size = 24922 },
+    { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 },
 ]
 
 [[package]]
 name = "fastapi"
-version = "0.115.0"
+version = "0.115.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "starlette" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7b/5e/bf0471f14bf6ebfbee8208148a3396d1a23298531a6cc10776c59f4c0f87/fastapi-0.115.0.tar.gz", hash = "sha256:f93b4ca3529a8ebc6fc3fcf710e5efa8de3df9b41570958abf1d97d843138004", size = 302295 }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/ce/b64ce344d7b13c0768dc5b131a69d52f57202eb85839408a7637ca0dd7e2/fastapi-0.115.3.tar.gz", hash = "sha256:c091c6a35599c036d676fa24bd4a6e19fa30058d93d950216cdc672881f6f7db", size = 300453 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/ab/a1f7eed031aeb1c406a6e9d45ca04bff401c8a25a30dd0e4fd2caae767c3/fastapi-0.115.0-py3-none-any.whl", hash = "sha256:17ea427674467486e997206a5ab25760f6b09e069f099b96f5b55a32fb6f1631", size = 94625 },
+    { url = "https://files.pythonhosted.org/packages/57/95/4c5b79e7ca1f7b372d16a32cad7c9cc6c3c899200bed8f45739f4415cfae/fastapi-0.115.3-py3-none-any.whl", hash = "sha256:8035e8f9a2b0aa89cea03b6c77721178ed5358e1aea4cd8570d9466895c0638c", size = 94647 },
 ]
 
 [[package]]
@@ -1184,11 +1206,11 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.15.4"
+version = "3.16.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/08/dd/49e06f09b6645156550fb9aee9cc1e59aba7efbc972d665a1bd6ae0435d4/filelock-3.15.4.tar.gz", hash = "sha256:2207938cbc1844345cb01a5a95524dae30f0ce089eba5b00378295a17e3e90cb", size = 18007 }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ae/f0/48285f0262fe47103a4a45972ed2f9b93e4c80b8fd609fa98da78b2a5706/filelock-3.15.4-py3-none-any.whl", hash = "sha256:6ca1fffae96225dab4c6eaf1c4f4f28cd2568d3ec2a44e15a08520504de468e7", size = 16159 },
+    { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 },
 ]
 
 [[package]]
@@ -1205,65 +1227,80 @@ wheels = [
 
 [[package]]
 name = "frozenlist"
-version = "1.4.1"
+version = "1.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cf/3d/2102257e7acad73efc4a0c306ad3953f68c504c16982bbdfee3ad75d8085/frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b", size = 37820 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/35/1328c7b0f780d34f8afc1d87ebdc2bb065a123b24766a0b475f0d67da637/frozenlist-1.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac", size = 94315 },
-    { url = "https://files.pythonhosted.org/packages/f4/d6/ca016b0adcf8327714ccef969740688808c86e0287bf3a639ff582f24e82/frozenlist-1.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29acab3f66f0f24674b7dc4736477bcd4bc3ad4b896f5f45379a67bce8b96868", size = 53805 },
-    { url = "https://files.pythonhosted.org/packages/ae/83/bcdaa437a9bd693ba658a0310f8cdccff26bd78e45fccf8e49897904a5cd/frozenlist-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776", size = 52163 },
-    { url = "https://files.pythonhosted.org/packages/d4/e9/759043ab7d169b74fe05ebfbfa9ee5c881c303ebc838e308346204309cd0/frozenlist-1.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:590344787a90ae57d62511dd7c736ed56b428f04cd8c161fcc5e7232c130c69a", size = 238595 },
-    { url = "https://files.pythonhosted.org/packages/f8/ce/b9de7dc61e753dc318cf0de862181b484178210c5361eae6eaf06792264d/frozenlist-1.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:068b63f23b17df8569b7fdca5517edef76171cf3897eb68beb01341131fbd2ad", size = 262428 },
-    { url = "https://files.pythonhosted.org/packages/36/ce/dc6f29e0352fa34ebe45421960c8e7352ca63b31630a576e8ffb381e9c08/frozenlist-1.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c849d495bf5154cd8da18a9eb15db127d4dba2968d88831aff6f0331ea9bd4c", size = 258867 },
-    { url = "https://files.pythonhosted.org/packages/51/47/159ac53faf8a11ae5ee8bb9db10327575557504e549cfd76f447b969aa91/frozenlist-1.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9750cc7fe1ae3b1611bb8cfc3f9ec11d532244235d75901fb6b8e42ce9229dfe", size = 229412 },
-    { url = "https://files.pythonhosted.org/packages/ec/25/0c87df2e53c0c5d90f7517ca0ff7aca78d050a8ec4d32c4278e8c0e52e51/frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a", size = 239539 },
-    { url = "https://files.pythonhosted.org/packages/97/94/a1305fa4716726ae0abf3b1069c2d922fcfd442538cb850f1be543f58766/frozenlist-1.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0633c8d5337cb5c77acbccc6357ac49a1770b8c487e5b3505c57b949b4b82e98", size = 253379 },
-    { url = "https://files.pythonhosted.org/packages/53/82/274e19f122e124aee6d113188615f63b0736b4242a875f482a81f91e07e2/frozenlist-1.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:27657df69e8801be6c3638054e202a135c7f299267f1a55ed3a598934f6c0d75", size = 245901 },
-    { url = "https://files.pythonhosted.org/packages/b8/28/899931015b8cffbe155392fe9ca663f981a17e1adc69589ee0e1e7cdc9a2/frozenlist-1.4.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:f9a3ea26252bd92f570600098783d1371354d89d5f6b7dfd87359d669f2109b5", size = 263797 },
-    { url = "https://files.pythonhosted.org/packages/6e/4f/b8a5a2f10c4a58c52a52a40cf6cf1ffcdbf3a3b64f276f41dab989bf3ab5/frozenlist-1.4.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:4f57dab5fe3407b6c0c1cc907ac98e8a189f9e418f3b6e54d65a718aaafe3950", size = 264415 },
-    { url = "https://files.pythonhosted.org/packages/b0/2c/7be3bdc59dbae444864dbd9cde82790314390ec54636baf6b9ce212627ad/frozenlist-1.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e02a0e11cf6597299b9f3bbd3f93d79217cb90cfd1411aec33848b13f5c656cc", size = 253964 },
-    { url = "https://files.pythonhosted.org/packages/2e/ec/4fb5a88f6b9a352aed45ab824dd7ce4801b7bcd379adcb927c17a8f0a1a8/frozenlist-1.4.1-cp310-cp310-win32.whl", hash = "sha256:a828c57f00f729620a442881cc60e57cfcec6842ba38e1b19fd3e47ac0ff8dc1", size = 44559 },
-    { url = "https://files.pythonhosted.org/packages/61/15/2b5d644d81282f00b61e54f7b00a96f9c40224107282efe4cd9d2bf1433a/frozenlist-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439", size = 50434 },
-    { url = "https://files.pythonhosted.org/packages/01/bc/8d33f2d84b9368da83e69e42720cff01c5e199b5a868ba4486189a4d8fa9/frozenlist-1.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0", size = 97060 },
-    { url = "https://files.pythonhosted.org/packages/af/b2/904500d6a162b98a70e510e743e7ea992241b4f9add2c8063bf666ca21df/frozenlist-1.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b46c8ae3a8f1f41a0d2ef350c0b6e65822d80772fe46b653ab6b6274f61d4a49", size = 55347 },
-    { url = "https://files.pythonhosted.org/packages/5b/9c/f12b69997d3891ddc0d7895999a00b0c6a67f66f79498c0e30f27876435d/frozenlist-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced", size = 53374 },
-    { url = "https://files.pythonhosted.org/packages/ac/6e/e0322317b7c600ba21dec224498c0c5959b2bce3865277a7c0badae340a9/frozenlist-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:722e1124aec435320ae01ee3ac7bec11a5d47f25d0ed6328f2273d287bc3abb0", size = 273288 },
-    { url = "https://files.pythonhosted.org/packages/a7/76/180ee1b021568dad5b35b7678616c24519af130ed3fa1e0f1ed4014e0f93/frozenlist-1.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2471c201b70d58a0f0c1f91261542a03d9a5e088ed3dc6c160d614c01649c106", size = 284737 },
-    { url = "https://files.pythonhosted.org/packages/05/08/40159d706a6ed983c8aca51922a93fc69f3c27909e82c537dd4054032674/frozenlist-1.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c757a9dd70d72b076d6f68efdbb9bc943665ae954dad2801b874c8c69e185068", size = 280267 },
-    { url = "https://files.pythonhosted.org/packages/e0/18/9f09f84934c2b2aa37d539a322267939770362d5495f37783440ca9c1b74/frozenlist-1.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f146e0911cb2f1da549fc58fc7bcd2b836a44b79ef871980d605ec392ff6b0d2", size = 258778 },
-    { url = "https://files.pythonhosted.org/packages/b3/c9/0bc5ee7e1f5cc7358ab67da0b7dfe60fbd05c254cea5c6108e7d1ae28c63/frozenlist-1.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19", size = 272276 },
-    { url = "https://files.pythonhosted.org/packages/12/5d/147556b73a53ad4df6da8bbb50715a66ac75c491fdedac3eca8b0b915345/frozenlist-1.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c302220494f5c1ebeb0912ea782bcd5e2f8308037b3c7553fad0e48ebad6ad82", size = 272424 },
-    { url = "https://files.pythonhosted.org/packages/83/61/2087bbf24070b66090c0af922685f1d0596c24bb3f3b5223625bdeaf03ca/frozenlist-1.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:442acde1e068288a4ba7acfe05f5f343e19fac87bfc96d89eb886b0363e977ec", size = 260881 },
-    { url = "https://files.pythonhosted.org/packages/a8/be/a235bc937dd803258a370fe21b5aa2dd3e7bfe0287a186a4bec30c6cccd6/frozenlist-1.4.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:1b280e6507ea8a4fa0c0a7150b4e526a8d113989e28eaaef946cc77ffd7efc0a", size = 282327 },
-    { url = "https://files.pythonhosted.org/packages/5d/e7/b2469e71f082948066b9382c7b908c22552cc705b960363c390d2e23f587/frozenlist-1.4.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:fe1a06da377e3a1062ae5fe0926e12b84eceb8a50b350ddca72dc85015873f74", size = 281502 },
-    { url = "https://files.pythonhosted.org/packages/db/1b/6a5b970e55dffc1a7d0bb54f57b184b2a2a2ad0b7bca16a97ca26d73c5b5/frozenlist-1.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:db9e724bebd621d9beca794f2a4ff1d26eed5965b004a97f1f1685a173b869c2", size = 272292 },
-    { url = "https://files.pythonhosted.org/packages/1a/05/ebad68130e6b6eb9b287dacad08ea357c33849c74550c015b355b75cc714/frozenlist-1.4.1-cp311-cp311-win32.whl", hash = "sha256:e774d53b1a477a67838a904131c4b0eef6b3d8a651f8b138b04f748fccfefe17", size = 44446 },
-    { url = "https://files.pythonhosted.org/packages/b3/21/c5aaffac47fd305d69df46cfbf118768cdf049a92ee6b0b5cb029d449dcf/frozenlist-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825", size = 50459 },
-    { url = "https://files.pythonhosted.org/packages/b4/db/4cf37556a735bcdb2582f2c3fa286aefde2322f92d3141e087b8aeb27177/frozenlist-1.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae", size = 93937 },
-    { url = "https://files.pythonhosted.org/packages/46/03/69eb64642ca8c05f30aa5931d6c55e50b43d0cd13256fdd01510a1f85221/frozenlist-1.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cc7b01b3754ea68a62bd77ce6020afaffb44a590c2289089289363472d13aedb", size = 53656 },
-    { url = "https://files.pythonhosted.org/packages/3f/ab/c543c13824a615955f57e082c8a5ee122d2d5368e80084f2834e6f4feced/frozenlist-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b", size = 51868 },
-    { url = "https://files.pythonhosted.org/packages/a9/b8/438cfd92be2a124da8259b13409224d9b19ef8f5a5b2507174fc7e7ea18f/frozenlist-1.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c3894db91f5a489fc8fa6a9991820f368f0b3cbdb9cd8849547ccfab3392d86", size = 280652 },
-    { url = "https://files.pythonhosted.org/packages/54/72/716a955521b97a25d48315c6c3653f981041ce7a17ff79f701298195bca3/frozenlist-1.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba60bb19387e13597fb059f32cd4d59445d7b18b69a745b8f8e5db0346f33480", size = 286739 },
-    { url = "https://files.pythonhosted.org/packages/65/d8/934c08103637567084568e4d5b4219c1016c60b4d29353b1a5b3587827d6/frozenlist-1.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8aefbba5f69d42246543407ed2461db31006b0f76c4e32dfd6f42215a2c41d09", size = 289447 },
-    { url = "https://files.pythonhosted.org/packages/70/bb/d3b98d83ec6ef88f9bd63d77104a305d68a146fd63a683569ea44c3085f6/frozenlist-1.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:780d3a35680ced9ce682fbcf4cb9c2bad3136eeff760ab33707b71db84664e3a", size = 265466 },
-    { url = "https://files.pythonhosted.org/packages/0b/f2/b8158a0f06faefec33f4dff6345a575c18095a44e52d4f10c678c137d0e0/frozenlist-1.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd", size = 281530 },
-    { url = "https://files.pythonhosted.org/packages/ea/a2/20882c251e61be653764038ece62029bfb34bd5b842724fff32a5b7a2894/frozenlist-1.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:23b701e65c7b36e4bf15546a89279bd4d8675faabc287d06bbcfac7d3c33e1e6", size = 281295 },
-    { url = "https://files.pythonhosted.org/packages/4c/f9/8894c05dc927af2a09663bdf31914d4fb5501653f240a5bbaf1e88cab1d3/frozenlist-1.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3e0153a805a98f5ada7e09826255ba99fb4f7524bb81bf6b47fb702666484ae1", size = 268054 },
-    { url = "https://files.pythonhosted.org/packages/37/ff/a613e58452b60166507d731812f3be253eb1229808e59980f0405d1eafbf/frozenlist-1.4.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:dd9b1baec094d91bf36ec729445f7769d0d0cf6b64d04d86e45baf89e2b9059b", size = 286904 },
-    { url = "https://files.pythonhosted.org/packages/cc/6e/0091d785187f4c2020d5245796d04213f2261ad097e0c1cf35c44317d517/frozenlist-1.4.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:1a4471094e146b6790f61b98616ab8e44f72661879cc63fa1049d13ef711e71e", size = 290754 },
-    { url = "https://files.pythonhosted.org/packages/a5/c2/e42ad54bae8bcffee22d1e12a8ee6c7717f7d5b5019261a8c861854f4776/frozenlist-1.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5667ed53d68d91920defdf4035d1cdaa3c3121dc0b113255124bcfada1cfa1b8", size = 282602 },
-    { url = "https://files.pythonhosted.org/packages/b6/61/56bad8cb94f0357c4bc134acc30822e90e203b5cb8ff82179947de90c17f/frozenlist-1.4.1-cp312-cp312-win32.whl", hash = "sha256:beee944ae828747fd7cb216a70f120767fc9f4f00bacae8543c14a6831673f89", size = 44063 },
-    { url = "https://files.pythonhosted.org/packages/3e/dc/96647994a013bc72f3d453abab18340b7f5e222b7b7291e3697ca1fcfbd5/frozenlist-1.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5", size = 50452 },
-    { url = "https://files.pythonhosted.org/packages/83/10/466fe96dae1bff622021ee687f68e5524d6392b0a2f80d05001cd3a451ba/frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7", size = 11552 },
+sdist = { url = "https://files.pythonhosted.org/packages/8f/ed/0f4cec13a93c02c47ec32d81d11c0c1efbadf4a471e3f3ce7cad366cbbd3/frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817", size = 39930 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/79/29d44c4af36b2b240725dce566b20f63f9b36ef267aaaa64ee7466f4f2f8/frozenlist-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5b6a66c18b5b9dd261ca98dffcb826a525334b2f29e7caa54e182255c5f6a65a", size = 94451 },
+    { url = "https://files.pythonhosted.org/packages/47/47/0c999aeace6ead8a44441b4f4173e2261b18219e4ad1fe9a479871ca02fc/frozenlist-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d1b3eb7b05ea246510b43a7e53ed1653e55c2121019a97e60cad7efb881a97bb", size = 54301 },
+    { url = "https://files.pythonhosted.org/packages/8d/60/107a38c1e54176d12e06e9d4b5d755b677d71d1219217cee063911b1384f/frozenlist-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:15538c0cbf0e4fa11d1e3a71f823524b0c46299aed6e10ebb4c2089abd8c3bec", size = 52213 },
+    { url = "https://files.pythonhosted.org/packages/17/62/594a6829ac5679c25755362a9dc93486a8a45241394564309641425d3ff6/frozenlist-1.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e79225373c317ff1e35f210dd5f1344ff31066ba8067c307ab60254cd3a78ad5", size = 240946 },
+    { url = "https://files.pythonhosted.org/packages/7e/75/6c8419d8f92c80dd0ee3f63bdde2702ce6398b0ac8410ff459f9b6f2f9cb/frozenlist-1.5.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9272fa73ca71266702c4c3e2d4a28553ea03418e591e377a03b8e3659d94fa76", size = 264608 },
+    { url = "https://files.pythonhosted.org/packages/88/3e/82a6f0b84bc6fb7e0be240e52863c6d4ab6098cd62e4f5b972cd31e002e8/frozenlist-1.5.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:498524025a5b8ba81695761d78c8dd7382ac0b052f34e66939c42df860b8ff17", size = 261361 },
+    { url = "https://files.pythonhosted.org/packages/fd/85/14e5f9ccac1b64ff2f10c927b3ffdf88772aea875882406f9ba0cec8ad84/frozenlist-1.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:92b5278ed9d50fe610185ecd23c55d8b307d75ca18e94c0e7de328089ac5dcba", size = 231649 },
+    { url = "https://files.pythonhosted.org/packages/ee/59/928322800306f6529d1852323014ee9008551e9bb027cc38d276cbc0b0e7/frozenlist-1.5.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3c8c1dacd037df16e85227bac13cca58c30da836c6f936ba1df0c05d046d8d", size = 241853 },
+    { url = "https://files.pythonhosted.org/packages/7d/bd/e01fa4f146a6f6c18c5d34cab8abdc4013774a26c4ff851128cd1bd3008e/frozenlist-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f2ac49a9bedb996086057b75bf93538240538c6d9b38e57c82d51f75a73409d2", size = 243652 },
+    { url = "https://files.pythonhosted.org/packages/a5/bd/e4771fd18a8ec6757033f0fa903e447aecc3fbba54e3630397b61596acf0/frozenlist-1.5.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e66cc454f97053b79c2ab09c17fbe3c825ea6b4de20baf1be28919460dd7877f", size = 241734 },
+    { url = "https://files.pythonhosted.org/packages/21/13/c83821fa5544af4f60c5d3a65d054af3213c26b14d3f5f48e43e5fb48556/frozenlist-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:5a3ba5f9a0dfed20337d3e966dc359784c9f96503674c2faf015f7fe8e96798c", size = 260959 },
+    { url = "https://files.pythonhosted.org/packages/71/f3/1f91c9a9bf7ed0e8edcf52698d23f3c211d8d00291a53c9f115ceb977ab1/frozenlist-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6321899477db90bdeb9299ac3627a6a53c7399c8cd58d25da094007402b039ab", size = 262706 },
+    { url = "https://files.pythonhosted.org/packages/4c/22/4a256fdf5d9bcb3ae32622c796ee5ff9451b3a13a68cfe3f68e2c95588ce/frozenlist-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:76e4753701248476e6286f2ef492af900ea67d9706a0155335a40ea21bf3b2f5", size = 250401 },
+    { url = "https://files.pythonhosted.org/packages/af/89/c48ebe1f7991bd2be6d5f4ed202d94960c01b3017a03d6954dd5fa9ea1e8/frozenlist-1.5.0-cp310-cp310-win32.whl", hash = "sha256:977701c081c0241d0955c9586ffdd9ce44f7a7795df39b9151cd9a6fd0ce4cfb", size = 45498 },
+    { url = "https://files.pythonhosted.org/packages/28/2f/cc27d5f43e023d21fe5c19538e08894db3d7e081cbf582ad5ed366c24446/frozenlist-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:189f03b53e64144f90990d29a27ec4f7997d91ed3d01b51fa39d2dbe77540fd4", size = 51622 },
+    { url = "https://files.pythonhosted.org/packages/79/43/0bed28bf5eb1c9e4301003b74453b8e7aa85fb293b31dde352aac528dafc/frozenlist-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fd74520371c3c4175142d02a976aee0b4cb4a7cc912a60586ffd8d5929979b30", size = 94987 },
+    { url = "https://files.pythonhosted.org/packages/bb/bf/b74e38f09a246e8abbe1e90eb65787ed745ccab6eaa58b9c9308e052323d/frozenlist-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2f3f7a0fbc219fb4455264cae4d9f01ad41ae6ee8524500f381de64ffaa077d5", size = 54584 },
+    { url = "https://files.pythonhosted.org/packages/2c/31/ab01375682f14f7613a1ade30149f684c84f9b8823a4391ed950c8285656/frozenlist-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f47c9c9028f55a04ac254346e92977bf0f166c483c74b4232bee19a6697e4778", size = 52499 },
+    { url = "https://files.pythonhosted.org/packages/98/a8/d0ac0b9276e1404f58fec3ab6e90a4f76b778a49373ccaf6a563f100dfbc/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0996c66760924da6e88922756d99b47512a71cfd45215f3570bf1e0b694c206a", size = 276357 },
+    { url = "https://files.pythonhosted.org/packages/ad/c9/c7761084fa822f07dac38ac29f841d4587570dd211e2262544aa0b791d21/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2fe128eb4edeabe11896cb6af88fca5346059f6c8d807e3b910069f39157869", size = 287516 },
+    { url = "https://files.pythonhosted.org/packages/a1/ff/cd7479e703c39df7bdab431798cef89dc75010d8aa0ca2514c5b9321db27/frozenlist-1.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a8ea951bbb6cacd492e3948b8da8c502a3f814f5d20935aae74b5df2b19cf3d", size = 283131 },
+    { url = "https://files.pythonhosted.org/packages/59/a0/370941beb47d237eca4fbf27e4e91389fd68699e6f4b0ebcc95da463835b/frozenlist-1.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de537c11e4aa01d37db0d403b57bd6f0546e71a82347a97c6a9f0dcc532b3a45", size = 261320 },
+    { url = "https://files.pythonhosted.org/packages/b8/5f/c10123e8d64867bc9b4f2f510a32042a306ff5fcd7e2e09e5ae5100ee333/frozenlist-1.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c2623347b933fcb9095841f1cc5d4ff0b278addd743e0e966cb3d460278840d", size = 274877 },
+    { url = "https://files.pythonhosted.org/packages/fa/79/38c505601ae29d4348f21706c5d89755ceded02a745016ba2f58bd5f1ea6/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cee6798eaf8b1416ef6909b06f7dc04b60755206bddc599f52232606e18179d3", size = 269592 },
+    { url = "https://files.pythonhosted.org/packages/19/e2/39f3a53191b8204ba9f0bb574b926b73dd2efba2a2b9d2d730517e8f7622/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f5f9da7f5dbc00a604fe74aa02ae7c98bcede8a3b8b9666f9f86fc13993bc71a", size = 265934 },
+    { url = "https://files.pythonhosted.org/packages/d5/c9/3075eb7f7f3a91f1a6b00284af4de0a65a9ae47084930916f5528144c9dd/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:90646abbc7a5d5c7c19461d2e3eeb76eb0b204919e6ece342feb6032c9325ae9", size = 283859 },
+    { url = "https://files.pythonhosted.org/packages/05/f5/549f44d314c29408b962fa2b0e69a1a67c59379fb143b92a0a065ffd1f0f/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bdac3c7d9b705d253b2ce370fde941836a5f8b3c5c2b8fd70940a3ea3af7f4f2", size = 287560 },
+    { url = "https://files.pythonhosted.org/packages/9d/f8/cb09b3c24a3eac02c4c07a9558e11e9e244fb02bf62c85ac2106d1eb0c0b/frozenlist-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03d33c2ddbc1816237a67f66336616416e2bbb6beb306e5f890f2eb22b959cdf", size = 277150 },
+    { url = "https://files.pythonhosted.org/packages/37/48/38c2db3f54d1501e692d6fe058f45b6ad1b358d82cd19436efab80cfc965/frozenlist-1.5.0-cp311-cp311-win32.whl", hash = "sha256:237f6b23ee0f44066219dae14c70ae38a63f0440ce6750f868ee08775073f942", size = 45244 },
+    { url = "https://files.pythonhosted.org/packages/ca/8c/2ddffeb8b60a4bce3b196c32fcc30d8830d4615e7b492ec2071da801b8ad/frozenlist-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:0cc974cc93d32c42e7b0f6cf242a6bd941c57c61b618e78b6c0a96cb72788c1d", size = 51634 },
+    { url = "https://files.pythonhosted.org/packages/79/73/fa6d1a96ab7fd6e6d1c3500700963eab46813847f01ef0ccbaa726181dd5/frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21", size = 94026 },
+    { url = "https://files.pythonhosted.org/packages/ab/04/ea8bf62c8868b8eada363f20ff1b647cf2e93377a7b284d36062d21d81d1/frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d", size = 54150 },
+    { url = "https://files.pythonhosted.org/packages/d0/9a/8e479b482a6f2070b26bda572c5e6889bb3ba48977e81beea35b5ae13ece/frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e", size = 51927 },
+    { url = "https://files.pythonhosted.org/packages/e3/12/2aad87deb08a4e7ccfb33600871bbe8f0e08cb6d8224371387f3303654d7/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a", size = 282647 },
+    { url = "https://files.pythonhosted.org/packages/77/f2/07f06b05d8a427ea0060a9cef6e63405ea9e0d761846b95ef3fb3be57111/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a", size = 289052 },
+    { url = "https://files.pythonhosted.org/packages/bd/9f/8bf45a2f1cd4aa401acd271b077989c9267ae8463e7c8b1eb0d3f561b65e/frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee", size = 291719 },
+    { url = "https://files.pythonhosted.org/packages/41/d1/1f20fd05a6c42d3868709b7604c9f15538a29e4f734c694c6bcfc3d3b935/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6", size = 267433 },
+    { url = "https://files.pythonhosted.org/packages/af/f2/64b73a9bb86f5a89fb55450e97cd5c1f84a862d4ff90d9fd1a73ab0f64a5/frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e", size = 283591 },
+    { url = "https://files.pythonhosted.org/packages/29/e2/ffbb1fae55a791fd6c2938dd9ea779509c977435ba3940b9f2e8dc9d5316/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9", size = 273249 },
+    { url = "https://files.pythonhosted.org/packages/2e/6e/008136a30798bb63618a114b9321b5971172a5abddff44a100c7edc5ad4f/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039", size = 271075 },
+    { url = "https://files.pythonhosted.org/packages/ae/f0/4e71e54a026b06724cec9b6c54f0b13a4e9e298cc8db0f82ec70e151f5ce/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784", size = 285398 },
+    { url = "https://files.pythonhosted.org/packages/4d/36/70ec246851478b1c0b59f11ef8ade9c482ff447c1363c2bd5fad45098b12/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631", size = 294445 },
+    { url = "https://files.pythonhosted.org/packages/37/e0/47f87544055b3349b633a03c4d94b405956cf2437f4ab46d0928b74b7526/frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f", size = 280569 },
+    { url = "https://files.pythonhosted.org/packages/f9/7c/490133c160fb6b84ed374c266f42800e33b50c3bbab1652764e6e1fc498a/frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8", size = 44721 },
+    { url = "https://files.pythonhosted.org/packages/b1/56/4e45136ffc6bdbfa68c29ca56ef53783ef4c2fd395f7cbf99a2624aa9aaa/frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f", size = 51329 },
+    { url = "https://files.pythonhosted.org/packages/da/3b/915f0bca8a7ea04483622e84a9bd90033bab54bdf485479556c74fd5eaf5/frozenlist-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7a1a048f9215c90973402e26c01d1cff8a209e1f1b53f72b95c13db61b00f953", size = 91538 },
+    { url = "https://files.pythonhosted.org/packages/c7/d1/a7c98aad7e44afe5306a2b068434a5830f1470675f0e715abb86eb15f15b/frozenlist-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dd47a5181ce5fcb463b5d9e17ecfdb02b678cca31280639255ce9d0e5aa67af0", size = 52849 },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/76f23bf9ab15d5f760eb48701909645f686f9c64fbb8982674c241fbef14/frozenlist-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1431d60b36d15cda188ea222033eec8e0eab488f39a272461f2e6d9e1a8e63c2", size = 50583 },
+    { url = "https://files.pythonhosted.org/packages/1f/22/462a3dd093d11df623179d7754a3b3269de3b42de2808cddef50ee0f4f48/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6482a5851f5d72767fbd0e507e80737f9c8646ae7fd303def99bfe813f76cf7f", size = 265636 },
+    { url = "https://files.pythonhosted.org/packages/80/cf/e075e407fc2ae7328155a1cd7e22f932773c8073c1fc78016607d19cc3e5/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44c49271a937625619e862baacbd037a7ef86dd1ee215afc298a417ff3270608", size = 270214 },
+    { url = "https://files.pythonhosted.org/packages/a1/58/0642d061d5de779f39c50cbb00df49682832923f3d2ebfb0fedf02d05f7f/frozenlist-1.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:12f78f98c2f1c2429d42e6a485f433722b0061d5c0b0139efa64f396efb5886b", size = 273905 },
+    { url = "https://files.pythonhosted.org/packages/ab/66/3fe0f5f8f2add5b4ab7aa4e199f767fd3b55da26e3ca4ce2cc36698e50c4/frozenlist-1.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ce3aa154c452d2467487765e3adc730a8c153af77ad84096bc19ce19a2400840", size = 250542 },
+    { url = "https://files.pythonhosted.org/packages/f6/b8/260791bde9198c87a465224e0e2bb62c4e716f5d198fc3a1dacc4895dbd1/frozenlist-1.5.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b7dc0c4338e6b8b091e8faf0db3168a37101943e687f373dce00959583f7439", size = 267026 },
+    { url = "https://files.pythonhosted.org/packages/2e/a4/3d24f88c527f08f8d44ade24eaee83b2627793fa62fa07cbb7ff7a2f7d42/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:45e0896250900b5aa25180f9aec243e84e92ac84bd4a74d9ad4138ef3f5c97de", size = 257690 },
+    { url = "https://files.pythonhosted.org/packages/de/9a/d311d660420b2beeff3459b6626f2ab4fb236d07afbdac034a4371fe696e/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:561eb1c9579d495fddb6da8959fd2a1fca2c6d060d4113f5844b433fc02f2641", size = 253893 },
+    { url = "https://files.pythonhosted.org/packages/c6/23/e491aadc25b56eabd0f18c53bb19f3cdc6de30b2129ee0bc39cd387cd560/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:df6e2f325bfee1f49f81aaac97d2aa757c7646534a06f8f577ce184afe2f0a9e", size = 267006 },
+    { url = "https://files.pythonhosted.org/packages/08/c4/ab918ce636a35fb974d13d666dcbe03969592aeca6c3ab3835acff01f79c/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:140228863501b44b809fb39ec56b5d4071f4d0aa6d216c19cbb08b8c5a7eadb9", size = 276157 },
+    { url = "https://files.pythonhosted.org/packages/c0/29/3b7a0bbbbe5a34833ba26f686aabfe982924adbdcafdc294a7a129c31688/frozenlist-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7707a25d6a77f5d27ea7dc7d1fc608aa0a478193823f88511ef5e6b8a48f9d03", size = 264642 },
+    { url = "https://files.pythonhosted.org/packages/ab/42/0595b3dbffc2e82d7fe658c12d5a5bafcd7516c6bf2d1d1feb5387caa9c1/frozenlist-1.5.0-cp313-cp313-win32.whl", hash = "sha256:31a9ac2b38ab9b5a8933b693db4939764ad3f299fcaa931a3e605bc3460e693c", size = 44914 },
+    { url = "https://files.pythonhosted.org/packages/17/c4/b7db1206a3fea44bf3b838ca61deb6f74424a8a5db1dd53ecb21da669be6/frozenlist-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:11aabdd62b8b9c4b84081a3c246506d1cddd2dd93ff0ad53ede5defec7886b28", size = 51167 },
+    { url = "https://files.pythonhosted.org/packages/c6/c8/a5be5b7550c10858fcf9b0ea054baccab474da77d37f1e828ce043a3a5d4/frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3", size = 11901 },
 ]
 
 [[package]]
 name = "fsspec"
-version = "2024.6.1"
+version = "2024.10.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/90/b6/eba5024a9889fcfff396db543a34bef0ab9d002278f163129f9f01005960/fsspec-2024.6.1.tar.gz", hash = "sha256:fad7d7e209dd4c1208e3bbfda706620e0da5142bebbd9c384afb95b07e798e49", size = 284584 }
+sdist = { url = "https://files.pythonhosted.org/packages/a0/52/f16a068ebadae42526484c31f4398e62962504e5724a8ba5dc3409483df2/fsspec-2024.10.0.tar.gz", hash = "sha256:eda2d8a4116d4f2429db8550f2457da57279247dd930bb12f821b58391359493", size = 286853 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/44/73bea497ac69bafde2ee4269292fa3b41f1198f4bb7bbaaabde30ad29d4a/fsspec-2024.6.1-py3-none-any.whl", hash = "sha256:3cb443f8bcd2efb31295a5b9fdb02aee81d8452c80d28f97a6d0959e6cee101e", size = 177561 },
+    { url = "https://files.pythonhosted.org/packages/c6/b2/454d6e7f0158951d8a78c2e1eb4f69ae81beb8dca5fee9809c6c99e9d0d0/fsspec-2024.10.0-py3-none-any.whl", hash = "sha256:03b9a6785766a4de40368b88906366755e2819e758b83705c88cd7cb5fe81871", size = 179641 },
 ]
 
 [[package]]
@@ -1283,7 +1320,7 @@ wheels = [
 
 [[package]]
 name = "google-api-core"
-version = "2.20.0"
+version = "2.21.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "google-auth" },
@@ -1292,9 +1329,9 @@ dependencies = [
     { name = "protobuf" },
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c8/5c/31c1742a53b79c8a0c4757b5fae2e8ab9c519cbd7b98c587d4294e1d2d16/google_api_core-2.20.0.tar.gz", hash = "sha256:f74dff1889ba291a4b76c5079df0711810e2d9da81abfdc99957bc961c1eb28f", size = 152583 }
+sdist = { url = "https://files.pythonhosted.org/packages/28/c8/046abf3ea11ec9cc3ea6d95e235a51161039d4a558484a997df60f9c51e9/google_api_core-2.21.0.tar.gz", hash = "sha256:4a152fd11a9f774ea606388d423b68aa7e6d6a0ffe4c8266f74979613ec09f81", size = 159313 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/dc/6143f67acf5f30717c9e1b1c48fc04c0f59b869be046e6639d3f171640ae/google_api_core-2.20.0-py3-none-any.whl", hash = "sha256:ef0591ef03c30bb83f79b3d0575c3f31219001fc9c5cf37024d08310aeffed8a", size = 142162 },
+    { url = "https://files.pythonhosted.org/packages/6a/ef/79fa8388c95edbd8fe36c763259dade36e5cb562dcf3e85c0e32070dc9b0/google_api_core-2.21.0-py3-none-any.whl", hash = "sha256:6869eacb2a37720380ba5898312af79a4d30b8bca1548fb4093e0697dc4bdf5d", size = 156437 },
 ]
 
 [package.optional-dependencies]
@@ -1305,7 +1342,7 @@ grpc = [
 
 [[package]]
 name = "google-api-python-client"
-version = "2.147.0"
+version = "2.149.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "google-api-core" },
@@ -1314,9 +1351,9 @@ dependencies = [
     { name = "httplib2" },
     { name = "uritemplate" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/35/a4/73b9d642fa82f6fad67b0449c109a06c8e19b5980204b24fa86b86e8da06/google_api_python_client-2.147.0.tar.gz", hash = "sha256:e864c2cf61d34c00f05278b8bdb72b93b6fa34f0de9ead51d20435f3b65f91be", size = 11729279 }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/36/a587319840f32c8a28b6700805ad18a70690f985538ea49e87e210118884/google_api_python_client-2.149.0.tar.gz", hash = "sha256:b9d68c6b14ec72580d66001bd33c5816b78e2134b93ccc5cf8f624516b561750", size = 11791789 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/44/c9/5750e53ec3d651e8bd986c9ded1608886205bc37880ce15333889622e9c5/google_api_python_client-2.147.0-py2.py3-none-any.whl", hash = "sha256:c6ecfa193c695baa41e84562d8f8f244fcd164419eca3fc9fd7565646668f9b2", size = 12235050 },
+    { url = "https://files.pythonhosted.org/packages/e1/33/b2fa6a8d7ca786c07ab4ab671aaa8dd5abb32893636fc44f684c396470cc/google_api_python_client-2.149.0-py2.py3-none-any.whl", hash = "sha256:1a5232e9cfed8c201799d9327e4d44dc7ea7daa3c6e1627fca41aa201539c0da", size = 12299231 },
 ]
 
 [[package]]
@@ -1348,7 +1385,7 @@ wheels = [
 
 [[package]]
 name = "google-cloud-aiplatform"
-version = "1.68.0"
+version = "1.70.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "docstring-parser" },
@@ -1363,9 +1400,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "shapely" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/d3/4c841ad0739c3ae27945d66ab67fc02439f8f9fd53dfe8bb9d52de9268c8/google-cloud-aiplatform-1.68.0.tar.gz", hash = "sha256:d74e9f33707c7a14c6a32a7cfe9acd32b90975dfba9fac487d105c8ba5197f40", size = 6290588 }
+sdist = { url = "https://files.pythonhosted.org/packages/88/06/bc8028c03d4bedb85114c780a9f749b67ff06ce29d25dc7f1a99622f2692/google-cloud-aiplatform-1.70.0.tar.gz", hash = "sha256:e8edef6dbc7911380d0ea55c47544e799f62b891cb1a83b504ca1c09fff9884b", size = 6311624 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a1/5e/08720e44285a744c14fc8057424437c5b53f10ceb3092618000838f2a9aa/google_cloud_aiplatform-1.68.0-py2.py3-none-any.whl", hash = "sha256:24dacc34457665ab6054bdf47e2475793dcf2d865b568420a909b452a477b3e6", size = 5251865 },
+    { url = "https://files.pythonhosted.org/packages/46/d9/280e5a9b5caf69322f64fa55f62bf447d76c5fe30e8df6e93373f22c4bd7/google_cloud_aiplatform-1.70.0-py2.py3-none-any.whl", hash = "sha256:690e6041f03d3aa85102ac3f316c958d6f43a99aefb7fb3f8938dee56d08abd9", size = 5267225 },
 ]
 
 [[package]]
@@ -1401,7 +1438,7 @@ wheels = [
 
 [[package]]
 name = "google-cloud-resource-manager"
-version = "1.12.5"
+version = "1.13.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "google-api-core", extra = ["grpc"] },
@@ -1410,9 +1447,9 @@ dependencies = [
     { name = "proto-plus" },
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/62/32/14d345dee1f290a26bd639da8edbca30958865b7cc7207961e10d2f32282/google_cloud_resource_manager-1.12.5.tar.gz", hash = "sha256:b7af4254401ed4efa3aba3a929cb3ddb803fa6baf91a78485e45583597de5891", size = 394678 }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/43/c654c0dc948b4661d350acba932a56adddea0927a838d2c66a623ff41bf6/google_cloud_resource_manager-1.13.0.tar.gz", hash = "sha256:ae4bf69443f14b37007d4d84150115b0942e8b01650fd7a1fc6ff4dc1760e5c4", size = 411515 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/ab/63ab13fb060714b9d1708ca32e0ee41f9ffe42a62e524e7429cde45cfe61/google_cloud_resource_manager-1.12.5-py2.py3-none-any.whl", hash = "sha256:2708a718b45c79464b7b21559c701b5c92e6b0b1ab2146d0a256277a623dc175", size = 341861 },
+    { url = "https://files.pythonhosted.org/packages/c3/c2/afdfd9b2d140d77091185a405aa6d91a6d74568862c54e83bf04de3b9693/google_cloud_resource_manager-1.13.0-py2.py3-none-any.whl", hash = "sha256:33beb4528c2b7aee7a97ed843710581a7b4a27f3dd1fa41a0bf3359b3d68853f", size = 359899 },
 ]
 
 [[package]]
@@ -1460,7 +1497,7 @@ wheels = [
 
 [[package]]
 name = "google-generativeai"
-version = "0.8.2"
+version = "0.8.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "google-ai-generativelanguage" },
@@ -1473,7 +1510,7 @@ dependencies = [
     { name = "typing-extensions" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d5/96/051944eb7ecc1250c0a9872f496425cc960211b001541c471ed000ce233b/google_generativeai-0.8.2-py3-none-any.whl", hash = "sha256:fabc0e2e8d2bfb6fdb1653e91dba83fecb2a2a6878883b80017def90fda8032d", size = 153432 },
+    { url = "https://files.pythonhosted.org/packages/e9/2f/b5c1d62e94409ed98d5425e83b8e6d3dd475b611be272f561b1a545d273a/google_generativeai-0.8.3-py3-none-any.whl", hash = "sha256:1108ff89d5b8e59f51e63d1a8bf84701cd84656e17ca28d73aeed745e736d9b7", size = 160822 },
 ]
 
 [[package]]
@@ -1507,37 +1544,53 @@ grpc = [
 
 [[package]]
 name = "greenlet"
-version = "3.0.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/17/14/3bddb1298b9a6786539ac609ba4b7c9c0842e12aa73aaa4d8d73ec8f8185/greenlet-3.0.3.tar.gz", hash = "sha256:43374442353259554ce33599da8b692d5aa96f8976d567d4badf263371fbe491", size = 182013 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/64/bea53c592e3e45799f7c8039a8ee7d6883c518eafef1fcae60beb776070f/greenlet-3.0.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9da2bd29ed9e4f15955dd1595ad7bc9320308a3b766ef7f837e23ad4b4aac31a", size = 270098 },
-    { url = "https://files.pythonhosted.org/packages/a6/d6/408ad9603339db28ce334021b1403dfcfbcb7501a435d49698408d928de7/greenlet-3.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d353cadd6083fdb056bb46ed07e4340b0869c305c8ca54ef9da3421acbdf6881", size = 651930 },
-    { url = "https://files.pythonhosted.org/packages/6c/90/5b14670653f7363fb3e1665f8da6d64bd4c31d53a796d09ef69f48be7273/greenlet-3.0.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dca1e2f3ca00b84a396bc1bce13dd21f680f035314d2379c4160c98153b2059b", size = 667643 },
-    { url = "https://files.pythonhosted.org/packages/ef/17/e8e72cabfb5a906c0d976d7fbcc88310df292beea0f816efbefdaf694284/greenlet-3.0.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ed7fb269f15dc662787f4119ec300ad0702fa1b19d2135a37c2c4de6fadfd4a", size = 659188 },
-    { url = "https://files.pythonhosted.org/packages/1c/2f/64628f6ae48e05f585e0eb3fb7399b52e240ef99f602107b445bf6be23ef/greenlet-3.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd4f49ae60e10adbc94b45c0b5e6a179acc1736cf7a90160b404076ee283cf83", size = 662673 },
-    { url = "https://files.pythonhosted.org/packages/24/35/945d5b10648fec9b20bcc6df8952d20bb3bba76413cd71c1fdbee98f5616/greenlet-3.0.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73a411ef564e0e097dbe7e866bb2dda0f027e072b04da387282b02c308807405", size = 616002 },
-    { url = "https://files.pythonhosted.org/packages/74/00/27e2da76b926e9b5a2c97d3f4c0baf1b7d8181209d3026c0171f621ae6c0/greenlet-3.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7f362975f2d179f9e26928c5b517524e89dd48530a0202570d55ad6ca5d8a56f", size = 1150603 },
-    { url = "https://files.pythonhosted.org/packages/e1/65/506e0a80931170b0dac1a03d36b7fc299f3fa3576235b916718602fff2c3/greenlet-3.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:649dde7de1a5eceb258f9cb00bdf50e978c9db1b996964cd80703614c86495eb", size = 1176756 },
-    { url = "https://files.pythonhosted.org/packages/a6/76/e1ee9f290bb0d46b09704c2fb0e609cae329eb308ad404c0ee6fa1ecb8a5/greenlet-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:68834da854554926fbedd38c76e60c4a2e3198c6fbed520b106a8986445caaf9", size = 292349 },
-    { url = "https://files.pythonhosted.org/packages/6e/20/68a278a6f93fa36e21cfc3d7599399a8a831225644eb3b6b18755cd3d6fc/greenlet-3.0.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b1b5667cced97081bf57b8fa1d6bfca67814b0afd38208d52538316e9422fc61", size = 271666 },
-    { url = "https://files.pythonhosted.org/packages/21/b4/90e06e07c78513ab03855768200bdb35c8e764e805b3f14fb488e56f82dc/greenlet-3.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52f59dd9c96ad2fc0d5724107444f76eb20aaccb675bf825df6435acb7703559", size = 657689 },
-    { url = "https://files.pythonhosted.org/packages/f6/a2/0ed21078039072f9dc738bbf3af12b103a84106b1385ac4723841f846ce7/greenlet-3.0.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:afaff6cf5200befd5cec055b07d1c0a5a06c040fe5ad148abcd11ba6ab9b114e", size = 673009 },
-    { url = "https://files.pythonhosted.org/packages/42/11/42ad6b1104c357826bbee7d7b9e4f24dbd9fde94899a03efb004aab62963/greenlet-3.0.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe754d231288e1e64323cfad462fcee8f0288654c10bdf4f603a39ed923bef33", size = 667432 },
-    { url = "https://files.pythonhosted.org/packages/bb/6b/384dee7e0121cbd1757bdc1824a5ee28e43d8d4e3f99aa59521f629442fe/greenlet-3.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2797aa5aedac23af156bbb5a6aa2cd3427ada2972c828244eb7d1b9255846379", size = 667442 },
-    { url = "https://files.pythonhosted.org/packages/c6/1f/12d5a6cc26e8b483c2e7975f9c22e088ac735c0d8dcb8a8f72d31a4e5f04/greenlet-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7f009caad047246ed379e1c4dbcb8b020f0a390667ea74d2387be2998f58a22", size = 620032 },
-    { url = "https://files.pythonhosted.org/packages/c7/ec/85b647e59e0f137c7792a809156f413e38379cf7f3f2e1353c37f4be4026/greenlet-3.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c5e1536de2aad7bf62e27baf79225d0d64360d4168cf2e6becb91baf1ed074f3", size = 1154218 },
-    { url = "https://files.pythonhosted.org/packages/94/ed/1e5f4bca691a81700e5a88e86d6f0e538acb10188cd2cc17140e523255ef/greenlet-3.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:894393ce10ceac937e56ec00bb71c4c2f8209ad516e96033e4b3b1de270e200d", size = 1180754 },
-    { url = "https://files.pythonhosted.org/packages/47/79/26d54d7d700ef65b689fc2665a40846d13e834da0486674a8d4f0f371a47/greenlet-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:1ea188d4f49089fc6fb283845ab18a2518d279c7cd9da1065d7a84e991748728", size = 292822 },
-    { url = "https://files.pythonhosted.org/packages/a2/2f/461615adc53ba81e99471303b15ac6b2a6daa8d2a0f7f77fd15605e16d5b/greenlet-3.0.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:70fb482fdf2c707765ab5f0b6655e9cfcf3780d8d87355a063547b41177599be", size = 273085 },
-    { url = "https://files.pythonhosted.org/packages/e9/55/2c3cfa3cdbb940cf7321fbcf544f0e9c74898eed43bf678abf416812d132/greenlet-3.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4d1ac74f5c0c0524e4a24335350edad7e5f03b9532da7ea4d3c54d527784f2e", size = 660514 },
-    { url = "https://files.pythonhosted.org/packages/38/77/efb21ab402651896c74f24a172eb4d7479f9f53898bd5e56b9e20bb24ffd/greenlet-3.0.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:149e94a2dd82d19838fe4b2259f1b6b9957d5ba1b25640d2380bea9c5df37676", size = 674295 },
-    { url = "https://files.pythonhosted.org/packages/74/3a/92f188ace0190f0066dca3636cf1b09481d0854c46e92ec5e29c7cefe5b1/greenlet-3.0.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15d79dd26056573940fcb8c7413d84118086f2ec1a8acdfa854631084393efcc", size = 669395 },
-    { url = "https://files.pythonhosted.org/packages/63/0f/847ed02cdfce10f0e6e3425cd054296bddb11a17ef1b34681fa01a055187/greenlet-3.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b7db1ebff4ba09aaaeae6aa491daeb226c8150fc20e836ad00041bcb11230", size = 670455 },
-    { url = "https://files.pythonhosted.org/packages/bd/37/56b0da468a85e7704f3b2bc045015301bdf4be2184a44868c71f6dca6fe2/greenlet-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcd2469d6a2cf298f198f0487e0a5b1a47a42ca0fa4dfd1b6862c999f018ebbf", size = 625692 },
-    { url = "https://files.pythonhosted.org/packages/7c/68/b5f4084c0a252d7e9c0d95fc1cfc845d08622037adb74e05be3a49831186/greenlet-3.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1f672519db1796ca0d8753f9e78ec02355e862d0998193038c7073045899f305", size = 1152597 },
-    { url = "https://files.pythonhosted.org/packages/a4/fa/31e22345518adcd69d1d6ab5087a12c178aa7f3c51103f6d5d702199d243/greenlet-3.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2516a9957eed41dd8f1ec0c604f1cdc86758b587d964668b5b196a9db5bfcde6", size = 1181043 },
-    { url = "https://files.pythonhosted.org/packages/53/80/3d94d5999b4179d91bcc93745d1b0815b073d61be79dd546b840d17adb18/greenlet-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:bba5387a6975598857d86de9eac14210a49d554a77eb8261cc68b7d082f78ce2", size = 293635 },
+version = "3.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2f/ff/df5fede753cc10f6a5be0931204ea30c35fa2f2ea7a35b25bdaf4fe40e46/greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467", size = 186022 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/25/90/5234a78dc0ef6496a6eb97b67a42a8e96742a56f7dc808cb954a85390448/greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563", size = 271235 },
+    { url = "https://files.pythonhosted.org/packages/7c/16/cd631fa0ab7d06ef06387135b7549fdcc77d8d859ed770a0d28e47b20972/greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83", size = 637168 },
+    { url = "https://files.pythonhosted.org/packages/2f/b1/aed39043a6fec33c284a2c9abd63ce191f4f1a07319340ffc04d2ed3256f/greenlet-3.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36b89d13c49216cadb828db8dfa6ce86bbbc476a82d3a6c397f0efae0525bdd0", size = 648826 },
+    { url = "https://files.pythonhosted.org/packages/76/25/40e0112f7f3ebe54e8e8ed91b2b9f970805143efef16d043dfc15e70f44b/greenlet-3.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b6150a85e1b33b40b1464a3f9988dcc5251d6ed06842abff82e42632fac120", size = 644443 },
+    { url = "https://files.pythonhosted.org/packages/fb/2f/3850b867a9af519794784a7eeed1dd5bc68ffbcc5b28cef703711025fd0a/greenlet-3.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93147c513fac16385d1036b7e5b102c7fbbdb163d556b791f0f11eada7ba65dc", size = 643295 },
+    { url = "https://files.pythonhosted.org/packages/cf/69/79e4d63b9387b48939096e25115b8af7cd8a90397a304f92436bcb21f5b2/greenlet-3.1.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da7a9bff22ce038e19bf62c4dd1ec8391062878710ded0a845bcf47cc0200617", size = 599544 },
+    { url = "https://files.pythonhosted.org/packages/46/1d/44dbcb0e6c323bd6f71b8c2f4233766a5faf4b8948873225d34a0b7efa71/greenlet-3.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b2795058c23988728eec1f36a4e5e4ebad22f8320c85f3587b539b9ac84128d7", size = 1125456 },
+    { url = "https://files.pythonhosted.org/packages/e0/1d/a305dce121838d0278cee39d5bb268c657f10a5363ae4b726848f833f1bb/greenlet-3.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ed10eac5830befbdd0c32f83e8aa6288361597550ba669b04c48f0f9a2c843c6", size = 1149111 },
+    { url = "https://files.pythonhosted.org/packages/96/28/d62835fb33fb5652f2e98d34c44ad1a0feacc8b1d3f1aecab035f51f267d/greenlet-3.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:77c386de38a60d1dfb8e55b8c1101d68c79dfdd25c7095d51fec2dd800892b80", size = 298392 },
+    { url = "https://files.pythonhosted.org/packages/28/62/1c2665558618553c42922ed47a4e6d6527e2fa3516a8256c2f431c5d0441/greenlet-3.1.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e4d333e558953648ca09d64f13e6d8f0523fa705f51cae3f03b5983489958c70", size = 272479 },
+    { url = "https://files.pythonhosted.org/packages/76/9d/421e2d5f07285b6e4e3a676b016ca781f63cfe4a0cd8eaecf3fd6f7a71ae/greenlet-3.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09fc016b73c94e98e29af67ab7b9a879c307c6731a2c9da0db5a7d9b7edd1159", size = 640404 },
+    { url = "https://files.pythonhosted.org/packages/e5/de/6e05f5c59262a584e502dd3d261bbdd2c97ab5416cc9c0b91ea38932a901/greenlet-3.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5e975ca70269d66d17dd995dafc06f1b06e8cb1ec1e9ed54c1d1e4a7c4cf26e", size = 652813 },
+    { url = "https://files.pythonhosted.org/packages/49/93/d5f93c84241acdea15a8fd329362c2c71c79e1a507c3f142a5d67ea435ae/greenlet-3.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2813dc3de8c1ee3f924e4d4227999285fd335d1bcc0d2be6dc3f1f6a318ec1", size = 648517 },
+    { url = "https://files.pythonhosted.org/packages/15/85/72f77fc02d00470c86a5c982b8daafdf65d38aefbbe441cebff3bf7037fc/greenlet-3.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e347b3bfcf985a05e8c0b7d462ba6f15b1ee1c909e2dcad795e49e91b152c383", size = 647831 },
+    { url = "https://files.pythonhosted.org/packages/f7/4b/1c9695aa24f808e156c8f4813f685d975ca73c000c2a5056c514c64980f6/greenlet-3.1.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e8f8c9cb53cdac7ba9793c276acd90168f416b9ce36799b9b885790f8ad6c0a", size = 602413 },
+    { url = "https://files.pythonhosted.org/packages/76/70/ad6e5b31ef330f03b12559d19fda2606a522d3849cde46b24f223d6d1619/greenlet-3.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:62ee94988d6b4722ce0028644418d93a52429e977d742ca2ccbe1c4f4a792511", size = 1129619 },
+    { url = "https://files.pythonhosted.org/packages/f4/fb/201e1b932e584066e0f0658b538e73c459b34d44b4bd4034f682423bc801/greenlet-3.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1776fd7f989fc6b8d8c8cb8da1f6b82c5814957264d1f6cf818d475ec2bf6395", size = 1155198 },
+    { url = "https://files.pythonhosted.org/packages/12/da/b9ed5e310bb8b89661b80cbcd4db5a067903bbcd7fc854923f5ebb4144f0/greenlet-3.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:48ca08c771c268a768087b408658e216133aecd835c0ded47ce955381105ba39", size = 298930 },
+    { url = "https://files.pythonhosted.org/packages/7d/ec/bad1ac26764d26aa1353216fcbfa4670050f66d445448aafa227f8b16e80/greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d", size = 274260 },
+    { url = "https://files.pythonhosted.org/packages/66/d4/c8c04958870f482459ab5956c2942c4ec35cac7fe245527f1039837c17a9/greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79", size = 649064 },
+    { url = "https://files.pythonhosted.org/packages/51/41/467b12a8c7c1303d20abcca145db2be4e6cd50a951fa30af48b6ec607581/greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa", size = 663420 },
+    { url = "https://files.pythonhosted.org/packages/27/8f/2a93cd9b1e7107d5c7b3b7816eeadcac2ebcaf6d6513df9abaf0334777f6/greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441", size = 658035 },
+    { url = "https://files.pythonhosted.org/packages/57/5c/7c6f50cb12be092e1dccb2599be5a942c3416dbcfb76efcf54b3f8be4d8d/greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36", size = 660105 },
+    { url = "https://files.pythonhosted.org/packages/f1/66/033e58a50fd9ec9df00a8671c74f1f3a320564c6415a4ed82a1c651654ba/greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9", size = 613077 },
+    { url = "https://files.pythonhosted.org/packages/19/c5/36384a06f748044d06bdd8776e231fadf92fc896bd12cb1c9f5a1bda9578/greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0", size = 1135975 },
+    { url = "https://files.pythonhosted.org/packages/38/f9/c0a0eb61bdf808d23266ecf1d63309f0e1471f284300ce6dac0ae1231881/greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942", size = 1163955 },
+    { url = "https://files.pythonhosted.org/packages/43/21/a5d9df1d21514883333fc86584c07c2b49ba7c602e670b174bd73cfc9c7f/greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01", size = 299655 },
+    { url = "https://files.pythonhosted.org/packages/f3/57/0db4940cd7bb461365ca8d6fd53e68254c9dbbcc2b452e69d0d41f10a85e/greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1", size = 272990 },
+    { url = "https://files.pythonhosted.org/packages/1c/ec/423d113c9f74e5e402e175b157203e9102feeb7088cee844d735b28ef963/greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff", size = 649175 },
+    { url = "https://files.pythonhosted.org/packages/a9/46/ddbd2db9ff209186b7b7c621d1432e2f21714adc988703dbdd0e65155c77/greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a", size = 663425 },
+    { url = "https://files.pythonhosted.org/packages/bc/f9/9c82d6b2b04aa37e38e74f0c429aece5eeb02bab6e3b98e7db89b23d94c6/greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e", size = 657736 },
+    { url = "https://files.pythonhosted.org/packages/d9/42/b87bc2a81e3a62c3de2b0d550bf91a86939442b7ff85abb94eec3fc0e6aa/greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4", size = 660347 },
+    { url = "https://files.pythonhosted.org/packages/37/fa/71599c3fd06336cdc3eac52e6871cfebab4d9d70674a9a9e7a482c318e99/greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e", size = 615583 },
+    { url = "https://files.pythonhosted.org/packages/4e/96/e9ef85de031703ee7a4483489b40cf307f93c1824a02e903106f2ea315fe/greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1", size = 1133039 },
+    { url = "https://files.pythonhosted.org/packages/87/76/b2b6362accd69f2d1889db61a18c94bc743e961e3cab344c2effaa4b4a25/greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c", size = 1160716 },
+    { url = "https://files.pythonhosted.org/packages/1f/1b/54336d876186920e185066d8c3024ad55f21d7cc3683c856127ddb7b13ce/greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761", size = 299490 },
+    { url = "https://files.pythonhosted.org/packages/5f/17/bea55bf36990e1638a2af5ba10c1640273ef20f627962cf97107f1e5d637/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011", size = 643731 },
+    { url = "https://files.pythonhosted.org/packages/78/d2/aa3d2157f9ab742a08e0fd8f77d4699f37c22adfbfeb0c610a186b5f75e0/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13", size = 649304 },
+    { url = "https://files.pythonhosted.org/packages/f1/8e/d0aeffe69e53ccff5a28fa86f07ad1d2d2d6537a9506229431a2a02e2f15/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475", size = 646537 },
+    { url = "https://files.pythonhosted.org/packages/05/79/e15408220bbb989469c8871062c97c6c9136770657ba779711b90870d867/greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b", size = 642506 },
+    { url = "https://files.pythonhosted.org/packages/18/87/470e01a940307796f1d25f8167b551a968540fbe0551c0ebb853cb527dd6/greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822", size = 602753 },
+    { url = "https://files.pythonhosted.org/packages/e2/72/576815ba674eddc3c25028238f74d7b8068902b3968cbe456771b166455e/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01", size = 1122731 },
+    { url = "https://files.pythonhosted.org/packages/ac/38/08cc303ddddc4b3d7c628c3039a61a3aae36c241ed01393d00c2fd663473/greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6", size = 1142112 },
 ]
 
 [[package]]
@@ -1657,15 +1710,15 @@ sdist = { url = "https://files.pythonhosted.org/packages/1a/43/e1d53588561e53321
 
 [[package]]
 name = "httpcore"
-version = "1.0.5"
+version = "1.0.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
     { name = "h11" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/17/b0/5e8b8674f8d203335a62fdfcfa0d11ebe09e23613c3391033cbba35f7926/httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61", size = 83234 }
+sdist = { url = "https://files.pythonhosted.org/packages/b6/44/ed0fa6a17845fb033bd885c03e842f08c1b9406c86a2e60ac1ae1b9206a6/httpcore-1.0.6.tar.gz", hash = "sha256:73f6dbd6eb8c21bbf7ef8efad555481853f5f6acdeaff1edb0694289269ee17f", size = 85180 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/78/d4/e5d7e4f2174f8a4d63c8897d79eb8fe2503f7ecc03282fee1fa2719c2704/httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5", size = 77926 },
+    { url = "https://files.pythonhosted.org/packages/06/89/b161908e2f51be56568184aeb4a880fd287178d176fd1c860d2217f41106/httpcore-1.0.6-py3-none-any.whl", hash = "sha256:27b59625743b85577a8c0e10e55b50b5368a4f2cfe8cc7bcfa9cf00829c2682f", size = 78011 },
 ]
 
 [[package]]
@@ -1696,9 +1749,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/56/95/9377bcb415797e44274b51d46e3249eba641711cf3348050f76ee7b15ffc/httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0", size = 76395 },
 ]
 
+[[package]]
+name = "httpx-sse"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/60/8f4281fa9bbf3c8034fd54c0e7412e66edbab6bc74c4996bd616f8d0406e/httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721", size = 12624 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/9b/a181f281f65d776426002f330c31849b86b31fc9d848db62e16f03ff739f/httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f", size = 7819 },
+]
+
 [[package]]
 name = "huggingface-hub"
-version = "0.24.6"
+version = "0.26.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -1709,18 +1771,18 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/65/24/b98fce967b7d63700e5805b915012ba25bb538a81fcf11e97f3cc3f4f012/huggingface_hub-0.24.6.tar.gz", hash = "sha256:cc2579e761d070713eaa9c323e3debe39d5b464ae3a7261c39a9195b27bb8000", size = 349200 }
+sdist = { url = "https://files.pythonhosted.org/packages/44/99/c8fdef6fe09a1719e5e5de24b012de5824889168c96143f5531cab5af42b/huggingface_hub-0.26.1.tar.gz", hash = "sha256:414c0d9b769eecc86c70f9d939d0f48bb28e8461dd1130021542eff0212db890", size = 375458 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/8f/d6718641c14d98a5848c6a24d2376028d292074ffade0702940a4b1dde76/huggingface_hub-0.24.6-py3-none-any.whl", hash = "sha256:a990f3232aa985fe749bc9474060cbad75e8b2f115f6665a9fda5b9c97818970", size = 417509 },
+    { url = "https://files.pythonhosted.org/packages/d7/4d/017d8d7cff5100092da8ea19139bcb1965bbadcbb5ddd0480e2badc299e8/huggingface_hub-0.26.1-py3-none-any.whl", hash = "sha256:5927a8fc64ae68859cd954b7cc29d1c8390a5e15caba6d3d349c973be8fdacf3", size = 447439 },
 ]
 
 [[package]]
 name = "idna"
-version = "3.8"
+version = "3.10"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/ac/e349c5e6d4543326c6883ee9491e3921e0d07b55fdf3cce184b40d63e72a/idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603", size = 189467 }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/7e/d71db821f177828df9dea8c42ac46473366f191be53080e552e628aad991/idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac", size = 66894 },
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 },
 ]
 
 [[package]]
@@ -1779,7 +1841,7 @@ wheels = [
 
 [[package]]
 name = "ipython"
-version = "8.26.0"
+version = "8.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -1794,9 +1856,9 @@ dependencies = [
     { name = "traitlets" },
     { name = "typing-extensions", marker = "python_full_version < '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7e/f4/dc45805e5c3e327a626139c023b296bafa4537e602a61055d377704ca54c/ipython-8.26.0.tar.gz", hash = "sha256:1cec0fbba8404af13facebe83d04436a7434c7400e59f47acf467c64abd0956c", size = 5493422 }
+sdist = { url = "https://files.pythonhosted.org/packages/85/e0/a3f36dde97e12121106807d80485423ae4c5b27ce60d40d4ab0bab18a9db/ipython-8.29.0.tar.gz", hash = "sha256:40b60e15b22591450eef73e40a027cf77bd652e757523eebc5bd7c7c498290eb", size = 5497513 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/48/4d2818054671bb272d1b12ca65748a4145dc602a463683b5c21b260becee/ipython-8.26.0-py3-none-any.whl", hash = "sha256:e6b347c27bdf9c32ee9d31ae85defc525755a1869f14057e900675b9e8d6e6ff", size = 817939 },
+    { url = "https://files.pythonhosted.org/packages/c5/a5/c15ed187f1b3fac445bb42a2dedd8dec1eee1718b35129242049a13a962f/ipython-8.29.0-py3-none-any.whl", hash = "sha256:0188a1bd83267192123ccea7f4a8ed0a78910535dbaa3f37671dca76ebd429c8", size = 819911 },
 ]
 
 [[package]]
@@ -1831,46 +1893,58 @@ wheels = [
 
 [[package]]
 name = "jiter"
-version = "0.5.0"
+version = "0.6.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d7/1a/aa64be757afc614484b370a4d9fc1747dc9237b37ce464f7f9d9ca2a3d38/jiter-0.5.0.tar.gz", hash = "sha256:1d916ba875bcab5c5f7d927df998c4cb694d27dceddf3392e58beaf10563368a", size = 158300 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/09/f659fc67d6aaa82c56432c4a7cc8365fff763acbf1c8f24121076617f207/jiter-0.5.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b599f4e89b3def9a94091e6ee52e1d7ad7bc33e238ebb9c4c63f211d74822c3f", size = 284126 },
-    { url = "https://files.pythonhosted.org/packages/07/2d/5bdaddfefc44f91af0f3340e75ef327950d790c9f86490757ac8b395c074/jiter-0.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a063f71c4b06225543dddadbe09d203dc0c95ba352d8b85f1221173480a71d5", size = 299265 },
-    { url = "https://files.pythonhosted.org/packages/74/bd/964485231deaec8caa6599f3f27c8787a54e9f9373ae80dcfbda2ad79c02/jiter-0.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acc0d5b8b3dd12e91dd184b87273f864b363dfabc90ef29a1092d269f18c7e28", size = 332178 },
-    { url = "https://files.pythonhosted.org/packages/cf/4f/6353179174db10254549bbf2eb2c7ea102e59e0460ee374adb12071c274d/jiter-0.5.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c22541f0b672f4d741382a97c65609332a783501551445ab2df137ada01e019e", size = 342533 },
-    { url = "https://files.pythonhosted.org/packages/76/6f/21576071b8b056ef743129b9dacf9da65e328b58766f3d1ea265e966f000/jiter-0.5.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:63314832e302cc10d8dfbda0333a384bf4bcfce80d65fe99b0f3c0da8945a91a", size = 363469 },
-    { url = "https://files.pythonhosted.org/packages/73/a1/9ef99a279c72a031dbe8a4085db41e3521ae01ab0058651d6ccc809a5e93/jiter-0.5.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a25fbd8a5a58061e433d6fae6d5298777c0814a8bcefa1e5ecfff20c594bd749", size = 379078 },
-    { url = "https://files.pythonhosted.org/packages/41/6a/c038077509d67fe876c724bfe9ad15334593851a7def0d84518172bdd44a/jiter-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:503b2c27d87dfff5ab717a8200fbbcf4714516c9d85558048b1fc14d2de7d8dc", size = 318943 },
-    { url = "https://files.pythonhosted.org/packages/67/0d/d82673814eb38c208b7881581df596e680f8c2c003e2b80c25ca58975ee4/jiter-0.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6d1f3d27cce923713933a844872d213d244e09b53ec99b7a7fdf73d543529d6d", size = 357394 },
-    { url = "https://files.pythonhosted.org/packages/56/9e/cbd8f6612346c38cc42e41e35cda19ce78f5b12e4106d1186e8e95ee839b/jiter-0.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:c95980207b3998f2c3b3098f357994d3fd7661121f30669ca7cb945f09510a87", size = 511080 },
-    { url = "https://files.pythonhosted.org/packages/ff/33/135c0c33565b6d5c3010d047710837427dd24c9adbc9ca090f3f92df446e/jiter-0.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:afa66939d834b0ce063f57d9895e8036ffc41c4bd90e4a99631e5f261d9b518e", size = 492827 },
-    { url = "https://files.pythonhosted.org/packages/68/c1/491a8ef682508edbaf2a32e41c1b1e34064078b369b0c2d141170999d1c9/jiter-0.5.0-cp310-none-win32.whl", hash = "sha256:f16ca8f10e62f25fd81d5310e852df6649af17824146ca74647a018424ddeccf", size = 195081 },
-    { url = "https://files.pythonhosted.org/packages/31/20/8cda4faa9571affea6130b150289522a22329778bdfa45a7aab4e7edff95/jiter-0.5.0-cp310-none-win_amd64.whl", hash = "sha256:b2950e4798e82dd9176935ef6a55cf6a448b5c71515a556da3f6b811a7844f1e", size = 190977 },
-    { url = "https://files.pythonhosted.org/packages/94/5f/3ac960ed598726aae46edea916e6df4df7ff6fe084bc60774b95cf3154e6/jiter-0.5.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d4c8e1ed0ef31ad29cae5ea16b9e41529eb50a7fba70600008e9f8de6376d553", size = 284131 },
-    { url = "https://files.pythonhosted.org/packages/03/eb/2308fa5f5c14c97c4c7720fef9465f1fa0771826cddb4eec9866bdd88846/jiter-0.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c6f16e21276074a12d8421692515b3fd6d2ea9c94fd0734c39a12960a20e85f3", size = 299310 },
-    { url = "https://files.pythonhosted.org/packages/3c/f6/dba34ca10b44715fa5302b8e8d2113f72eb00a9297ddf3fa0ae4fd22d1d1/jiter-0.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5280e68e7740c8c128d3ae5ab63335ce6d1fb6603d3b809637b11713487af9e6", size = 332282 },
-    { url = "https://files.pythonhosted.org/packages/69/f7/64e0a7439790ec47f7681adb3871c9d9c45fff771102490bbee5e92c00b7/jiter-0.5.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:583c57fc30cc1fec360e66323aadd7fc3edeec01289bfafc35d3b9dcb29495e4", size = 342370 },
-    { url = "https://files.pythonhosted.org/packages/55/31/1efbfff2ae8e4d919144c53db19b828049ad0622a670be3bbea94a86282c/jiter-0.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26351cc14507bdf466b5f99aba3df3143a59da75799bf64a53a3ad3155ecded9", size = 363591 },
-    { url = "https://files.pythonhosted.org/packages/30/c3/7ab2ca2276426a7398c6dfb651e38dbc81954c79a3bfbc36c514d8599499/jiter-0.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4829df14d656b3fb87e50ae8b48253a8851c707da9f30d45aacab2aa2ba2d614", size = 378551 },
-    { url = "https://files.pythonhosted.org/packages/47/e7/5d88031cd743c62199b125181a591b1671df3ff2f6e102df85c58d8f7d31/jiter-0.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a42a4bdcf7307b86cb863b2fb9bb55029b422d8f86276a50487982d99eed7c6e", size = 319152 },
-    { url = "https://files.pythonhosted.org/packages/4c/2d/09ea58e1adca9f0359f3d41ef44a1a18e59518d7c43a21f4ece9e72e28c0/jiter-0.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04d461ad0aebf696f8da13c99bc1b3e06f66ecf6cfd56254cc402f6385231c06", size = 357377 },
-    { url = "https://files.pythonhosted.org/packages/7d/2f/83ff1058cb56fc3ff73e0d3c6440703ddc9cdb7f759b00cfbde8228fc435/jiter-0.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e6375923c5f19888c9226582a124b77b622f8fd0018b843c45eeb19d9701c403", size = 511091 },
-    { url = "https://files.pythonhosted.org/packages/ae/c9/4f85f97c9894382ab457382337aea0012711baaa17f2ed55c0ff25f3668a/jiter-0.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:2cec323a853c24fd0472517113768c92ae0be8f8c384ef4441d3632da8baa646", size = 492948 },
-    { url = "https://files.pythonhosted.org/packages/4d/f2/2e987e0eb465e064c5f52c2f29c8d955452e3b316746e326269263bfb1b7/jiter-0.5.0-cp311-none-win32.whl", hash = "sha256:aa1db0967130b5cab63dfe4d6ff547c88b2a394c3410db64744d491df7f069bb", size = 195183 },
-    { url = "https://files.pythonhosted.org/packages/ab/59/05d1c3203c349b37c4dd28b02b9b4e5915a7bcbd9319173b4548a67d2e93/jiter-0.5.0-cp311-none-win_amd64.whl", hash = "sha256:aa9d2b85b2ed7dc7697597dcfaac66e63c1b3028652f751c81c65a9f220899ae", size = 191032 },
-    { url = "https://files.pythonhosted.org/packages/aa/bd/c3950e2c478161e131bed8cb67c36aed418190e2a961a1c981e69954e54b/jiter-0.5.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:9f664e7351604f91dcdd557603c57fc0d551bc65cc0a732fdacbf73ad335049a", size = 283511 },
-    { url = "https://files.pythonhosted.org/packages/80/1c/8ce58d8c37a589eeaaa5d07d131fd31043886f5e77ab50c00a66d869a361/jiter-0.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:044f2f1148b5248ad2c8c3afb43430dccf676c5a5834d2f5089a4e6c5bbd64df", size = 296974 },
-    { url = "https://files.pythonhosted.org/packages/4d/b8/6faeff9eed8952bed93a77ea1cffae7b946795b88eafd1a60e87a67b09e0/jiter-0.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:702e3520384c88b6e270c55c772d4bd6d7b150608dcc94dea87ceba1b6391248", size = 331897 },
-    { url = "https://files.pythonhosted.org/packages/4f/54/1d9a2209b46d39ce6f0cef3ad87c462f9c50312ab84585e6bd5541292b35/jiter-0.5.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:528d742dcde73fad9d63e8242c036ab4a84389a56e04efd854062b660f559544", size = 342962 },
-    { url = "https://files.pythonhosted.org/packages/2a/de/90360be7fc54b2b4c2dfe79eb4ed1f659fce9c96682e6a0be4bbe71371f7/jiter-0.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8cf80e5fe6ab582c82f0c3331df27a7e1565e2dcf06265afd5173d809cdbf9ba", size = 363844 },
-    { url = "https://files.pythonhosted.org/packages/ba/ad/ef32b173191b7a53ea8a6757b80723cba321f8469834825e8c71c96bde17/jiter-0.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:44dfc9ddfb9b51a5626568ef4e55ada462b7328996294fe4d36de02fce42721f", size = 378709 },
-    { url = "https://files.pythonhosted.org/packages/07/de/353ce53743c0defbbbd652e89c106a97dbbac4eb42c95920b74b5056b93a/jiter-0.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c451f7922992751a936b96c5f5b9bb9312243d9b754c34b33d0cb72c84669f4e", size = 319038 },
-    { url = "https://files.pythonhosted.org/packages/3f/92/42d47310bf9530b9dece9e2d7c6d51cf419af5586ededaf5e66622d160e2/jiter-0.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:308fce789a2f093dca1ff91ac391f11a9f99c35369117ad5a5c6c4903e1b3e3a", size = 357763 },
-    { url = "https://files.pythonhosted.org/packages/bd/8c/2bb76a9a84474d48fdd133d3445db8a4413da4e87c23879d917e000a9d87/jiter-0.5.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7f5ad4a7c6b0d90776fdefa294f662e8a86871e601309643de30bf94bb93a64e", size = 511031 },
-    { url = "https://files.pythonhosted.org/packages/33/4f/9f23d79c0795e0a8e56e7988e8785c2dcda27e0ed37977256d50c77c6a19/jiter-0.5.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ea189db75f8eca08807d02ae27929e890c7d47599ce3d0a6a5d41f2419ecf338", size = 493042 },
-    { url = "https://files.pythonhosted.org/packages/df/67/8a4f975aa834b8aecdb6b131422390173928fd47f42f269dcc32034ab432/jiter-0.5.0-cp312-none-win32.whl", hash = "sha256:e3bbe3910c724b877846186c25fe3c802e105a2c1fc2b57d6688b9f8772026e4", size = 195405 },
-    { url = "https://files.pythonhosted.org/packages/15/81/296b1e25c43db67848728cdab34ac3eb5c5cbb4955ceb3f51ae60d4a5e3d/jiter-0.5.0-cp312-none-win_amd64.whl", hash = "sha256:a586832f70c3f1481732919215f36d41c59ca080fa27a65cf23d9490e75b2ef5", size = 189720 },
+sdist = { url = "https://files.pythonhosted.org/packages/26/ef/64458dfad180debd70d9dd1ca4f607e52bb6de748e5284d748556a0d5173/jiter-0.6.1.tar.gz", hash = "sha256:e19cd21221fc139fb032e4112986656cb2739e9fe6d84c13956ab30ccc7d4449", size = 161306 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/1d/9dede54580112c1403a9b6ef0cab33d10c58e3e7e55548d6b97bfd890748/jiter-0.6.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:d08510593cb57296851080018006dfc394070178d238b767b1879dc1013b106c", size = 290507 },
+    { url = "https://files.pythonhosted.org/packages/b2/28/cf5586637c8c21ad1d68bcc3361d60ade8e81524340454f21c68e8368b70/jiter-0.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:adef59d5e2394ebbad13b7ed5e0306cceb1df92e2de688824232a91588e77aa7", size = 301642 },
+    { url = "https://files.pythonhosted.org/packages/6b/ab/07e67b0a9ad816f5130def05537177f2efdfe451480a584ae9fbb31cdaf8/jiter-0.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3e02f7a27f2bcc15b7d455c9df05df8ffffcc596a2a541eeda9a3110326e7a3", size = 337364 },
+    { url = "https://files.pythonhosted.org/packages/25/3a/bb625446b95b7f964ac8c5e9260190262b629c1aecc9f7e9fd7730e2e2b1/jiter-0.6.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed69a7971d67b08f152c17c638f0e8c2aa207e9dd3a5fcd3cba294d39b5a8d2d", size = 353782 },
+    { url = "https://files.pythonhosted.org/packages/44/78/fb2bf870418360ac523ac1591a7418add2e9385e207ca6320907d22a0699/jiter-0.6.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2019d966e98f7c6df24b3b8363998575f47d26471bfb14aade37630fae836a1", size = 370761 },
+    { url = "https://files.pythonhosted.org/packages/ae/c3/4e68a0e52a3790df68b95a5fa0d70aae3f6d1f376adf515fb9016080ccf3/jiter-0.6.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:36c0b51a285b68311e207a76c385650322734c8717d16c2eb8af75c9d69506e7", size = 392957 },
+    { url = "https://files.pythonhosted.org/packages/bd/5a/d2fe7904a3f12cb2a425e83382186d23325c3316d40382cd17cd4a2205b9/jiter-0.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:220e0963b4fb507c525c8f58cde3da6b1be0bfddb7ffd6798fb8f2531226cdb1", size = 325211 },
+    { url = "https://files.pythonhosted.org/packages/d6/4a/9db9f1f7034187290ffb370c9b579e647b3e5889a541b54d113353d29a14/jiter-0.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aa25c7a9bf7875a141182b9c95aed487add635da01942ef7ca726e42a0c09058", size = 366109 },
+    { url = "https://files.pythonhosted.org/packages/0c/4b/487e2623703da76405d3ccd5f6047a7c7f9e238eda7a3043b806542e53ac/jiter-0.6.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e90552109ca8ccd07f47ca99c8a1509ced93920d271bb81780a973279974c5ab", size = 514433 },
+    { url = "https://files.pythonhosted.org/packages/33/18/ed55ecd669f5ce963045f9cd3404c937d51509324070af5bba17cda789fd/jiter-0.6.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:67723a011964971864e0b484b0ecfee6a14de1533cff7ffd71189e92103b38a8", size = 496282 },
+    { url = "https://files.pythonhosted.org/packages/c1/8e/2854fe24b38e7180396a991e34363f3e7a72ea99c4a05f2c3940ae01fda8/jiter-0.6.1-cp310-none-win32.whl", hash = "sha256:33af2b7d2bf310fdfec2da0177eab2fedab8679d1538d5b86a633ebfbbac4edd", size = 197413 },
+    { url = "https://files.pythonhosted.org/packages/5b/bd/ff2f6a84574e0e01759dd81255c3145cacd9f374d01efc49574b03638105/jiter-0.6.1-cp310-none-win_amd64.whl", hash = "sha256:7cea41c4c673353799906d940eee8f2d8fd1d9561d734aa921ae0f75cb9732f4", size = 200042 },
+    { url = "https://files.pythonhosted.org/packages/95/91/d1605f3cabcf47193ecab3712e5a4c55a19cf1a4d86ef67402325e28a44e/jiter-0.6.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b03c24e7da7e75b170c7b2b172d9c5e463aa4b5c95696a368d52c295b3f6847f", size = 290963 },
+    { url = "https://files.pythonhosted.org/packages/91/35/85ef9eaef7dec14f28dd9b8a2116c07075bb2731a405b650a55fda4c74d7/jiter-0.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:47fee1be677b25d0ef79d687e238dc6ac91a8e553e1a68d0839f38c69e0ee491", size = 302639 },
+    { url = "https://files.pythonhosted.org/packages/3b/c7/87a809bf95eb6fbcd8b30ea1d0f922c2187590de64a7f0944615008fde45/jiter-0.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25f0d2f6e01a8a0fb0eab6d0e469058dab2be46ff3139ed2d1543475b5a1d8e7", size = 337048 },
+    { url = "https://files.pythonhosted.org/packages/bf/70/c31f21c109a01e6ebb0e032c8296d24761b5244b37d16bb3e9b0789a0eb0/jiter-0.6.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0b809e39e342c346df454b29bfcc7bca3d957f5d7b60e33dae42b0e5ec13e027", size = 354239 },
+    { url = "https://files.pythonhosted.org/packages/b9/86/6e4ef77c86175bbcc2cff6e8c6a8f98a554f88ce99b9c892c9330858d07c/jiter-0.6.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e9ac7c2f092f231f5620bef23ce2e530bd218fc046098747cc390b21b8738a7a", size = 370842 },
+    { url = "https://files.pythonhosted.org/packages/ba/e3/ef93fc307278d98c981b09b4f965f49312d0639ba31c2db4fe073b78a833/jiter-0.6.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e51a2d80d5fe0ffb10ed2c82b6004458be4a3f2b9c7d09ed85baa2fbf033f54b", size = 392489 },
+    { url = "https://files.pythonhosted.org/packages/63/6d/bff2bce7cc17bd7e0f517490cfa4444ad94d20720eb2ccd3152a6cd57a30/jiter-0.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3343d4706a2b7140e8bd49b6c8b0a82abf9194b3f0f5925a78fc69359f8fc33c", size = 325493 },
+    { url = "https://files.pythonhosted.org/packages/49/4b/56e8a5e2be5439e503b77d2c9479197e0d8199827d7f79b06592747c5210/jiter-0.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:82521000d18c71e41c96960cb36e915a357bc83d63a8bed63154b89d95d05ad1", size = 365974 },
+    { url = "https://files.pythonhosted.org/packages/d3/9b/967752fb36ddb4b6ea7a2a8cd0ef3f167a112a2d3a2131ee544969203659/jiter-0.6.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3c843e7c1633470708a3987e8ce617ee2979ee18542d6eb25ae92861af3f1d62", size = 514144 },
+    { url = "https://files.pythonhosted.org/packages/58/55/9b7e0021e567731b076a8bf017a1df7d6f148bb175be2ac647a0c6433bbd/jiter-0.6.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a2e861658c3fe849efc39b06ebb98d042e4a4c51a8d7d1c3ddc3b1ea091d0784", size = 496072 },
+    { url = "https://files.pythonhosted.org/packages/ca/37/9e0638d2a129a1b72344a90a03b2b518c048066db0858aaf0877cb9d4acd/jiter-0.6.1-cp311-none-win32.whl", hash = "sha256:7d72fc86474862c9c6d1f87b921b70c362f2b7e8b2e3c798bb7d58e419a6bc0f", size = 197571 },
+    { url = "https://files.pythonhosted.org/packages/65/8a/78d337464e2b2e552d2988148e3e51da5445d910345c0d00f1982fd9aad4/jiter-0.6.1-cp311-none-win_amd64.whl", hash = "sha256:3e36a320634f33a07794bb15b8da995dccb94f944d298c8cfe2bd99b1b8a574a", size = 201994 },
+    { url = "https://files.pythonhosted.org/packages/2e/d5/fcdfbcea637f8b9b833597797d6b77fd7e22649b4794fc571674477c8520/jiter-0.6.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1fad93654d5a7dcce0809aff66e883c98e2618b86656aeb2129db2cd6f26f867", size = 289279 },
+    { url = "https://files.pythonhosted.org/packages/9a/47/8e4a7704a267b8d1d3287b4353fc07f1f4a3541b27988ea3e49ccbf3164a/jiter-0.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4e6e340e8cd92edab7f6a3a904dbbc8137e7f4b347c49a27da9814015cc0420c", size = 300931 },
+    { url = "https://files.pythonhosted.org/packages/ea/4f/fbb1e11fcc3881d108359d3db8456715c9d30ddfce84dc5f9e0856e08e11/jiter-0.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:691352e5653af84ed71763c3c427cff05e4d658c508172e01e9c956dfe004aba", size = 336534 },
+    { url = "https://files.pythonhosted.org/packages/29/8a/4c1e1229f89127187df166de760438b2a20e5a311391ba10d2b69db0da6f/jiter-0.6.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:defee3949313c1f5b55e18be45089970cdb936eb2a0063f5020c4185db1b63c9", size = 354266 },
+    { url = "https://files.pythonhosted.org/packages/19/15/3f27f4b9d40bc7709a30fda99876cbe9e9f75a0ea2ef7d55f3dd4d04f927/jiter-0.6.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26d2bdd5da097e624081c6b5d416d3ee73e5b13f1703bcdadbb1881f0caa1933", size = 370492 },
+    { url = "https://files.pythonhosted.org/packages/1f/9d/9ec03c07325bc3a3c5b5082840b8ecb7e7ad38f3071c149b7c6fb9e78706/jiter-0.6.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18aa9d1626b61c0734b973ed7088f8a3d690d0b7f5384a5270cd04f4d9f26c86", size = 390330 },
+    { url = "https://files.pythonhosted.org/packages/bd/3b/612ea6daa52d64bc0cc46f2bd2e138952c58f1edbe86b17fd89e07c33d86/jiter-0.6.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a3567c8228afa5ddcce950631c6b17397ed178003dc9ee7e567c4c4dcae9fa0", size = 324245 },
+    { url = "https://files.pythonhosted.org/packages/21/0f/f3a1ffd9f203d4014b4e5045c0ea2c67ee71a7eee8bf3408dbf11007cf07/jiter-0.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e5c0507131c922defe3f04c527d6838932fcdfd69facebafd7d3574fa3395314", size = 368232 },
+    { url = "https://files.pythonhosted.org/packages/62/12/5d75729e0a57804852de0affc6f03b3df8518259e47ed4cd89aeeb671a71/jiter-0.6.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:540fcb224d7dc1bcf82f90f2ffb652df96f2851c031adca3c8741cb91877143b", size = 513820 },
+    { url = "https://files.pythonhosted.org/packages/5f/e8/e47734280e19cd465832e610e1c69367ee72947de738785c4b6fc4031e25/jiter-0.6.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e7b75436d4fa2032b2530ad989e4cb0ca74c655975e3ff49f91a1a3d7f4e1df2", size = 496023 },
+    { url = "https://files.pythonhosted.org/packages/52/01/5f65dd1387d39aa3fd4a98a5be1d8470e929a0cb0dd6cbfebaccd9a20ac5/jiter-0.6.1-cp312-none-win32.whl", hash = "sha256:883d2ced7c21bf06874fdeecab15014c1c6d82216765ca6deef08e335fa719e0", size = 197425 },
+    { url = "https://files.pythonhosted.org/packages/43/b2/bd6665030f7d7cd5d9182c62a869c3d5ceadd7bff9f1b305de9192e7dbf8/jiter-0.6.1-cp312-none-win_amd64.whl", hash = "sha256:91e63273563401aadc6c52cca64a7921c50b29372441adc104127b910e98a5b6", size = 198966 },
+    { url = "https://files.pythonhosted.org/packages/23/38/7b48e0149778ff4b893567c9fd997ecfcc013e290375aa7823e1f681b3d3/jiter-0.6.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:852508a54fe3228432e56019da8b69208ea622a3069458252f725d634e955b31", size = 288674 },
+    { url = "https://files.pythonhosted.org/packages/85/3b/96d15b483d82a637279da53a1d299dd5da6e029b9905bcd1a4e1f89b8e4f/jiter-0.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f491cc69ff44e5a1e8bc6bf2b94c1f98d179e1aaf4a554493c171a5b2316b701", size = 301531 },
+    { url = "https://files.pythonhosted.org/packages/cf/54/9681f112cbec4e197259e9db679bd4bc314f4bd24f74b9aa5e93073990b5/jiter-0.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc56c8f0b2a28ad4d8047f3ae62d25d0e9ae01b99940ec0283263a04724de1f3", size = 335954 },
+    { url = "https://files.pythonhosted.org/packages/4a/4d/f9c0ba82b154c66278e28348086086264ccf50622ae468ec215e4bbc2873/jiter-0.6.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:51b58f7a0d9e084a43b28b23da2b09fc5e8df6aa2b6a27de43f991293cab85fd", size = 353996 },
+    { url = "https://files.pythonhosted.org/packages/ee/be/7f26b258ef190f6d582e21c76c7dd1097753a2203bad3e1643f45392720a/jiter-0.6.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f79ce15099154c90ef900d69c6b4c686b64dfe23b0114e0971f2fecd306ec6c", size = 369733 },
+    { url = "https://files.pythonhosted.org/packages/5f/85/037ed5261fa622312471ef5520b2135c26b29256c83adc16c8cc55dc4108/jiter-0.6.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:03a025b52009f47e53ea619175d17e4ded7c035c6fbd44935cb3ada11e1fd592", size = 389920 },
+    { url = "https://files.pythonhosted.org/packages/a8/f3/2e01294712faa476be9e6ceb49e424c3919e03415ded76d103378a06bb80/jiter-0.6.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c74a8d93718137c021d9295248a87c2f9fdc0dcafead12d2930bc459ad40f885", size = 324138 },
+    { url = "https://files.pythonhosted.org/packages/00/45/50377814f21b6412c7785be27f2dace225af52e0af20be7af899a7e3f264/jiter-0.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:40b03b75f903975f68199fc4ec73d546150919cb7e534f3b51e727c4d6ccca5a", size = 367610 },
+    { url = "https://files.pythonhosted.org/packages/af/fc/51ba30875125381bfe21a1572c176de1a7dd64a386a7498355fc100decc4/jiter-0.6.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:825651a3f04cf92a661d22cad61fc913400e33aa89b3e3ad9a6aa9dc8a1f5a71", size = 512945 },
+    { url = "https://files.pythonhosted.org/packages/69/60/af26168bd4916f9199ed433161e9f8a4eeda581a4e5982560d0f22dd146c/jiter-0.6.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:928bf25eb69ddb292ab8177fe69d3fbf76c7feab5fce1c09265a7dccf25d3991", size = 494963 },
+    { url = "https://files.pythonhosted.org/packages/f3/2f/4f3cc5c9067a6fd1020d3c4365546535a69ed77da7fba2bec24368f3662c/jiter-0.6.1-cp313-none-win32.whl", hash = "sha256:352cd24121e80d3d053fab1cc9806258cad27c53cad99b7a3cac57cf934b12e4", size = 196869 },
+    { url = "https://files.pythonhosted.org/packages/7a/fc/8709ee90837e94790d8b50db51c7b8a70e86e41b2c81e824c20b0ecfeba7/jiter-0.6.1-cp313-none-win_amd64.whl", hash = "sha256:be7503dd6f4bf02c2a9bacb5cc9335bc59132e7eee9d3e931b13d76fd80d7fda", size = 198919 },
 ]
 
 [[package]]
@@ -1929,14 +2003,14 @@ wheels = [
 
 [[package]]
 name = "jsonschema-specifications"
-version = "2023.12.1"
+version = "2024.10.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "referencing" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f8/b9/cc0cc592e7c195fb8a650c1d5990b10175cf13b4c97465c72ec841de9e4b/jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc", size = 13983 }
+sdist = { url = "https://files.pythonhosted.org/packages/10/db/58f950c996c793472e336ff3655b13fbcf1e3b359dcf52dcf3ed3b52c352/jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272", size = 15561 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ee/07/44bd408781594c4d0a027666ef27fab1e441b109dc3b76b4f836f8fd04fe/jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c", size = 18482 },
+    { url = "https://files.pythonhosted.org/packages/d1/0f/8910b19ac0670a0f80ce1008e5e751c4a57e14d2c4c13a482aa6079fa9d6/jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf", size = 18459 },
 ]
 
 [[package]]
@@ -1960,7 +2034,7 @@ wheels = [
 
 [[package]]
 name = "jupyter-client"
-version = "8.6.2"
+version = "8.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jupyter-core" },
@@ -1969,9 +2043,9 @@ dependencies = [
     { name = "tornado" },
     { name = "traitlets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ff/61/3cd51dea7878691919adc34ff6ad180f13bfe25fb8c7662a9ee6dc64e643/jupyter_client-8.6.2.tar.gz", hash = "sha256:2bda14d55ee5ba58552a8c53ae43d215ad9868853489213f37da060ced54d8df", size = 341102 }
+sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cf/d3/c4bb02580bc0db807edb9a29b2d0c56031be1ef0d804336deb2699a470f6/jupyter_client-8.6.2-py3-none-any.whl", hash = "sha256:50cbc5c66fd1b8f65ecb66bc490ab73217993632809b6e505687de18e9dea39f", size = 105901 },
+    { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105 },
 ]
 
 [[package]]
@@ -1990,7 +2064,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "0.3.6"
+version = "0.3.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -2001,64 +2075,80 @@ dependencies = [
     { name = "tenacity" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/08/0e/fa5137d090dff446fa9b1d617a76d91daa3aa2efa099aacd2fdc94494711/langchain_core-0.3.6.tar.gz", hash = "sha256:eb190494a5483f1965f693bb2085edb523370b20fc52dc294d3bd425773cd076", size = 320190 }
+sdist = { url = "https://files.pythonhosted.org/packages/02/d6/5a16b853a19ba0200dbf77010d9a3b3effc84c62bc952fff7bf81e90f9d8/langchain_core-0.3.13.tar.gz", hash = "sha256:d3a6c838284ff73705dd0f24a36cd8b2fa34a348e6b357e6b3d58199ab063cde", size = 327206 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3e/0b/f189d87ccc7a5f388649bbf7e513ad774b14d66a4bb96278cb211347a17c/langchain_core-0.3.6-py3-none-any.whl", hash = "sha256:7bb3df0117bdc628b18b6c8748de72c6f537d745d47566053ce6650d5712281c", size = 399888 },
+    { url = "https://files.pythonhosted.org/packages/38/53/b5436750c392370cff44f8e3669a4886fa18579ad0ce33a505f8f261c1a0/langchain_core-0.3.13-py3-none-any.whl", hash = "sha256:e79cfac046cab293c02047f081741f4a433ca5aa54a3973e179eaef147cdfba4", size = 408049 },
 ]
 
 [[package]]
 name = "langchain-openai"
-version = "0.2.0"
+version = "0.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "openai" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/52/c4/212c859112aaa7f11d6f1c5b643ac65f8d5f6e218600546180421dfa6557/langchain_openai-0.2.0.tar.gz", hash = "sha256:441ec8fd254992e5fa81d375e60849993a81db5e9e42a79344ebff7a40a0b45f", size = 45142 }
+sdist = { url = "https://files.pythonhosted.org/packages/41/31/82c8a33354dd0a59438973cfdfc771fde0df2c9fb8388e0c23dc36119959/langchain_openai-0.2.3.tar.gz", hash = "sha256:e142031704de1104735f503f76352c53b27ac0a2806466392993c4508c42bf0c", size = 42572 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8c/de/865dedcb252db4725e6e458fb28845038217fdade1df40a9e41b0579c534/langchain_openai-0.2.0-py3-none-any.whl", hash = "sha256:9a1a69ba0706f23ec2941096ead0bc39202cac0e9782a5d6c8d92cb2280c2759", size = 51465 },
+    { url = "https://files.pythonhosted.org/packages/66/ea/dcc59d9b818a4d7f25d4d6b3018355a0e0243a351b1d4ef8b26ec107ee00/langchain_openai-0.2.3-py3-none-any.whl", hash = "sha256:f498c94817c980cb302439b95d3f3275cdf2743e022ee674692c75898523cf57", size = 49907 },
 ]
 
 [[package]]
 name = "langgraph"
-version = "0.2.28"
+version = "0.2.39"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "langgraph-checkpoint" },
+    { name = "langgraph-sdk" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f6/83/886c702d510d5246d3e43c563084def3f036dc1a1b686a1148e7119a6370/langgraph-0.2.28.tar.gz", hash = "sha256:c968a1ed85025e0651d9390a7ba978447ab80d676f81dd0a049a7456754b3bce", size = 89076 }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/ba/eb6da29e5c4608191c00cb9ad1dbfb0686a02441ff52f16c216e6bd2d823/langgraph-0.2.39.tar.gz", hash = "sha256:32af60291f9260c3acb8a3d4bec99e32abd89ddb6b4a10a79aa3dbc90fa920ac", size = 94566 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/1b/ff6ba8bb002bd400f39f7a8ed4401bd2617644208d3e9e6a9b9147db7438/langgraph-0.2.28-py3-none-any.whl", hash = "sha256:23390763c025139f71dc1f1576b31b6755fecff8dcc51a84505e24e63ec1218b", size = 107720 },
+    { url = "https://files.pythonhosted.org/packages/72/67/ffad3820b879aa7f6f6956d4499d59017e51e944addaf6121dd3fc06eb21/langgraph-0.2.39-py3-none-any.whl", hash = "sha256:5dfbdeefbf599f16d245799609f2b43c1ec7a7e8ed6e1d7981b1a7979a4ad7fe", size = 113522 },
 ]
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "1.0.11"
+version = "2.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "msgpack" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8f/8c/8a5126c88706fe0954a5d179cd78873d66666f3aff98edb3319877752abc/langgraph_checkpoint-1.0.11.tar.gz", hash = "sha256:156af1666272a0be3cda4a2c4ffe6b2e2f5af8ead7d450d345cbb39828ce4b05", size = 15870 }
+sdist = { url = "https://files.pythonhosted.org/packages/22/49/8596e8f51299fd035515704da305b77965f937cb2175277a7740dde7e492/langgraph_checkpoint-2.0.2.tar.gz", hash = "sha256:c1d033e4e4855f580fa56830327eb86513b64ab5be527245363498e76b19a0b9", size = 20362 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/8e/78872f64d4b37dddc5ab06ad214a74dab4d56140b09169ae86881392328c/langgraph_checkpoint-2.0.2-py3-none-any.whl", hash = "sha256:6e5dfd90e1fc71b91ccff75939ada1114e5d7f824df5f24c62d39bed69039ee2", size = 23349 },
+]
+
+[[package]]
+name = "langgraph-sdk"
+version = "0.1.34"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "orjson" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9a/2c/6d0afafac86b3c59726c2b845b392147160f1647221ddbc4f8e648dc8939/langgraph_sdk-0.1.34.tar.gz", hash = "sha256:ee76507018414a08bcf63e0de916e956340ee2e9b5c60d5252d1b2b1fe47c5f3", size = 27625 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/7a/cc607f84376ef73d97c737bac431aed0533ba076d026ea6c7fb187513a89/langgraph_checkpoint-1.0.11-py3-none-any.whl", hash = "sha256:9644bd61e3ab5b03fc0422aa5e625061ad14aa2012d046bf4bb306451da95371", size = 17116 },
+    { url = "https://files.pythonhosted.org/packages/9b/00/454f94ab2754392f5cb78bf8f8ea005ae1cfef17d257103126d19e3968c7/langgraph_sdk-0.1.34-py3-none-any.whl", hash = "sha256:3c44967382e073055c1731d9dde004a49ca04a063183747031b8a8286bad0b19", size = 28439 },
 ]
 
 [[package]]
 name = "langsmith"
-version = "0.1.128"
+version = "0.1.137"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
     { name = "orjson" },
     { name = "pydantic" },
     { name = "requests" },
+    { name = "requests-toolbelt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/37/34/1ebd4f2b2bf24bd1118734fba99fb265eb44e2ed80499d00d7e532cd980b/langsmith-0.1.128.tar.gz", hash = "sha256:3299e17a659f3c47725c97c47f4445fc34113ac668becce425919866fbcb6ec2", size = 283480 }
+sdist = { url = "https://files.pythonhosted.org/packages/95/b0/b6c112e5080765ad31272b92f16478d2d38c54727e00cc8bbc9a66bbaa44/langsmith-0.1.137.tar.gz", hash = "sha256:56cdfcc6c74cb20a3f437d5bd144feb5bf93f54c5a2918d1e568cbd084a372d4", size = 287888 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/a3/57759a704cf8dda067ad3d0a5f274edc503a2765c4e6fa89f4727a07294a/langsmith-0.1.128-py3-none-any.whl", hash = "sha256:c1b59d947584be7487ac53dffb4e232704626964011b714fd3d9add4b3694cbc", size = 292085 },
+    { url = "https://files.pythonhosted.org/packages/71/fd/7713b0e737f4e171112e44134790823ccec4aabe31f07d6e836fcbeb3b8a/langsmith-0.1.137-py3-none-any.whl", hash = "sha256:4256d5c61133749890f7b5c88321dbb133ce0f440c621ea28e76513285859b81", size = 296895 },
 ]
 
 [[package]]
@@ -2075,20 +2165,20 @@ wheels = [
 
 [[package]]
 name = "llama-cloud"
-version = "0.0.15"
+version = "0.1.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3e/eb/ee019dd7bd72f3ee91e264c3a1b7f1bd1a6e47438904b51593b1e796b0cb/llama_cloud-0.0.15.tar.gz", hash = "sha256:be06fd888e889623796b9c2aa0fc0d09ef039ed5145ff267d8408ccbea70c048", size = 67849 }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/da/4d98e8b07356722377c9921ca0ae2ebb91403dfa46f1520c1282c4c562b6/llama_cloud-0.1.4.tar.gz", hash = "sha256:6f0155979bd96160951cb812c48836f1face037bc79ccfd8d185b18ef4c9faf8", size = 65003 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/e6/7c80b3fd6e38477caa6f4848786f254945bad2f103c77244d9a526dc741f/llama_cloud-0.0.15-py3-none-any.whl", hash = "sha256:52f18a3870e23c4a9b5f66827a58dc87d5a1c3034d1ce6ab513ca7eb09ae8b36", size = 180203 },
+    { url = "https://files.pythonhosted.org/packages/e2/c8/550908552364cf77c835f1027c619fc37a12256c896348cce5a71dabcf5e/llama_cloud-0.1.4-py3-none-any.whl", hash = "sha256:cfca6c4e0a87468b922d732f0f313a2ecd3a8e0bf74382ee80829ce49dcbc5e0", size = 176822 },
 ]
 
 [[package]]
 name = "llama-index"
-version = "0.11.2"
+version = "0.11.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-agent-openai" },
@@ -2105,42 +2195,42 @@ dependencies = [
     { name = "llama-index-readers-llama-parse" },
     { name = "nltk" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/81/9e/80cb08c0b73f05bd45eb8f221d3026c7d8516eb14786f7a073fca3558ab7/llama_index-0.11.2.tar.gz", hash = "sha256:8430b589e372c2b1614da259c4a8e4c2790d9278cd82f3a3b9e19972e8c2d834", size = 7753 }
+sdist = { url = "https://files.pythonhosted.org/packages/c1/37/b97d994212393f302b87f41783615bc38ce054c702829c6962ff8c1de8c4/llama_index-0.11.20.tar.gz", hash = "sha256:5e8e3fcb5af5b4e4525498b075ff0a54160b00bf0fc0b83801fc7faf1c8a8c1d", size = 7785 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/de/e16818a5307f880e39e1e458ecf43566dff7e48a50d2c8817dd80cad5fc1/llama_index-0.11.2-py3-none-any.whl", hash = "sha256:3e70d09a48d8aaf479679c3de0598fe7b3276613a6927a5612fcafb2ecef60f0", size = 6792 },
+    { url = "https://files.pythonhosted.org/packages/63/c4/2ea55ee0dba1b86cfaaa54cf0311294714ce12309db389b50bf8c2ecd2ee/llama_index-0.11.20-py3-none-any.whl", hash = "sha256:fc9e5e47e6da3610bc3b788d208bb782c03a342fd71e3b22b37abc83ecebe46e", size = 6819 },
 ]
 
 [[package]]
 name = "llama-index-agent-openai"
-version = "0.3.0"
+version = "0.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "llama-index-llms-openai" },
     { name = "openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/bb/d2/febe1039c037b2a89675f385d70748a000dbfd2b204e0ee839cc8046ccdc/llama_index_agent_openai-0.3.0.tar.gz", hash = "sha256:dade70e8b987194d7afb6925f723060e9f4953eb134400da2fcd4ceedf2c3dff", size = 10645 }
+sdist = { url = "https://files.pythonhosted.org/packages/ef/b2/95121d8ea4da363dabdacca7b340dfae4353b099a6b6b910de948f9684af/llama_index_agent_openai-0.3.4.tar.gz", hash = "sha256:80e3408d97121bebca3fa3ffd14b51285870c1c3c73d4ee04d3d18cfe6040466", size = 10401 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/e3/f0fd37795337132ade36ae9e189def1430ea2db474614c55fa1033a0daf4/llama_index_agent_openai-0.3.0-py3-none-any.whl", hash = "sha256:2b7d0e3d0e95271e5244e75a0366248c48d733497d93ae5bb09f548afe24ec98", size = 13168 },
+    { url = "https://files.pythonhosted.org/packages/9d/69/69857756c139897f209a2c372380509f718fb147170e2f2287cf4d77314a/llama_index_agent_openai-0.3.4-py3-none-any.whl", hash = "sha256:3720ce9bb12417a99a3fe84e52cce23e762b13f88a2dfc4292c76f4df9b26b4a", size = 13036 },
 ]
 
 [[package]]
 name = "llama-index-cli"
-version = "0.3.0"
+version = "0.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "llama-index-embeddings-openai" },
     { name = "llama-index-llms-openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/84/96/02806097faff68f364dd25acdb7dc62baef2b40cca1cfe2d4c539262b6f2/llama_index_cli-0.3.0.tar.gz", hash = "sha256:a42e01fe2a02aa0fd3b645eb1403f9058fa7f62fbeea2a06a55b7fb8c07d5d02", size = 24680 }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/d2/5894ccc0f86c4e95d557c8c7ef0c15d19c67e0ad3d4628247684350c7363/llama_index_cli-0.3.1.tar.gz", hash = "sha256:1890dd687cf440f3651365a549e303363162c167b8efbd87a3aa10058d6d5c77", size = 24450 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dd/c2/3bb98c98dc1f782783ae48fd75b84cfa2742ae41c2e508d2a87f6db52101/llama_index_cli-0.3.0-py3-none-any.whl", hash = "sha256:23227f305b7b320c7909f54ef2eeba90b9ad1a56231fbfbe1298280542bb9f24", size = 27761 },
+    { url = "https://files.pythonhosted.org/packages/28/58/fb9d85d8f29d7379e953caf50278e095d302231a508d3e46dafd3a4bea1e/llama_index_cli-0.3.1-py3-none-any.whl", hash = "sha256:2111fbb6973f5b1eabce0d6cca3986499f0f2f625b13d7f48269a49c64c027d4", size = 27767 },
 ]
 
 [[package]]
 name = "llama-index-core"
-version = "0.11.2"
+version = "0.11.20"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -2165,49 +2255,49 @@ dependencies = [
     { name = "typing-inspect" },
     { name = "wrapt" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/37/3445e6b4a146a7a6270f9bde75b6f25436c2feb02c20fd227ef46dad0362/llama_index_core-0.11.2.tar.gz", hash = "sha256:eec37976fe3b1baa3bb31bd3c5f6ea821555c7065ac6a55b71b5601a7e097977", size = 1315973 }
+sdist = { url = "https://files.pythonhosted.org/packages/07/68/22bb16497be9556322f78f001742f0d3e8e847b007c5896c1da09dc2b27c/llama_index_core-0.11.20.tar.gz", hash = "sha256:6b5eaaf4be5030808b9ba953e8f7aead7ba495b8e72ba0a81dfc7dda96be416f", size = 1323570 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f0/7b/5db489b13598f375ca0745cdaf018d5292cec3f8e42e6520c08f15e2d614/llama_index_core-0.11.2-py3-none-any.whl", hash = "sha256:6c55667c4943ba197199e21e9b0e4641449f5e5dca662b0c91f5306f8c114e4f", size = 1564343 },
+    { url = "https://files.pythonhosted.org/packages/fc/ee/3bd7a6037d90c50e8b5600a1d975e7a70e309262952e0097ef74d015c173/llama_index_core-0.11.20-py3-none-any.whl", hash = "sha256:e84daf45e90e4b5d9e135baf40ab9853a1c3169a1076af6d58739d098e70adb1", size = 1574327 },
 ]
 
 [[package]]
 name = "llama-index-embeddings-azure-openai"
-version = "0.2.4"
+version = "0.2.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "llama-index-embeddings-openai" },
     { name = "llama-index-llms-azure-openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ea/67/8eec011d3561eceebc8f16ed98d089589ef79ffe5757eaafb7e1b3a94bdd/llama_index_embeddings_azure_openai-0.2.4.tar.gz", hash = "sha256:f5d4c460f91f8bc587aa98b6e319d42f990c09afe2aa66c79750870e0029ea18", size = 2952 }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/b9/fa9c729c001e062069d3a20b7f03a577187eeb0fb4272fb32fcde59e7bba/llama_index_embeddings_azure_openai-0.2.5.tar.gz", hash = "sha256:d8b2e3134c2b3510214f2260e6c17be18396d0c765f3edd6c3ffe6109528aed0", size = 3053 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5b/e0/22d36b357824d343b123c18922b20d0cebfdc9f96cade701c0b9d6852974/llama_index_embeddings_azure_openai-0.2.4-py3-none-any.whl", hash = "sha256:90181a10de8873bfefd6e0cd1a6590482d2ceb6445f396b08e69d7c951fdafaf", size = 3326 },
+    { url = "https://files.pythonhosted.org/packages/6e/aa/73aafa3bb97d2ba62a5af1ec86b1c5fcb0619ee16101e765e734c4eebf7e/llama_index_embeddings_azure_openai-0.2.5-py3-none-any.whl", hash = "sha256:e3384002618d027c3d188134e7fe09ffb16029202db6b3e6955a9f1f6d591a3e", size = 3430 },
 ]
 
 [[package]]
 name = "llama-index-embeddings-openai"
-version = "0.2.3"
+version = "0.2.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a6/58/81df3edadfa74d67a73173171200c0fc5c6a55d117057c48f4f78a0b89f1/llama_index_embeddings_openai-0.2.3.tar.gz", hash = "sha256:2f7adef6b61fd4f1bea487166ff9a5ff063227686b7dbb5d2227e46450a7ec4c", size = 5507 }
+sdist = { url = "https://files.pythonhosted.org/packages/85/06/35969946f229212c17133ca5aa446824381e309141f8ae952d0d40bfa8f5/llama_index_embeddings_openai-0.2.5.tar.gz", hash = "sha256:0047dd71d747068645ed728c29312aa91b65bbe4c6142180034c64dfc5c6f6e8", size = 5395 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/6e/135bc85d6c7f953069bc084a607c48eb3d9da02b727b9b5a75afb00bfc57/llama_index_embeddings_openai-0.2.3-py3-none-any.whl", hash = "sha256:be7d2aad0884e54d291af786b23d2feb7770cd1c3950f0de1fd5e36c60d83c06", size = 6269 },
+    { url = "https://files.pythonhosted.org/packages/a4/4e/2cabf16c4ef7dda74c233d14d017ba57e933c4dea8a9807b90d145177e88/llama_index_embeddings_openai-0.2.5-py3-none-any.whl", hash = "sha256:823c8311e556349ba19dda408a64a314fa3dafe0e5759709c54d33a0269aa6ba", size = 6089 },
 ]
 
 [[package]]
 name = "llama-index-indices-managed-llama-cloud"
-version = "0.3.0"
+version = "0.4.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-cloud" },
     { name = "llama-index-core" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ad/88/e661badc0ebb6230ab332e0b08223b489939397b204c3501d6fc1769e17f/llama_index_indices_managed_llama_cloud-0.3.0.tar.gz", hash = "sha256:02a1d0b413fffb55022e7e84e05788ccb18cbdcf54cfec0466d84c565509fae6", size = 8970 }
+sdist = { url = "https://files.pythonhosted.org/packages/cf/82/7597547f339209d2abbf17717bea6208f9b380427bd765aee460403a576d/llama_index_indices_managed_llama_cloud-0.4.0.tar.gz", hash = "sha256:fbebff7876a219b6ab96892ae7c432a9299195fab8f67d4a4a0ebf6da210b242", size = 9800 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/23/2d/123c6646532dbf0afa119ce014d2f4e625aa8eacc49dc928d2b757e86603/llama_index_indices_managed_llama_cloud-0.3.0-py3-none-any.whl", hash = "sha256:ee3df2bd877d716abb303f486b479b1caca6030b87b2e4756b93ef246827c8c4", size = 9473 },
+    { url = "https://files.pythonhosted.org/packages/a8/bf/3c1986159e047306ebdfb32555ef667fe8305ef6ab772f0624ada7537440/llama_index_indices_managed_llama_cloud-0.4.0-py3-none-any.whl", hash = "sha256:c2c54821f1bf17a7810e6c013fbe7ddfef4154b7e5b100f7bf8673098f8004e4", size = 10365 },
 ]
 
 [[package]]
@@ -2241,7 +2331,7 @@ wheels = [
 
 [[package]]
 name = "llama-index-llms-azure-openai"
-version = "0.2.0"
+version = "0.2.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "azure-identity" },
@@ -2249,35 +2339,35 @@ dependencies = [
     { name = "llama-index-core" },
     { name = "llama-index-llms-openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8c/d9/29bd1ae55402d4137e56fba2b649a0a7c1ccd29b6ecc28ae17fda7f86767/llama_index_llms_azure_openai-0.2.0.tar.gz", hash = "sha256:dbec54553780bb530f06e187a61bdd3a46cfd417b04f9d135c7dbc8bd07b13f7", size = 4557 }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/6659a0b4e4cf3c47f6ebfe8e7dcbc035d046cacf8050d0b340d0e116ddf6/llama_index_llms_azure_openai-0.2.2.tar.gz", hash = "sha256:717bc3bf858e800d66e4f2ddec85a2e7dd503006d55981053d08e98771ec3abc", size = 5466 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/40/86/8a823957469c5a109aa45ffd09935cc1cda48d6e27d9484c5abc81fe76a9/llama_index_llms_azure_openai-0.2.0-py3-none-any.whl", hash = "sha256:9b3b9b910698a698f851643109630a5e43e328090c96abe6573c84a0c2718407", size = 5126 },
+    { url = "https://files.pythonhosted.org/packages/58/91/44a6d7c546e8b23be76743768b815a36f27770434108a69b1d08f6884abc/llama_index_llms_azure_openai-0.2.2-py3-none-any.whl", hash = "sha256:c8a7d04a111ceff0b4335dc9273fbdb37fdb5095b6234190ca727736f6466d7b", size = 6306 },
 ]
 
 [[package]]
 name = "llama-index-llms-openai"
-version = "0.2.0"
+version = "0.2.16"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/08/64e048a7f0e53784ad37aef3dad90e3e3aa5c7e6593b653130b17b9093da/llama_index_llms_openai-0.2.0.tar.gz", hash = "sha256:13c85d4cf12bd07b9eab9805cbc42dfb2e35d0dfc9dc26720edd1bdf1c112a54", size = 11384 }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/e7/46f16e0f3ad25f49a050f1421a20b738ec312a5003bd07d749095eedb235/llama_index_llms_openai-0.2.16.tar.gz", hash = "sha256:7c666dd27056c278a079ff45d53f1fbfc8ed363764aa7baeee2e03df47f9072a", size = 13437 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/81/036135a109ae1626246570fb57a1f6e874d8d33f2751763d642af98179f8/llama_index_llms_openai-0.2.0-py3-none-any.whl", hash = "sha256:70c5d97b9b03fbb689e45b434fb71a7ff047bc7c38241e09be977bad64f61aba", size = 12038 },
+    { url = "https://files.pythonhosted.org/packages/3b/49/bae3a019eba473a0b9bf21ad911786f86941e86dd0dac3c3e909352eaf54/llama_index_llms_openai-0.2.16-py3-none-any.whl", hash = "sha256:413466acbb894bd81f8dab2037f595e92392d869eec6d8274a16d43123cac8b6", size = 13623 },
 ]
 
 [[package]]
 name = "llama-index-multi-modal-llms-openai"
-version = "0.2.0"
+version = "0.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "llama-index-llms-openai" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/91/3a/538be48ab3a9e6a59c0f983738f82de1c3cfc2f838e9833c5a8d73a8d53b/llama_index_multi_modal_llms_openai-0.2.0.tar.gz", hash = "sha256:81196b730374cc88d283f8794357d0bd66646b9a4daa5c09cf57619030b4696c", size = 5155 }
+sdist = { url = "https://files.pythonhosted.org/packages/03/26/298362f1c9531c637b46466847d8aad967aac3b8561c8a0dc859921f6feb/llama_index_multi_modal_llms_openai-0.2.3.tar.gz", hash = "sha256:8eb9b7f1ff3956ef0979e21bc83e6a885e40987b7199f195e46525d06e3ae402", size = 5098 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/ab/9bc1c12b88ccc252c66de9021b88766cb4223bfd10940da47aa41d7cc3e5/llama_index_multi_modal_llms_openai-0.2.0-py3-none-any.whl", hash = "sha256:b7eab7854861d5b390bab1376f5896c4813827ff67c7fe3b3eaaad1b5aecd7e3", size = 5869 },
+    { url = "https://files.pythonhosted.org/packages/c6/e2/3e2b639880baf5fd5ca0f88abd68719d2ed7af4d5076698cb5aff612505c/llama_index_multi_modal_llms_openai-0.2.3-py3-none-any.whl", hash = "sha256:96b36beb2c3fca4faca80c59ecf7c6c6629ecdb96c288ef89777b592ec43f872", size = 5886 },
 ]
 
 [[package]]
@@ -2310,7 +2400,7 @@ wheels = [
 
 [[package]]
 name = "llama-index-readers-file"
-version = "0.2.0"
+version = "0.2.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -2319,27 +2409,27 @@ dependencies = [
     { name = "pypdf" },
     { name = "striprtf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/07/87dac35a8274c10c9a4181dd9a33ef3fa4bd54550058886ef3f08690be4b/llama_index_readers_file-0.2.0.tar.gz", hash = "sha256:55db7c31666bab2b2dd2f762d622f2dc8e73933943c92f8838868a901e505708", size = 22672 }
+sdist = { url = "https://files.pythonhosted.org/packages/77/3b/e5b9fdef6f773aa0ba42cc2ced42f107412fd32bead6e938acb2702e9a9e/llama_index_readers_file-0.2.2.tar.gz", hash = "sha256:48459f90960b863737147b66ed83afec9ce8984f8eda2561b6d2500214365db2", size = 21936 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e9/a0/9e6b855ef8d365ac3241d1d8e3369f7b7987bdbb957b001821d86ea2cd34/llama_index_readers_file-0.2.0-py3-none-any.whl", hash = "sha256:d9e88eacb313fbc2325445760feab611c6ae1a95ec61f4c3aec11908ccb31536", size = 38876 },
+    { url = "https://files.pythonhosted.org/packages/ad/0c/9cb1a0cd5005a222502995f7fe804c3e03dfe1ef7c7e97da2237f4e26fef/llama_index_readers_file-0.2.2-py3-none-any.whl", hash = "sha256:ffec878771c1e7575afb742887561059bcca77b97a81c1c1be310ebb73f10f46", size = 38887 },
 ]
 
 [[package]]
 name = "llama-index-readers-llama-parse"
-version = "0.2.0"
+version = "0.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core" },
     { name = "llama-parse" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c8/76/e73dbf4377dd5992ef7d7e511c4483b7ce372a7abbf801e5e0766e66f604/llama_index_readers_llama_parse-0.2.0.tar.gz", hash = "sha256:c54e8a207d73efb9f011636a30a4c1076b43d77a34d2563d374dc67c0cddfc83", size = 2503 }
+sdist = { url = "https://files.pythonhosted.org/packages/04/33/dba0313ac42ca5082e2931a6d15ebfd2e0ffb34390da199639ef6ff378e3/llama_index_readers_llama_parse-0.3.0.tar.gz", hash = "sha256:a5feada0895714dcc41d65dd512c1c38cf70d8ae19947cff82b80d58e6aa367e", size = 2471 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/f3/8ab161ceab323f7d55f0d1288f2293c9530c6e992e8af354d1b5d6fa4731/llama_index_readers_llama_parse-0.2.0-py3-none-any.whl", hash = "sha256:c0cb103fac8cd0a6de62a1b71a56884bef99a2d55c3afcabb073f078e727494f", size = 2473 },
+    { url = "https://files.pythonhosted.org/packages/49/b2/174bb131b767f9873b9f95b6c216043ccde4cfbeb3bcaf01fa23594f810a/llama_index_readers_llama_parse-0.3.0-py3-none-any.whl", hash = "sha256:1973cc710dbd5e110c7500c9983ecb45787ad1ff92e6b2113f94a57cf48f3038", size = 2474 },
 ]
 
 [[package]]
 name = "llama-index-readers-web"
-version = "0.2.1"
+version = "0.2.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -2354,9 +2444,9 @@ dependencies = [
     { name = "spider-client" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/54/0a/28ff78a9bc1e01938d2bccd17758acb1f97c0e70fb5badddb0890ced4d9e/llama_index_readers_web-0.2.1.tar.gz", hash = "sha256:8bac9b8541487811c559e4f67d117723a15efda3e49daa35ad411b1c1298a706", size = 51512 }
+sdist = { url = "https://files.pythonhosted.org/packages/21/3b/cffc65023c5c19062d64438e7bdfbbdf64663603f45bf21e41d372d18e68/llama_index_readers_web-0.2.4.tar.gz", hash = "sha256:7fce3a98c3b3f7621a69161d92677abc69d535a8dd7a43a2411f8e369b0b741e", size = 53837 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/75/094f2ddd0f08fb3ee51024a233ff3b712a4667a0ec3c17f7071836604da3/llama_index_readers_web-0.2.1-py3-none-any.whl", hash = "sha256:8caec0ed223014d79200be2dff962ca265eca897c381115221cbfdaa3a6df2ec", size = 72928 },
+    { url = "https://files.pythonhosted.org/packages/ac/62/fcc840717af6760805739fe3f1c37e070fa321de1e142ecffb1d75784a71/llama_index_readers_web-0.2.4-py3-none-any.whl", hash = "sha256:02b13fa546aad5472bffdfc57fb9d074631b68406ebc908bf0bdec06daf7c90e", size = 76427 },
 ]
 
 [[package]]
@@ -2386,14 +2476,15 @@ wheels = [
 
 [[package]]
 name = "llama-parse"
-version = "0.5.1"
+version = "0.5.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "click" },
     { name = "llama-index-core" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/b2/eb796685a531f1889951ce35b11146730ef807ac23babe8641fd4872e64a/llama_parse-0.5.1.tar.gz", hash = "sha256:206c34814791e9644daed0da0fad504dcb6b6d52bda542a87bc081eda92700a0", size = 9760 }
+sdist = { url = "https://files.pythonhosted.org/packages/bb/8b/d784e42f3999a5278dd8a23de35f8fedef559eaa33bc188e42304d5b246b/llama_parse-0.5.12.tar.gz", hash = "sha256:e241606cf3574425df76c0f5d01a31a95c792c6fbef80aaf72f8ed6448bd1715", size = 13584 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/a5/bd03605cf7283900c263145a95d3886683430df032107d1ef17955174b30/llama_parse-0.5.1-py3-none-any.whl", hash = "sha256:615c5044876d59667840fb9c2f1f48f6639d5acb8fded832aea4cdfb90f92824", size = 9465 },
+    { url = "https://files.pythonhosted.org/packages/4a/80/ee558246d4a70bb401d768ab60d84001b6c1b7c5914236a4d1d8997fc5e2/llama_parse-0.5.12-py3-none-any.whl", hash = "sha256:6011feb49da5db4bcbeea1cc6688b6ff24b483877fda80b03fe59239cd08b907", size = 13059 },
 ]
 
 [[package]]
@@ -2493,14 +2584,14 @@ wheels = [
 
 [[package]]
 name = "mako"
-version = "1.3.5"
+version = "1.3.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markupsafe" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/67/03/fb5ba97ff65ce64f6d35b582aacffc26b693a98053fa831ab43a437cbddb/Mako-1.3.5.tar.gz", hash = "sha256:48dbc20568c1d276a2698b36d968fa76161bf127194907ea6fc594fa81f943bc", size = 392738 }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/0b/29bc5a230948bf209d3ed3165006d257e547c02c3c2a96f6286320dfe8dc/mako-1.3.6.tar.gz", hash = "sha256:9ec3a1583713479fae654f83ed9fa8c9a4c16b7bb0daba0e6bbebff50c0d983d", size = 390206 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/62/70f5a0c2dd208f9f3f2f9afd103aec42ee4d9ad2401d78342f75e9b8da36/Mako-1.3.5-py3-none-any.whl", hash = "sha256:260f1dbc3a519453a9c856dedfe4beb4e50bd5a26d96386cb6c80856556bb91a", size = 78565 },
+    { url = "https://files.pythonhosted.org/packages/48/22/bc14c6f02e6dccaafb3eba95764c8f096714260c2aa5f76f654fd16a23dd/Mako-1.3.6-py3-none-any.whl", hash = "sha256:a91198468092a2f1a0de86ca92690fb0cfc43ca90ee17e15d93662b4c04b241a", size = 78557 },
 ]
 
 [[package]]
@@ -2550,52 +2641,72 @@ wheels = [
 
 [[package]]
 name = "markupsafe"
-version = "2.1.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/87/5b/aae44c6655f3801e81aa3eef09dbbf012431987ba564d7231722f68df02d/MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b", size = 19384 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e4/54/ad5eb37bf9d51800010a74e4665425831a9db4e7c4e0fde4352e391e808e/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc", size = 18206 },
-    { url = "https://files.pythonhosted.org/packages/6a/4a/a4d49415e600bacae038c67f9fecc1d5433b9d3c71a4de6f33537b89654c/MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5", size = 14079 },
-    { url = "https://files.pythonhosted.org/packages/0a/7b/85681ae3c33c385b10ac0f8dd025c30af83c78cec1c37a6aa3b55e67f5ec/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46", size = 26620 },
-    { url = "https://files.pythonhosted.org/packages/7c/52/2b1b570f6b8b803cef5ac28fdf78c0da318916c7d2fe9402a84d591b394c/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f", size = 25818 },
-    { url = "https://files.pythonhosted.org/packages/29/fe/a36ba8c7ca55621620b2d7c585313efd10729e63ef81e4e61f52330da781/MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900", size = 25493 },
-    { url = "https://files.pythonhosted.org/packages/60/ae/9c60231cdfda003434e8bd27282b1f4e197ad5a710c14bee8bea8a9ca4f0/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff", size = 30630 },
-    { url = "https://files.pythonhosted.org/packages/65/dc/1510be4d179869f5dafe071aecb3f1f41b45d37c02329dfba01ff59e5ac5/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad", size = 29745 },
-    { url = "https://files.pythonhosted.org/packages/30/39/8d845dd7d0b0613d86e0ef89549bfb5f61ed781f59af45fc96496e897f3a/MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd", size = 30021 },
-    { url = "https://files.pythonhosted.org/packages/c7/5c/356a6f62e4f3c5fbf2602b4771376af22a3b16efa74eb8716fb4e328e01e/MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4", size = 16659 },
-    { url = "https://files.pythonhosted.org/packages/69/48/acbf292615c65f0604a0c6fc402ce6d8c991276e16c80c46a8f758fbd30c/MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5", size = 17213 },
-    { url = "https://files.pythonhosted.org/packages/11/e7/291e55127bb2ae67c64d66cef01432b5933859dfb7d6949daa721b89d0b3/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f", size = 18219 },
-    { url = "https://files.pythonhosted.org/packages/6b/cb/aed7a284c00dfa7c0682d14df85ad4955a350a21d2e3b06d8240497359bf/MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2", size = 14098 },
-    { url = "https://files.pythonhosted.org/packages/1c/cf/35fe557e53709e93feb65575c93927942087e9b97213eabc3fe9d5b25a55/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced", size = 29014 },
-    { url = "https://files.pythonhosted.org/packages/97/18/c30da5e7a0e7f4603abfc6780574131221d9148f323752c2755d48abad30/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5", size = 28220 },
-    { url = "https://files.pythonhosted.org/packages/0c/40/2e73e7d532d030b1e41180807a80d564eda53babaf04d65e15c1cf897e40/MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c", size = 27756 },
-    { url = "https://files.pythonhosted.org/packages/18/46/5dca760547e8c59c5311b332f70605d24c99d1303dd9a6e1fc3ed0d73561/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f", size = 33988 },
-    { url = "https://files.pythonhosted.org/packages/6d/c5/27febe918ac36397919cd4a67d5579cbbfa8da027fa1238af6285bb368ea/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a", size = 32718 },
-    { url = "https://files.pythonhosted.org/packages/f8/81/56e567126a2c2bc2684d6391332e357589a96a76cb9f8e5052d85cb0ead8/MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f", size = 33317 },
-    { url = "https://files.pythonhosted.org/packages/00/0b/23f4b2470accb53285c613a3ab9ec19dc944eaf53592cb6d9e2af8aa24cc/MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906", size = 16670 },
-    { url = "https://files.pythonhosted.org/packages/b7/a2/c78a06a9ec6d04b3445a949615c4c7ed86a0b2eb68e44e7541b9d57067cc/MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617", size = 17224 },
-    { url = "https://files.pythonhosted.org/packages/53/bd/583bf3e4c8d6a321938c13f49d44024dbe5ed63e0a7ba127e454a66da974/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1", size = 18215 },
-    { url = "https://files.pythonhosted.org/packages/48/d6/e7cd795fc710292c3af3a06d80868ce4b02bfbbf370b7cee11d282815a2a/MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4", size = 14069 },
-    { url = "https://files.pythonhosted.org/packages/51/b5/5d8ec796e2a08fc814a2c7d2584b55f889a55cf17dd1a90f2beb70744e5c/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee", size = 29452 },
-    { url = "https://files.pythonhosted.org/packages/0a/0d/2454f072fae3b5a137c119abf15465d1771319dfe9e4acbb31722a0fff91/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5", size = 28462 },
-    { url = "https://files.pythonhosted.org/packages/2d/75/fd6cb2e68780f72d47e6671840ca517bda5ef663d30ada7616b0462ad1e3/MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b", size = 27869 },
-    { url = "https://files.pythonhosted.org/packages/b0/81/147c477391c2750e8fc7705829f7351cf1cd3be64406edcf900dc633feb2/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a", size = 33906 },
-    { url = "https://files.pythonhosted.org/packages/8b/ff/9a52b71839d7a256b563e85d11050e307121000dcebc97df120176b3ad93/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f", size = 32296 },
-    { url = "https://files.pythonhosted.org/packages/88/07/2dc76aa51b481eb96a4c3198894f38b480490e834479611a4053fbf08623/MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169", size = 33038 },
-    { url = "https://files.pythonhosted.org/packages/96/0c/620c1fb3661858c0e37eb3cbffd8c6f732a67cd97296f725789679801b31/MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad", size = 16572 },
-    { url = "https://files.pythonhosted.org/packages/3f/14/c3554d512d5f9100a95e737502f4a2323a1959f6d0d01e0d0997b35f7b10/MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb", size = 17127 },
+version = "3.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/90/d08277ce111dd22f77149fd1a5d4653eeb3b3eaacbdfcbae5afb2600eebd/MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8", size = 14357 },
+    { url = "https://files.pythonhosted.org/packages/04/e1/6e2194baeae0bca1fae6629dc0cbbb968d4d941469cbab11a3872edff374/MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158", size = 12393 },
+    { url = "https://files.pythonhosted.org/packages/1d/69/35fa85a8ece0a437493dc61ce0bb6d459dcba482c34197e3efc829aa357f/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579", size = 21732 },
+    { url = "https://files.pythonhosted.org/packages/22/35/137da042dfb4720b638d2937c38a9c2df83fe32d20e8c8f3185dbfef05f7/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d", size = 20866 },
+    { url = "https://files.pythonhosted.org/packages/29/28/6d029a903727a1b62edb51863232152fd335d602def598dade38996887f0/MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb", size = 20964 },
+    { url = "https://files.pythonhosted.org/packages/cc/cd/07438f95f83e8bc028279909d9c9bd39e24149b0d60053a97b2bc4f8aa51/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b", size = 21977 },
+    { url = "https://files.pythonhosted.org/packages/29/01/84b57395b4cc062f9c4c55ce0df7d3108ca32397299d9df00fedd9117d3d/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c", size = 21366 },
+    { url = "https://files.pythonhosted.org/packages/bd/6e/61ebf08d8940553afff20d1fb1ba7294b6f8d279df9fd0c0db911b4bbcfd/MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171", size = 21091 },
+    { url = "https://files.pythonhosted.org/packages/11/23/ffbf53694e8c94ebd1e7e491de185124277964344733c45481f32ede2499/MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50", size = 15065 },
+    { url = "https://files.pythonhosted.org/packages/44/06/e7175d06dd6e9172d4a69a72592cb3f7a996a9c396eee29082826449bbc3/MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a", size = 15514 },
+    { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353 },
+    { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392 },
+    { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984 },
+    { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120 },
+    { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032 },
+    { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057 },
+    { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359 },
+    { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306 },
+    { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094 },
+    { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521 },
+    { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274 },
+    { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348 },
+    { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149 },
+    { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118 },
+    { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993 },
+    { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178 },
+    { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319 },
+    { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352 },
+    { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097 },
+    { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601 },
+    { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274 },
+    { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352 },
+    { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122 },
+    { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085 },
+    { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978 },
+    { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208 },
+    { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357 },
+    { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344 },
+    { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101 },
+    { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603 },
+    { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510 },
+    { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486 },
+    { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480 },
+    { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914 },
+    { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796 },
+    { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473 },
+    { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114 },
+    { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098 },
+    { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208 },
+    { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739 },
 ]
 
 [[package]]
 name = "marshmallow"
-version = "3.22.0"
+version = "3.23.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "packaging" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/40/faa10dc4500bca85f41ca9d8cefab282dd23d0fcc7a9b5fab40691e72e76/marshmallow-3.22.0.tar.gz", hash = "sha256:4972f529104a220bb8637d595aa4c9762afbe7f7a77d82dc58c1615d70c5823e", size = 176836 }
+sdist = { url = "https://files.pythonhosted.org/packages/b7/41/05580fed5798ba8032341e7e330b866adc88dfca3bc3ec86c04e4ffdc427/marshmallow-3.23.0.tar.gz", hash = "sha256:98d8827a9f10c03d44ead298d2e99c6aea8197df18ccfad360dae7f89a50da2e", size = 177439 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/78/c1de55eb3311f2c200a8b91724414b8d6f5ae78891c15d9d936ea43c3dba/marshmallow-3.22.0-py3-none-any.whl", hash = "sha256:71a2dce49ef901c3f97ed296ae5051135fd3febd2bf43afe0ae9a82143a494d9", size = 49334 },
+    { url = "https://files.pythonhosted.org/packages/9a/9e/f8f0308b66ff5fcc3b351ffa5fcba19ae725dfeda75d3c673f4427f3fc99/marshmallow-3.23.0-py3-none-any.whl", hash = "sha256:82f20a2397834fe6d9611b241f2f7e7b680ed89c49f84728a1ad937be6b4bdf4", size = 49490 },
 ]
 
 [[package]]
@@ -2612,14 +2723,14 @@ wheels = [
 
 [[package]]
 name = "mdit-py-plugins"
-version = "0.4.1"
+version = "0.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/00/6c/79c52651b22b64dba5c7bbabd7a294cc410bfb2353250dc8ade44d7d8ad8/mdit_py_plugins-0.4.1.tar.gz", hash = "sha256:834b8ac23d1cd60cec703646ffd22ae97b7955a6d596eb1d304be1e251ae499c", size = 42713 }
+sdist = { url = "https://files.pythonhosted.org/packages/19/03/a2ecab526543b152300717cf232bb4bb8605b6edb946c845016fa9c9c9fd/mdit_py_plugins-0.4.2.tar.gz", hash = "sha256:5f2cd1fdb606ddf152d37ec30e46101a60512bc0e5fa1a7002c36647b09e26b5", size = 43542 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/f7/8a4dcea720a581e69ac8c5a38524baf0e3e2bb5f3819a9ff661464fe7d10/mdit_py_plugins-0.4.1-py3-none-any.whl", hash = "sha256:1020dfe4e6bfc2c79fb49ae4e3f5b297f5ccd20f010187acc52af2921e27dc6a", size = 54794 },
+    { url = "https://files.pythonhosted.org/packages/a7/f7/7782a043553ee469c1ff49cfa1cdace2d6bf99a1f333cf38676b3ddf30da/mdit_py_plugins-0.4.2-py3-none-any.whl", hash = "sha256:0c673c3f889399a33b95e88d2f0d111b4447bdfea7f237dab2d488f459835636", size = 55316 },
 ]
 
 [[package]]
@@ -2633,32 +2744,33 @@ wheels = [
 
 [[package]]
 name = "mistralai"
-version = "1.0.3"
+version = "1.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "eval-type-backport" },
     { name = "httpx" },
     { name = "jsonpath-python" },
     { name = "pydantic" },
     { name = "python-dateutil" },
     { name = "typing-inspect" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ac/91/77c5de3c42c7eeea8fd8484ef614f722c78bfe9dc63e486e86adaec99cee/mistralai-1.0.3.tar.gz", hash = "sha256:84f1a217666c76fec9d477ae266399b813c3ac32a4a348d2ecd5fe1c039b0667", size = 110376 }
+sdist = { url = "https://files.pythonhosted.org/packages/f8/9c/4ea3ee3c8aac270e3d7fde9eb18c34209348f89815fbb356d04bf949e2aa/mistralai-1.1.0.tar.gz", hash = "sha256:9d1fe778e0e8c6ddab714e6a64c6096bd39cfe119ff38ceb5019d8e089df08ba", size = 117553 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/29/3d/4d0dcaf194bfcdf83e076d6609b26ea3a3474b7c9ad19fdca3977c1367c3/mistralai-1.0.3-py3-none-any.whl", hash = "sha256:64af7c9192e64dc66b2da6d1c4d54a1324a881c21665a2f93d6b35d9de9f87c8", size = 216251 },
+    { url = "https://files.pythonhosted.org/packages/64/9b/97d1f2f8fb4648008882284b2235d0b7b64b094ad4a4ee02c9c67c361578/mistralai-1.1.0-py3-none-any.whl", hash = "sha256:eea0938975195f331d0ded12d14e3c982f09f1b68210200ed4ff0c6b9b22d0fb", size = 229749 },
 ]
 
 [[package]]
 name = "msal"
-version = "1.30.0"
+version = "1.31.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cryptography" },
     { name = "pyjwt", extra = ["crypto"] },
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/03/ce/45b9af8f43fbbf34d15162e1e39ce34b675c234c56638277cc05562b6dbf/msal-1.30.0.tar.gz", hash = "sha256:b4bf00850092e465157d814efa24a18f788284c9a479491024d62903085ea2fb", size = 142510 }
+sdist = { url = "https://files.pythonhosted.org/packages/59/04/8d7aa5c671a26ca5612257fd419f97380ba89cdd231b2eb67df58483796d/msal-1.31.0.tar.gz", hash = "sha256:2c4f189cf9cc8f00c80045f66d39b7c0f3ed45873fd3d1f2af9f22db2e12ff4b", size = 144950 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ab/82/8f19334da43b7ef72d995587991a446f140346d76edb96a2c1a2689588e9/msal-1.30.0-py3-none-any.whl", hash = "sha256:423872177410cb61683566dc3932db7a76f661a5d2f6f52f02a047f101e1c1de", size = 111760 },
+    { url = "https://files.pythonhosted.org/packages/cd/40/0a5d743484e1ad00493bdffa8d10d7dbc6a51fec95290ad396e47e79fa43/msal-1.31.0-py3-none-any.whl", hash = "sha256:96bc37cff82ebe4b160d5fc0f1196f6ca8b50e274ecd0ec5bf69c438514086e7", size = 113109 },
 ]
 
 [[package]]
@@ -2728,56 +2840,74 @@ wheels = [
 
 [[package]]
 name = "multidict"
-version = "6.0.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/79/722ca999a3a09a63b35aac12ec27dfa8e5bb3a38b0f857f7a1a209a88836/multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da", size = 59867 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/36/48097b96135017ed1b806c5ea27b6cdc2ed3a6861c5372b793563206c586/multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9", size = 50955 },
-    { url = "https://files.pythonhosted.org/packages/d9/48/037440edb5d4a1c65e002925b2f24071d6c27754e6f4734f63037e3169d6/multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604", size = 30361 },
-    { url = "https://files.pythonhosted.org/packages/a4/eb/d8e7693c9064554a1585698d1902839440c6c695b0f53c9a8be5d9d4a3b8/multidict-6.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600", size = 30508 },
-    { url = "https://files.pythonhosted.org/packages/f3/7d/fe7648d4b2f200f8854066ce6e56bf51889abfaf859814c62160dd0e32a9/multidict-6.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c", size = 126318 },
-    { url = "https://files.pythonhosted.org/packages/8d/ea/0230b6faa9a5bc10650fd50afcc4a86e6c37af2fe05bc679b74d79253732/multidict-6.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5", size = 133998 },
-    { url = "https://files.pythonhosted.org/packages/36/6d/d2f982fb485175727a193b4900b5f929d461e7aa87d6fb5a91a377fcc9c0/multidict-6.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f", size = 129150 },
-    { url = "https://files.pythonhosted.org/packages/33/62/2c9085e571318d51212a6914566fe41dd0e33d7f268f7e2f23dcd3f06c56/multidict-6.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae", size = 124266 },
-    { url = "https://files.pythonhosted.org/packages/ce/e2/88cdfeaf03eab3498f688a19b62ca704d371cd904cb74b682541ca7b20a7/multidict-6.0.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182", size = 116637 },
-    { url = "https://files.pythonhosted.org/packages/12/4d/99dfc36872dcc53956879f5da80a6505bbd29214cce90ce792a86e15fddf/multidict-6.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf", size = 155908 },
-    { url = "https://files.pythonhosted.org/packages/c2/5c/1e76b2c742cb9e0248d1e8c4ed420817879230c833fa27d890b5fd22290b/multidict-6.0.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442", size = 147111 },
-    { url = "https://files.pythonhosted.org/packages/bc/84/9579004267e1cc5968ef2ef8718dab9d8950d99354d85b739dd67b09c273/multidict-6.0.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a", size = 160502 },
-    { url = "https://files.pythonhosted.org/packages/11/b7/bef33e84e3722bc42531af020d7ae8c31235ce8846bacaa852b6484cf868/multidict-6.0.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef", size = 156587 },
-    { url = "https://files.pythonhosted.org/packages/26/ce/f745a2d6104e56f7fa0d7d0756bb9ed27b771dd7b8d9d7348cd7f0f7b9de/multidict-6.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc", size = 151948 },
-    { url = "https://files.pythonhosted.org/packages/f1/50/714da64281d2b2b3b4068e84f115e1ef3bd3ed3715b39503ff3c59e8d30d/multidict-6.0.5-cp310-cp310-win32.whl", hash = "sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319", size = 25734 },
-    { url = "https://files.pythonhosted.org/packages/ef/3d/ba0dc18e96c5d83731c54129819d5892389e180f54ebb045c6124b2e8b87/multidict-6.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8", size = 28182 },
-    { url = "https://files.pythonhosted.org/packages/5f/da/b10ea65b850b54f44a6479177c6987f456bc2d38f8dc73009b78afcf0ede/multidict-6.0.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba", size = 50815 },
-    { url = "https://files.pythonhosted.org/packages/21/db/3403263f158b0bc7b0d4653766d71cb39498973f2042eead27b2e9758782/multidict-6.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e", size = 30269 },
-    { url = "https://files.pythonhosted.org/packages/02/c1/b15ecceb6ffa5081ed2ed450aea58d65b0e0358001f2b426705f9f41f4c2/multidict-6.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd", size = 30500 },
-    { url = "https://files.pythonhosted.org/packages/3f/e1/7fdd0f39565df3af87d6c2903fb66a7d529fbd0a8a066045d7a5b6ad1145/multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3", size = 130751 },
-    { url = "https://files.pythonhosted.org/packages/76/bc/9f593f9e38c6c09bbf0344b56ad67dd53c69167937c2edadee9719a5e17d/multidict-6.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf", size = 138185 },
-    { url = "https://files.pythonhosted.org/packages/28/32/d7799a208701d537b92705f46c777ded812a6dc139c18d8ed599908f6b1c/multidict-6.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29", size = 133585 },
-    { url = "https://files.pythonhosted.org/packages/52/ec/be54a3ad110f386d5bd7a9a42a4ff36b3cd723ebe597f41073a73ffa16b8/multidict-6.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed", size = 128684 },
-    { url = "https://files.pythonhosted.org/packages/36/e1/a680eabeb71e25d4733276d917658dfa1cd3a99b1223625dbc247d266c98/multidict-6.0.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733", size = 120994 },
-    { url = "https://files.pythonhosted.org/packages/ef/08/08f4f44a8a43ea4cee13aa9cdbbf4a639af8db49310a0637ca389c4cf817/multidict-6.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f", size = 159689 },
-    { url = "https://files.pythonhosted.org/packages/aa/a9/46cdb4cb40bbd4b732169413f56b04a6553460b22bd914f9729c9ba63761/multidict-6.0.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4", size = 150611 },
-    { url = "https://files.pythonhosted.org/packages/e9/32/35668bb3e6ab2f12f4e4f7f4000f72f714882a94f904d4c3633fbd036753/multidict-6.0.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1", size = 164444 },
-    { url = "https://files.pythonhosted.org/packages/fa/10/f1388a91552af732d8ec48dab928abc209e732767e9e8f92d24c3544353c/multidict-6.0.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc", size = 160158 },
-    { url = "https://files.pythonhosted.org/packages/14/c3/f602601f1819983e018156e728e57b3f19726cb424b543667faab82f6939/multidict-6.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e", size = 156072 },
-    { url = "https://files.pythonhosted.org/packages/82/a6/0290af8487326108c0d03d14f8a0b8b1001d71e4494df5f96ab0c88c0b88/multidict-6.0.5-cp311-cp311-win32.whl", hash = "sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c", size = 25731 },
-    { url = "https://files.pythonhosted.org/packages/88/aa/ea217cb18325aa05cb3e3111c19715f1e97c50a4a900cbc20e54648de5f5/multidict-6.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea", size = 28176 },
-    { url = "https://files.pythonhosted.org/packages/90/9c/7fda9c0defa09538c97b1f195394be82a1f53238536f70b32eb5399dfd4e/multidict-6.0.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e", size = 49575 },
-    { url = "https://files.pythonhosted.org/packages/be/21/d6ca80dd1b9b2c5605ff7475699a8ff5dc6ea958cd71fb2ff234afc13d79/multidict-6.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b", size = 29638 },
-    { url = "https://files.pythonhosted.org/packages/9c/18/9565f32c19d186168731e859692dfbc0e98f66a1dcf9e14d69c02a78b75a/multidict-6.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5", size = 29874 },
-    { url = "https://files.pythonhosted.org/packages/4e/4e/3815190e73e6ef101b5681c174c541bf972a1b064e926e56eea78d06e858/multidict-6.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450", size = 129914 },
-    { url = "https://files.pythonhosted.org/packages/0c/08/bb47f886457e2259aefc10044e45c8a1b62f0c27228557e17775869d0341/multidict-6.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496", size = 134589 },
-    { url = "https://files.pythonhosted.org/packages/d5/2f/952f79b5f0795cf4e34852fc5cf4dfda6166f63c06c798361215b69c131d/multidict-6.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a", size = 133259 },
-    { url = "https://files.pythonhosted.org/packages/24/1f/af976383b0b772dd351210af5b60ff9927e3abb2f4a103e93da19a957da0/multidict-6.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226", size = 130779 },
-    { url = "https://files.pythonhosted.org/packages/fc/b1/b0a7744be00b0f5045c7ed4e4a6b8ee6bde4672b2c620474712299df5979/multidict-6.0.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271", size = 120125 },
-    { url = "https://files.pythonhosted.org/packages/d0/bf/2a1d667acf11231cdf0b97a6cd9f30e7a5cf847037b5cf6da44884284bd0/multidict-6.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb", size = 167095 },
-    { url = "https://files.pythonhosted.org/packages/5e/e8/ad6ee74b1a2050d3bc78f566dabcc14c8bf89cbe87eecec866c011479815/multidict-6.0.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef", size = 155823 },
-    { url = "https://files.pythonhosted.org/packages/45/7c/06926bb91752c52abca3edbfefac1ea90d9d1bc00c84d0658c137589b920/multidict-6.0.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24", size = 170233 },
-    { url = "https://files.pythonhosted.org/packages/3c/29/3dd36cf6b9c5abba8b97bba84eb499a168ba59c3faec8829327b3887d123/multidict-6.0.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6", size = 169035 },
-    { url = "https://files.pythonhosted.org/packages/60/47/9a0f43470c70bbf6e148311f78ef5a3d4996b0226b6d295bdd50fdcfe387/multidict-6.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda", size = 166229 },
-    { url = "https://files.pythonhosted.org/packages/1d/23/c1b7ae7a0b8a3e08225284ef3ecbcf014b292a3ee821bc4ed2185fd4ce7d/multidict-6.0.5-cp312-cp312-win32.whl", hash = "sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5", size = 25840 },
-    { url = "https://files.pythonhosted.org/packages/4a/68/66fceb758ad7a88993940dbdf3ac59911ba9dc46d7798bf6c8652f89f853/multidict-6.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556", size = 27905 },
-    { url = "https://files.pythonhosted.org/packages/fa/a2/17e1e23c6be0a916219c5292f509360c345b5fa6beeb50d743203c27532c/multidict-6.0.5-py3-none-any.whl", hash = "sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7", size = 9729 },
+version = "6.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d6/be/504b89a5e9ca731cd47487e91c469064f8ae5af93b7259758dcfc2b9c848/multidict-6.1.0.tar.gz", hash = "sha256:22ae2ebf9b0c69d206c003e2f6a914ea33f0a932d4aa16f236afc049d9958f4a", size = 64002 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/29/68/259dee7fd14cf56a17c554125e534f6274c2860159692a414d0b402b9a6d/multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60", size = 48628 },
+    { url = "https://files.pythonhosted.org/packages/50/79/53ba256069fe5386a4a9e80d4e12857ced9de295baf3e20c68cdda746e04/multidict-6.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:99f826cbf970077383d7de805c0681799491cb939c25450b9b5b3ced03ca99f1", size = 29327 },
+    { url = "https://files.pythonhosted.org/packages/ff/10/71f1379b05b196dae749b5ac062e87273e3f11634f447ebac12a571d90ae/multidict-6.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a114d03b938376557927ab23f1e950827c3b893ccb94b62fd95d430fd0e5cf53", size = 29689 },
+    { url = "https://files.pythonhosted.org/packages/71/45/70bac4f87438ded36ad4793793c0095de6572d433d98575a5752629ef549/multidict-6.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b1c416351ee6271b2f49b56ad7f308072f6f44b37118d69c2cad94f3fa8a40d5", size = 126639 },
+    { url = "https://files.pythonhosted.org/packages/80/cf/17f35b3b9509b4959303c05379c4bfb0d7dd05c3306039fc79cf035bbac0/multidict-6.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b5d83030255983181005e6cfbac1617ce9746b219bc2aad52201ad121226581", size = 134315 },
+    { url = "https://files.pythonhosted.org/packages/ef/1f/652d70ab5effb33c031510a3503d4d6efc5ec93153562f1ee0acdc895a57/multidict-6.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3e97b5e938051226dc025ec80980c285b053ffb1e25a3db2a3aa3bc046bf7f56", size = 129471 },
+    { url = "https://files.pythonhosted.org/packages/a6/64/2dd6c4c681688c0165dea3975a6a4eab4944ea30f35000f8b8af1df3148c/multidict-6.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d618649d4e70ac6efcbba75be98b26ef5078faad23592f9b51ca492953012429", size = 124585 },
+    { url = "https://files.pythonhosted.org/packages/87/56/e6ee5459894c7e554b57ba88f7257dc3c3d2d379cb15baaa1e265b8c6165/multidict-6.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10524ebd769727ac77ef2278390fb0068d83f3acb7773792a5080f2b0abf7748", size = 116957 },
+    { url = "https://files.pythonhosted.org/packages/36/9e/616ce5e8d375c24b84f14fc263c7ef1d8d5e8ef529dbc0f1df8ce71bb5b8/multidict-6.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ff3827aef427c89a25cc96ded1759271a93603aba9fb977a6d264648ebf989db", size = 128609 },
+    { url = "https://files.pythonhosted.org/packages/8c/4f/4783e48a38495d000f2124020dc96bacc806a4340345211b1ab6175a6cb4/multidict-6.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:06809f4f0f7ab7ea2cabf9caca7d79c22c0758b58a71f9d32943ae13c7ace056", size = 123016 },
+    { url = "https://files.pythonhosted.org/packages/3e/b3/4950551ab8fc39862ba5e9907dc821f896aa829b4524b4deefd3e12945ab/multidict-6.1.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f179dee3b863ab1c59580ff60f9d99f632f34ccb38bf67a33ec6b3ecadd0fd76", size = 133542 },
+    { url = "https://files.pythonhosted.org/packages/96/4d/f0ce6ac9914168a2a71df117935bb1f1781916acdecbb43285e225b484b8/multidict-6.1.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:aaed8b0562be4a0876ee3b6946f6869b7bcdb571a5d1496683505944e268b160", size = 130163 },
+    { url = "https://files.pythonhosted.org/packages/be/72/17c9f67e7542a49dd252c5ae50248607dfb780bcc03035907dafefb067e3/multidict-6.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3c8b88a2ccf5493b6c8da9076fb151ba106960a2df90c2633f342f120751a9e7", size = 126832 },
+    { url = "https://files.pythonhosted.org/packages/71/9f/72d719e248cbd755c8736c6d14780533a1606ffb3fbb0fbd77da9f0372da/multidict-6.1.0-cp310-cp310-win32.whl", hash = "sha256:4a9cb68166a34117d6646c0023c7b759bf197bee5ad4272f420a0141d7eb03a0", size = 26402 },
+    { url = "https://files.pythonhosted.org/packages/04/5a/d88cd5d00a184e1ddffc82aa2e6e915164a6d2641ed3606e766b5d2f275a/multidict-6.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:20b9b5fbe0b88d0bdef2012ef7dee867f874b72528cf1d08f1d59b0e3850129d", size = 28800 },
+    { url = "https://files.pythonhosted.org/packages/93/13/df3505a46d0cd08428e4c8169a196131d1b0c4b515c3649829258843dde6/multidict-6.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3efe2c2cb5763f2f1b275ad2bf7a287d3f7ebbef35648a9726e3b69284a4f3d6", size = 48570 },
+    { url = "https://files.pythonhosted.org/packages/f0/e1/a215908bfae1343cdb72f805366592bdd60487b4232d039c437fe8f5013d/multidict-6.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7053d3b0353a8b9de430a4f4b4268ac9a4fb3481af37dfe49825bf45ca24156", size = 29316 },
+    { url = "https://files.pythonhosted.org/packages/70/0f/6dc70ddf5d442702ed74f298d69977f904960b82368532c88e854b79f72b/multidict-6.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:27e5fc84ccef8dfaabb09d82b7d179c7cf1a3fbc8a966f8274fcb4ab2eb4cadb", size = 29640 },
+    { url = "https://files.pythonhosted.org/packages/d8/6d/9c87b73a13d1cdea30b321ef4b3824449866bd7f7127eceed066ccb9b9ff/multidict-6.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2b90b43e696f25c62656389d32236e049568b39320e2735d51f08fd362761b", size = 131067 },
+    { url = "https://files.pythonhosted.org/packages/cc/1e/1b34154fef373371fd6c65125b3d42ff5f56c7ccc6bfff91b9b3c60ae9e0/multidict-6.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d83a047959d38a7ff552ff94be767b7fd79b831ad1cd9920662db05fec24fe72", size = 138507 },
+    { url = "https://files.pythonhosted.org/packages/fb/e0/0bc6b2bac6e461822b5f575eae85da6aae76d0e2a79b6665d6206b8e2e48/multidict-6.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1a9dd711d0877a1ece3d2e4fea11a8e75741ca21954c919406b44e7cf971304", size = 133905 },
+    { url = "https://files.pythonhosted.org/packages/ba/af/73d13b918071ff9b2205fcf773d316e0f8fefb4ec65354bbcf0b10908cc6/multidict-6.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec2abea24d98246b94913b76a125e855eb5c434f7c46546046372fe60f666351", size = 129004 },
+    { url = "https://files.pythonhosted.org/packages/74/21/23960627b00ed39643302d81bcda44c9444ebcdc04ee5bedd0757513f259/multidict-6.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4867cafcbc6585e4b678876c489b9273b13e9fff9f6d6d66add5e15d11d926cb", size = 121308 },
+    { url = "https://files.pythonhosted.org/packages/8b/5c/cf282263ffce4a596ed0bb2aa1a1dddfe1996d6a62d08842a8d4b33dca13/multidict-6.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b48204e8d955c47c55b72779802b219a39acc3ee3d0116d5080c388970b76e3", size = 132608 },
+    { url = "https://files.pythonhosted.org/packages/d7/3e/97e778c041c72063f42b290888daff008d3ab1427f5b09b714f5a8eff294/multidict-6.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d8fff389528cad1618fb4b26b95550327495462cd745d879a8c7c2115248e399", size = 127029 },
+    { url = "https://files.pythonhosted.org/packages/47/ac/3efb7bfe2f3aefcf8d103e9a7162572f01936155ab2f7ebcc7c255a23212/multidict-6.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a7a9541cd308eed5e30318430a9c74d2132e9a8cb46b901326272d780bf2d423", size = 137594 },
+    { url = "https://files.pythonhosted.org/packages/42/9b/6c6e9e8dc4f915fc90a9b7798c44a30773dea2995fdcb619870e705afe2b/multidict-6.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:da1758c76f50c39a2efd5e9859ce7d776317eb1dd34317c8152ac9251fc574a3", size = 134556 },
+    { url = "https://files.pythonhosted.org/packages/1d/10/8e881743b26aaf718379a14ac58572a240e8293a1c9d68e1418fb11c0f90/multidict-6.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c943a53e9186688b45b323602298ab727d8865d8c9ee0b17f8d62d14b56f0753", size = 130993 },
+    { url = "https://files.pythonhosted.org/packages/45/84/3eb91b4b557442802d058a7579e864b329968c8d0ea57d907e7023c677f2/multidict-6.1.0-cp311-cp311-win32.whl", hash = "sha256:90f8717cb649eea3504091e640a1b8568faad18bd4b9fcd692853a04475a4b80", size = 26405 },
+    { url = "https://files.pythonhosted.org/packages/9f/0b/ad879847ecbf6d27e90a6eabb7eff6b62c129eefe617ea45eae7c1f0aead/multidict-6.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:82176036e65644a6cc5bd619f65f6f19781e8ec2e5330f51aa9ada7504cc1926", size = 28795 },
+    { url = "https://files.pythonhosted.org/packages/fd/16/92057c74ba3b96d5e211b553895cd6dc7cc4d1e43d9ab8fafc727681ef71/multidict-6.1.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b04772ed465fa3cc947db808fa306d79b43e896beb677a56fb2347ca1a49c1fa", size = 48713 },
+    { url = "https://files.pythonhosted.org/packages/94/3d/37d1b8893ae79716179540b89fc6a0ee56b4a65fcc0d63535c6f5d96f217/multidict-6.1.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6180c0ae073bddeb5a97a38c03f30c233e0a4d39cd86166251617d1bbd0af436", size = 29516 },
+    { url = "https://files.pythonhosted.org/packages/a2/12/adb6b3200c363062f805275b4c1e656be2b3681aada66c80129932ff0bae/multidict-6.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:071120490b47aa997cca00666923a83f02c7fbb44f71cf7f136df753f7fa8761", size = 29557 },
+    { url = "https://files.pythonhosted.org/packages/47/e9/604bb05e6e5bce1e6a5cf80a474e0f072e80d8ac105f1b994a53e0b28c42/multidict-6.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50b3a2710631848991d0bf7de077502e8994c804bb805aeb2925a981de58ec2e", size = 130170 },
+    { url = "https://files.pythonhosted.org/packages/7e/13/9efa50801785eccbf7086b3c83b71a4fb501a4d43549c2f2f80b8787d69f/multidict-6.1.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b58c621844d55e71c1b7f7c498ce5aa6985d743a1a59034c57a905b3f153c1ef", size = 134836 },
+    { url = "https://files.pythonhosted.org/packages/bf/0f/93808b765192780d117814a6dfcc2e75de6dcc610009ad408b8814dca3ba/multidict-6.1.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55b6d90641869892caa9ca42ff913f7ff1c5ece06474fbd32fb2cf6834726c95", size = 133475 },
+    { url = "https://files.pythonhosted.org/packages/d3/c8/529101d7176fe7dfe1d99604e48d69c5dfdcadb4f06561f465c8ef12b4df/multidict-6.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b820514bfc0b98a30e3d85462084779900347e4d49267f747ff54060cc33925", size = 131049 },
+    { url = "https://files.pythonhosted.org/packages/ca/0c/fc85b439014d5a58063e19c3a158a889deec399d47b5269a0f3b6a2e28bc/multidict-6.1.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:10a9b09aba0c5b48c53761b7c720aaaf7cf236d5fe394cd399c7ba662d5f9966", size = 120370 },
+    { url = "https://files.pythonhosted.org/packages/db/46/d4416eb20176492d2258fbd47b4abe729ff3b6e9c829ea4236f93c865089/multidict-6.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e16bf3e5fc9f44632affb159d30a437bfe286ce9e02754759be5536b169b305", size = 125178 },
+    { url = "https://files.pythonhosted.org/packages/5b/46/73697ad7ec521df7de5531a32780bbfd908ded0643cbe457f981a701457c/multidict-6.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:76f364861c3bfc98cbbcbd402d83454ed9e01a5224bb3a28bf70002a230f73e2", size = 119567 },
+    { url = "https://files.pythonhosted.org/packages/cd/ed/51f060e2cb0e7635329fa6ff930aa5cffa17f4c7f5c6c3ddc3500708e2f2/multidict-6.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:820c661588bd01a0aa62a1283f20d2be4281b086f80dad9e955e690c75fb54a2", size = 129822 },
+    { url = "https://files.pythonhosted.org/packages/df/9e/ee7d1954b1331da3eddea0c4e08d9142da5f14b1321c7301f5014f49d492/multidict-6.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0e5f362e895bc5b9e67fe6e4ded2492d8124bdf817827f33c5b46c2fe3ffaca6", size = 128656 },
+    { url = "https://files.pythonhosted.org/packages/77/00/8538f11e3356b5d95fa4b024aa566cde7a38aa7a5f08f4912b32a037c5dc/multidict-6.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ec660d19bbc671e3a6443325f07263be452c453ac9e512f5eb935e7d4ac28b3", size = 125360 },
+    { url = "https://files.pythonhosted.org/packages/be/05/5d334c1f2462d43fec2363cd00b1c44c93a78c3925d952e9a71caf662e96/multidict-6.1.0-cp312-cp312-win32.whl", hash = "sha256:58130ecf8f7b8112cdb841486404f1282b9c86ccb30d3519faf301b2e5659133", size = 26382 },
+    { url = "https://files.pythonhosted.org/packages/a3/bf/f332a13486b1ed0496d624bcc7e8357bb8053823e8cd4b9a18edc1d97e73/multidict-6.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:188215fc0aafb8e03341995e7c4797860181562380f81ed0a87ff455b70bf1f1", size = 28529 },
+    { url = "https://files.pythonhosted.org/packages/22/67/1c7c0f39fe069aa4e5d794f323be24bf4d33d62d2a348acdb7991f8f30db/multidict-6.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d569388c381b24671589335a3be6e1d45546c2988c2ebe30fdcada8457a31008", size = 48771 },
+    { url = "https://files.pythonhosted.org/packages/3c/25/c186ee7b212bdf0df2519eacfb1981a017bda34392c67542c274651daf23/multidict-6.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:052e10d2d37810b99cc170b785945421141bf7bb7d2f8799d431e7db229c385f", size = 29533 },
+    { url = "https://files.pythonhosted.org/packages/67/5e/04575fd837e0958e324ca035b339cea174554f6f641d3fb2b4f2e7ff44a2/multidict-6.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f90c822a402cb865e396a504f9fc8173ef34212a342d92e362ca498cad308e28", size = 29595 },
+    { url = "https://files.pythonhosted.org/packages/d3/b2/e56388f86663810c07cfe4a3c3d87227f3811eeb2d08450b9e5d19d78876/multidict-6.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b225d95519a5bf73860323e633a664b0d85ad3d5bede6d30d95b35d4dfe8805b", size = 130094 },
+    { url = "https://files.pythonhosted.org/packages/6c/ee/30ae9b4186a644d284543d55d491fbd4239b015d36b23fea43b4c94f7052/multidict-6.1.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:23bfd518810af7de1116313ebd9092cb9aa629beb12f6ed631ad53356ed6b86c", size = 134876 },
+    { url = "https://files.pythonhosted.org/packages/84/c7/70461c13ba8ce3c779503c70ec9d0345ae84de04521c1f45a04d5f48943d/multidict-6.1.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c09fcfdccdd0b57867577b719c69e347a436b86cd83747f179dbf0cc0d4c1f3", size = 133500 },
+    { url = "https://files.pythonhosted.org/packages/4a/9f/002af221253f10f99959561123fae676148dd730e2daa2cd053846a58507/multidict-6.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf6bea52ec97e95560af5ae576bdac3aa3aae0b6758c6efa115236d9e07dae44", size = 131099 },
+    { url = "https://files.pythonhosted.org/packages/82/42/d1c7a7301d52af79d88548a97e297f9d99c961ad76bbe6f67442bb77f097/multidict-6.1.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57feec87371dbb3520da6192213c7d6fc892d5589a93db548331954de8248fd2", size = 120403 },
+    { url = "https://files.pythonhosted.org/packages/68/f3/471985c2c7ac707547553e8f37cff5158030d36bdec4414cb825fbaa5327/multidict-6.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0c3f390dc53279cbc8ba976e5f8035eab997829066756d811616b652b00a23a3", size = 125348 },
+    { url = "https://files.pythonhosted.org/packages/67/2c/e6df05c77e0e433c214ec1d21ddd203d9a4770a1f2866a8ca40a545869a0/multidict-6.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:59bfeae4b25ec05b34f1956eaa1cb38032282cd4dfabc5056d0a1ec4d696d3aa", size = 119673 },
+    { url = "https://files.pythonhosted.org/packages/c5/cd/bc8608fff06239c9fb333f9db7743a1b2eafe98c2666c9a196e867a3a0a4/multidict-6.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b2f59caeaf7632cc633b5cf6fc449372b83bbdf0da4ae04d5be36118e46cc0aa", size = 129927 },
+    { url = "https://files.pythonhosted.org/packages/44/8e/281b69b7bc84fc963a44dc6e0bbcc7150e517b91df368a27834299a526ac/multidict-6.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:37bb93b2178e02b7b618893990941900fd25b6b9ac0fa49931a40aecdf083fe4", size = 128711 },
+    { url = "https://files.pythonhosted.org/packages/12/a4/63e7cd38ed29dd9f1881d5119f272c898ca92536cdb53ffe0843197f6c85/multidict-6.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4e9f48f58c2c523d5a06faea47866cd35b32655c46b443f163d08c6d0ddb17d6", size = 125519 },
+    { url = "https://files.pythonhosted.org/packages/38/e0/4f5855037a72cd8a7a2f60a3952d9aa45feedb37ae7831642102604e8a37/multidict-6.1.0-cp313-cp313-win32.whl", hash = "sha256:3a37ffb35399029b45c6cc33640a92bef403c9fd388acce75cdc88f58bd19a81", size = 26426 },
+    { url = "https://files.pythonhosted.org/packages/7e/a5/17ee3a4db1e310b7405f5d25834460073a8ccd86198ce044dfaf69eac073/multidict-6.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:e9aa71e15d9d9beaad2c6b9319edcdc0a49a43ef5c0a4c8265ca9ee7d6c67774", size = 28531 },
+    { url = "https://files.pythonhosted.org/packages/99/b7/b9e70fde2c0f0c9af4cc5277782a89b66d35948ea3369ec9f598358c3ac5/multidict-6.1.0-py3-none-any.whl", hash = "sha256:48e171e52d1c4d33888e529b999e5900356b9ae588c2f09a52dcefb158b27506", size = 10051 },
 ]
 
 [[package]]
@@ -2925,11 +3055,11 @@ wheels = [
 
 [[package]]
 name = "networkx"
-version = "3.3"
+version = "3.4.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/04/e6/b164f94c869d6b2c605b5128b7b0cfe912795a87fc90e78533920001f3ec/networkx-3.3.tar.gz", hash = "sha256:0c127d8b2f4865f59ae9cb8aafcd60b5c70f3241ebd66f7defad7c4ab90126c9", size = 2126579 }
+sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/38/e9/5f72929373e1a0e8d142a130f3f97e6ff920070f87f91c4e13e40e0fba5a/networkx-3.3-py3-none-any.whl", hash = "sha256:28575580c6ebdaf4505b22c6256a2b9de86b316dc63ba9e93abde3d78dfdbcf2", size = 1702396 },
+    { url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 },
 ]
 
 [[package]]
@@ -3014,7 +3144,7 @@ wheels = [
 
 [[package]]
 name = "openai"
-version = "1.43.0"
+version = "1.52.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -3026,9 +3156,9 @@ dependencies = [
     { name = "tqdm" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/41/80/9390645de4e76bf8195073f23029a9b54cd13b4294e3a5bcb56e4df1aafc/openai-1.43.0.tar.gz", hash = "sha256:e607aff9fc3e28eade107e5edd8ca95a910a4b12589336d3cbb6bfe2ac306b3c", size = 292477 }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/78/1c4658043cdbb7faf7f388cbb3902d5f8b9a307e10f2021b1a8a4b0b8b15/openai-1.52.2.tar.gz", hash = "sha256:87b7d0f69d85f5641678d414b7ee3082363647a5c66a462ed7f3ccb59582da0d", size = 310119 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/4d/affea11bd85ca69d9fdd15567495bb9088ac1c37498c95cb42d9ecd984ed/openai-1.43.0-py3-none-any.whl", hash = "sha256:1a748c2728edd3a738a72a0212ba866f4fdbe39c9ae03813508b267d45104abe", size = 365744 },
+    { url = "https://files.pythonhosted.org/packages/55/4c/906b5b32c4c01402ac3b4c3fc28f601443ac5c6f13c84a95dd178c8d545d/openai-1.52.2-py3-none-any.whl", hash = "sha256:57e9e37bc407f39bb6ec3a27d7e8fb9728b2779936daa1fcf95df17d3edfaccc", size = 386947 },
 ]
 
 [[package]]
@@ -3085,46 +3215,47 @@ wheels = [
 
 [[package]]
 name = "orjson"
-version = "3.10.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9e/03/821c8197d0515e46ea19439f5c5d5fd9a9889f76800613cfac947b5d7845/orjson-3.10.7.tar.gz", hash = "sha256:75ef0640403f945f3a1f9f6400686560dbfb0fb5b16589ad62cd477043c4eee3", size = 5056450 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/49/12/60931cf808b9334f26210ab496442f4a7a3d66e29d1cf12e0a01857e756f/orjson-3.10.7-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:74f4544f5a6405b90da8ea724d15ac9c36da4d72a738c64685003337401f5c12", size = 251312 },
-    { url = "https://files.pythonhosted.org/packages/fe/0e/efbd0a2d25f8e82b230eb20b6b8424be6dd95b6811b669be9af16234b6db/orjson-3.10.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:34a566f22c28222b08875b18b0dfbf8a947e69df21a9ed5c51a6bf91cfb944ac", size = 148124 },
-    { url = "https://files.pythonhosted.org/packages/dd/47/1ddff6e23fe5f4aeaaed996a3cde422b3eaac4558c03751723e106184c68/orjson-3.10.7-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf6ba8ebc8ef5792e2337fb0419f8009729335bb400ece005606336b7fd7bab7", size = 147277 },
-    { url = "https://files.pythonhosted.org/packages/04/da/d03d72b54bdd60d05de372114abfbd9f05050946895140c6ff5f27ab8f49/orjson-3.10.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac7cf6222b29fbda9e3a472b41e6a5538b48f2c8f99261eecd60aafbdb60690c", size = 152955 },
-    { url = "https://files.pythonhosted.org/packages/7f/7e/ef8522dbba112af6cc52227dcc746dd3447c7d53ea8cea35740239b547ee/orjson-3.10.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:de817e2f5fc75a9e7dd350c4b0f54617b280e26d1631811a43e7e968fa71e3e9", size = 163955 },
-    { url = "https://files.pythonhosted.org/packages/b6/bc/fbd345d771a73cacc5b0e774d034cd081590b336754c511f4ead9fdc4cf1/orjson-3.10.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:348bdd16b32556cf8d7257b17cf2bdb7ab7976af4af41ebe79f9796c218f7e91", size = 141896 },
-    { url = "https://files.pythonhosted.org/packages/82/0a/1f09c12d15b1e83156b7f3f621561d38650fe5b8f39f38f04a64de1a87fc/orjson-3.10.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:479fd0844ddc3ca77e0fd99644c7fe2de8e8be1efcd57705b5c92e5186e8a250", size = 170166 },
-    { url = "https://files.pythonhosted.org/packages/a6/d8/eee30caba21a8d6a9df06d2519bb0ecd0adbcd57f2e79d360de5570031cf/orjson-3.10.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:fdf5197a21dd660cf19dfd2a3ce79574588f8f5e2dbf21bda9ee2d2b46924d84", size = 167804 },
-    { url = "https://files.pythonhosted.org/packages/44/fe/d1d89d3f15e343511417195f6ccd2bdeb7ebc5a48a882a79ab3bbcdf5fc7/orjson-3.10.7-cp310-none-win32.whl", hash = "sha256:d374d36726746c81a49f3ff8daa2898dccab6596864ebe43d50733275c629175", size = 143010 },
-    { url = "https://files.pythonhosted.org/packages/88/8c/0e7b8d5a523927774758ac4ce2de4d8ca5dda569955ba3aeb5e208344eda/orjson-3.10.7-cp310-none-win_amd64.whl", hash = "sha256:cb61938aec8b0ffb6eef484d480188a1777e67b05d58e41b435c74b9d84e0b9c", size = 137306 },
-    { url = "https://files.pythonhosted.org/packages/89/c9/dd286c97c2f478d43839bd859ca4d9820e2177d4e07a64c516dc3e018062/orjson-3.10.7-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:7db8539039698ddfb9a524b4dd19508256107568cdad24f3682d5773e60504a2", size = 251312 },
-    { url = "https://files.pythonhosted.org/packages/b9/72/d90bd11e83a0e9623b3803b079478a93de8ec4316c98fa66110d594de5fa/orjson-3.10.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:480f455222cb7a1dea35c57a67578848537d2602b46c464472c995297117fa09", size = 148125 },
-    { url = "https://files.pythonhosted.org/packages/9d/b6/ed61e87f327a4cbb2075ed0716e32ba68cb029aa654a68c3eb27803050d8/orjson-3.10.7-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8a9c9b168b3a19e37fe2778c0003359f07822c90fdff8f98d9d2a91b3144d8e0", size = 147278 },
-    { url = "https://files.pythonhosted.org/packages/66/9f/e6a11b5d1ad11e9dc869d938707ef93ff5ed20b53d6cda8b5e2ac532a9d2/orjson-3.10.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8de062de550f63185e4c1c54151bdddfc5625e37daf0aa1e75d2a1293e3b7d9a", size = 152954 },
-    { url = "https://files.pythonhosted.org/packages/92/ee/702d5e8ccd42dc2b9d1043f22daa1ba75165616aa021dc19fb0c5a726ce8/orjson-3.10.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6b0dd04483499d1de9c8f6203f8975caf17a6000b9c0c54630cef02e44ee624e", size = 163953 },
-    { url = "https://files.pythonhosted.org/packages/d3/cb/55205f3f1ee6ba80c0a9a18ca07423003ca8de99192b18be30f1f31b4cdd/orjson-3.10.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b58d3795dafa334fc8fd46f7c5dc013e6ad06fd5b9a4cc98cb1456e7d3558bd6", size = 141895 },
-    { url = "https://files.pythonhosted.org/packages/bb/ab/1185e472f15c00d37d09c395e478803ed0eae7a3a3d055a5f3885e1ea136/orjson-3.10.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:33cfb96c24034a878d83d1a9415799a73dc77480e6c40417e5dda0710d559ee6", size = 170169 },
-    { url = "https://files.pythonhosted.org/packages/53/b9/10abe9089bdb08cd4218cc45eb7abfd787c82cf301cecbfe7f141542d7f4/orjson-3.10.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e724cebe1fadc2b23c6f7415bad5ee6239e00a69f30ee423f319c6af70e2a5c0", size = 167808 },
-    { url = "https://files.pythonhosted.org/packages/8a/ad/26b40ccef119dcb0f4a39745ffd7d2d319152c1a52859b1ebbd114eca19c/orjson-3.10.7-cp311-none-win32.whl", hash = "sha256:82763b46053727a7168d29c772ed5c870fdae2f61aa8a25994c7984a19b1021f", size = 143010 },
-    { url = "https://files.pythonhosted.org/packages/e7/63/5f4101e4895b78ada568f4cf8f870dd594139ca2e75e654e373da78b03b0/orjson-3.10.7-cp311-none-win_amd64.whl", hash = "sha256:eb8d384a24778abf29afb8e41d68fdd9a156cf6e5390c04cc07bbc24b89e98b5", size = 137307 },
-    { url = "https://files.pythonhosted.org/packages/14/7c/b4ecc2069210489696a36e42862ccccef7e49e1454a3422030ef52881b01/orjson-3.10.7-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:44a96f2d4c3af51bfac6bc4ef7b182aa33f2f054fd7f34cc0ee9a320d051d41f", size = 251409 },
-    { url = "https://files.pythonhosted.org/packages/60/84/e495edb919ef0c98d054a9b6d05f2700fdeba3886edd58f1c4dfb25d514a/orjson-3.10.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76ac14cd57df0572453543f8f2575e2d01ae9e790c21f57627803f5e79b0d3c3", size = 147913 },
-    { url = "https://files.pythonhosted.org/packages/c5/27/e40bc7d79c4afb7e9264f22320c285d06d2c9574c9c682ba0f1be3012833/orjson-3.10.7-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bdbb61dcc365dd9be94e8f7df91975edc9364d6a78c8f7adb69c1cdff318ec93", size = 147390 },
-    { url = "https://files.pythonhosted.org/packages/30/be/fd646fb1a461de4958a6eacf4ecf064b8d5479c023e0e71cc89b28fa91ac/orjson-3.10.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b48b3db6bb6e0a08fa8c83b47bc169623f801e5cc4f24442ab2b6617da3b5313", size = 152973 },
-    { url = "https://files.pythonhosted.org/packages/b1/00/414f8d4bc5ec3447e27b5c26b4e996e4ef08594d599e79b3648f64da060c/orjson-3.10.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23820a1563a1d386414fef15c249040042b8e5d07b40ab3fe3efbfbbcbcb8864", size = 164039 },
-    { url = "https://files.pythonhosted.org/packages/a0/6b/34e6904ac99df811a06e42d8461d47b6e0c9b86e2fe7ee84934df6e35f0d/orjson-3.10.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0c6a008e91d10a2564edbb6ee5069a9e66df3fbe11c9a005cb411f441fd2c09", size = 142035 },
-    { url = "https://files.pythonhosted.org/packages/17/7e/254189d9b6df89660f65aec878d5eeaa5b1ae371bd2c458f85940445d36f/orjson-3.10.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d352ee8ac1926d6193f602cbe36b1643bbd1bbcb25e3c1a657a4390f3000c9a5", size = 169941 },
-    { url = "https://files.pythonhosted.org/packages/02/1a/d11805670c29d3a1b29fc4bd048dc90b094784779690592efe8c9f71249a/orjson-3.10.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2d9f990623f15c0ae7ac608103c33dfe1486d2ed974ac3f40b693bad1a22a7b", size = 167994 },
-    { url = "https://files.pythonhosted.org/packages/20/5f/03d89b007f9d6733dc11bc35d64812101c85d6c4e9c53af9fa7e7689cb11/orjson-3.10.7-cp312-none-win32.whl", hash = "sha256:7c4c17f8157bd520cdb7195f75ddbd31671997cbe10aee559c2d613592e7d7eb", size = 143130 },
-    { url = "https://files.pythonhosted.org/packages/c6/9d/9b9fb6c60b8a0e04031ba85414915e19ecea484ebb625402d968ea45b8d5/orjson-3.10.7-cp312-none-win_amd64.whl", hash = "sha256:1d9c0e733e02ada3ed6098a10a8ee0052dd55774de3d9110d29868d24b17faa1", size = 137326 },
-    { url = "https://files.pythonhosted.org/packages/15/05/121af8a87513c56745d01ad7cf215c30d08356da9ad882ebe2ba890824cd/orjson-3.10.7-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:77d325ed866876c0fa6492598ec01fe30e803272a6e8b10e992288b009cbe149", size = 251331 },
-    { url = "https://files.pythonhosted.org/packages/73/7f/8d6ccd64a6f8bdbfe6c9be7c58aeb8094aa52a01fbbb2cda42ff7e312bd7/orjson-3.10.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ea2c232deedcb605e853ae1db2cc94f7390ac776743b699b50b071b02bea6fe", size = 142012 },
-    { url = "https://files.pythonhosted.org/packages/04/65/f2a03fd1d4f0308f01d372e004c049f7eb9bc5676763a15f20f383fa9c01/orjson-3.10.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3dcfbede6737fdbef3ce9c37af3fb6142e8e1ebc10336daa05872bfb1d87839c", size = 169920 },
-    { url = "https://files.pythonhosted.org/packages/e2/1c/3ef8d83d7c6a619ad3d69a4d5318591b4ce5862e6eda7c26bbe8208652ca/orjson-3.10.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:11748c135f281203f4ee695b7f80bb1358a82a63905f9f0b794769483ea854ad", size = 167916 },
-    { url = "https://files.pythonhosted.org/packages/f2/0d/820a640e5a7dfbe525e789c70871ebb82aff73b0c7bf80082653f86b9431/orjson-3.10.7-cp313-none-win32.whl", hash = "sha256:a7e19150d215c7a13f39eb787d84db274298d3f83d85463e61d277bbd7f401d2", size = 143089 },
-    { url = "https://files.pythonhosted.org/packages/1a/72/a424db9116c7cad2950a8f9e4aeb655a7b57de988eb015acd0fcd1b4609b/orjson-3.10.7-cp313-none-win_amd64.whl", hash = "sha256:eef44224729e9525d5261cc8d28d6b11cafc90e6bd0be2157bde69a52ec83024", size = 137081 },
+version = "3.10.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/80/44/d36e86b33fc84f224b5f2cdf525adf3b8f9f475753e721c402b1ddef731e/orjson-3.10.10.tar.gz", hash = "sha256:37949383c4df7b4337ce82ee35b6d7471e55195efa7dcb45ab8226ceadb0fe3b", size = 5404170 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/c7/07ca73c32d49550490572235e5000aa0d75e333997cbb3a221890ef0fa04/orjson-3.10.10-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:b788a579b113acf1c57e0a68e558be71d5d09aa67f62ca1f68e01117e550a998", size = 270718 },
+    { url = "https://files.pythonhosted.org/packages/4d/6e/eaefdfe4b11fd64b38f6663c71a3c9063054c8c643a52555c5b6d4350446/orjson-3.10.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:804b18e2b88022c8905bb79bd2cbe59c0cd014b9328f43da8d3b28441995cda4", size = 153292 },
+    { url = "https://files.pythonhosted.org/packages/cf/87/94474cbf63306f196a0a85a2f3ea6cea261328b4141a260b7ec5e7145bc5/orjson-3.10.10-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9972572a1d042ec9ee421b6da69f7cc823da5962237563fa548ab17f152f0b9b", size = 168625 },
+    { url = "https://files.pythonhosted.org/packages/0a/67/1a6bd763282bc89fcc0269e3a44a8ecbb236a1e4b6f5a6320301726b36a1/orjson-3.10.10-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc6993ab1c2ae7dd0711161e303f1db69062955ac2668181bfdf2dd410e65258", size = 155845 },
+    { url = "https://files.pythonhosted.org/packages/ae/28/bb2dd7a988159896be9fa59ef4c991dca8cca9af85ebdc27164234929008/orjson-3.10.10-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d78e4cacced5781b01d9bc0f0cd8b70b906a0e109825cb41c1b03f9c41e4ce86", size = 166406 },
+    { url = "https://files.pythonhosted.org/packages/e3/88/42199849c791b4b5b92fcace0e8ef178d5ae1ea9865dfd4d5809e650d652/orjson-3.10.10-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e6eb2598df518281ba0cbc30d24c5b06124ccf7e19169e883c14e0831217a0bc", size = 144518 },
+    { url = "https://files.pythonhosted.org/packages/c7/77/e684fe4ed34e73149bc0e7320b91a459386693279cd62efab6e82da072a3/orjson-3.10.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23776265c5215ec532de6238a52707048401a568f0fa0d938008e92a147fe2c7", size = 172184 },
+    { url = "https://files.pythonhosted.org/packages/fa/b2/9dc2ed13121b27b9f99acba077c821ad2c0deff9feeb617efef4699fad35/orjson-3.10.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8cc2a654c08755cef90b468ff17c102e2def0edd62898b2486767204a7f5cc9c", size = 170148 },
+    { url = "https://files.pythonhosted.org/packages/86/0a/b06967f9374856f491f297a914c588eae97ef9490a77ec0e146a2e4bfe7f/orjson-3.10.10-cp310-none-win32.whl", hash = "sha256:081b3fc6a86d72efeb67c13d0ea7c030017bd95f9868b1e329a376edc456153b", size = 145116 },
+    { url = "https://files.pythonhosted.org/packages/1f/c7/1aecf5e320828261ece0683e472ee77c520f4e6c52c468486862e2257962/orjson-3.10.10-cp310-none-win_amd64.whl", hash = "sha256:ff38c5fb749347768a603be1fb8a31856458af839f31f064c5aa74aca5be9efe", size = 139307 },
+    { url = "https://files.pythonhosted.org/packages/79/bc/2a0eb0029729f1e466d5a595261446e5c5b6ed9213759ee56b6202f99417/orjson-3.10.10-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:879e99486c0fbb256266c7c6a67ff84f46035e4f8749ac6317cc83dacd7f993a", size = 270717 },
+    { url = "https://files.pythonhosted.org/packages/3d/2b/5af226f183ce264bf64f15afe58647b09263dc1bde06aaadae6bbeca17f1/orjson-3.10.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:019481fa9ea5ff13b5d5d95e6fd5ab25ded0810c80b150c2c7b1cc8660b662a7", size = 153294 },
+    { url = "https://files.pythonhosted.org/packages/1d/95/d6a68ab51ed76e3794669dabb51bf7fa6ec2f4745f66e4af4518aeab4b73/orjson-3.10.10-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0dd57eff09894938b4c86d4b871a479260f9e156fa7f12f8cad4b39ea8028bb5", size = 168628 },
+    { url = "https://files.pythonhosted.org/packages/c0/c9/1bbe5262f5e9df3e1aeec44ca8cc86846c7afb2746fa76bf668a7d0979e9/orjson-3.10.10-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dbde6d70cd95ab4d11ea8ac5e738e30764e510fc54d777336eec09bb93b8576c", size = 155845 },
+    { url = "https://files.pythonhosted.org/packages/bf/22/e17b14ff74646e6c080dccb2859686a820bc6468f6b62ea3fe29a8bd3b05/orjson-3.10.10-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2625cb37b8fb42e2147404e5ff7ef08712099197a9cd38895006d7053e69d6", size = 166406 },
+    { url = "https://files.pythonhosted.org/packages/8a/1e/b3abbe352f648f96a418acd1e602b1c77ffcc60cf801a57033da990b2c49/orjson-3.10.10-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dbf3c20c6a7db69df58672a0d5815647ecf78c8e62a4d9bd284e8621c1fe5ccb", size = 144518 },
+    { url = "https://files.pythonhosted.org/packages/0e/5e/28f521ee0950d279489db1522e7a2460d0596df7c5ca452e242ff1509cfe/orjson-3.10.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:75c38f5647e02d423807d252ce4528bf6a95bd776af999cb1fb48867ed01d1f6", size = 172187 },
+    { url = "https://files.pythonhosted.org/packages/04/b4/538bf6f42eb0fd5a485abbe61e488d401a23fd6d6a758daefcf7811b6807/orjson-3.10.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:23458d31fa50ec18e0ec4b0b4343730928296b11111df5f547c75913714116b2", size = 170152 },
+    { url = "https://files.pythonhosted.org/packages/94/5c/a1a326a58452f9261972ad326ae3bb46d7945681239b7062a1b85d8811e2/orjson-3.10.10-cp311-none-win32.whl", hash = "sha256:2787cd9dedc591c989f3facd7e3e86508eafdc9536a26ec277699c0aa63c685b", size = 145116 },
+    { url = "https://files.pythonhosted.org/packages/df/12/a02965df75f5a247091306d6cf40a77d20bf6c0490d0a5cb8719551ee815/orjson-3.10.10-cp311-none-win_amd64.whl", hash = "sha256:6514449d2c202a75183f807bc755167713297c69f1db57a89a1ef4a0170ee269", size = 139307 },
+    { url = "https://files.pythonhosted.org/packages/21/c6/f1d2ec3ffe9d6a23a62af0477cd11dd2926762e0186a1fad8658a4f48117/orjson-3.10.10-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:8564f48f3620861f5ef1e080ce7cd122ee89d7d6dacf25fcae675ff63b4d6e05", size = 270801 },
+    { url = "https://files.pythonhosted.org/packages/52/01/eba0226efaa4d4be8e44d9685750428503a3803648878fa5607100a74f81/orjson-3.10.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5bf161a32b479034098c5b81f2608f09167ad2fa1c06abd4e527ea6bf4837a9", size = 153221 },
+    { url = "https://files.pythonhosted.org/packages/da/4b/a705f9d3ae4786955ee0ac840b20960add357e612f1b0a54883d1811fe1a/orjson-3.10.10-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:68b65c93617bcafa7f04b74ae8bc2cc214bd5cb45168a953256ff83015c6747d", size = 168590 },
+    { url = "https://files.pythonhosted.org/packages/de/6c/eb405252e7d9ae9905a12bad582cfe37ef8ef18fdfee941549cb5834c7b2/orjson-3.10.10-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e8e28406f97fc2ea0c6150f4c1b6e8261453318930b334abc419214c82314f85", size = 156052 },
+    { url = "https://files.pythonhosted.org/packages/9f/e7/65a0461574078a38f204575153524876350f0865162faa6e6e300ecaa199/orjson-3.10.10-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4d0d9fe174cc7a5bdce2e6c378bcdb4c49b2bf522a8f996aa586020e1b96cee", size = 166562 },
+    { url = "https://files.pythonhosted.org/packages/dd/99/85780be173e7014428859ba0211e6f2a8f8038ea6ebabe344b42d5daa277/orjson-3.10.10-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3be81c42f1242cbed03cbb3973501fcaa2675a0af638f8be494eaf37143d999", size = 144892 },
+    { url = "https://files.pythonhosted.org/packages/ed/c0/c7c42a2daeb262da417f70064746b700786ee0811b9a5821d9d37543b29d/orjson-3.10.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:65f9886d3bae65be026219c0a5f32dbbe91a9e6272f56d092ab22561ad0ea33b", size = 172093 },
+    { url = "https://files.pythonhosted.org/packages/ad/9b/be8b3d3aec42aa47f6058482ace0d2ca3023477a46643d766e96281d5d31/orjson-3.10.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:730ed5350147db7beb23ddaf072f490329e90a1d059711d364b49fe352ec987b", size = 170424 },
+    { url = "https://files.pythonhosted.org/packages/1b/15/a4cc61e23c39b9dec4620cb95817c83c84078be1771d602f6d03f0e5c696/orjson-3.10.10-cp312-none-win32.whl", hash = "sha256:a8f4bf5f1c85bea2170800020d53a8877812892697f9c2de73d576c9307a8a5f", size = 145132 },
+    { url = "https://files.pythonhosted.org/packages/9f/8a/ce7c28e4ea337f6d95261345d7c61322f8561c52f57b263a3ad7025984f4/orjson-3.10.10-cp312-none-win_amd64.whl", hash = "sha256:384cd13579a1b4cd689d218e329f459eb9ddc504fa48c5a83ef4889db7fd7a4f", size = 139389 },
+    { url = "https://files.pythonhosted.org/packages/0c/69/f1c4382cd44bdaf10006c4e82cb85d2bcae735369f84031e203c4e5d87de/orjson-3.10.10-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:44bffae68c291f94ff5a9b4149fe9d1bdd4cd0ff0fb575bcea8351d48db629a1", size = 270695 },
+    { url = "https://files.pythonhosted.org/packages/61/29/aeb5153271d4953872b06ed239eb54993a5f344353727c42d3aabb2046f6/orjson-3.10.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e27b4c6437315df3024f0835887127dac2a0a3ff643500ec27088d2588fa5ae1", size = 141632 },
+    { url = "https://files.pythonhosted.org/packages/bc/a2/c8ac38d8fb461a9b717c766fbe1f7d3acf9bde2f12488eb13194960782e4/orjson-3.10.10-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca84df16d6b49325a4084fd8b2fe2229cb415e15c46c529f868c3387bb1339d", size = 144854 },
+    { url = "https://files.pythonhosted.org/packages/79/51/e7698fdb28bdec633888cc667edc29fd5376fce9ade0a5b3e22f5ebe0343/orjson-3.10.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c14ce70e8f39bd71f9f80423801b5d10bf93d1dceffdecd04df0f64d2c69bc01", size = 172023 },
+    { url = "https://files.pythonhosted.org/packages/02/2d/0d99c20878658c7e33b90e6a4bb75cf2924d6ff29c2365262cff3c26589a/orjson-3.10.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:24ac62336da9bda1bd93c0491eff0613003b48d3cb5d01470842e7b52a40d5b4", size = 170429 },
+    { url = "https://files.pythonhosted.org/packages/cd/45/6a4a446f4fb29bb4703c3537d5c6a2bf7fed768cb4d7b7dce9d71b72fc93/orjson-3.10.10-cp313-none-win32.whl", hash = "sha256:eb0a42831372ec2b05acc9ee45af77bcaccbd91257345f93780a8e654efc75db", size = 145099 },
+    { url = "https://files.pythonhosted.org/packages/72/6e/4631fe219a4203aa111e9bb763ad2e2e0cdd1a03805029e4da124d96863f/orjson-3.10.10-cp313-none-win_amd64.whl", hash = "sha256:f0c4f37f8bf3f1075c6cc8dd8a9f843689a4b618628f8812d0a71e6968b95ffd", size = 139176 },
 ]
 
 [[package]]
@@ -3150,7 +3281,7 @@ wheels = [
 
 [[package]]
 name = "pandas"
-version = "2.2.2"
+version = "2.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy" },
@@ -3158,29 +3289,42 @@ dependencies = [
     { name = "pytz" },
     { name = "tzdata" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/88/d9/ecf715f34c73ccb1d8ceb82fc01cd1028a65a5f6dbc57bfa6ea155119058/pandas-2.2.2.tar.gz", hash = "sha256:9e79019aba43cb4fda9e4d983f8e88ca0373adbb697ae9c6c43093218de28b54", size = 4398391 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/2d/39600d073ea70b9cafdc51fab91d69c72b49dd92810f24cb5ac6631f387f/pandas-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90c6fca2acf139569e74e8781709dccb6fe25940488755716d1d354d6bc58bce", size = 12551798 },
-    { url = "https://files.pythonhosted.org/packages/fd/4b/0cd38e68ab690b9df8ef90cba625bf3f93b82d1c719703b8e1b333b2c72d/pandas-2.2.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c7adfc142dac335d8c1e0dcbd37eb8617eac386596eb9e1a1b77791cf2498238", size = 11287392 },
-    { url = "https://files.pythonhosted.org/packages/01/c6/d3d2612aea9b9f28e79a30b864835dad8f542dcf474eee09afeee5d15d75/pandas-2.2.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4abfe0be0d7221be4f12552995e58723c7422c80a659da13ca382697de830c08", size = 15634823 },
-    { url = "https://files.pythonhosted.org/packages/89/1b/12521efcbc6058e2673583bb096c2b5046a9df39bd73eca392c1efed24e5/pandas-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8635c16bf3d99040fdf3ca3db669a7250ddf49c55dc4aa8fe0ae0fa8d6dcc1f0", size = 13032214 },
-    { url = "https://files.pythonhosted.org/packages/e4/d7/303dba73f1c3a9ef067d23e5afbb6175aa25e8121be79be354dcc740921a/pandas-2.2.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:40ae1dffb3967a52203105a077415a86044a2bea011b5f321c6aa64b379a3f51", size = 16278302 },
-    { url = "https://files.pythonhosted.org/packages/ba/df/8ff7c5ed1cc4da8c6ab674dc8e4860a4310c3880df1283e01bac27a4333d/pandas-2.2.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e5a0b00e1e56a842f922e7fae8ae4077aee4af0acb5ae3622bd4b4c30aedf99", size = 13892866 },
-    { url = "https://files.pythonhosted.org/packages/69/a6/81d5dc9a612cf0c1810c2ebc4f2afddb900382276522b18d128213faeae3/pandas-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:ddf818e4e6c7c6f4f7c8a12709696d193976b591cc7dc50588d3d1a6b5dc8772", size = 11621592 },
-    { url = "https://files.pythonhosted.org/packages/1b/70/61704497903d43043e288017cb2b82155c0d41e15f5c17807920877b45c2/pandas-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:696039430f7a562b74fa45f540aca068ea85fa34c244d0deee539cb6d70aa288", size = 12574808 },
-    { url = "https://files.pythonhosted.org/packages/16/c6/75231fd47afd6b3f89011e7077f1a3958441264aca7ae9ff596e3276a5d0/pandas-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8e90497254aacacbc4ea6ae5e7a8cd75629d6ad2b30025a4a8b09aa4faf55151", size = 11304876 },
-    { url = "https://files.pythonhosted.org/packages/97/2d/7b54f80b93379ff94afb3bd9b0cd1d17b48183a0d6f98045bc01ce1e06a7/pandas-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:58b84b91b0b9f4bafac2a0ac55002280c094dfc6402402332c0913a59654ab2b", size = 15602548 },
-    { url = "https://files.pythonhosted.org/packages/fc/a5/4d82be566f069d7a9a702dcdf6f9106df0e0b042e738043c0cc7ddd7e3f6/pandas-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d2123dc9ad6a814bcdea0f099885276b31b24f7edf40f6cdbc0912672e22eee", size = 13031332 },
-    { url = "https://files.pythonhosted.org/packages/92/a2/b79c48f530673567805e607712b29814b47dcaf0d167e87145eb4b0118c6/pandas-2.2.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2925720037f06e89af896c70bca73459d7e6a4be96f9de79e2d440bd499fe0db", size = 16286054 },
-    { url = "https://files.pythonhosted.org/packages/40/c7/47e94907f1d8fdb4868d61bd6c93d57b3784a964d52691b77ebfdb062842/pandas-2.2.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:0cace394b6ea70c01ca1595f839cf193df35d1575986e484ad35c4aeae7266c1", size = 13879507 },
-    { url = "https://files.pythonhosted.org/packages/ab/63/966db1321a0ad55df1d1fe51505d2cdae191b84c907974873817b0a6e849/pandas-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:873d13d177501a28b2756375d59816c365e42ed8417b41665f346289adc68d24", size = 11634249 },
-    { url = "https://files.pythonhosted.org/packages/dd/49/de869130028fb8d90e25da3b7d8fb13e40f5afa4c4af1781583eb1ff3839/pandas-2.2.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9dfde2a0ddef507a631dc9dc4af6a9489d5e2e740e226ad426a05cabfbd7c8ef", size = 12500886 },
-    { url = "https://files.pythonhosted.org/packages/db/7c/9a60add21b96140e22465d9adf09832feade45235cd22f4cb1668a25e443/pandas-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e9b79011ff7a0f4b1d6da6a61aa1aa604fb312d6647de5bad20013682d1429ce", size = 11340320 },
-    { url = "https://files.pythonhosted.org/packages/b0/85/f95b5f322e1ae13b7ed7e97bd999160fa003424711ab4dc8344b8772c270/pandas-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cb51fe389360f3b5a4d57dbd2848a5f033350336ca3b340d1c53a1fad33bcad", size = 15204346 },
-    { url = "https://files.pythonhosted.org/packages/40/10/79e52ef01dfeb1c1ca47a109a01a248754ebe990e159a844ece12914de83/pandas-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eee3a87076c0756de40b05c5e9a6069c035ba43e8dd71c379e68cab2c20f16ad", size = 12733396 },
-    { url = "https://files.pythonhosted.org/packages/35/9d/208febf8c4eb5c1d9ea3314d52d8bd415fd0ef0dd66bb24cc5bdbc8fa71a/pandas-2.2.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3e374f59e440d4ab45ca2fffde54b81ac3834cf5ae2cdfa69c90bc03bde04d76", size = 15858913 },
-    { url = "https://files.pythonhosted.org/packages/99/d1/2d9bd05def7a9e08a92ec929b5a4c8d5556ec76fae22b0fa486cbf33ea63/pandas-2.2.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:43498c0bdb43d55cb162cdc8c06fac328ccb5d2eabe3cadeb3529ae6f0517c32", size = 13417786 },
-    { url = "https://files.pythonhosted.org/packages/22/a5/a0b255295406ed54269814bc93723cfd1a0da63fb9aaf99e1364f07923e5/pandas-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:d187d355ecec3629624fccb01d104da7d7f391db0311145817525281e2804d23", size = 11498828 },
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 },
+    { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 },
+    { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 },
+    { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 },
+    { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 },
+    { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 },
+    { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 },
+    { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 },
+    { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 },
+    { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 },
+    { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 },
+    { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 },
+    { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 },
+    { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 },
+    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 },
+    { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 },
+    { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 },
+    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 },
+    { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 },
+    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 },
+    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 },
+    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
+    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 },
+    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 },
+    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
+    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 },
+    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
+    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
+    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 },
+    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 },
+    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 },
+    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
 ]
 
 [[package]]
@@ -3246,61 +3390,69 @@ wheels = [
 
 [[package]]
 name = "pillow"
-version = "10.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/cd/74/ad3d526f3bf7b6d3f408b73fde271ec69dfac8b81341a318ce825f2b3812/pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06", size = 46555059 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/69/a31cccd538ca0b5272be2a38347f8839b97a14be104ea08b0db92f749c74/pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e", size = 3509271 },
-    { url = "https://files.pythonhosted.org/packages/9a/9e/4143b907be8ea0bce215f2ae4f7480027473f8b61fcedfda9d851082a5d2/pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d", size = 3375658 },
-    { url = "https://files.pythonhosted.org/packages/8a/25/1fc45761955f9359b1169aa75e241551e74ac01a09f487adaaf4c3472d11/pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856", size = 4332075 },
-    { url = "https://files.pythonhosted.org/packages/5e/dd/425b95d0151e1d6c951f45051112394f130df3da67363b6bc75dc4c27aba/pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f", size = 4444808 },
-    { url = "https://files.pythonhosted.org/packages/b1/84/9a15cc5726cbbfe7f9f90bfb11f5d028586595907cd093815ca6644932e3/pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b", size = 4356290 },
-    { url = "https://files.pythonhosted.org/packages/b5/5b/6651c288b08df3b8c1e2f8c1152201e0b25d240e22ddade0f1e242fc9fa0/pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc", size = 4525163 },
-    { url = "https://files.pythonhosted.org/packages/07/8b/34854bf11a83c248505c8cb0fcf8d3d0b459a2246c8809b967963b6b12ae/pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e", size = 4463100 },
-    { url = "https://files.pythonhosted.org/packages/78/63/0632aee4e82476d9cbe5200c0cdf9ba41ee04ed77887432845264d81116d/pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46", size = 4592880 },
-    { url = "https://files.pythonhosted.org/packages/df/56/b8663d7520671b4398b9d97e1ed9f583d4afcbefbda3c6188325e8c297bd/pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984", size = 2235218 },
-    { url = "https://files.pythonhosted.org/packages/f4/72/0203e94a91ddb4a9d5238434ae6c1ca10e610e8487036132ea9bf806ca2a/pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141", size = 2554487 },
-    { url = "https://files.pythonhosted.org/packages/bd/52/7e7e93d7a6e4290543f17dc6f7d3af4bd0b3dd9926e2e8a35ac2282bc5f4/pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1", size = 2243219 },
-    { url = "https://files.pythonhosted.org/packages/a7/62/c9449f9c3043c37f73e7487ec4ef0c03eb9c9afc91a92b977a67b3c0bbc5/pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c", size = 3509265 },
-    { url = "https://files.pythonhosted.org/packages/f4/5f/491dafc7bbf5a3cc1845dc0430872e8096eb9e2b6f8161509d124594ec2d/pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be", size = 3375655 },
-    { url = "https://files.pythonhosted.org/packages/73/d5/c4011a76f4207a3c151134cd22a1415741e42fa5ddecec7c0182887deb3d/pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3", size = 4340304 },
-    { url = "https://files.pythonhosted.org/packages/ac/10/c67e20445a707f7a610699bba4fe050583b688d8cd2d202572b257f46600/pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6", size = 4452804 },
-    { url = "https://files.pythonhosted.org/packages/a9/83/6523837906d1da2b269dee787e31df3b0acb12e3d08f024965a3e7f64665/pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe", size = 4365126 },
-    { url = "https://files.pythonhosted.org/packages/ba/e5/8c68ff608a4203085158cff5cc2a3c534ec384536d9438c405ed6370d080/pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319", size = 4533541 },
-    { url = "https://files.pythonhosted.org/packages/f4/7c/01b8dbdca5bc6785573f4cee96e2358b0918b7b2c7b60d8b6f3abf87a070/pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d", size = 4471616 },
-    { url = "https://files.pythonhosted.org/packages/c8/57/2899b82394a35a0fbfd352e290945440e3b3785655a03365c0ca8279f351/pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696", size = 4600802 },
-    { url = "https://files.pythonhosted.org/packages/4d/d7/a44f193d4c26e58ee5d2d9db3d4854b2cfb5b5e08d360a5e03fe987c0086/pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496", size = 2235213 },
-    { url = "https://files.pythonhosted.org/packages/c1/d0/5866318eec2b801cdb8c82abf190c8343d8a1cd8bf5a0c17444a6f268291/pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91", size = 2554498 },
-    { url = "https://files.pythonhosted.org/packages/d4/c8/310ac16ac2b97e902d9eb438688de0d961660a87703ad1561fd3dfbd2aa0/pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22", size = 2243219 },
-    { url = "https://files.pythonhosted.org/packages/05/cb/0353013dc30c02a8be34eb91d25e4e4cf594b59e5a55ea1128fde1e5f8ea/pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94", size = 3509350 },
-    { url = "https://files.pythonhosted.org/packages/e7/cf/5c558a0f247e0bf9cec92bff9b46ae6474dd736f6d906315e60e4075f737/pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597", size = 3374980 },
-    { url = "https://files.pythonhosted.org/packages/84/48/6e394b86369a4eb68b8a1382c78dc092245af517385c086c5094e3b34428/pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80", size = 4343799 },
-    { url = "https://files.pythonhosted.org/packages/3b/f3/a8c6c11fa84b59b9df0cd5694492da8c039a24cd159f0f6918690105c3be/pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca", size = 4459973 },
-    { url = "https://files.pythonhosted.org/packages/7d/1b/c14b4197b80150fb64453585247e6fb2e1d93761fa0fa9cf63b102fde822/pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef", size = 4370054 },
-    { url = "https://files.pythonhosted.org/packages/55/77/40daddf677897a923d5d33329acd52a2144d54a9644f2a5422c028c6bf2d/pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a", size = 4539484 },
-    { url = "https://files.pythonhosted.org/packages/40/54/90de3e4256b1207300fb2b1d7168dd912a2fb4b2401e439ba23c2b2cabde/pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b", size = 4477375 },
-    { url = "https://files.pythonhosted.org/packages/13/24/1bfba52f44193860918ff7c93d03d95e3f8748ca1de3ceaf11157a14cf16/pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9", size = 4608773 },
-    { url = "https://files.pythonhosted.org/packages/55/04/5e6de6e6120451ec0c24516c41dbaf80cce1b6451f96561235ef2429da2e/pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42", size = 2235690 },
-    { url = "https://files.pythonhosted.org/packages/74/0a/d4ce3c44bca8635bd29a2eab5aa181b654a734a29b263ca8efe013beea98/pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a", size = 2554951 },
-    { url = "https://files.pythonhosted.org/packages/b5/ca/184349ee40f2e92439be9b3502ae6cfc43ac4b50bc4fc6b3de7957563894/pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9", size = 2243427 },
-    { url = "https://files.pythonhosted.org/packages/c3/00/706cebe7c2c12a6318aabe5d354836f54adff7156fd9e1bd6c89f4ba0e98/pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3", size = 3525685 },
-    { url = "https://files.pythonhosted.org/packages/cf/76/f658cbfa49405e5ecbfb9ba42d07074ad9792031267e782d409fd8fe7c69/pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb", size = 3374883 },
-    { url = "https://files.pythonhosted.org/packages/46/2b/99c28c4379a85e65378211971c0b430d9c7234b1ec4d59b2668f6299e011/pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70", size = 4339837 },
-    { url = "https://files.pythonhosted.org/packages/f1/74/b1ec314f624c0c43711fdf0d8076f82d9d802afd58f1d62c2a86878e8615/pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be", size = 4455562 },
-    { url = "https://files.pythonhosted.org/packages/4a/2a/4b04157cb7b9c74372fa867096a1607e6fedad93a44deeff553ccd307868/pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0", size = 4366761 },
-    { url = "https://files.pythonhosted.org/packages/ac/7b/8f1d815c1a6a268fe90481232c98dd0e5fa8c75e341a75f060037bd5ceae/pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc", size = 4536767 },
-    { url = "https://files.pythonhosted.org/packages/e5/77/05fa64d1f45d12c22c314e7b97398ffb28ef2813a485465017b7978b3ce7/pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a", size = 4477989 },
-    { url = "https://files.pythonhosted.org/packages/12/63/b0397cfc2caae05c3fb2f4ed1b4fc4fc878f0243510a7a6034ca59726494/pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309", size = 4610255 },
-    { url = "https://files.pythonhosted.org/packages/7b/f9/cfaa5082ca9bc4a6de66ffe1c12c2d90bf09c309a5f52b27759a596900e7/pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060", size = 2235603 },
-    { url = "https://files.pythonhosted.org/packages/01/6a/30ff0eef6e0c0e71e55ded56a38d4859bf9d3634a94a88743897b5f96936/pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea", size = 2554972 },
-    { url = "https://files.pythonhosted.org/packages/48/2c/2e0a52890f269435eee38b21c8218e102c621fe8d8df8b9dd06fabf879ba/pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d", size = 2243375 },
-    { url = "https://files.pythonhosted.org/packages/38/30/095d4f55f3a053392f75e2eae45eba3228452783bab3d9a920b951ac495c/pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4", size = 3493889 },
-    { url = "https://files.pythonhosted.org/packages/f3/e8/4ff79788803a5fcd5dc35efdc9386af153569853767bff74540725b45863/pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da", size = 3346160 },
-    { url = "https://files.pythonhosted.org/packages/d7/ac/4184edd511b14f760c73f5bb8a5d6fd85c591c8aff7c2229677a355c4179/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026", size = 3435020 },
-    { url = "https://files.pythonhosted.org/packages/da/21/1749cd09160149c0a246a81d646e05f35041619ce76f6493d6a96e8d1103/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e", size = 3490539 },
-    { url = "https://files.pythonhosted.org/packages/b6/f5/f71fe1888b96083b3f6dfa0709101f61fc9e972c0c8d04e9d93ccef2a045/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5", size = 3476125 },
-    { url = "https://files.pythonhosted.org/packages/96/b9/c0362c54290a31866c3526848583a2f45a535aa9d725fd31e25d318c805f/pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885", size = 3579373 },
-    { url = "https://files.pythonhosted.org/packages/52/3b/ce7a01026a7cf46e5452afa86f97a5e88ca97f562cafa76570178ab56d8d/pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5", size = 2554661 },
+version = "11.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/26/0d95c04c868f6bdb0c447e3ee2de5564411845e36a858cfd63766bc7b563/pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739", size = 46737780 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/fb/a6ce6836bd7fd93fbf9144bf54789e02babc27403b50a9e1583ee877d6da/pillow-11.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6619654954dc4936fcff82db8eb6401d3159ec6be81e33c6000dfd76ae189947", size = 3154708 },
+    { url = "https://files.pythonhosted.org/packages/6a/1d/1f51e6e912d8ff316bb3935a8cda617c801783e0b998bf7a894e91d3bd4c/pillow-11.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b3c5ac4bed7519088103d9450a1107f76308ecf91d6dabc8a33a2fcfb18d0fba", size = 2979223 },
+    { url = "https://files.pythonhosted.org/packages/90/83/e2077b0192ca8a9ef794dbb74700c7e48384706467067976c2a95a0f40a1/pillow-11.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a65149d8ada1055029fcb665452b2814fe7d7082fcb0c5bed6db851cb69b2086", size = 4183167 },
+    { url = "https://files.pythonhosted.org/packages/0e/74/467af0146970a98349cdf39e9b79a6cc8a2e7558f2c01c28a7b6b85c5bda/pillow-11.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a58d8ac0cc0e7f3a014509f0455248a76629ca9b604eca7dc5927cc593c5e9", size = 4283912 },
+    { url = "https://files.pythonhosted.org/packages/85/b1/d95d4f7ca3a6c1ae120959605875a31a3c209c4e50f0029dc1a87566cf46/pillow-11.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c26845094b1af3c91852745ae78e3ea47abf3dbcd1cf962f16b9a5fbe3ee8488", size = 4195815 },
+    { url = "https://files.pythonhosted.org/packages/41/c3/94f33af0762ed76b5a237c5797e088aa57f2b7fa8ee7932d399087be66a8/pillow-11.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1a61b54f87ab5786b8479f81c4b11f4d61702830354520837f8cc791ebba0f5f", size = 4366117 },
+    { url = "https://files.pythonhosted.org/packages/ba/3c/443e7ef01f597497268899e1cca95c0de947c9bbf77a8f18b3c126681e5d/pillow-11.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:674629ff60030d144b7bca2b8330225a9b11c482ed408813924619c6f302fdbb", size = 4278607 },
+    { url = "https://files.pythonhosted.org/packages/26/95/1495304448b0081e60c0c5d63f928ef48bb290acee7385804426fa395a21/pillow-11.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:598b4e238f13276e0008299bd2482003f48158e2b11826862b1eb2ad7c768b97", size = 4410685 },
+    { url = "https://files.pythonhosted.org/packages/45/da/861e1df971ef0de9870720cb309ca4d553b26a9483ec9be3a7bf1de4a095/pillow-11.0.0-cp310-cp310-win32.whl", hash = "sha256:9a0f748eaa434a41fccf8e1ee7a3eed68af1b690e75328fd7a60af123c193b50", size = 2249185 },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/78f7c5202ea2a772a5ab05069c1b82503e6353cd79c7e474d4945f4b82c3/pillow-11.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a5629742881bcbc1f42e840af185fd4d83a5edeb96475a575f4da50d6ede337c", size = 2566726 },
+    { url = "https://files.pythonhosted.org/packages/77/e4/6e84eada35cbcc646fc1870f72ccfd4afacb0fae0c37ffbffe7f5dc24bf1/pillow-11.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:ee217c198f2e41f184f3869f3e485557296d505b5195c513b2bfe0062dc537f1", size = 2254585 },
+    { url = "https://files.pythonhosted.org/packages/f0/eb/f7e21b113dd48a9c97d364e0915b3988c6a0b6207652f5a92372871b7aa4/pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1c1d72714f429a521d8d2d018badc42414c3077eb187a59579f28e4270b4b0fc", size = 3154705 },
+    { url = "https://files.pythonhosted.org/packages/25/b3/2b54a1d541accebe6bd8b1358b34ceb2c509f51cb7dcda8687362490da5b/pillow-11.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:499c3a1b0d6fc8213519e193796eb1a86a1be4b1877d678b30f83fd979811d1a", size = 2979222 },
+    { url = "https://files.pythonhosted.org/packages/20/12/1a41eddad8265c5c19dda8fb6c269ce15ee25e0b9f8f26286e6202df6693/pillow-11.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8b2351c85d855293a299038e1f89db92a2f35e8d2f783489c6f0b2b5f3fe8a3", size = 4190220 },
+    { url = "https://files.pythonhosted.org/packages/a9/9b/8a8c4d07d77447b7457164b861d18f5a31ae6418ef5c07f6f878fa09039a/pillow-11.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f4dba50cfa56f910241eb7f883c20f1e7b1d8f7d91c750cd0b318bad443f4d5", size = 4291399 },
+    { url = "https://files.pythonhosted.org/packages/fc/e4/130c5fab4a54d3991129800dd2801feeb4b118d7630148cd67f0e6269d4c/pillow-11.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5ddbfd761ee00c12ee1be86c9c0683ecf5bb14c9772ddbd782085779a63dd55b", size = 4202709 },
+    { url = "https://files.pythonhosted.org/packages/39/63/b3fc299528d7df1f678b0666002b37affe6b8751225c3d9c12cf530e73ed/pillow-11.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:45c566eb10b8967d71bf1ab8e4a525e5a93519e29ea071459ce517f6b903d7fa", size = 4372556 },
+    { url = "https://files.pythonhosted.org/packages/c6/a6/694122c55b855b586c26c694937d36bb8d3b09c735ff41b2f315c6e66a10/pillow-11.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b4fd7bd29610a83a8c9b564d457cf5bd92b4e11e79a4ee4716a63c959699b306", size = 4287187 },
+    { url = "https://files.pythonhosted.org/packages/ba/a9/f9d763e2671a8acd53d29b1e284ca298bc10a595527f6be30233cdb9659d/pillow-11.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb929ca942d0ec4fac404cbf520ee6cac37bf35be479b970c4ffadf2b6a1cad9", size = 4418468 },
+    { url = "https://files.pythonhosted.org/packages/6e/0e/b5cbad2621377f11313a94aeb44ca55a9639adabcaaa073597a1925f8c26/pillow-11.0.0-cp311-cp311-win32.whl", hash = "sha256:006bcdd307cc47ba43e924099a038cbf9591062e6c50e570819743f5607404f5", size = 2249249 },
+    { url = "https://files.pythonhosted.org/packages/dc/83/1470c220a4ff06cd75fc609068f6605e567ea51df70557555c2ab6516b2c/pillow-11.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:52a2d8323a465f84faaba5236567d212c3668f2ab53e1c74c15583cf507a0291", size = 2566769 },
+    { url = "https://files.pythonhosted.org/packages/52/98/def78c3a23acee2bcdb2e52005fb2810ed54305602ec1bfcfab2bda6f49f/pillow-11.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:16095692a253047fe3ec028e951fa4221a1f3ed3d80c397e83541a3037ff67c9", size = 2254611 },
+    { url = "https://files.pythonhosted.org/packages/1c/a3/26e606ff0b2daaf120543e537311fa3ae2eb6bf061490e4fea51771540be/pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923", size = 3147642 },
+    { url = "https://files.pythonhosted.org/packages/4f/d5/1caabedd8863526a6cfa44ee7a833bd97f945dc1d56824d6d76e11731939/pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903", size = 2978999 },
+    { url = "https://files.pythonhosted.org/packages/d9/ff/5a45000826a1aa1ac6874b3ec5a856474821a1b59d838c4f6ce2ee518fe9/pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4", size = 4196794 },
+    { url = "https://files.pythonhosted.org/packages/9d/21/84c9f287d17180f26263b5f5c8fb201de0f88b1afddf8a2597a5c9fe787f/pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f", size = 4300762 },
+    { url = "https://files.pythonhosted.org/packages/84/39/63fb87cd07cc541438b448b1fed467c4d687ad18aa786a7f8e67b255d1aa/pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9", size = 4210468 },
+    { url = "https://files.pythonhosted.org/packages/7f/42/6e0f2c2d5c60f499aa29be14f860dd4539de322cd8fb84ee01553493fb4d/pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7", size = 4381824 },
+    { url = "https://files.pythonhosted.org/packages/31/69/1ef0fb9d2f8d2d114db982b78ca4eeb9db9a29f7477821e160b8c1253f67/pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6", size = 4296436 },
+    { url = "https://files.pythonhosted.org/packages/44/ea/dad2818c675c44f6012289a7c4f46068c548768bc6c7f4e8c4ae5bbbc811/pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc", size = 4429714 },
+    { url = "https://files.pythonhosted.org/packages/af/3a/da80224a6eb15bba7a0dcb2346e2b686bb9bf98378c0b4353cd88e62b171/pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6", size = 2249631 },
+    { url = "https://files.pythonhosted.org/packages/57/97/73f756c338c1d86bb802ee88c3cab015ad7ce4b838f8a24f16b676b1ac7c/pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47", size = 2567533 },
+    { url = "https://files.pythonhosted.org/packages/0b/30/2b61876e2722374558b871dfbfcbe4e406626d63f4f6ed92e9c8e24cac37/pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25", size = 2254890 },
+    { url = "https://files.pythonhosted.org/packages/63/24/e2e15e392d00fcf4215907465d8ec2a2f23bcec1481a8ebe4ae760459995/pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699", size = 3147300 },
+    { url = "https://files.pythonhosted.org/packages/43/72/92ad4afaa2afc233dc44184adff289c2e77e8cd916b3ddb72ac69495bda3/pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38", size = 2978742 },
+    { url = "https://files.pythonhosted.org/packages/9e/da/c8d69c5bc85d72a8523fe862f05ababdc52c0a755cfe3d362656bb86552b/pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2", size = 4194349 },
+    { url = "https://files.pythonhosted.org/packages/cd/e8/686d0caeed6b998351d57796496a70185376ed9c8ec7d99e1d19ad591fc6/pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2", size = 4298714 },
+    { url = "https://files.pythonhosted.org/packages/ec/da/430015cec620d622f06854be67fd2f6721f52fc17fca8ac34b32e2d60739/pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527", size = 4208514 },
+    { url = "https://files.pythonhosted.org/packages/44/ae/7e4f6662a9b1cb5f92b9cc9cab8321c381ffbee309210940e57432a4063a/pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa", size = 4380055 },
+    { url = "https://files.pythonhosted.org/packages/74/d5/1a807779ac8a0eeed57f2b92a3c32ea1b696e6140c15bd42eaf908a261cd/pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f", size = 4296751 },
+    { url = "https://files.pythonhosted.org/packages/38/8c/5fa3385163ee7080bc13026d59656267daaaaf3c728c233d530e2c2757c8/pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb", size = 4430378 },
+    { url = "https://files.pythonhosted.org/packages/ca/1d/ad9c14811133977ff87035bf426875b93097fb50af747793f013979facdb/pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798", size = 2249588 },
+    { url = "https://files.pythonhosted.org/packages/fb/01/3755ba287dac715e6afdb333cb1f6d69740a7475220b4637b5ce3d78cec2/pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de", size = 2567509 },
+    { url = "https://files.pythonhosted.org/packages/c0/98/2c7d727079b6be1aba82d195767d35fcc2d32204c7a5820f822df5330152/pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84", size = 2254791 },
+    { url = "https://files.pythonhosted.org/packages/eb/38/998b04cc6f474e78b563716b20eecf42a2fa16a84589d23c8898e64b0ffd/pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b", size = 3150854 },
+    { url = "https://files.pythonhosted.org/packages/13/8e/be23a96292113c6cb26b2aa3c8b3681ec62b44ed5c2bd0b258bd59503d3c/pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003", size = 2982369 },
+    { url = "https://files.pythonhosted.org/packages/97/8a/3db4eaabb7a2ae8203cd3a332a005e4aba00067fc514aaaf3e9721be31f1/pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2", size = 4333703 },
+    { url = "https://files.pythonhosted.org/packages/28/ac/629ffc84ff67b9228fe87a97272ab125bbd4dc462745f35f192d37b822f1/pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a", size = 4412550 },
+    { url = "https://files.pythonhosted.org/packages/d6/07/a505921d36bb2df6868806eaf56ef58699c16c388e378b0dcdb6e5b2fb36/pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8", size = 4461038 },
+    { url = "https://files.pythonhosted.org/packages/d6/b9/fb620dd47fc7cc9678af8f8bd8c772034ca4977237049287e99dda360b66/pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8", size = 2253197 },
+    { url = "https://files.pythonhosted.org/packages/df/86/25dde85c06c89d7fc5db17940f07aae0a56ac69aa9ccb5eb0f09798862a8/pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904", size = 2572169 },
+    { url = "https://files.pythonhosted.org/packages/51/85/9c33f2517add612e17f3381aee7c4072779130c634921a756c97bc29fb49/pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3", size = 2256828 },
+    { url = "https://files.pythonhosted.org/packages/36/57/42a4dd825eab762ba9e690d696d894ba366e06791936056e26e099398cda/pillow-11.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1187739620f2b365de756ce086fdb3604573337cc28a0d3ac4a01ab6b2d2a6d2", size = 3119239 },
+    { url = "https://files.pythonhosted.org/packages/98/f7/25f9f9e368226a1d6cf3507081a1a7944eddd3ca7821023377043f5a83c8/pillow-11.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbbcb7b57dc9c794843e3d1258c0fbf0f48656d46ffe9e09b63bbd6e8cd5d0a2", size = 2950803 },
+    { url = "https://files.pythonhosted.org/packages/59/01/98ead48a6c2e31e6185d4c16c978a67fe3ccb5da5c2ff2ba8475379bb693/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d203af30149ae339ad1b4f710d9844ed8796e97fda23ffbc4cc472968a47d0b", size = 3281098 },
+    { url = "https://files.pythonhosted.org/packages/51/c0/570255b2866a0e4d500a14f950803a2ec273bac7badc43320120b9262450/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a0d3b115009ebb8ac3d2ebec5c2982cc693da935f4ab7bb5c8ebe2f47d36f2", size = 3323665 },
+    { url = "https://files.pythonhosted.org/packages/0e/75/689b4ec0483c42bfc7d1aacd32ade7a226db4f4fac57c6fdcdf90c0731e3/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:73853108f56df97baf2bb8b522f3578221e56f646ba345a372c78326710d3830", size = 3310533 },
+    { url = "https://files.pythonhosted.org/packages/3d/30/38bd6149cf53da1db4bad304c543ade775d225961c4310f30425995cb9ec/pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e58876c91f97b0952eb766123bfef372792ab3f4e3e1f1a2267834c2ab131734", size = 3414886 },
+    { url = "https://files.pythonhosted.org/packages/ec/3d/c32a51d848401bd94cabb8767a39621496491ee7cd5199856b77da9b18ad/pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316", size = 2567508 },
 ]
 
 [[package]]
@@ -3314,29 +3466,29 @@ wheels = [
 
 [[package]]
 name = "platformdirs"
-version = "4.2.2"
+version = "4.3.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f5/52/0763d1d976d5c262df53ddda8d8d4719eedf9594d046f117c25a27261a19/platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3", size = 20916 }
+sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/13/2aa1f0e1364feb2c9ef45302f387ac0bd81484e9c9a4c5688a322fbdfd08/platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee", size = 18146 },
+    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 },
 ]
 
 [[package]]
 name = "playwright"
-version = "1.46.0"
+version = "1.48.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "greenlet" },
     { name = "pyee" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/8f/cf024e7cd4f1f365fea772b7fdde21e421fcd5c0c206bc7cb1c4866cdfbe/playwright-1.46.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:fa60b95c16f6ce954636229a6c9dd885485326bca52d5ba20d02c0bc731a2bbb", size = 34799014 },
-    { url = "https://files.pythonhosted.org/packages/98/d2/50db19ce9b25c2033a6836b5a4eacb7f4be1adff63cfb4c58b46a9eb04ab/playwright-1.46.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:73dcfc24834f4d004bc862ed0d74b4c1406793a8164734238ad035356fddc8ac", size = 33117618 },
-    { url = "https://files.pythonhosted.org/packages/9f/c9/8d0381489d082f86246579a4d51b20ccd6b5b6e570e809fd103b63d1b9bd/playwright-1.46.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:f5acfec1dbdc84d02dc696a17a344227e66c91413eab2036428dab405f195b82", size = 34799011 },
-    { url = "https://files.pythonhosted.org/packages/75/4f/0a410deb48a0ff93107884a6cf06bbdbc97571f41b49e06cf7673c192264/playwright-1.46.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:3b418509f45879f1403d070858657a39bd0b333b23d92c37355682b671726df9", size = 37946374 },
-    { url = "https://files.pythonhosted.org/packages/1f/ac/4df6b6c12bbfbcfd2d2f1c59645ff99732852e920027b877c7c775341ca0/playwright-1.46.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23580f6a3f99757bb9779d29be37144cb9328cd9bafa178e6db5b3ab4b7faf4c", size = 37693981 },
-    { url = "https://files.pythonhosted.org/packages/55/cc/3de814e8e7540d9c6d1b131c5e4457d5a3a56880b3a20235cfe94bbdfef7/playwright-1.46.0-py3-none-win32.whl", hash = "sha256:85f44dd32a23d02850f0ff4dafe51580e5199531fff5121a62489d9838707782", size = 29819013 },
-    { url = "https://files.pythonhosted.org/packages/ba/27/b5f21695ee2ea32fdf826e531066e5633e1056171e217bac3daeefa46017/playwright-1.46.0-py3-none-win_amd64.whl", hash = "sha256:f14a7fd7e24e954eec6ce61d787d499e41937ade811a0818e9a088aabe28ebb6", size = 29819024 },
+    { url = "https://files.pythonhosted.org/packages/b8/41/0166d58c3eeae72377cbcd4cbed84b36cddc551a2b094bf7984198aafb79/playwright-1.48.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:082bce2739f1078acc7d0734da8cc0e23eb91b7fae553f3316d733276f09a6b1", size = 34989519 },
+    { url = "https://files.pythonhosted.org/packages/64/41/d77c47743800fbeb86657611e651e56a17cbb4ebfefa1da0318dc39092df/playwright-1.48.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7da2eb51a19c7f3b523e9faa9d98e7af92e52eb983a099979ea79c9668e3cbf7", size = 33302881 },
+    { url = "https://files.pythonhosted.org/packages/b0/f2/f184f613e6f496ed78e7808ac729900257567d2c1a7930e61026f0e48a5f/playwright-1.48.0-py3-none-macosx_11_0_universal2.whl", hash = "sha256:115b988d1da322358b77bc3bf2d3cc90f8c881e691461538e7df91614c4833c9", size = 34989518 },
+    { url = "https://files.pythonhosted.org/packages/f9/0c/8cde1a86a9a7449a0ba95197f42156198083be1749b717831fba16ab2b5f/playwright-1.48.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:8dabb80e62f667fe2640a8b694e26a7b884c0b4803f7514a3954fc849126227b", size = 38171658 },
+    { url = "https://files.pythonhosted.org/packages/31/dc/121be574222fc74d12ac42921728fb6ba8ac17264a1fdab1993263389082/playwright-1.48.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8ff8303409ebed76bed4c3d655340320b768817d900ba208b394fdd7d7939a5c", size = 37919223 },
+    { url = "https://files.pythonhosted.org/packages/3a/c5/ff02a780c76e9cf20296e2d1743bb42b1e81d62535802eb6d67b1b6b7b47/playwright-1.48.0-py3-none-win32.whl", hash = "sha256:85598c360c590076d4f435525be991246d74a905b654ac19d26eab7ed9b98b2d", size = 29983089 },
+    { url = "https://files.pythonhosted.org/packages/45/88/b6459c93a8bc0b96e7a33b6744bbef2740a0b78b0534542a037d220427f0/playwright-1.48.0-py3-none-win_amd64.whl", hash = "sha256:e0e87b0c4dc8fce83c725dd851aec37bc4e882bb225ec8a96bd83cf32d4f1623", size = 29983099 },
 ]
 
 [[package]]
@@ -3350,28 +3502,29 @@ wheels = [
 
 [[package]]
 name = "poethepoet"
-version = "0.27.0"
+version = "0.29.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pastel" },
-    { name = "tomli" },
+    { name = "pyyaml" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/90/d9/9bc436232310b5097df77662a6786c0337d52a4209ede516f9f59422286b/poethepoet-0.27.0.tar.gz", hash = "sha256:907ab4dc1bc6326be5a3b10d2aa39d1acc0ca12024317d9506fbe9c0cdc912c9", size = 57044 }
+sdist = { url = "https://files.pythonhosted.org/packages/dc/7a/7144e47128022146502e179e259b312335bc1465384025eee92d4c7e16b2/poethepoet-0.29.0.tar.gz", hash = "sha256:676842302f2304a86b31ac56398dd672fae8471128d2086896393384dbafc095", size = 58619 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/91/98f449a28499125b3cf60048d5c48addf19ae3937485f8cb6cc319026e2f/poethepoet-0.27.0-py3-none-any.whl", hash = "sha256:0032d980a623b96e26dc7450ae200b0998be523f27d297d799b97510fe252a24", size = 73476 },
+    { url = "https://files.pythonhosted.org/packages/b5/7d/871be58cc970ab4c9a541d64b77b7454d150a409c3e48b53fc9eac7a8967/poethepoet-0.29.0-py3-none-any.whl", hash = "sha256:f8dfe55006dcfb5cf31bcb1904e1262e1c642a4502fee3688cbf1bddfe5c7601", size = 76069 },
 ]
 
 [[package]]
 name = "polars"
-version = "1.6.0"
+version = "1.11.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/2b/a9/cf169ce361224d4b397f52d6fcceb191452ecdc50813ce2aa6c60ff46e04/polars-1.6.0.tar.gz", hash = "sha256:d7e8d5e577883a9755bc3be92ecbf6f20bced68267bdb8bdb440120e905cc19c", size = 3929590 }
+sdist = { url = "https://files.pythonhosted.org/packages/42/88/4b06b7636f80575b9286781d12e263514a21108ba00e0f8b209478fa2a04/polars-1.11.0.tar.gz", hash = "sha256:4fbdd772b5f4538eb9f5ae4f3256290dba1f6c6b9d5226aed918801ed51089f4", size = 4076185 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/51/a6/00e9c0cc08d8b279ee576dca105fb5b6c3f812f56ce6bbefdf127773641b/polars-1.6.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:6d1665c23e3574ebd47a26a5d7b619e6e73e53718c3b0bfd7d08b6a0a4ae7daa", size = 30510442 },
-    { url = "https://files.pythonhosted.org/packages/95/0d/7665314925d774236404919678c197abe4818d1820387017a23f21e27815/polars-1.6.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d7f3abf085adf034720b358119c4c8e144bcc2d96010b7e7d0afa11b80da383c", size = 26758515 },
-    { url = "https://files.pythonhosted.org/packages/04/1c/1a0a0a2c076bec8501ada9496afe5486c9e994558b0c80057f7e3ee6ec16/polars-1.6.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a166adb429f8ee099c9d803e7470a80c76368437a8b272c67cef9eef6d5e9da1", size = 31869680 },
-    { url = "https://files.pythonhosted.org/packages/c1/95/224139dbd93ce450f194233f643f08e759f369c10c5bd62a13d615dd886c/polars-1.6.0-cp38-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:1c811b772c9476f7f0bb4445a8387d2ab6d86f5e79140b1bfba914a32788d261", size = 28441792 },
-    { url = "https://files.pythonhosted.org/packages/fa/cb/8f97ea9bbe41f862cc685b1f223ee8508c60f6510918de75637b3539e62d/polars-1.6.0-cp38-abi3-win_amd64.whl", hash = "sha256:ffae15ffa80fda5cc3af44a340b565bcf7f2ab6d7854d3f967baf505710c78e2", size = 31424668 },
+    { url = "https://files.pythonhosted.org/packages/74/fa/185cf232322e6e1b0b07ef92914853f60b067b16bfae5e9f4ebfc752a3d2/polars-1.11.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d20152fc29b83ffa4ca7d92b056866b1755dda346a3841106d9b361ccc96d94b", size = 32847858 },
+    { url = "https://files.pythonhosted.org/packages/9c/dc/fda904586956236da0e26da51ed4f09487aa42f51634b8df6477f08ee7d5/polars-1.11.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:fd48e8f607ae42f49abf4491e67fb1ad7d85157cb0a45a164fc4d1760d67e8ef", size = 28813631 },
+    { url = "https://files.pythonhosted.org/packages/94/25/7eaafa7320e5bdb88f7f793a08ab0a877309eef1a4537351e362cbd1dcba/polars-1.11.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1293f826e5469626d2a4da5e66afb0b46c6f8cb43d16e301d99aa5b911518c34", size = 34046798 },
+    { url = "https://files.pythonhosted.org/packages/47/03/374d9c4e6176ba4af5aa95ff002f3b5e41aff86da6037332b5107b74b5df/polars-1.11.0-cp39-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:0c41c79fc7e2159a0d8fb69a3d0d26c402846d10fe6ff772b2591766e39dfac4", size = 30410176 },
+    { url = "https://files.pythonhosted.org/packages/28/6b/0420d9a29e303b43be581ec70025329d84bd536ccef1a7907c81b8e352f6/polars-1.11.0-cp39-abi3-win_amd64.whl", hash = "sha256:a361d50ab5b0a6387bfe07a8a755bad7e61ba3d03381e4d1e343f49f6f0eb893", size = 33713325 },
 ]
 
 [[package]]
@@ -3388,57 +3541,130 @@ wheels = [
 
 [[package]]
 name = "prompt-toolkit"
-version = "3.0.47"
+version = "3.0.48"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "wcwidth" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/47/6d/0279b119dafc74c1220420028d490c4399b790fc1256998666e3a341879f/prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360", size = 425859 }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/4f/feb5e137aff82f7c7f3248267b97451da3644f6cdc218edfe549fb354127/prompt_toolkit-3.0.48.tar.gz", hash = "sha256:d6623ab0477a80df74e646bdbc93621143f5caf104206aa29294d53de1a03d90", size = 424684 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/23/22750c4b768f09386d1c3cc4337953e8936f48a888fa6dddfb669b2c9088/prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10", size = 386411 },
+    { url = "https://files.pythonhosted.org/packages/a9/6a/fd08d94654f7e67c52ca30523a178b3f8ccc4237fce4be90d39c938a831a/prompt_toolkit-3.0.48-py3-none-any.whl", hash = "sha256:f49a827f90062e411f1ce1f854f2aedb3c23353244f8108b89283587397ac10e", size = 386595 },
+]
+
+[[package]]
+name = "propcache"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/4d/5e5a60b78dbc1d464f8a7bbaeb30957257afdc8512cbb9dfd5659304f5cd/propcache-0.2.0.tar.gz", hash = "sha256:df81779732feb9d01e5d513fad0122efb3d53bbc75f61b2a4f29a020bc985e70", size = 40951 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/08/1963dfb932b8d74d5b09098507b37e9b96c835ba89ab8aad35aa330f4ff3/propcache-0.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c5869b8fd70b81835a6f187c5fdbe67917a04d7e52b6e7cc4e5fe39d55c39d58", size = 80712 },
+    { url = "https://files.pythonhosted.org/packages/e6/59/49072aba9bf8a8ed958e576182d46f038e595b17ff7408bc7e8807e721e1/propcache-0.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:952e0d9d07609d9c5be361f33b0d6d650cd2bae393aabb11d9b719364521984b", size = 46301 },
+    { url = "https://files.pythonhosted.org/packages/33/a2/6b1978c2e0d80a678e2c483f45e5443c15fe5d32c483902e92a073314ef1/propcache-0.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:33ac8f098df0585c0b53009f039dfd913b38c1d2edafed0cedcc0c32a05aa110", size = 45581 },
+    { url = "https://files.pythonhosted.org/packages/43/95/55acc9adff8f997c7572f23d41993042290dfb29e404cdadb07039a4386f/propcache-0.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:97e48e8875e6c13909c800fa344cd54cc4b2b0db1d5f911f840458a500fde2c2", size = 208659 },
+    { url = "https://files.pythonhosted.org/packages/bd/2c/ef7371ff715e6cd19ea03fdd5637ecefbaa0752fee5b0f2fe8ea8407ee01/propcache-0.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:388f3217649d6d59292b722d940d4d2e1e6a7003259eb835724092a1cca0203a", size = 222613 },
+    { url = "https://files.pythonhosted.org/packages/5e/1c/fef251f79fd4971a413fa4b1ae369ee07727b4cc2c71e2d90dfcde664fbb/propcache-0.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f571aea50ba5623c308aa146eb650eebf7dbe0fd8c5d946e28343cb3b5aad577", size = 221067 },
+    { url = "https://files.pythonhosted.org/packages/8d/e7/22e76ae6fc5a1708bdce92bdb49de5ebe89a173db87e4ef597d6bbe9145a/propcache-0.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3dfafb44f7bb35c0c06eda6b2ab4bfd58f02729e7c4045e179f9a861b07c9850", size = 208920 },
+    { url = "https://files.pythonhosted.org/packages/04/3e/f10aa562781bcd8a1e0b37683a23bef32bdbe501d9cc7e76969becaac30d/propcache-0.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3ebe9a75be7ab0b7da2464a77bb27febcb4fab46a34f9288f39d74833db7f61", size = 200050 },
+    { url = "https://files.pythonhosted.org/packages/d0/98/8ac69f638358c5f2a0043809c917802f96f86026e86726b65006830f3dc6/propcache-0.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d2f0d0f976985f85dfb5f3d685697ef769faa6b71993b46b295cdbbd6be8cc37", size = 202346 },
+    { url = "https://files.pythonhosted.org/packages/ee/78/4acfc5544a5075d8e660af4d4e468d60c418bba93203d1363848444511ad/propcache-0.2.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:a3dc1a4b165283bd865e8f8cb5f0c64c05001e0718ed06250d8cac9bec115b48", size = 199750 },
+    { url = "https://files.pythonhosted.org/packages/a2/8f/90ada38448ca2e9cf25adc2fe05d08358bda1b9446f54a606ea38f41798b/propcache-0.2.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9e0f07b42d2a50c7dd2d8675d50f7343d998c64008f1da5fef888396b7f84630", size = 201279 },
+    { url = "https://files.pythonhosted.org/packages/08/31/0e299f650f73903da851f50f576ef09bfffc8e1519e6a2f1e5ed2d19c591/propcache-0.2.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:e63e3e1e0271f374ed489ff5ee73d4b6e7c60710e1f76af5f0e1a6117cd26394", size = 211035 },
+    { url = "https://files.pythonhosted.org/packages/85/3e/e356cc6b09064bff1c06d0b2413593e7c925726f0139bc7acef8a21e87a8/propcache-0.2.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:56bb5c98f058a41bb58eead194b4db8c05b088c93d94d5161728515bd52b052b", size = 215565 },
+    { url = "https://files.pythonhosted.org/packages/8b/54/4ef7236cd657e53098bd05aa59cbc3cbf7018fba37b40eaed112c3921e51/propcache-0.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7665f04d0c7f26ff8bb534e1c65068409bf4687aa2534faf7104d7182debb336", size = 207604 },
+    { url = "https://files.pythonhosted.org/packages/1f/27/d01d7799c068443ee64002f0655d82fb067496897bf74b632e28ee6a32cf/propcache-0.2.0-cp310-cp310-win32.whl", hash = "sha256:7cf18abf9764746b9c8704774d8b06714bcb0a63641518a3a89c7f85cc02c2ad", size = 40526 },
+    { url = "https://files.pythonhosted.org/packages/bb/44/6c2add5eeafb7f31ff0d25fbc005d930bea040a1364cf0f5768750ddf4d1/propcache-0.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:cfac69017ef97db2438efb854edf24f5a29fd09a536ff3a992b75990720cdc99", size = 44958 },
+    { url = "https://files.pythonhosted.org/packages/e0/1c/71eec730e12aec6511e702ad0cd73c2872eccb7cad39de8ba3ba9de693ef/propcache-0.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:63f13bf09cc3336eb04a837490b8f332e0db41da66995c9fd1ba04552e516354", size = 80811 },
+    { url = "https://files.pythonhosted.org/packages/89/c3/7e94009f9a4934c48a371632197406a8860b9f08e3f7f7d922ab69e57a41/propcache-0.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608cce1da6f2672a56b24a015b42db4ac612ee709f3d29f27a00c943d9e851de", size = 46365 },
+    { url = "https://files.pythonhosted.org/packages/c0/1d/c700d16d1d6903aeab28372fe9999762f074b80b96a0ccc953175b858743/propcache-0.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:466c219deee4536fbc83c08d09115249db301550625c7fef1c5563a584c9bc87", size = 45602 },
+    { url = "https://files.pythonhosted.org/packages/2e/5e/4a3e96380805bf742712e39a4534689f4cddf5fa2d3a93f22e9fd8001b23/propcache-0.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc2db02409338bf36590aa985a461b2c96fce91f8e7e0f14c50c5fcc4f229016", size = 236161 },
+    { url = "https://files.pythonhosted.org/packages/a5/85/90132481183d1436dff6e29f4fa81b891afb6cb89a7306f32ac500a25932/propcache-0.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a6ed8db0a556343d566a5c124ee483ae113acc9a557a807d439bcecc44e7dfbb", size = 244938 },
+    { url = "https://files.pythonhosted.org/packages/4a/89/c893533cb45c79c970834274e2d0f6d64383ec740be631b6a0a1d2b4ddc0/propcache-0.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:91997d9cb4a325b60d4e3f20967f8eb08dfcb32b22554d5ef78e6fd1dda743a2", size = 243576 },
+    { url = "https://files.pythonhosted.org/packages/8c/56/98c2054c8526331a05f205bf45cbb2cda4e58e56df70e76d6a509e5d6ec6/propcache-0.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c7dde9e533c0a49d802b4f3f218fa9ad0a1ce21f2c2eb80d5216565202acab4", size = 236011 },
+    { url = "https://files.pythonhosted.org/packages/2d/0c/8b8b9f8a6e1abd869c0fa79b907228e7abb966919047d294ef5df0d136cf/propcache-0.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffcad6c564fe6b9b8916c1aefbb37a362deebf9394bd2974e9d84232e3e08504", size = 224834 },
+    { url = "https://files.pythonhosted.org/packages/18/bb/397d05a7298b7711b90e13108db697732325cafdcd8484c894885c1bf109/propcache-0.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:97a58a28bcf63284e8b4d7b460cbee1edaab24634e82059c7b8c09e65284f178", size = 224946 },
+    { url = "https://files.pythonhosted.org/packages/25/19/4fc08dac19297ac58135c03770b42377be211622fd0147f015f78d47cd31/propcache-0.2.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:945db8ee295d3af9dbdbb698cce9bbc5c59b5c3fe328bbc4387f59a8a35f998d", size = 217280 },
+    { url = "https://files.pythonhosted.org/packages/7e/76/c79276a43df2096ce2aba07ce47576832b1174c0c480fe6b04bd70120e59/propcache-0.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:39e104da444a34830751715f45ef9fc537475ba21b7f1f5b0f4d71a3b60d7fe2", size = 220088 },
+    { url = "https://files.pythonhosted.org/packages/c3/9a/8a8cf428a91b1336b883f09c8b884e1734c87f724d74b917129a24fe2093/propcache-0.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c5ecca8f9bab618340c8e848d340baf68bcd8ad90a8ecd7a4524a81c1764b3db", size = 233008 },
+    { url = "https://files.pythonhosted.org/packages/25/7b/768a8969abd447d5f0f3333df85c6a5d94982a1bc9a89c53c154bf7a8b11/propcache-0.2.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c436130cc779806bdf5d5fae0d848713105472b8566b75ff70048c47d3961c5b", size = 237719 },
+    { url = "https://files.pythonhosted.org/packages/ed/0d/e5d68ccc7976ef8b57d80613ac07bbaf0614d43f4750cf953f0168ef114f/propcache-0.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:191db28dc6dcd29d1a3e063c3be0b40688ed76434622c53a284e5427565bbd9b", size = 227729 },
+    { url = "https://files.pythonhosted.org/packages/05/64/17eb2796e2d1c3d0c431dc5f40078d7282f4645af0bb4da9097fbb628c6c/propcache-0.2.0-cp311-cp311-win32.whl", hash = "sha256:5f2564ec89058ee7c7989a7b719115bdfe2a2fb8e7a4543b8d1c0cc4cf6478c1", size = 40473 },
+    { url = "https://files.pythonhosted.org/packages/83/c5/e89fc428ccdc897ade08cd7605f174c69390147526627a7650fb883e0cd0/propcache-0.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e2e54267980349b723cff366d1e29b138b9a60fa376664a157a342689553f71", size = 44921 },
+    { url = "https://files.pythonhosted.org/packages/7c/46/a41ca1097769fc548fc9216ec4c1471b772cc39720eb47ed7e38ef0006a9/propcache-0.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2ee7606193fb267be4b2e3b32714f2d58cad27217638db98a60f9efb5efeccc2", size = 80800 },
+    { url = "https://files.pythonhosted.org/packages/75/4f/93df46aab9cc473498ff56be39b5f6ee1e33529223d7a4d8c0a6101a9ba2/propcache-0.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:91ee8fc02ca52e24bcb77b234f22afc03288e1dafbb1f88fe24db308910c4ac7", size = 46443 },
+    { url = "https://files.pythonhosted.org/packages/0b/17/308acc6aee65d0f9a8375e36c4807ac6605d1f38074b1581bd4042b9fb37/propcache-0.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2e900bad2a8456d00a113cad8c13343f3b1f327534e3589acc2219729237a2e8", size = 45676 },
+    { url = "https://files.pythonhosted.org/packages/65/44/626599d2854d6c1d4530b9a05e7ff2ee22b790358334b475ed7c89f7d625/propcache-0.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f52a68c21363c45297aca15561812d542f8fc683c85201df0bebe209e349f793", size = 246191 },
+    { url = "https://files.pythonhosted.org/packages/f2/df/5d996d7cb18df076debae7d76ac3da085c0575a9f2be6b1f707fe227b54c/propcache-0.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1e41d67757ff4fbc8ef2af99b338bfb955010444b92929e9e55a6d4dcc3c4f09", size = 251791 },
+    { url = "https://files.pythonhosted.org/packages/2e/6d/9f91e5dde8b1f662f6dd4dff36098ed22a1ef4e08e1316f05f4758f1576c/propcache-0.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a64e32f8bd94c105cc27f42d3b658902b5bcc947ece3c8fe7bc1b05982f60e89", size = 253434 },
+    { url = "https://files.pythonhosted.org/packages/3c/e9/1b54b7e26f50b3e0497cd13d3483d781d284452c2c50dd2a615a92a087a3/propcache-0.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:55346705687dbd7ef0d77883ab4f6fabc48232f587925bdaf95219bae072491e", size = 248150 },
+    { url = "https://files.pythonhosted.org/packages/a7/ef/a35bf191c8038fe3ce9a414b907371c81d102384eda5dbafe6f4dce0cf9b/propcache-0.2.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:00181262b17e517df2cd85656fcd6b4e70946fe62cd625b9d74ac9977b64d8d9", size = 233568 },
+    { url = "https://files.pythonhosted.org/packages/97/d9/d00bb9277a9165a5e6d60f2142cd1a38a750045c9c12e47ae087f686d781/propcache-0.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6994984550eaf25dd7fc7bd1b700ff45c894149341725bb4edc67f0ffa94efa4", size = 229874 },
+    { url = "https://files.pythonhosted.org/packages/8e/78/c123cf22469bdc4b18efb78893e69c70a8b16de88e6160b69ca6bdd88b5d/propcache-0.2.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:56295eb1e5f3aecd516d91b00cfd8bf3a13991de5a479df9e27dd569ea23959c", size = 225857 },
+    { url = "https://files.pythonhosted.org/packages/31/1b/fd6b2f1f36d028820d35475be78859d8c89c8f091ad30e377ac49fd66359/propcache-0.2.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:439e76255daa0f8151d3cb325f6dd4a3e93043e6403e6491813bcaaaa8733887", size = 227604 },
+    { url = "https://files.pythonhosted.org/packages/99/36/b07be976edf77a07233ba712e53262937625af02154353171716894a86a6/propcache-0.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f6475a1b2ecb310c98c28d271a30df74f9dd436ee46d09236a6b750a7599ce57", size = 238430 },
+    { url = "https://files.pythonhosted.org/packages/0d/64/5822f496c9010e3966e934a011ac08cac8734561842bc7c1f65586e0683c/propcache-0.2.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3444cdba6628accf384e349014084b1cacd866fbb88433cd9d279d90a54e0b23", size = 244814 },
+    { url = "https://files.pythonhosted.org/packages/fd/bd/8657918a35d50b18a9e4d78a5df7b6c82a637a311ab20851eef4326305c1/propcache-0.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a9d9b4d0a9b38d1c391bb4ad24aa65f306c6f01b512e10a8a34a2dc5675d348", size = 235922 },
+    { url = "https://files.pythonhosted.org/packages/a8/6f/ec0095e1647b4727db945213a9f395b1103c442ef65e54c62e92a72a3f75/propcache-0.2.0-cp312-cp312-win32.whl", hash = "sha256:69d3a98eebae99a420d4b28756c8ce6ea5a29291baf2dc9ff9414b42676f61d5", size = 40177 },
+    { url = "https://files.pythonhosted.org/packages/20/a2/bd0896fdc4f4c1db46d9bc361c8c79a9bf08ccc08ba054a98e38e7ba1557/propcache-0.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:ad9c9b99b05f163109466638bd30ada1722abb01bbb85c739c50b6dc11f92dc3", size = 44446 },
+    { url = "https://files.pythonhosted.org/packages/a8/a7/5f37b69197d4f558bfef5b4bceaff7c43cc9b51adf5bd75e9081d7ea80e4/propcache-0.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ecddc221a077a8132cf7c747d5352a15ed763b674c0448d811f408bf803d9ad7", size = 78120 },
+    { url = "https://files.pythonhosted.org/packages/c8/cd/48ab2b30a6b353ecb95a244915f85756d74f815862eb2ecc7a518d565b48/propcache-0.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0e53cb83fdd61cbd67202735e6a6687a7b491c8742dfc39c9e01e80354956763", size = 45127 },
+    { url = "https://files.pythonhosted.org/packages/a5/ba/0a1ef94a3412aab057bd996ed5f0ac7458be5bf469e85c70fa9ceb43290b/propcache-0.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92fe151145a990c22cbccf9ae15cae8ae9eddabfc949a219c9f667877e40853d", size = 44419 },
+    { url = "https://files.pythonhosted.org/packages/b4/6c/ca70bee4f22fa99eacd04f4d2f1699be9d13538ccf22b3169a61c60a27fa/propcache-0.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6a21ef516d36909931a2967621eecb256018aeb11fc48656e3257e73e2e247a", size = 229611 },
+    { url = "https://files.pythonhosted.org/packages/19/70/47b872a263e8511ca33718d96a10c17d3c853aefadeb86dc26e8421184b9/propcache-0.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f88a4095e913f98988f5b338c1d4d5d07dbb0b6bad19892fd447484e483ba6b", size = 234005 },
+    { url = "https://files.pythonhosted.org/packages/4f/be/3b0ab8c84a22e4a3224719099c1229ddfdd8a6a1558cf75cb55ee1e35c25/propcache-0.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5a5b3bb545ead161be780ee85a2b54fdf7092815995661947812dde94a40f6fb", size = 237270 },
+    { url = "https://files.pythonhosted.org/packages/04/d8/f071bb000d4b8f851d312c3c75701e586b3f643fe14a2e3409b1b9ab3936/propcache-0.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67aeb72e0f482709991aa91345a831d0b707d16b0257e8ef88a2ad246a7280bf", size = 231877 },
+    { url = "https://files.pythonhosted.org/packages/93/e7/57a035a1359e542bbb0a7df95aad6b9871ebee6dce2840cb157a415bd1f3/propcache-0.2.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c997f8c44ec9b9b0bcbf2d422cc00a1d9b9c681f56efa6ca149a941e5560da2", size = 217848 },
+    { url = "https://files.pythonhosted.org/packages/f0/93/d1dea40f112ec183398fb6c42fde340edd7bab202411c4aa1a8289f461b6/propcache-0.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a66df3d4992bc1d725b9aa803e8c5a66c010c65c741ad901e260ece77f58d2f", size = 216987 },
+    { url = "https://files.pythonhosted.org/packages/62/4c/877340871251145d3522c2b5d25c16a1690ad655fbab7bb9ece6b117e39f/propcache-0.2.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3ebbcf2a07621f29638799828b8d8668c421bfb94c6cb04269130d8de4fb7136", size = 212451 },
+    { url = "https://files.pythonhosted.org/packages/7c/bb/a91b72efeeb42906ef58ccf0cdb87947b54d7475fee3c93425d732f16a61/propcache-0.2.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1235c01ddaa80da8235741e80815ce381c5267f96cc49b1477fdcf8c047ef325", size = 212879 },
+    { url = "https://files.pythonhosted.org/packages/9b/7f/ee7fea8faac57b3ec5d91ff47470c6c5d40d7f15d0b1fccac806348fa59e/propcache-0.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3947483a381259c06921612550867b37d22e1df6d6d7e8361264b6d037595f44", size = 222288 },
+    { url = "https://files.pythonhosted.org/packages/ff/d7/acd67901c43d2e6b20a7a973d9d5fd543c6e277af29b1eb0e1f7bd7ca7d2/propcache-0.2.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d5bed7f9805cc29c780f3aee05de3262ee7ce1f47083cfe9f77471e9d6777e83", size = 228257 },
+    { url = "https://files.pythonhosted.org/packages/8d/6f/6272ecc7a8daad1d0754cfc6c8846076a8cb13f810005c79b15ce0ef0cf2/propcache-0.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e4a91d44379f45f5e540971d41e4626dacd7f01004826a18cb048e7da7e96544", size = 221075 },
+    { url = "https://files.pythonhosted.org/packages/7c/bd/c7a6a719a6b3dd8b3aeadb3675b5783983529e4a3185946aa444d3e078f6/propcache-0.2.0-cp313-cp313-win32.whl", hash = "sha256:f902804113e032e2cdf8c71015651c97af6418363bea8d78dc0911d56c335032", size = 39654 },
+    { url = "https://files.pythonhosted.org/packages/88/e7/0eef39eff84fa3e001b44de0bd41c7c0e3432e7648ffd3d64955910f002d/propcache-0.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:8f188cfcc64fb1266f4684206c9de0e80f54622c3f22a910cbd200478aeae61e", size = 43705 },
+    { url = "https://files.pythonhosted.org/packages/3d/b6/e6d98278f2d49b22b4d033c9f792eda783b9ab2094b041f013fc69bcde87/propcache-0.2.0-py3-none-any.whl", hash = "sha256:2ccc28197af5313706511fab3a8b66dcd6da067a1331372c82ea1cb74285e036", size = 11603 },
 ]
 
 [[package]]
 name = "proto-plus"
-version = "1.24.0"
+version = "1.25.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3e/fc/e9a65cd52c1330d8d23af6013651a0bc50b6d76bcbdf91fae7cd19c68f29/proto-plus-1.24.0.tar.gz", hash = "sha256:30b72a5ecafe4406b0d339db35b56c4059064e69227b8c3bda7462397f966445", size = 55942 }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/05/74417b2061e1bf1b82776037cad97094228fa1c1b6e82d08a78d3fb6ddb6/proto_plus-1.25.0.tar.gz", hash = "sha256:fbb17f57f7bd05a68b7707e745e26528b0b3c34e378db91eef93912c54982d91", size = 56124 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/6f/db31f0711c0402aa477257205ce7d29e86a75cb52cd19f7afb585f75cda0/proto_plus-1.24.0-py3-none-any.whl", hash = "sha256:402576830425e5f6ce4c2a6702400ac79897dab0b4343821aa5188b0fab81a12", size = 50080 },
+    { url = "https://files.pythonhosted.org/packages/dd/25/0b7cc838ae3d76d46539020ec39fc92bfc9acc29367e58fe912702c2a79e/proto_plus-1.25.0-py3-none-any.whl", hash = "sha256:c91fc4a65074ade8e458e95ef8bac34d4008daa7cce4a12d6707066fca648961", size = 50126 },
 ]
 
 [[package]]
 name = "protobuf"
-version = "4.25.4"
+version = "4.25.5"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/ab/cb61a4b87b2e7e6c312dce33602bd5884797fd054e0e53205f1c27cf0f66/protobuf-4.25.4.tar.gz", hash = "sha256:0dc4a62cc4052a036ee2204d26fe4d835c62827c855c8a03f29fe6da146b380d", size = 380283 }
+sdist = { url = "https://files.pythonhosted.org/packages/67/dd/48d5fdb68ec74d70fabcc252e434492e56f70944d9f17b6a15e3746d2295/protobuf-4.25.5.tar.gz", hash = "sha256:7f8249476b4a9473645db7f8ab42b02fe1488cbe5fb72fddd445e0665afd8584", size = 380315 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/43/27b48d9040763b78177d3083e16c70dba6e3c3ee2af64b659f6332c2b06e/protobuf-4.25.4-cp310-abi3-win32.whl", hash = "sha256:db9fd45183e1a67722cafa5c1da3e85c6492a5383f127c86c4c4aa4845867dc4", size = 392409 },
-    { url = "https://files.pythonhosted.org/packages/0c/d4/589d673ada9c4c62d5f155218d7ff7ac796efb9c6af95b0bd29d438ae16e/protobuf-4.25.4-cp310-abi3-win_amd64.whl", hash = "sha256:ba3d8504116a921af46499471c63a85260c1a5fc23333154a427a310e015d26d", size = 413398 },
-    { url = "https://files.pythonhosted.org/packages/34/ca/bf85ffe3dd16f1f2aaa6c006da8118800209af3da160ae4d4f47500eabd9/protobuf-4.25.4-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:eecd41bfc0e4b1bd3fa7909ed93dd14dd5567b98c941d6c1ad08fdcab3d6884b", size = 394160 },
-    { url = "https://files.pythonhosted.org/packages/68/1d/e8961af9a8e534d66672318d6b70ea8e3391a6b13e16a29b039e4a99c214/protobuf-4.25.4-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:4c8a70fdcb995dcf6c8966cfa3a29101916f7225e9afe3ced4395359955d3835", size = 293700 },
-    { url = "https://files.pythonhosted.org/packages/ca/6c/cc7ab2fb3a4a7f07f211d8a7bbb76bba633eb09b148296dbd4281e217f95/protobuf-4.25.4-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:3319e073562e2515c6ddc643eb92ce20809f5d8f10fead3332f71c63be6a7040", size = 294612 },
-    { url = "https://files.pythonhosted.org/packages/b5/95/0ba7f66934a0a798006f06fc3d74816da2b7a2bcfd9b98c53d26f684c89e/protobuf-4.25.4-py3-none-any.whl", hash = "sha256:bfbebc1c8e4793cfd58589acfb8a1026be0003e852b9da7db5a4285bde996978", size = 156464 },
+    { url = "https://files.pythonhosted.org/packages/00/35/1b3c5a5e6107859c4ca902f4fbb762e48599b78129a05d20684fef4a4d04/protobuf-4.25.5-cp310-abi3-win32.whl", hash = "sha256:5e61fd921603f58d2f5acb2806a929b4675f8874ff5f330b7d6f7e2e784bbcd8", size = 392457 },
+    { url = "https://files.pythonhosted.org/packages/a7/ad/bf3f358e90b7e70bf7fb520702cb15307ef268262292d3bdb16ad8ebc815/protobuf-4.25.5-cp310-abi3-win_amd64.whl", hash = "sha256:4be0571adcbe712b282a330c6e89eae24281344429ae95c6d85e79e84780f5ea", size = 413449 },
+    { url = "https://files.pythonhosted.org/packages/51/49/d110f0a43beb365758a252203c43eaaad169fe7749da918869a8c991f726/protobuf-4.25.5-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:b2fde3d805354df675ea4c7c6338c1aecd254dfc9925e88c6d31a2bcb97eb173", size = 394248 },
+    { url = "https://files.pythonhosted.org/packages/c6/ab/0f384ca0bc6054b1a7b6009000ab75d28a5506e4459378b81280ae7fd358/protobuf-4.25.5-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:919ad92d9b0310070f8356c24b855c98df2b8bd207ebc1c0c6fcc9ab1e007f3d", size = 293717 },
+    { url = "https://files.pythonhosted.org/packages/05/a6/094a2640be576d760baa34c902dcb8199d89bce9ed7dd7a6af74dcbbd62d/protobuf-4.25.5-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:fe14e16c22be926d3abfcb500e60cab068baf10b542b8c858fa27e098123e331", size = 294635 },
+    { url = "https://files.pythonhosted.org/packages/33/90/f198a61df8381fb43ae0fe81b3d2718e8dcc51ae8502c7657ab9381fbc4f/protobuf-4.25.5-py3-none-any.whl", hash = "sha256:0aebecb809cae990f8129ada5ca273d9d670b76d9bfc9b1809f0a9c02b7dbf41", size = 156467 },
 ]
 
 [[package]]
 name = "psutil"
-version = "6.0.0"
+version = "6.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/c7/8c6872f7372eb6a6b2e4708b88419fb46b857f7a2e1892966b851cc79fc9/psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2", size = 508067 }
+sdist = { url = "https://files.pythonhosted.org/packages/26/10/2a30b13c61e7cf937f4adf90710776b7918ed0a9c434e2c38224732af310/psutil-6.1.0.tar.gz", hash = "sha256:353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a", size = 508565 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c5/66/78c9c3020f573c58101dc43a44f6855d01bbbd747e24da2f0c4491200ea3/psutil-6.0.0-cp27-none-win32.whl", hash = "sha256:02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35", size = 249766 },
-    { url = "https://files.pythonhosted.org/packages/e1/3f/2403aa9558bea4d3854b0e5e567bc3dd8e9fbc1fc4453c0aa9aafeb75467/psutil-6.0.0-cp27-none-win_amd64.whl", hash = "sha256:21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1", size = 253024 },
-    { url = "https://files.pythonhosted.org/packages/0b/37/f8da2fbd29690b3557cca414c1949f92162981920699cd62095a984983bf/psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0", size = 250961 },
-    { url = "https://files.pythonhosted.org/packages/35/56/72f86175e81c656a01c4401cd3b1c923f891b31fbcebe98985894176d7c9/psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0", size = 287478 },
-    { url = "https://files.pythonhosted.org/packages/19/74/f59e7e0d392bc1070e9a70e2f9190d652487ac115bb16e2eff6b22ad1d24/psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd", size = 290455 },
-    { url = "https://files.pythonhosted.org/packages/cd/5f/60038e277ff0a9cc8f0c9ea3d0c5eb6ee1d2470ea3f9389d776432888e47/psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132", size = 292046 },
-    { url = "https://files.pythonhosted.org/packages/8b/20/2ff69ad9c35c3df1858ac4e094f20bd2374d33c8643cf41da8fd7cdcb78b/psutil-6.0.0-cp37-abi3-win32.whl", hash = "sha256:a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d", size = 253560 },
-    { url = "https://files.pythonhosted.org/packages/73/44/561092313ae925f3acfaace6f9ddc4f6a9c748704317bad9c8c8f8a36a79/psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3", size = 257399 },
-    { url = "https://files.pythonhosted.org/packages/7c/06/63872a64c312a24fb9b4af123ee7007a306617da63ff13bcc1432386ead7/psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0", size = 251988 },
+    { url = "https://files.pythonhosted.org/packages/da/2b/f4dea5d993d9cd22ad958eea828a41d5d225556123d372f02547c29c4f97/psutil-6.1.0-cp27-none-win32.whl", hash = "sha256:9118f27452b70bb1d9ab3198c1f626c2499384935aaf55388211ad982611407e", size = 246648 },
+    { url = "https://files.pythonhosted.org/packages/9f/14/4aa97a7f2e0ac33a050d990ab31686d651ae4ef8c86661fef067f00437b9/psutil-6.1.0-cp27-none-win_amd64.whl", hash = "sha256:a8506f6119cff7015678e2bce904a4da21025cc70ad283a53b099e7620061d85", size = 249905 },
+    { url = "https://files.pythonhosted.org/packages/01/9e/8be43078a171381953cfee33c07c0d628594b5dbfc5157847b85022c2c1b/psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688", size = 247762 },
+    { url = "https://files.pythonhosted.org/packages/1d/cb/313e80644ea407f04f6602a9e23096540d9dc1878755f3952ea8d3d104be/psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e", size = 248777 },
+    { url = "https://files.pythonhosted.org/packages/65/8e/bcbe2025c587b5d703369b6a75b65d41d1367553da6e3f788aff91eaf5bd/psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38", size = 284259 },
+    { url = "https://files.pythonhosted.org/packages/58/4d/8245e6f76a93c98aab285a43ea71ff1b171bcd90c9d238bf81f7021fb233/psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b", size = 287255 },
+    { url = "https://files.pythonhosted.org/packages/27/c2/d034856ac47e3b3cdfa9720d0e113902e615f4190d5d1bdb8df4b2015fb2/psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a", size = 288804 },
+    { url = "https://files.pythonhosted.org/packages/ea/55/5389ed243c878725feffc0d6a3bc5ef6764312b6fc7c081faaa2cfa7ef37/psutil-6.1.0-cp37-abi3-win32.whl", hash = "sha256:1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e", size = 250386 },
+    { url = "https://files.pythonhosted.org/packages/11/91/87fa6f060e649b1e1a7b19a4f5869709fbf750b7c8c262ee776ec32f3028/psutil-6.1.0-cp37-abi3-win_amd64.whl", hash = "sha256:a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be", size = 254228 },
 ]
 
 [[package]]
@@ -3474,11 +3700,11 @@ wheels = [
 
 [[package]]
 name = "puremagic"
-version = "1.27"
+version = "1.28"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d5/ce/dc3a664654f1abed89d4e8a95ac3af02a2a0449c776ccea5ef9f48bde267/puremagic-1.27.tar.gz", hash = "sha256:7cb316f40912f56f34149f8ebdd77a91d099212d2ed936feb2feacfc7cbce2c1", size = 312737 }
+sdist = { url = "https://files.pythonhosted.org/packages/09/2d/40599f25667733e41bbc3d7e4c7c36d5e7860874aa5fe9c584e90b34954d/puremagic-1.28.tar.gz", hash = "sha256:195893fc129657f611b86b959aab337207d6df7f25372209269ed9e303c1a8c0", size = 314945 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/5c/c277e7638815795a8fd6487e70eeeb30698e5033f4d562619e1571c660d2/puremagic-1.27-py3-none-any.whl", hash = "sha256:b5519ad89e9b7c96a5fd9947d9a907e44f97cc30eae6dcf746d90a58e3681936", size = 40728 },
+    { url = "https://files.pythonhosted.org/packages/c5/53/200a97332d10ed3edd7afcbc5f5543920ac59badfe5762598327999f012e/puremagic-1.28-py3-none-any.whl", hash = "sha256:e16cb9708ee2007142c37931c58f07f7eca956b3472489106a7245e5c3aa1241", size = 43241 },
 ]
 
 [[package]]
@@ -3558,96 +3784,96 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.8.2"
+version = "2.9.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
     { name = "pydantic-core" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8c/99/d0a5dca411e0a017762258013ba9905cd6e7baa9a3fd1fe8b6529472902e/pydantic-2.8.2.tar.gz", hash = "sha256:6f62c13d067b0755ad1c21a34bdd06c0c12625a22b0fc09c6b149816604f7c2a", size = 739834 }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/b7/d9e3f12af310e1120c21603644a1cd86f59060e040ec5c3a80b8f05fae30/pydantic-2.9.2.tar.gz", hash = "sha256:d155cef71265d1e9807ed1c32b4c8deec042a44a50a4188b25ac67ecd81a9c0f", size = 769917 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/fa/b7f815b8c9ad021c07f88875b601222ef5e70619391ade4a49234d12d278/pydantic-2.8.2-py3-none-any.whl", hash = "sha256:73ee9fddd406dc318b885c7a2eab8a6472b68b8fb5ba8150949fc3db939f23c8", size = 423875 },
+    { url = "https://files.pythonhosted.org/packages/df/e4/ba44652d562cbf0bf320e0f3810206149c8a4e99cdbf66da82e97ab53a15/pydantic-2.9.2-py3-none-any.whl", hash = "sha256:f048cec7b26778210e28a0459867920654d48e5e62db0958433636cde4254f12", size = 434928 },
 ]
 
 [[package]]
 name = "pydantic-core"
-version = "2.20.1"
+version = "2.23.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/12/e3/0d5ad91211dba310f7ded335f4dad871172b9cc9ce204f5a56d76ccd6247/pydantic_core-2.20.1.tar.gz", hash = "sha256:26ca695eeee5f9f1aeeb211ffc12f10bcb6f71e2989988fda61dabd65db878d4", size = 388371 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/9d/f30f080f745682e762512f3eef1f6e392c7d74a102e6e96de8a013a5db84/pydantic_core-2.20.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3acae97ffd19bf091c72df4d726d552c473f3576409b2a7ca36b2f535ffff4a3", size = 1837257 },
-    { url = "https://files.pythonhosted.org/packages/f2/89/77e7aebdd4a235497ac1e07f0a99e9f40e47f6e0f6783fe30500df08fc42/pydantic_core-2.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:41f4c96227a67a013e7de5ff8f20fb496ce573893b7f4f2707d065907bffdbd6", size = 1776715 },
-    { url = "https://files.pythonhosted.org/packages/18/50/5a4e9120b395108c2a0441a425356c0d26a655d7c617288bec1c28b854ac/pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f239eb799a2081495ea659d8d4a43a8f42cd1fe9ff2e7e436295c38a10c286a", size = 1789023 },
-    { url = "https://files.pythonhosted.org/packages/c7/e5/f19e13ba86b968d024b56aa53f40b24828652ac026e5addd0ae49eeada02/pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53e431da3fc53360db73eedf6f7124d1076e1b4ee4276b36fb25514544ceb4a3", size = 1775598 },
-    { url = "https://files.pythonhosted.org/packages/c9/c7/f3c29bed28bd022c783baba5bf9946c4f694cb837a687e62f453c81eb5c6/pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f1f62b2413c3a0e846c3b838b2ecd6c7a19ec6793b2a522745b0869e37ab5bc1", size = 1977691 },
-    { url = "https://files.pythonhosted.org/packages/41/3e/f62c2a05c554fff34570f6788617e9670c83ed7bc07d62a55cccd1bc0be6/pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d41e6daee2813ecceea8eda38062d69e280b39df793f5a942fa515b8ed67953", size = 2693214 },
-    { url = "https://files.pythonhosted.org/packages/ae/49/8a6fe79d35e2f3bea566d8ea0e4e6f436d4f749d7838c8e8c4c5148ae706/pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d482efec8b7dc6bfaedc0f166b2ce349df0011f5d2f1f25537ced4cfc34fd98", size = 2061047 },
-    { url = "https://files.pythonhosted.org/packages/51/c6/585355c7c8561e11197dbf6333c57dd32f9f62165d48589b57ced2373d97/pydantic_core-2.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e93e1a4b4b33daed65d781a57a522ff153dcf748dee70b40c7258c5861e1768a", size = 1895106 },
-    { url = "https://files.pythonhosted.org/packages/ce/23/829f6b87de0775919e82f8addef8b487ace1c77bb4cb754b217f7b1301b6/pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e7c4ea22b6739b162c9ecaaa41d718dfad48a244909fe7ef4b54c0b530effc5a", size = 1968506 },
-    { url = "https://files.pythonhosted.org/packages/ca/2f/f8ca8f0c40b3ee0a4d8730a51851adb14c5eda986ec09f8d754b2fba784e/pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4f2790949cf385d985a31984907fecb3896999329103df4e4983a4a41e13e840", size = 2110217 },
-    { url = "https://files.pythonhosted.org/packages/bb/a0/1876656c7b17eb69cc683452cce6bb890dd722222a71b3de57ddb512f561/pydantic_core-2.20.1-cp310-none-win32.whl", hash = "sha256:5e999ba8dd90e93d57410c5e67ebb67ffcaadcea0ad973240fdfd3a135506250", size = 1709669 },
-    { url = "https://files.pythonhosted.org/packages/be/4a/576524eefa9b301c088c4818dc50ff1c51a88fe29efd87ab75748ae15fd7/pydantic_core-2.20.1-cp310-none-win_amd64.whl", hash = "sha256:512ecfbefef6dac7bc5eaaf46177b2de58cdf7acac8793fe033b24ece0b9566c", size = 1902386 },
-    { url = "https://files.pythonhosted.org/packages/61/db/f6a724db226d990a329910727cfac43539ff6969edc217286dd05cda3ef6/pydantic_core-2.20.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d2a8fa9d6d6f891f3deec72f5cc668e6f66b188ab14bb1ab52422fe8e644f312", size = 1834507 },
-    { url = "https://files.pythonhosted.org/packages/9b/83/6f2bfe75209d557ae1c3550c1252684fc1827b8b12fbed84c3b4439e135d/pydantic_core-2.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:175873691124f3d0da55aeea1d90660a6ea7a3cfea137c38afa0a5ffabe37b88", size = 1773527 },
-    { url = "https://files.pythonhosted.org/packages/93/ef/513ea76d7ca81f2354bb9c8d7839fc1157673e652613f7e1aff17d8ce05d/pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37eee5b638f0e0dcd18d21f59b679686bbd18917b87db0193ae36f9c23c355fc", size = 1787879 },
-    { url = "https://files.pythonhosted.org/packages/31/0a/ac294caecf235f0cc651de6232f1642bb793af448d1cfc541b0dc1fd72b8/pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25e9185e2d06c16ee438ed39bf62935ec436474a6ac4f9358524220f1b236e43", size = 1774694 },
-    { url = "https://files.pythonhosted.org/packages/46/a4/08f12b5512f095963550a7cb49ae010e3f8f3f22b45e508c2cb4d7744fce/pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:150906b40ff188a3260cbee25380e7494ee85048584998c1e66df0c7a11c17a6", size = 1976369 },
-    { url = "https://files.pythonhosted.org/packages/15/59/b2495be4410462aedb399071c71884042a2c6443319cbf62d00b4a7ed7a5/pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ad4aeb3e9a97286573c03df758fc7627aecdd02f1da04516a86dc159bf70121", size = 2691250 },
-    { url = "https://files.pythonhosted.org/packages/3c/ae/fc99ce1ba791c9e9d1dee04ce80eef1dae5b25b27e3fc8e19f4e3f1348bf/pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3f3ed29cd9f978c604708511a1f9c2fdcb6c38b9aae36a51905b8811ee5cbf1", size = 2061462 },
-    { url = "https://files.pythonhosted.org/packages/44/bb/eb07cbe47cfd638603ce3cb8c220f1a054b821e666509e535f27ba07ca5f/pydantic_core-2.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b0dae11d8f5ded51699c74d9548dcc5938e0804cc8298ec0aa0da95c21fff57b", size = 1893923 },
-    { url = "https://files.pythonhosted.org/packages/ce/ef/5a52400553b8faa0e7f11fd7a2ba11e8d2feb50b540f9e7973c49b97eac0/pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:faa6b09ee09433b87992fb5a2859efd1c264ddc37280d2dd5db502126d0e7f27", size = 1966779 },
-    { url = "https://files.pythonhosted.org/packages/4c/5b/fb37fe341344d9651f5c5f579639cd97d50a457dc53901aa8f7e9f28beb9/pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9dc1b507c12eb0481d071f3c1808f0529ad41dc415d0ca11f7ebfc666e66a18b", size = 2109044 },
-    { url = "https://files.pythonhosted.org/packages/70/1a/6f7278802dbc66716661618807ab0dfa4fc32b09d1235923bbbe8b3a5757/pydantic_core-2.20.1-cp311-none-win32.whl", hash = "sha256:fa2fddcb7107e0d1808086ca306dcade7df60a13a6c347a7acf1ec139aa6789a", size = 1708265 },
-    { url = "https://files.pythonhosted.org/packages/35/7f/58758c42c61b0bdd585158586fecea295523d49933cb33664ea888162daf/pydantic_core-2.20.1-cp311-none-win_amd64.whl", hash = "sha256:40a783fb7ee353c50bd3853e626f15677ea527ae556429453685ae32280c19c2", size = 1901750 },
-    { url = "https://files.pythonhosted.org/packages/6f/47/ef0d60ae23c41aced42921728650460dc831a0adf604bfa66b76028cb4d0/pydantic_core-2.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:595ba5be69b35777474fa07f80fc260ea71255656191adb22a8c53aba4479231", size = 1839225 },
-    { url = "https://files.pythonhosted.org/packages/6a/23/430f2878c9cd977a61bb39f71751d9310ec55cee36b3d5bf1752c6341fd0/pydantic_core-2.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a4f55095ad087474999ee28d3398bae183a66be4823f753cd7d67dd0153427c9", size = 1768604 },
-    { url = "https://files.pythonhosted.org/packages/9e/2b/ec4e7225dee79e0dc80ccc3c35ab33cc2c4bbb8a1a7ecf060e5e453651ec/pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9aa05d09ecf4c75157197f27cdc9cfaeb7c5f15021c6373932bf3e124af029f", size = 1789767 },
-    { url = "https://files.pythonhosted.org/packages/64/b0/38b24a1fa6d2f96af3148362e10737ec073768cd44d3ec21dca3be40a519/pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e97fdf088d4b31ff4ba35db26d9cc472ac7ef4a2ff2badeabf8d727b3377fc52", size = 1772061 },
-    { url = "https://files.pythonhosted.org/packages/5e/da/bb73274c42cb60decfa61e9eb0c9029da78b3b9af0a9de0309dbc8ff87b6/pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc633a9fe1eb87e250b5c57d389cf28998e4292336926b0b6cdaee353f89a237", size = 1974573 },
-    { url = "https://files.pythonhosted.org/packages/c8/65/41693110fb3552556180460daffdb8bbeefb87fc026fd9aa4b849374015c/pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d573faf8eb7e6b1cbbcb4f5b247c60ca8be39fe2c674495df0eb4318303137fe", size = 2625596 },
-    { url = "https://files.pythonhosted.org/packages/09/b3/a5a54b47cccd1ab661ed5775235c5e06924753c2d4817737c5667bfa19a8/pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26dc97754b57d2fd00ac2b24dfa341abffc380b823211994c4efac7f13b9e90e", size = 2099064 },
-    { url = "https://files.pythonhosted.org/packages/52/fa/443a7a6ea54beaba45ff3a59f3d3e6e3004b7460bcfb0be77bcf98719d3b/pydantic_core-2.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:33499e85e739a4b60c9dac710c20a08dc73cb3240c9a0e22325e671b27b70d24", size = 1900345 },
-    { url = "https://files.pythonhosted.org/packages/8e/e6/9aca9ffae60f9cdf0183069de3e271889b628d0fb175913fcb3db5618fb1/pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:bebb4d6715c814597f85297c332297c6ce81e29436125ca59d1159b07f423eb1", size = 1968252 },
-    { url = "https://files.pythonhosted.org/packages/46/5e/6c716810ea20a6419188992973a73c2fb4eb99cd382368d0637ddb6d3c99/pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:516d9227919612425c8ef1c9b869bbbee249bc91912c8aaffb66116c0b447ebd", size = 2119191 },
-    { url = "https://files.pythonhosted.org/packages/06/fc/6123b00a9240fbb9ae0babad7a005d51103d9a5d39c957a986f5cdd0c271/pydantic_core-2.20.1-cp312-none-win32.whl", hash = "sha256:469f29f9093c9d834432034d33f5fe45699e664f12a13bf38c04967ce233d688", size = 1717788 },
-    { url = "https://files.pythonhosted.org/packages/d5/36/e61ad5a46607a469e2786f398cd671ebafcd9fb17f09a2359985c7228df5/pydantic_core-2.20.1-cp312-none-win_amd64.whl", hash = "sha256:035ede2e16da7281041f0e626459bcae33ed998cca6a0a007a5ebb73414ac72d", size = 1898188 },
-    { url = "https://files.pythonhosted.org/packages/49/75/40b0e98b658fdba02a693b3bacb4c875a28bba87796c7b13975976597d8c/pydantic_core-2.20.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0827505a5c87e8aa285dc31e9ec7f4a17c81a813d45f70b1d9164e03a813a686", size = 1838688 },
-    { url = "https://files.pythonhosted.org/packages/75/02/d8ba2d4a266591a6a623c68b331b96523d4b62ab82a951794e3ed8907390/pydantic_core-2.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19c0fa39fa154e7e0b7f82f88ef85faa2a4c23cc65aae2f5aea625e3c13c735a", size = 1768409 },
-    { url = "https://files.pythonhosted.org/packages/91/ae/25ecd9bc4ce4993e99a1a3c9ab111c082630c914260e129572fafed4ecc2/pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa223cd1e36b642092c326d694d8bf59b71ddddc94cdb752bbbb1c5c91d833b", size = 1789317 },
-    { url = "https://files.pythonhosted.org/packages/7a/80/72057580681cdbe55699c367963d9c661b569a1d39338b4f6239faf36cdc/pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c336a6d235522a62fef872c6295a42ecb0c4e1d0f1a3e500fe949415761b8a19", size = 1771949 },
-    { url = "https://files.pythonhosted.org/packages/a2/be/d9bbabc55b05019013180f141fcaf3b14dbe15ca7da550e95b60c321009a/pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7eb6a0587eded33aeefea9f916899d42b1799b7b14b8f8ff2753c0ac1741edac", size = 1974392 },
-    { url = "https://files.pythonhosted.org/packages/79/2d/7bcd938c6afb0f40293283f5f09988b61fb0a4f1d180abe7c23a2f665f8e/pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:70c8daf4faca8da5a6d655f9af86faf6ec2e1768f4b8b9d0226c02f3d6209703", size = 2625565 },
-    { url = "https://files.pythonhosted.org/packages/ac/88/ca758e979457096008a4b16a064509028e3e092a1e85a5ed6c18ced8da88/pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9fa4c9bf273ca41f940bceb86922a7667cd5bf90e95dbb157cbb8441008482c", size = 2098784 },
-    { url = "https://files.pythonhosted.org/packages/eb/de/2fad6d63c3c42e472e985acb12ec45b7f56e42e6f4cd6dfbc5e87ee8678c/pydantic_core-2.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:11b71d67b4725e7e2a9f6e9c0ac1239bbc0c48cce3dc59f98635efc57d6dac83", size = 1900198 },
-    { url = "https://files.pythonhosted.org/packages/fe/50/077c7f35b6488dc369a6d22993af3a37901e198630f38ac43391ca730f5b/pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:270755f15174fb983890c49881e93f8f1b80f0b5e3a3cc1394a255706cabd203", size = 1968005 },
-    { url = "https://files.pythonhosted.org/packages/5d/1f/f378631574ead46d636b9a04a80ff878b9365d4b361b1905ef1667d4182a/pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c81131869240e3e568916ef4c307f8b99583efaa60a8112ef27a366eefba8ef0", size = 2118920 },
-    { url = "https://files.pythonhosted.org/packages/7a/ea/e4943f17df7a3031d709481fe4363d4624ae875a6409aec34c28c9e6cf59/pydantic_core-2.20.1-cp313-none-win32.whl", hash = "sha256:b91ced227c41aa29c672814f50dbb05ec93536abf8f43cd14ec9521ea09afe4e", size = 1717397 },
-    { url = "https://files.pythonhosted.org/packages/13/63/b95781763e8d84207025071c0cec16d921c0163c7a9033ae4b9a0e020dc7/pydantic_core-2.20.1-cp313-none-win_amd64.whl", hash = "sha256:65db0f2eefcaad1a3950f498aabb4875c8890438bc80b19362cf633b87a8ab20", size = 1898013 },
-    { url = "https://files.pythonhosted.org/packages/73/73/0c7265903f66cce39ed7ca939684fba344210cefc91ccc999cfd5b113fd3/pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a45f84b09ac9c3d35dfcf6a27fd0634d30d183205230a0ebe8373a0e8cfa0906", size = 1828190 },
-    { url = "https://files.pythonhosted.org/packages/27/55/60b8b0e58b49ee3ed36a18562dd7c6bc06a551c390e387af5872a238f2ec/pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d02a72df14dfdbaf228424573a07af10637bd490f0901cee872c4f434a735b94", size = 1715252 },
-    { url = "https://files.pythonhosted.org/packages/28/3d/d66314bad6bb777a36559195a007b31e916bd9e2c198f7bb8f4ccdceb4fa/pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2b27e6af28f07e2f195552b37d7d66b150adbaa39a6d327766ffd695799780f", size = 1782641 },
-    { url = "https://files.pythonhosted.org/packages/9e/f5/f178f4354d0d6c1431a8f9ede71f3c4269ac4dc55d314fdb7555814276dc/pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084659fac3c83fd674596612aeff6041a18402f1e1bc19ca39e417d554468482", size = 1928788 },
-    { url = "https://files.pythonhosted.org/packages/9c/51/1f5e27bb194df79e30b593b608c66e881ed481241e2b9ed5bdf86d165480/pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:242b8feb3c493ab78be289c034a1f659e8826e2233786e36f2893a950a719bb6", size = 1886116 },
-    { url = "https://files.pythonhosted.org/packages/ac/76/450d9258c58dc7c70b9e3aadf6bebe23ddd99e459c365e2adbde80e238da/pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:38cf1c40a921d05c5edc61a785c0ddb4bed67827069f535d794ce6bcded919fc", size = 1960125 },
-    { url = "https://files.pythonhosted.org/packages/dd/9e/0309a7a4bea51771729515e413b3987be0789837de99087f7415e0db1f9b/pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e0bbdd76ce9aa5d4209d65f2b27fc6e5ef1312ae6c5333c26db3f5ade53a1e99", size = 2100407 },
-    { url = "https://files.pythonhosted.org/packages/af/93/06d44e08277b3b818b75bd5f25e879d7693e4b7dd3505fde89916fcc9ca2/pydantic_core-2.20.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:254ec27fdb5b1ee60684f91683be95e5133c994cc54e86a0b0963afa25c8f8a6", size = 1914966 },
+sdist = { url = "https://files.pythonhosted.org/packages/e2/aa/6b6a9b9f8537b872f552ddd46dd3da230367754b6f707b8e1e963f515ea3/pydantic_core-2.23.4.tar.gz", hash = "sha256:2584f7cf844ac4d970fba483a717dbe10c1c1c96a969bf65d61ffe94df1b2863", size = 402156 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5c/8b/d3ae387f66277bd8104096d6ec0a145f4baa2966ebb2cad746c0920c9526/pydantic_core-2.23.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b10bd51f823d891193d4717448fab065733958bdb6a6b351967bd349d48d5c9b", size = 1867835 },
+    { url = "https://files.pythonhosted.org/packages/46/76/f68272e4c3a7df8777798282c5e47d508274917f29992d84e1898f8908c7/pydantic_core-2.23.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4fc714bdbfb534f94034efaa6eadd74e5b93c8fa6315565a222f7b6f42ca1166", size = 1776689 },
+    { url = "https://files.pythonhosted.org/packages/cc/69/5f945b4416f42ea3f3bc9d2aaec66c76084a6ff4ff27555bf9415ab43189/pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63e46b3169866bd62849936de036f901a9356e36376079b05efa83caeaa02ceb", size = 1800748 },
+    { url = "https://files.pythonhosted.org/packages/50/ab/891a7b0054bcc297fb02d44d05c50e68154e31788f2d9d41d0b72c89fdf7/pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed1a53de42fbe34853ba90513cea21673481cd81ed1be739f7f2efb931b24916", size = 1806469 },
+    { url = "https://files.pythonhosted.org/packages/31/7c/6e3fa122075d78f277a8431c4c608f061881b76c2b7faca01d317ee39b5d/pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cfdd16ab5e59fc31b5e906d1a3f666571abc367598e3e02c83403acabc092e07", size = 2002246 },
+    { url = "https://files.pythonhosted.org/packages/ad/6f/22d5692b7ab63fc4acbc74de6ff61d185804a83160adba5e6cc6068e1128/pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:255a8ef062cbf6674450e668482456abac99a5583bbafb73f9ad469540a3a232", size = 2659404 },
+    { url = "https://files.pythonhosted.org/packages/11/ac/1e647dc1121c028b691028fa61a4e7477e6aeb5132628fde41dd34c1671f/pydantic_core-2.23.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a7cd62e831afe623fbb7aabbb4fe583212115b3ef38a9f6b71869ba644624a2", size = 2053940 },
+    { url = "https://files.pythonhosted.org/packages/91/75/984740c17f12c3ce18b5a2fcc4bdceb785cce7df1511a4ce89bca17c7e2d/pydantic_core-2.23.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f09e2ff1f17c2b51f2bc76d1cc33da96298f0a036a137f5440ab3ec5360b624f", size = 1921437 },
+    { url = "https://files.pythonhosted.org/packages/a0/74/13c5f606b64d93f0721e7768cd3e8b2102164866c207b8cd6f90bb15d24f/pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e38e63e6f3d1cec5a27e0afe90a085af8b6806ee208b33030e65b6516353f1a3", size = 1966129 },
+    { url = "https://files.pythonhosted.org/packages/18/03/9c4aa5919457c7b57a016c1ab513b1a926ed9b2bb7915bf8e506bf65c34b/pydantic_core-2.23.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0dbd8dbed2085ed23b5c04afa29d8fd2771674223135dc9bc937f3c09284d071", size = 2110908 },
+    { url = "https://files.pythonhosted.org/packages/92/2c/053d33f029c5dc65e5cf44ff03ceeefb7cce908f8f3cca9265e7f9b540c8/pydantic_core-2.23.4-cp310-none-win32.whl", hash = "sha256:6531b7ca5f951d663c339002e91aaebda765ec7d61b7d1e3991051906ddde119", size = 1735278 },
+    { url = "https://files.pythonhosted.org/packages/de/81/7dfe464eca78d76d31dd661b04b5f2036ec72ea8848dd87ab7375e185c23/pydantic_core-2.23.4-cp310-none-win_amd64.whl", hash = "sha256:7c9129eb40958b3d4500fa2467e6a83356b3b61bfff1b414c7361d9220f9ae8f", size = 1917453 },
+    { url = "https://files.pythonhosted.org/packages/5d/30/890a583cd3f2be27ecf32b479d5d615710bb926d92da03e3f7838ff3e58b/pydantic_core-2.23.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:77733e3892bb0a7fa797826361ce8a9184d25c8dffaec60b7ffe928153680ba8", size = 1865160 },
+    { url = "https://files.pythonhosted.org/packages/1d/9a/b634442e1253bc6889c87afe8bb59447f106ee042140bd57680b3b113ec7/pydantic_core-2.23.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b84d168f6c48fabd1f2027a3d1bdfe62f92cade1fb273a5d68e621da0e44e6d", size = 1776777 },
+    { url = "https://files.pythonhosted.org/packages/75/9a/7816295124a6b08c24c96f9ce73085032d8bcbaf7e5a781cd41aa910c891/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df49e7a0861a8c36d089c1ed57d308623d60416dab2647a4a17fe050ba85de0e", size = 1799244 },
+    { url = "https://files.pythonhosted.org/packages/a9/8f/89c1405176903e567c5f99ec53387449e62f1121894aa9fc2c4fdc51a59b/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ff02b6d461a6de369f07ec15e465a88895f3223eb75073ffea56b84d9331f607", size = 1805307 },
+    { url = "https://files.pythonhosted.org/packages/d5/a5/1a194447d0da1ef492e3470680c66048fef56fc1f1a25cafbea4bc1d1c48/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:996a38a83508c54c78a5f41456b0103c30508fed9abcad0a59b876d7398f25fd", size = 2000663 },
+    { url = "https://files.pythonhosted.org/packages/13/a5/1df8541651de4455e7d587cf556201b4f7997191e110bca3b589218745a5/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d97683ddee4723ae8c95d1eddac7c192e8c552da0c73a925a89fa8649bf13eea", size = 2655941 },
+    { url = "https://files.pythonhosted.org/packages/44/31/a3899b5ce02c4316865e390107f145089876dff7e1dfc770a231d836aed8/pydantic_core-2.23.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:216f9b2d7713eb98cb83c80b9c794de1f6b7e3145eef40400c62e86cee5f4e1e", size = 2052105 },
+    { url = "https://files.pythonhosted.org/packages/1b/aa/98e190f8745d5ec831f6d5449344c48c0627ac5fed4e5340a44b74878f8e/pydantic_core-2.23.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6f783e0ec4803c787bcea93e13e9932edab72068f68ecffdf86a99fd5918878b", size = 1919967 },
+    { url = "https://files.pythonhosted.org/packages/ae/35/b6e00b6abb2acfee3e8f85558c02a0822e9a8b2f2d812ea8b9079b118ba0/pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d0776dea117cf5272382634bd2a5c1b6eb16767c223c6a5317cd3e2a757c61a0", size = 1964291 },
+    { url = "https://files.pythonhosted.org/packages/13/46/7bee6d32b69191cd649bbbd2361af79c472d72cb29bb2024f0b6e350ba06/pydantic_core-2.23.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d5f7a395a8cf1621939692dba2a6b6a830efa6b3cee787d82c7de1ad2930de64", size = 2109666 },
+    { url = "https://files.pythonhosted.org/packages/39/ef/7b34f1b122a81b68ed0a7d0e564da9ccdc9a2924c8d6c6b5b11fa3a56970/pydantic_core-2.23.4-cp311-none-win32.whl", hash = "sha256:74b9127ffea03643e998e0c5ad9bd3811d3dac8c676e47db17b0ee7c3c3bf35f", size = 1732940 },
+    { url = "https://files.pythonhosted.org/packages/2f/76/37b7e76c645843ff46c1d73e046207311ef298d3f7b2f7d8f6ac60113071/pydantic_core-2.23.4-cp311-none-win_amd64.whl", hash = "sha256:98d134c954828488b153d88ba1f34e14259284f256180ce659e8d83e9c05eaa3", size = 1916804 },
+    { url = "https://files.pythonhosted.org/packages/74/7b/8e315f80666194b354966ec84b7d567da77ad927ed6323db4006cf915f3f/pydantic_core-2.23.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f3e0da4ebaef65158d4dfd7d3678aad692f7666877df0002b8a522cdf088f231", size = 1856459 },
+    { url = "https://files.pythonhosted.org/packages/14/de/866bdce10ed808323d437612aca1ec9971b981e1c52e5e42ad9b8e17a6f6/pydantic_core-2.23.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f69a8e0b033b747bb3e36a44e7732f0c99f7edd5cea723d45bc0d6e95377ffee", size = 1770007 },
+    { url = "https://files.pythonhosted.org/packages/dc/69/8edd5c3cd48bb833a3f7ef9b81d7666ccddd3c9a635225214e044b6e8281/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723314c1d51722ab28bfcd5240d858512ffd3116449c557a1336cbe3919beb87", size = 1790245 },
+    { url = "https://files.pythonhosted.org/packages/80/33/9c24334e3af796ce80d2274940aae38dd4e5676298b4398eff103a79e02d/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb2802e667b7051a1bebbfe93684841cc9351004e2badbd6411bf357ab8d5ac8", size = 1801260 },
+    { url = "https://files.pythonhosted.org/packages/a5/6f/e9567fd90104b79b101ca9d120219644d3314962caa7948dd8b965e9f83e/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d18ca8148bebe1b0a382a27a8ee60350091a6ddaf475fa05ef50dc35b5df6327", size = 1996872 },
+    { url = "https://files.pythonhosted.org/packages/2d/ad/b5f0fe9e6cfee915dd144edbd10b6e9c9c9c9d7a56b69256d124b8ac682e/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:33e3d65a85a2a4a0dc3b092b938a4062b1a05f3a9abde65ea93b233bca0e03f2", size = 2661617 },
+    { url = "https://files.pythonhosted.org/packages/06/c8/7d4b708f8d05a5cbfda3243aad468052c6e99de7d0937c9146c24d9f12e9/pydantic_core-2.23.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:128585782e5bfa515c590ccee4b727fb76925dd04a98864182b22e89a4e6ed36", size = 2071831 },
+    { url = "https://files.pythonhosted.org/packages/89/4d/3079d00c47f22c9a9a8220db088b309ad6e600a73d7a69473e3a8e5e3ea3/pydantic_core-2.23.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:68665f4c17edcceecc112dfed5dbe6f92261fb9d6054b47d01bf6371a6196126", size = 1917453 },
+    { url = "https://files.pythonhosted.org/packages/e9/88/9df5b7ce880a4703fcc2d76c8c2d8eb9f861f79d0c56f4b8f5f2607ccec8/pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:20152074317d9bed6b7a95ade3b7d6054845d70584216160860425f4fbd5ee9e", size = 1968793 },
+    { url = "https://files.pythonhosted.org/packages/e3/b9/41f7efe80f6ce2ed3ee3c2dcfe10ab7adc1172f778cc9659509a79518c43/pydantic_core-2.23.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:9261d3ce84fa1d38ed649c3638feefeae23d32ba9182963e465d58d62203bd24", size = 2116872 },
+    { url = "https://files.pythonhosted.org/packages/63/08/b59b7a92e03dd25554b0436554bf23e7c29abae7cce4b1c459cd92746811/pydantic_core-2.23.4-cp312-none-win32.whl", hash = "sha256:4ba762ed58e8d68657fc1281e9bb72e1c3e79cc5d464be146e260c541ec12d84", size = 1738535 },
+    { url = "https://files.pythonhosted.org/packages/88/8d/479293e4d39ab409747926eec4329de5b7129beaedc3786eca070605d07f/pydantic_core-2.23.4-cp312-none-win_amd64.whl", hash = "sha256:97df63000f4fea395b2824da80e169731088656d1818a11b95f3b173747b6cd9", size = 1917992 },
+    { url = "https://files.pythonhosted.org/packages/ad/ef/16ee2df472bf0e419b6bc68c05bf0145c49247a1095e85cee1463c6a44a1/pydantic_core-2.23.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7530e201d10d7d14abce4fb54cfe5b94a0aefc87da539d0346a484ead376c3cc", size = 1856143 },
+    { url = "https://files.pythonhosted.org/packages/da/fa/bc3dbb83605669a34a93308e297ab22be82dfb9dcf88c6cf4b4f264e0a42/pydantic_core-2.23.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df933278128ea1cd77772673c73954e53a1c95a4fdf41eef97c2b779271bd0bd", size = 1770063 },
+    { url = "https://files.pythonhosted.org/packages/4e/48/e813f3bbd257a712303ebdf55c8dc46f9589ec74b384c9f652597df3288d/pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cb3da3fd1b6a5d0279a01877713dbda118a2a4fc6f0d821a57da2e464793f05", size = 1790013 },
+    { url = "https://files.pythonhosted.org/packages/b4/e0/56eda3a37929a1d297fcab1966db8c339023bcca0b64c5a84896db3fcc5c/pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:42c6dcb030aefb668a2b7009c85b27f90e51e6a3b4d5c9bc4c57631292015b0d", size = 1801077 },
+    { url = "https://files.pythonhosted.org/packages/04/be/5e49376769bfbf82486da6c5c1683b891809365c20d7c7e52792ce4c71f3/pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:696dd8d674d6ce621ab9d45b205df149399e4bb9aa34102c970b721554828510", size = 1996782 },
+    { url = "https://files.pythonhosted.org/packages/bc/24/e3ee6c04f1d58cc15f37bcc62f32c7478ff55142b7b3e6d42ea374ea427c/pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2971bb5ffe72cc0f555c13e19b23c85b654dd2a8f7ab493c262071377bfce9f6", size = 2661375 },
+    { url = "https://files.pythonhosted.org/packages/c1/f8/11a9006de4e89d016b8de74ebb1db727dc100608bb1e6bbe9d56a3cbbcce/pydantic_core-2.23.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8394d940e5d400d04cad4f75c0598665cbb81aecefaca82ca85bd28264af7f9b", size = 2071635 },
+    { url = "https://files.pythonhosted.org/packages/7c/45/bdce5779b59f468bdf262a5bc9eecbae87f271c51aef628d8c073b4b4b4c/pydantic_core-2.23.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0dff76e0602ca7d4cdaacc1ac4c005e0ce0dcfe095d5b5259163a80d3a10d327", size = 1916994 },
+    { url = "https://files.pythonhosted.org/packages/d8/fa/c648308fe711ee1f88192cad6026ab4f925396d1293e8356de7e55be89b5/pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7d32706badfe136888bdea71c0def994644e09fff0bfe47441deaed8e96fdbc6", size = 1968877 },
+    { url = "https://files.pythonhosted.org/packages/16/16/b805c74b35607d24d37103007f899abc4880923b04929547ae68d478b7f4/pydantic_core-2.23.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed541d70698978a20eb63d8c5d72f2cc6d7079d9d90f6b50bad07826f1320f5f", size = 2116814 },
+    { url = "https://files.pythonhosted.org/packages/d1/58/5305e723d9fcdf1c5a655e6a4cc2a07128bf644ff4b1d98daf7a9dbf57da/pydantic_core-2.23.4-cp313-none-win32.whl", hash = "sha256:3d5639516376dce1940ea36edf408c554475369f5da2abd45d44621cb616f769", size = 1738360 },
+    { url = "https://files.pythonhosted.org/packages/a5/ae/e14b0ff8b3f48e02394d8acd911376b7b66e164535687ef7dc24ea03072f/pydantic_core-2.23.4-cp313-none-win_amd64.whl", hash = "sha256:5a1504ad17ba4210df3a045132a7baeeba5a200e930f57512ee02909fc5c4cb5", size = 1919411 },
+    { url = "https://files.pythonhosted.org/packages/13/a9/5d582eb3204464284611f636b55c0a7410d748ff338756323cb1ce721b96/pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f455ee30a9d61d3e1a15abd5068827773d6e4dc513e795f380cdd59932c782d5", size = 1857135 },
+    { url = "https://files.pythonhosted.org/packages/2c/57/faf36290933fe16717f97829eabfb1868182ac495f99cf0eda9f59687c9d/pydantic_core-2.23.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1e90d2e3bd2c3863d48525d297cd143fe541be8bbf6f579504b9712cb6b643ec", size = 1740583 },
+    { url = "https://files.pythonhosted.org/packages/91/7c/d99e3513dc191c4fec363aef1bf4c8af9125d8fa53af7cb97e8babef4e40/pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e203fdf807ac7e12ab59ca2bfcabb38c7cf0b33c41efeb00f8e5da1d86af480", size = 1793637 },
+    { url = "https://files.pythonhosted.org/packages/29/18/812222b6d18c2d13eebbb0f7cdc170a408d9ced65794fdb86147c77e1982/pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e08277a400de01bc72436a0ccd02bdf596631411f592ad985dcee21445bd0068", size = 1941963 },
+    { url = "https://files.pythonhosted.org/packages/0f/36/c1f3642ac3f05e6bb4aec3ffc399fa3f84895d259cf5f0ce3054b7735c29/pydantic_core-2.23.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f220b0eea5965dec25480b6333c788fb72ce5f9129e8759ef876a1d805d00801", size = 1915332 },
+    { url = "https://files.pythonhosted.org/packages/f7/ca/9c0854829311fb446020ebb540ee22509731abad886d2859c855dd29b904/pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:d06b0c8da4f16d1d1e352134427cb194a0a6e19ad5db9161bf32b2113409e728", size = 1957926 },
+    { url = "https://files.pythonhosted.org/packages/c0/1c/7836b67c42d0cd4441fcd9fafbf6a027ad4b79b6559f80cf11f89fd83648/pydantic_core-2.23.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:ba1a0996f6c2773bd83e63f18914c1de3c9dd26d55f4ac302a7efe93fb8e7433", size = 2100342 },
+    { url = "https://files.pythonhosted.org/packages/a9/f9/b6bcaf874f410564a78908739c80861a171788ef4d4f76f5009656672dfe/pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753", size = 1920344 },
 ]
 
 [[package]]
 name = "pydantic-settings"
-version = "2.5.2"
+version = "2.6.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pydantic" },
     { name = "python-dotenv" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/68/27/0bed9dd26b93328b60a1402febc780e7be72b42847fa8b5c94b7d0aeb6d1/pydantic_settings-2.5.2.tar.gz", hash = "sha256:f90b139682bee4d2065273d5185d71d37ea46cfe57e1b5ae184fc6a0b2484ca0", size = 70938 }
+sdist = { url = "https://files.pythonhosted.org/packages/6c/66/5f1a9da10675bfb3b9da52f5b689c77e0a5612263fcce510cfac3e99a168/pydantic_settings-2.6.0.tar.gz", hash = "sha256:44a1804abffac9e6a30372bb45f6cafab945ef5af25e66b1c634c01dd39e0188", size = 75232 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/29/8d/29e82e333f32d9e2051c10764b906c2a6cd140992910b5f49762790911ba/pydantic_settings-2.5.2-py3-none-any.whl", hash = "sha256:2c912e55fd5794a59bf8c832b9de832dcfdf4778d79ff79b708744eed499a907", size = 26864 },
+    { url = "https://files.pythonhosted.org/packages/34/19/26bb6bdb9fdad5f0dfce538780814084fb667b4bc37fcb28459c14b8d3b5/pydantic_settings-2.6.0-py3-none-any.whl", hash = "sha256:4a819166f119b74d7f8c765196b165f95cc7487ce58ea27dec8a5a26be0970e0", size = 28578 },
 ]
 
 [[package]]
@@ -3680,14 +3906,14 @@ wheels = [
 
 [[package]]
 name = "pyee"
-version = "11.1.0"
+version = "12.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/f7/22/b4c7f3d9579204a014c4eda0e019e6bfe56af52a96cacc82004b60eec079/pyee-11.1.0.tar.gz", hash = "sha256:b53af98f6990c810edd9b56b87791021a8f54fd13db4edd1142438d44ba2263f", size = 29806 }
+sdist = { url = "https://files.pythonhosted.org/packages/d2/a7/8faaa62a488a2a1e0d56969757f087cbd2729e9bcfa508c230299f366b4c/pyee-12.0.0.tar.gz", hash = "sha256:c480603f4aa2927d4766eb41fa82793fe60a82cbfdb8d688e0d08c55a534e145", size = 29675 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/cc/5cea8a0a0d3deb90b5a0d39ad1a6a1ccaa40a9ea86d793eb8a49d32a6ed0/pyee-11.1.0-py3-none-any.whl", hash = "sha256:5d346a7d0f861a4b2e6c47960295bd895f816725b27d656181947346be98d7c1", size = 15263 },
+    { url = "https://files.pythonhosted.org/packages/1d/0d/95993c08c721ec68892547f2117e8f9dfbcef2ca71e098533541b4a54d5f/pyee-12.0.0-py3-none-any.whl", hash = "sha256:7b14b74320600049ccc7d0e0b1becd3b4bd0a03c745758225e31a59f4095c990", size = 14831 },
 ]
 
 [[package]]
@@ -3715,11 +3941,11 @@ crypto = [
 
 [[package]]
 name = "pyparsing"
-version = "3.1.4"
+version = "3.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/83/08/13f3bce01b2061f2bbd582c9df82723de943784cf719a35ac886c652043a/pyparsing-3.1.4.tar.gz", hash = "sha256:f86ec8d1a83f11977c9a6ea7598e8c27fc5cddfa5b07ea2241edbbde1d7bc032", size = 900231 }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/d5/e5aeee5387091148a19e1145f63606619cb5f20b83fccb63efae6474e7b2/pyparsing-3.2.0.tar.gz", hash = "sha256:cbf74e27246d595d9a74b186b810f6fbb86726dbf3b9532efb343f6d7294fe9c", size = 920984 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e5/0c/0e3c05b1c87bb6a1c76d281b0f35e78d2d80ac91b5f8f524cebf77f51049/pyparsing-3.1.4-py3-none-any.whl", hash = "sha256:a6a7ee4235a3f944aa1fa2249307708f893fe5717dc603503c6c7969c070fb7c", size = 104100 },
+    { url = "https://files.pythonhosted.org/packages/be/ec/2eb3cd785efd67806c46c13a17339708ddc346cbb684eade7a6e6f79536a/pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84", size = 106921 },
 ]
 
 [[package]]
@@ -3757,7 +3983,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "8.3.2"
+version = "8.3.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -3767,9 +3993,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b4/8c/9862305bdcd6020bc7b45b1b5e7397a6caf1a33d3025b9a003b39075ffb2/pytest-8.3.2.tar.gz", hash = "sha256:c132345d12ce551242c87269de812483f5bcc87cdbb4722e48487ba194f9fdce", size = 1439314 }
+sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/f9/cf155cf32ca7d6fa3601bc4c5dd19086af4b320b706919d48a4c79081cf9/pytest-8.3.2-py3-none-any.whl", hash = "sha256:4ba08f9ae7dcf84ded419494d229b48d0903ea6407b030eaec46df5e6a73bba5", size = 341802 },
+    { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
 ]
 
 [[package]]
@@ -3811,14 +4037,14 @@ wheels = [
 
 [[package]]
 name = "python-dateutil"
-version = "2.9.0.post0"
+version = "2.8.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "six" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/c4/13b4776ea2d76c115c1d1b84579f3764ee6d57204f6be27119f13a61d0a9/python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86", size = 357324 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+    { url = "https://files.pythonhosted.org/packages/36/7a/87837f39d0296e723bb9b62bbb257d0355c7f6128853c78955f57342a56d/python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9", size = 247702 },
 ]
 
 [[package]]
@@ -3859,26 +4085,30 @@ wheels = [
 
 [[package]]
 name = "pytz"
-version = "2024.1"
+version = "2024.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/90/26/9f1f00a5d021fff16dee3de13d43e5e978f3d58928e129c3a62cf7eb9738/pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812", size = 316214 }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9c/3d/a121f284241f08268b21359bd425f7d4825cffc5ac5cd0e1b3d82ffd2b10/pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319", size = 505474 },
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
 ]
 
 [[package]]
 name = "pywin32"
-version = "306"
+version = "308"
 source = { registry = "https://pypi.org/simple" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/08/dc/28c668097edfaf4eac4617ef7adf081b9cf50d254672fcf399a70f5efc41/pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d", size = 8506422 },
-    { url = "https://files.pythonhosted.org/packages/d3/d6/891894edec688e72c2e308b3243fad98b4066e1839fd2fe78f04129a9d31/pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8", size = 9226392 },
-    { url = "https://files.pythonhosted.org/packages/8b/1e/fc18ad83ca553e01b97aa8393ff10e33c1fb57801db05488b83282ee9913/pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407", size = 8507689 },
-    { url = "https://files.pythonhosted.org/packages/7e/9e/ad6b1ae2a5ad1066dc509350e0fbf74d8d50251a51e420a2a8feaa0cecbd/pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e", size = 9227547 },
-    { url = "https://files.pythonhosted.org/packages/91/20/f744bff1da8f43388498503634378dbbefbe493e65675f2cc52f7185c2c2/pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a", size = 10388324 },
-    { url = "https://files.pythonhosted.org/packages/14/91/17e016d5923e178346aabda3dfec6629d1a26efe587d19667542105cf0a6/pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b", size = 8507705 },
-    { url = "https://files.pythonhosted.org/packages/83/1c/25b79fc3ec99b19b0a0730cc47356f7e2959863bf9f3cd314332bddb4f68/pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e", size = 9227429 },
-    { url = "https://files.pythonhosted.org/packages/1c/43/e3444dc9a12f8365d9603c2145d16bf0a2f8180f343cf87be47f5579e547/pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040", size = 10388145 },
+    { url = "https://files.pythonhosted.org/packages/72/a6/3e9f2c474895c1bb61b11fa9640be00067b5c5b363c501ee9c3fa53aec01/pywin32-308-cp310-cp310-win32.whl", hash = "sha256:796ff4426437896550d2981b9c2ac0ffd75238ad9ea2d3bfa67a1abd546d262e", size = 5927028 },
+    { url = "https://files.pythonhosted.org/packages/d9/b4/84e2463422f869b4b718f79eb7530a4c1693e96b8a4e5e968de38be4d2ba/pywin32-308-cp310-cp310-win_amd64.whl", hash = "sha256:4fc888c59b3c0bef905ce7eb7e2106a07712015ea1c8234b703a088d46110e8e", size = 6558484 },
+    { url = "https://files.pythonhosted.org/packages/9f/8f/fb84ab789713f7c6feacaa08dad3ec8105b88ade8d1c4f0f0dfcaaa017d6/pywin32-308-cp310-cp310-win_arm64.whl", hash = "sha256:a5ab5381813b40f264fa3495b98af850098f814a25a63589a8e9eb12560f450c", size = 7971454 },
+    { url = "https://files.pythonhosted.org/packages/eb/e2/02652007469263fe1466e98439831d65d4ca80ea1a2df29abecedf7e47b7/pywin32-308-cp311-cp311-win32.whl", hash = "sha256:5d8c8015b24a7d6855b1550d8e660d8daa09983c80e5daf89a273e5c6fb5095a", size = 5928156 },
+    { url = "https://files.pythonhosted.org/packages/48/ef/f4fb45e2196bc7ffe09cad0542d9aff66b0e33f6c0954b43e49c33cad7bd/pywin32-308-cp311-cp311-win_amd64.whl", hash = "sha256:575621b90f0dc2695fec346b2d6302faebd4f0f45c05ea29404cefe35d89442b", size = 6559559 },
+    { url = "https://files.pythonhosted.org/packages/79/ef/68bb6aa865c5c9b11a35771329e95917b5559845bd75b65549407f9fc6b4/pywin32-308-cp311-cp311-win_arm64.whl", hash = "sha256:100a5442b7332070983c4cd03f2e906a5648a5104b8a7f50175f7906efd16bb6", size = 7972495 },
+    { url = "https://files.pythonhosted.org/packages/00/7c/d00d6bdd96de4344e06c4afbf218bc86b54436a94c01c71a8701f613aa56/pywin32-308-cp312-cp312-win32.whl", hash = "sha256:587f3e19696f4bf96fde9d8a57cec74a57021ad5f204c9e627e15c33ff568897", size = 5939729 },
+    { url = "https://files.pythonhosted.org/packages/21/27/0c8811fbc3ca188f93b5354e7c286eb91f80a53afa4e11007ef661afa746/pywin32-308-cp312-cp312-win_amd64.whl", hash = "sha256:00b3e11ef09ede56c6a43c71f2d31857cf7c54b0ab6e78ac659497abd2834f47", size = 6543015 },
+    { url = "https://files.pythonhosted.org/packages/9d/0f/d40f8373608caed2255781a3ad9a51d03a594a1248cd632d6a298daca693/pywin32-308-cp312-cp312-win_arm64.whl", hash = "sha256:9b4de86c8d909aed15b7011182c8cab38c8850de36e6afb1f0db22b8959e3091", size = 7976033 },
+    { url = "https://files.pythonhosted.org/packages/a9/a4/aa562d8935e3df5e49c161b427a3a2efad2ed4e9cf81c3de636f1fdddfd0/pywin32-308-cp313-cp313-win32.whl", hash = "sha256:1c44539a37a5b7b21d02ab34e6a4d314e0788f1690d65b48e9b0b89f31abbbed", size = 5938579 },
+    { url = "https://files.pythonhosted.org/packages/c7/50/b0efb8bb66210da67a53ab95fd7a98826a97ee21f1d22949863e6d588b22/pywin32-308-cp313-cp313-win_amd64.whl", hash = "sha256:fd380990e792eaf6827fcb7e187b2b4b1cede0585e3d0c9e84201ec27b9905e4", size = 6542056 },
+    { url = "https://files.pythonhosted.org/packages/26/df/2b63e3e4f2df0224f8aaf6d131f54fe4e8c96400eb9df563e2aae2e1a1f9/pywin32-308-cp313-cp313-win_arm64.whl", hash = "sha256:ef313c46d4c18dfb82a2431e3051ac8f112ccee1a34f29c263c583c568db63cd", size = 7974986 },
 ]
 
 [[package]]
@@ -4013,56 +4243,71 @@ wheels = [
 
 [[package]]
 name = "regex"
-version = "2024.7.24"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3f/51/64256d0dc72816a4fe3779449627c69ec8fee5a5625fd60ba048f53b3478/regex-2024.7.24.tar.gz", hash = "sha256:9cfd009eed1a46b27c14039ad5bbc5e71b6367c5b2e6d5f5da0ea91600817506", size = 393485 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/97/283bd32777e6c30a9bede976cd72ba4b9aa144dc0f0f462bd37fa1a86e01/regex-2024.7.24-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b0d3f567fafa0633aee87f08b9276c7062da9616931382993c03808bb68ce", size = 470812 },
-    { url = "https://files.pythonhosted.org/packages/e4/80/80bc4d7329d04ba519ebcaf26ae21d9e30d33934c458691177c623ceff70/regex-2024.7.24-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3426de3b91d1bc73249042742f45c2148803c111d1175b283270177fdf669024", size = 282129 },
-    { url = "https://files.pythonhosted.org/packages/e5/8a/cddcb7942d05ad9a427ad97ab29f1a62c0607ab72bdb2f3a26fc5b07ac0f/regex-2024.7.24-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f273674b445bcb6e4409bf8d1be67bc4b58e8b46fd0d560055d515b8830063cd", size = 278909 },
-    { url = "https://files.pythonhosted.org/packages/a6/d4/93b4011cb83f9a66e0fa398b4d3c6d564d94b686dace676c66502b13dae9/regex-2024.7.24-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23acc72f0f4e1a9e6e9843d6328177ae3074b4182167e34119ec7233dfeccf53", size = 777687 },
-    { url = "https://files.pythonhosted.org/packages/d0/11/d0a12e1cecc1d35bbcbeb99e2ddcb8c1b152b1b58e2ff55f50c3d762b09e/regex-2024.7.24-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65fd3d2e228cae024c411c5ccdffae4c315271eee4a8b839291f84f796b34eca", size = 818982 },
-    { url = "https://files.pythonhosted.org/packages/ae/41/01a073765d75427e24710af035d8f0a773b5cedf23f61b63e7ef2ce960d6/regex-2024.7.24-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c414cbda77dbf13c3bc88b073a1a9f375c7b0cb5e115e15d4b73ec3a2fbc6f59", size = 804015 },
-    { url = "https://files.pythonhosted.org/packages/3e/66/04b63f31580026c8b819aed7f171149177d10cfab27477ea8800a2268d50/regex-2024.7.24-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf7a89eef64b5455835f5ed30254ec19bf41f7541cd94f266ab7cbd463f00c41", size = 776517 },
-    { url = "https://files.pythonhosted.org/packages/be/49/0c08a7a232e4e26e17afeedf13f331224d9377dde4876ed6e21e4a584a5d/regex-2024.7.24-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:19c65b00d42804e3fbea9708f0937d157e53429a39b7c61253ff15670ff62cb5", size = 766860 },
-    { url = "https://files.pythonhosted.org/packages/24/44/35769388845cdd7be97e1232a59446b738054b61bc9c92a3b0bacfaf7bb1/regex-2024.7.24-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:7a5486ca56c8869070a966321d5ab416ff0f83f30e0e2da1ab48815c8d165d46", size = 692181 },
-    { url = "https://files.pythonhosted.org/packages/50/be/4e09d5bc8de176153f209c95ca4e64b9def1748d693694a95dd4401ee7be/regex-2024.7.24-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6f51f9556785e5a203713f5efd9c085b4a45aecd2a42573e2b5041881b588d1f", size = 762956 },
-    { url = "https://files.pythonhosted.org/packages/90/63/b37152f25fe348aa31806bafa91df607d096e8f477fed9a5cf3de339dd5f/regex-2024.7.24-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a4997716674d36a82eab3e86f8fa77080a5d8d96a389a61ea1d0e3a94a582cf7", size = 771978 },
-    { url = "https://files.pythonhosted.org/packages/ab/ac/38186431f7c1874e3f790669be933accf1090ee53aba0ab1a811ef38f07e/regex-2024.7.24-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:c0abb5e4e8ce71a61d9446040c1e86d4e6d23f9097275c5bd49ed978755ff0fe", size = 840800 },
-    { url = "https://files.pythonhosted.org/packages/e8/23/91b04dbf51a2c0ddf5b1e055e9e05ed091ebcf46f2b0e6e3d2fff121f903/regex-2024.7.24-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:18300a1d78cf1290fa583cd8b7cde26ecb73e9f5916690cf9d42de569c89b1ce", size = 838991 },
-    { url = "https://files.pythonhosted.org/packages/36/fd/822110cc14b99bdd7d8c61487bc774f454120cd3d7492935bf13f3399716/regex-2024.7.24-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:416c0e4f56308f34cdb18c3f59849479dde5b19febdcd6e6fa4d04b6c31c9faa", size = 767539 },
-    { url = "https://files.pythonhosted.org/packages/82/54/e24a8adfca74f9a421cd47657c51413919e7755e729608de6f4c5556e002/regex-2024.7.24-cp310-cp310-win32.whl", hash = "sha256:fb168b5924bef397b5ba13aabd8cf5df7d3d93f10218d7b925e360d436863f66", size = 257712 },
-    { url = "https://files.pythonhosted.org/packages/fb/cc/6485c2fc72d0de9b55392246b80921639f1be62bed1e33e982940306b5ba/regex-2024.7.24-cp310-cp310-win_amd64.whl", hash = "sha256:6b9fc7e9cc983e75e2518496ba1afc524227c163e43d706688a6bb9eca41617e", size = 269661 },
-    { url = "https://files.pythonhosted.org/packages/cb/ec/261f8434a47685d61e59a4ef3d9ce7902af521219f3ebd2194c7adb171a6/regex-2024.7.24-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:382281306e3adaaa7b8b9ebbb3ffb43358a7bbf585fa93821300a418bb975281", size = 470810 },
-    { url = "https://files.pythonhosted.org/packages/f0/47/f33b1cac88841f95fff862476a9e875d9a10dae6912a675c6f13c128e5d9/regex-2024.7.24-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4fdd1384619f406ad9037fe6b6eaa3de2749e2e12084abc80169e8e075377d3b", size = 282126 },
-    { url = "https://files.pythonhosted.org/packages/fc/1b/256ca4e2d5041c0aa2f1dc222f04412b796346ab9ce2aa5147405a9457b4/regex-2024.7.24-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3d974d24edb231446f708c455fd08f94c41c1ff4f04bcf06e5f36df5ef50b95a", size = 278920 },
-    { url = "https://files.pythonhosted.org/packages/91/03/4603ec057c0bafd2f6f50b0bdda4b12a0ff81022decf1de007b485c356a6/regex-2024.7.24-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2ec4419a3fe6cf8a4795752596dfe0adb4aea40d3683a132bae9c30b81e8d73", size = 785420 },
-    { url = "https://files.pythonhosted.org/packages/75/f8/13b111fab93e6273e26de2926345e5ecf6ddad1e44c4d419d7b0924f9c52/regex-2024.7.24-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb563dd3aea54c797adf513eeec819c4213d7dbfc311874eb4fd28d10f2ff0f2", size = 828164 },
-    { url = "https://files.pythonhosted.org/packages/4a/80/bc3b9d31bd47ff578758af929af0ac1d6169b247e26fa6e87764007f3d93/regex-2024.7.24-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:45104baae8b9f67569f0f1dca5e1f1ed77a54ae1cd8b0b07aba89272710db61e", size = 812621 },
-    { url = "https://files.pythonhosted.org/packages/8b/77/92d4a14530900d46dddc57b728eea65d723cc9fcfd07b96c2c141dabba84/regex-2024.7.24-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:994448ee01864501912abf2bad9203bffc34158e80fe8bfb5b031f4f8e16da51", size = 786609 },
-    { url = "https://files.pythonhosted.org/packages/35/58/06695fd8afad4c8ed0a53ec5e222156398b9fe5afd58887ab94ea68e4d16/regex-2024.7.24-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3fac296f99283ac232d8125be932c5cd7644084a30748fda013028c815ba3364", size = 775290 },
-    { url = "https://files.pythonhosted.org/packages/1b/0f/50b97ee1fc6965744b9e943b5c0f3740792ab54792df73d984510964ef29/regex-2024.7.24-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7e37e809b9303ec3a179085415cb5f418ecf65ec98cdfe34f6a078b46ef823ee", size = 772849 },
-    { url = "https://files.pythonhosted.org/packages/8f/64/565ff6cf241586ab7ae76bb4138c4d29bc1d1780973b457c2db30b21809a/regex-2024.7.24-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:01b689e887f612610c869421241e075c02f2e3d1ae93a037cb14f88ab6a8934c", size = 778428 },
-    { url = "https://files.pythonhosted.org/packages/e5/fe/4ceabf4382e44e1e096ac46fd5e3bca490738b24157116a48270fd542e88/regex-2024.7.24-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f6442f0f0ff81775eaa5b05af8a0ffa1dda36e9cf6ec1e0d3d245e8564b684ce", size = 849436 },
-    { url = "https://files.pythonhosted.org/packages/68/23/1868e40d6b594843fd1a3498ffe75d58674edfc90d95e18dd87865b93bf2/regex-2024.7.24-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:871e3ab2838fbcb4e0865a6e01233975df3a15e6fce93b6f99d75cacbd9862d1", size = 849484 },
-    { url = "https://files.pythonhosted.org/packages/f3/52/bff76de2f6e2bc05edce3abeb7e98e6309aa022fc06071100a0216fbeb50/regex-2024.7.24-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c918b7a1e26b4ab40409820ddccc5d49871a82329640f5005f73572d5eaa9b5e", size = 776712 },
-    { url = "https://files.pythonhosted.org/packages/f2/72/70ade7b0b5fe5c6df38fdfa2a5a8273e3ea6a10b772aa671b7e889e78bae/regex-2024.7.24-cp311-cp311-win32.whl", hash = "sha256:2dfbb8baf8ba2c2b9aa2807f44ed272f0913eeeba002478c4577b8d29cde215c", size = 257716 },
-    { url = "https://files.pythonhosted.org/packages/04/4d/80e04f4e27ab0cbc9096e2d10696da6d9c26a39b60db52670fd57614fea5/regex-2024.7.24-cp311-cp311-win_amd64.whl", hash = "sha256:538d30cd96ed7d1416d3956f94d54e426a8daf7c14527f6e0d6d425fcb4cca52", size = 269662 },
-    { url = "https://files.pythonhosted.org/packages/0f/26/f505782f386ac0399a9237571833f187414882ab6902e2e71a1ecb506835/regex-2024.7.24-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:fe4ebef608553aff8deb845c7f4f1d0740ff76fa672c011cc0bacb2a00fbde86", size = 471748 },
-    { url = "https://files.pythonhosted.org/packages/bb/1d/ea9a21beeb433dbfca31ab82867d69cb67ff8674af9fab6ebd55fa9d3387/regex-2024.7.24-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:74007a5b25b7a678459f06559504f1eec2f0f17bca218c9d56f6a0a12bfffdad", size = 282841 },
-    { url = "https://files.pythonhosted.org/packages/9b/f2/c6182095baf0a10169c34e87133a8e73b2e816a80035669b1278e927685e/regex-2024.7.24-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7df9ea48641da022c2a3c9c641650cd09f0cd15e8908bf931ad538f5ca7919c9", size = 279114 },
-    { url = "https://files.pythonhosted.org/packages/72/58/b5161bf890b6ca575a25685f19a4a3e3b6f4a072238814f8658123177d84/regex-2024.7.24-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a1141a1dcc32904c47f6846b040275c6e5de0bf73f17d7a409035d55b76f289", size = 789749 },
-    { url = "https://files.pythonhosted.org/packages/09/fb/5381b19b62f3a3494266be462f6a015a869cf4bfd8e14d6e7db67e2c8069/regex-2024.7.24-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80c811cfcb5c331237d9bad3bea2c391114588cf4131707e84d9493064d267f9", size = 831666 },
-    { url = "https://files.pythonhosted.org/packages/3d/6d/2a21c85f970f9be79357d12cf4b97f4fc6bf3bf6b843c39dabbc4e5f1181/regex-2024.7.24-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7214477bf9bd195894cf24005b1e7b496f46833337b5dedb7b2a6e33f66d962c", size = 817544 },
-    { url = "https://files.pythonhosted.org/packages/f9/ae/5f23e64f6cf170614237c654f3501a912dfb8549143d4b91d1cd13dba319/regex-2024.7.24-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d55588cba7553f0b6ec33130bc3e114b355570b45785cebdc9daed8c637dd440", size = 790854 },
-    { url = "https://files.pythonhosted.org/packages/29/0a/d04baad1bbc49cdfb4aef90c4fc875a60aaf96d35a1616f1dfe8149716bc/regex-2024.7.24-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:558a57cfc32adcf19d3f791f62b5ff564922942e389e3cfdb538a23d65a6b610", size = 779242 },
-    { url = "https://files.pythonhosted.org/packages/3a/27/b242a962f650c3213da4596d70e24c7c1c46e3aa0f79f2a81164291085f8/regex-2024.7.24-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a512eed9dfd4117110b1881ba9a59b31433caed0c4101b361f768e7bcbaf93c5", size = 776932 },
-    { url = "https://files.pythonhosted.org/packages/9c/ae/de659bdfff80ad2c0b577a43dd89dbc43870a4fc4bbf604e452196758e83/regex-2024.7.24-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:86b17ba823ea76256b1885652e3a141a99a5c4422f4a869189db328321b73799", size = 784521 },
-    { url = "https://files.pythonhosted.org/packages/d4/ac/eb6a796da0bdefbf09644a7868309423b18d344cf49963a9d36c13502d46/regex-2024.7.24-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5eefee9bfe23f6df09ffb6dfb23809f4d74a78acef004aa904dc7c88b9944b05", size = 854548 },
-    { url = "https://files.pythonhosted.org/packages/56/77/fde8d825dec69e70256e0925af6c81eea9acf0a634d3d80f619d8dcd6888/regex-2024.7.24-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:731fcd76bbdbf225e2eb85b7c38da9633ad3073822f5ab32379381e8c3c12e94", size = 853345 },
-    { url = "https://files.pythonhosted.org/packages/ff/04/2b79ad0bb9bc05ab4386caa2c19aa047a66afcbdfc2640618ffc729841e4/regex-2024.7.24-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eaef80eac3b4cfbdd6de53c6e108b4c534c21ae055d1dbea2de6b3b8ff3def38", size = 781414 },
-    { url = "https://files.pythonhosted.org/packages/bf/71/d0af58199283ada7d25b20e416f5b155f50aad99b0e791c0966ff5a1cd00/regex-2024.7.24-cp312-cp312-win32.whl", hash = "sha256:185e029368d6f89f36e526764cf12bf8d6f0e3a2a7737da625a76f594bdfcbfc", size = 258125 },
-    { url = "https://files.pythonhosted.org/packages/95/b3/10e875c45c60b010b66fc109b899c6fc4f05d485fe1d54abff98ce791124/regex-2024.7.24-cp312-cp312-win_amd64.whl", hash = "sha256:2f1baff13cc2521bea83ab2528e7a80cbe0ebb2c6f0bfad15be7da3aed443908", size = 269162 },
+version = "2024.9.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/38/148df33b4dbca3bd069b963acab5e0fa1a9dbd6820f8c322d0dd6faeff96/regex-2024.9.11.tar.gz", hash = "sha256:6c188c307e8433bcb63dc1915022deb553b4203a70722fc542c363bf120a01fd", size = 399403 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/12/497bd6599ce8a239ade68678132296aec5ee25ebea45fc8ba91aa60fceec/regex-2024.9.11-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1494fa8725c285a81d01dc8c06b55287a1ee5e0e382d8413adc0a9197aac6408", size = 482488 },
+    { url = "https://files.pythonhosted.org/packages/c1/24/595ddb9bec2a9b151cdaf9565b0c9f3da9f0cb1dca6c158bc5175332ddf8/regex-2024.9.11-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0e12c481ad92d129c78f13a2a3662317e46ee7ef96c94fd332e1c29131875b7d", size = 287443 },
+    { url = "https://files.pythonhosted.org/packages/69/a8/b2fb45d9715b1469383a0da7968f8cacc2f83e9fbbcd6b8713752dd980a6/regex-2024.9.11-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:16e13a7929791ac1216afde26f712802e3df7bf0360b32e4914dca3ab8baeea5", size = 284561 },
+    { url = "https://files.pythonhosted.org/packages/88/87/1ce4a5357216b19b7055e7d3b0efc75a6e426133bf1e7d094321df514257/regex-2024.9.11-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:46989629904bad940bbec2106528140a218b4a36bb3042d8406980be1941429c", size = 783177 },
+    { url = "https://files.pythonhosted.org/packages/3c/65/b9f002ab32f7b68e7d1dcabb67926f3f47325b8dbc22cc50b6a043e1d07c/regex-2024.9.11-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a906ed5e47a0ce5f04b2c981af1c9acf9e8696066900bf03b9d7879a6f679fc8", size = 823193 },
+    { url = "https://files.pythonhosted.org/packages/22/91/8339dd3abce101204d246e31bc26cdd7ec07c9f91598472459a3a902aa41/regex-2024.9.11-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e9a091b0550b3b0207784a7d6d0f1a00d1d1c8a11699c1a4d93db3fbefc3ad35", size = 809950 },
+    { url = "https://files.pythonhosted.org/packages/cb/19/556638aa11c2ec9968a1da998f07f27ec0abb9bf3c647d7c7985ca0b8eea/regex-2024.9.11-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ddcd9a179c0a6fa8add279a4444015acddcd7f232a49071ae57fa6e278f1f71", size = 782661 },
+    { url = "https://files.pythonhosted.org/packages/d1/e9/7a5bc4c6ef8d9cd2bdd83a667888fc35320da96a4cc4da5fa084330f53db/regex-2024.9.11-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6b41e1adc61fa347662b09398e31ad446afadff932a24807d3ceb955ed865cc8", size = 772348 },
+    { url = "https://files.pythonhosted.org/packages/f1/0b/29f2105bfac3ed08e704914c38e93b07c784a6655f8a015297ee7173e95b/regex-2024.9.11-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ced479f601cd2f8ca1fd7b23925a7e0ad512a56d6e9476f79b8f381d9d37090a", size = 697460 },
+    { url = "https://files.pythonhosted.org/packages/71/3a/52ff61054d15a4722605f5872ad03962b319a04c1ebaebe570b8b9b7dde1/regex-2024.9.11-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:635a1d96665f84b292e401c3d62775851aedc31d4f8784117b3c68c4fcd4118d", size = 769151 },
+    { url = "https://files.pythonhosted.org/packages/97/07/37e460ab5ca84be8e1e197c3b526c5c86993dcc9e13cbc805c35fc2463c1/regex-2024.9.11-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:c0256beda696edcf7d97ef16b2a33a8e5a875affd6fa6567b54f7c577b30a137", size = 777478 },
+    { url = "https://files.pythonhosted.org/packages/65/7b/953075723dd5ab00780043ac2f9de667306ff9e2a85332975e9f19279174/regex-2024.9.11-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:3ce4f1185db3fbde8ed8aa223fc9620f276c58de8b0d4f8cc86fd1360829edb6", size = 845373 },
+    { url = "https://files.pythonhosted.org/packages/40/b8/3e9484c6230b8b6e8f816ab7c9a080e631124991a4ae2c27a81631777db0/regex-2024.9.11-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:09d77559e80dcc9d24570da3745ab859a9cf91953062e4ab126ba9d5993688ca", size = 845369 },
+    { url = "https://files.pythonhosted.org/packages/b7/99/38434984d912edbd2e1969d116257e869578f67461bd7462b894c45ed874/regex-2024.9.11-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7a22ccefd4db3f12b526eccb129390942fe874a3a9fdbdd24cf55773a1faab1a", size = 773935 },
+    { url = "https://files.pythonhosted.org/packages/ab/67/43174d2b46fa947b7b9dfe56b6c8a8a76d44223f35b1d64645a732fd1d6f/regex-2024.9.11-cp310-cp310-win32.whl", hash = "sha256:f745ec09bc1b0bd15cfc73df6fa4f726dcc26bb16c23a03f9e3367d357eeedd0", size = 261624 },
+    { url = "https://files.pythonhosted.org/packages/c4/2a/4f9c47d9395b6aff24874c761d8d620c0232f97c43ef3cf668c8b355e7a7/regex-2024.9.11-cp310-cp310-win_amd64.whl", hash = "sha256:01c2acb51f8a7d6494c8c5eafe3d8e06d76563d8a8a4643b37e9b2dd8a2ff623", size = 274020 },
+    { url = "https://files.pythonhosted.org/packages/86/a1/d526b7b6095a0019aa360948c143aacfeb029919c898701ce7763bbe4c15/regex-2024.9.11-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2cce2449e5927a0bf084d346da6cd5eb016b2beca10d0013ab50e3c226ffc0df", size = 482483 },
+    { url = "https://files.pythonhosted.org/packages/32/d9/bfdd153179867c275719e381e1e8e84a97bd186740456a0dcb3e7125c205/regex-2024.9.11-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3b37fa423beefa44919e009745ccbf353d8c981516e807995b2bd11c2c77d268", size = 287442 },
+    { url = "https://files.pythonhosted.org/packages/33/c4/60f3370735135e3a8d673ddcdb2507a8560d0e759e1398d366e43d000253/regex-2024.9.11-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:64ce2799bd75039b480cc0360907c4fb2f50022f030bf9e7a8705b636e408fad", size = 284561 },
+    { url = "https://files.pythonhosted.org/packages/b1/51/91a5ebdff17f9ec4973cb0aa9d37635efec1c6868654bbc25d1543aca4ec/regex-2024.9.11-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4cc92bb6db56ab0c1cbd17294e14f5e9224f0cc6521167ef388332604e92679", size = 791779 },
+    { url = "https://files.pythonhosted.org/packages/07/4a/022c5e6f0891a90cd7eb3d664d6c58ce2aba48bff107b00013f3d6167069/regex-2024.9.11-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d05ac6fa06959c4172eccd99a222e1fbf17b5670c4d596cb1e5cde99600674c4", size = 832605 },
+    { url = "https://files.pythonhosted.org/packages/ac/1c/3793990c8c83ca04e018151ddda83b83ecc41d89964f0f17749f027fc44d/regex-2024.9.11-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040562757795eeea356394a7fb13076ad4f99d3c62ab0f8bdfb21f99a1f85664", size = 818556 },
+    { url = "https://files.pythonhosted.org/packages/e9/5c/8b385afbfacb853730682c57be56225f9fe275c5bf02ac1fc88edbff316d/regex-2024.9.11-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6113c008a7780792efc80f9dfe10ba0cd043cbf8dc9a76ef757850f51b4edc50", size = 792808 },
+    { url = "https://files.pythonhosted.org/packages/9b/8b/a4723a838b53c771e9240951adde6af58c829fb6a6a28f554e8131f53839/regex-2024.9.11-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8e5fb5f77c8745a60105403a774fe2c1759b71d3e7b4ca237a5e67ad066c7199", size = 781115 },
+    { url = "https://files.pythonhosted.org/packages/83/5f/031a04b6017033d65b261259c09043c06f4ef2d4eac841d0649d76d69541/regex-2024.9.11-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:54d9ff35d4515debf14bc27f1e3b38bfc453eff3220f5bce159642fa762fe5d4", size = 778155 },
+    { url = "https://files.pythonhosted.org/packages/fd/cd/4660756070b03ce4a66663a43f6c6e7ebc2266cc6b4c586c167917185eb4/regex-2024.9.11-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df5cbb1fbc74a8305b6065d4ade43b993be03dbe0f8b30032cced0d7740994bd", size = 784614 },
+    { url = "https://files.pythonhosted.org/packages/93/8d/65b9bea7df120a7be8337c415b6d256ba786cbc9107cebba3bf8ff09da99/regex-2024.9.11-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7fb89ee5d106e4a7a51bce305ac4efb981536301895f7bdcf93ec92ae0d91c7f", size = 853744 },
+    { url = "https://files.pythonhosted.org/packages/96/a7/fba1eae75eb53a704475baf11bd44b3e6ccb95b316955027eb7748f24ef8/regex-2024.9.11-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a738b937d512b30bf75995c0159c0ddf9eec0775c9d72ac0202076c72f24aa96", size = 855890 },
+    { url = "https://files.pythonhosted.org/packages/45/14/d864b2db80a1a3358534392373e8a281d95b28c29c87d8548aed58813910/regex-2024.9.11-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e28f9faeb14b6f23ac55bfbbfd3643f5c7c18ede093977f1df249f73fd22c7b1", size = 781887 },
+    { url = "https://files.pythonhosted.org/packages/4d/a9/bfb29b3de3eb11dc9b412603437023b8e6c02fb4e11311863d9bf62c403a/regex-2024.9.11-cp311-cp311-win32.whl", hash = "sha256:18e707ce6c92d7282dfce370cd205098384b8ee21544e7cb29b8aab955b66fa9", size = 261644 },
+    { url = "https://files.pythonhosted.org/packages/c7/ab/1ad2511cf6a208fde57fafe49829cab8ca018128ab0d0b48973d8218634a/regex-2024.9.11-cp311-cp311-win_amd64.whl", hash = "sha256:313ea15e5ff2a8cbbad96ccef6be638393041b0a7863183c2d31e0c6116688cf", size = 274033 },
+    { url = "https://files.pythonhosted.org/packages/6e/92/407531450762bed778eedbde04407f68cbd75d13cee96c6f8d6903d9c6c1/regex-2024.9.11-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b0d0a6c64fcc4ef9c69bd5b3b3626cc3776520a1637d8abaa62b9edc147a58f7", size = 483590 },
+    { url = "https://files.pythonhosted.org/packages/8e/a2/048acbc5ae1f615adc6cba36cc45734e679b5f1e4e58c3c77f0ed611d4e2/regex-2024.9.11-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:49b0e06786ea663f933f3710a51e9385ce0cba0ea56b67107fd841a55d56a231", size = 288175 },
+    { url = "https://files.pythonhosted.org/packages/8a/ea/909d8620329ab710dfaf7b4adee41242ab7c9b95ea8d838e9bfe76244259/regex-2024.9.11-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5b513b6997a0b2f10e4fd3a1313568e373926e8c252bd76c960f96fd039cd28d", size = 284749 },
+    { url = "https://files.pythonhosted.org/packages/ca/fa/521eb683b916389b4975337873e66954e0f6d8f91bd5774164a57b503185/regex-2024.9.11-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee439691d8c23e76f9802c42a95cfeebf9d47cf4ffd06f18489122dbb0a7ad64", size = 795181 },
+    { url = "https://files.pythonhosted.org/packages/28/db/63047feddc3280cc242f9c74f7aeddc6ee662b1835f00046f57d5630c827/regex-2024.9.11-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8f877c89719d759e52783f7fe6e1c67121076b87b40542966c02de5503ace42", size = 835842 },
+    { url = "https://files.pythonhosted.org/packages/e3/94/86adc259ff8ec26edf35fcca7e334566c1805c7493b192cb09679f9c3dee/regex-2024.9.11-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:23b30c62d0f16827f2ae9f2bb87619bc4fba2044911e2e6c2eb1af0161cdb766", size = 823533 },
+    { url = "https://files.pythonhosted.org/packages/29/52/84662b6636061277cb857f658518aa7db6672bc6d1a3f503ccd5aefc581e/regex-2024.9.11-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85ab7824093d8f10d44330fe1e6493f756f252d145323dd17ab6b48733ff6c0a", size = 797037 },
+    { url = "https://files.pythonhosted.org/packages/c3/2a/cd4675dd987e4a7505f0364a958bc41f3b84942de9efaad0ef9a2646681c/regex-2024.9.11-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8dee5b4810a89447151999428fe096977346cf2f29f4d5e29609d2e19e0199c9", size = 784106 },
+    { url = "https://files.pythonhosted.org/packages/6f/75/3ea7ec29de0bbf42f21f812f48781d41e627d57a634f3f23947c9a46e303/regex-2024.9.11-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98eeee2f2e63edae2181c886d7911ce502e1292794f4c5ee71e60e23e8d26b5d", size = 782468 },
+    { url = "https://files.pythonhosted.org/packages/d3/67/15519d69b52c252b270e679cb578e22e0c02b8dd4e361f2b04efcc7f2335/regex-2024.9.11-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:57fdd2e0b2694ce6fc2e5ccf189789c3e2962916fb38779d3e3521ff8fe7a822", size = 790324 },
+    { url = "https://files.pythonhosted.org/packages/9c/71/eff77d3fe7ba08ab0672920059ec30d63fa7e41aa0fb61c562726e9bd721/regex-2024.9.11-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d552c78411f60b1fdaafd117a1fca2f02e562e309223b9d44b7de8be451ec5e0", size = 860214 },
+    { url = "https://files.pythonhosted.org/packages/81/11/e1bdf84a72372e56f1ea4b833dd583b822a23138a616ace7ab57a0e11556/regex-2024.9.11-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a0b2b80321c2ed3fcf0385ec9e51a12253c50f146fddb2abbb10f033fe3d049a", size = 859420 },
+    { url = "https://files.pythonhosted.org/packages/ea/75/9753e9dcebfa7c3645563ef5c8a58f3a47e799c872165f37c55737dadd3e/regex-2024.9.11-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:18406efb2f5a0e57e3a5881cd9354c1512d3bb4f5c45d96d110a66114d84d23a", size = 787333 },
+    { url = "https://files.pythonhosted.org/packages/bc/4e/ba1cbca93141f7416624b3ae63573e785d4bc1834c8be44a8f0747919eca/regex-2024.9.11-cp312-cp312-win32.whl", hash = "sha256:e464b467f1588e2c42d26814231edecbcfe77f5ac414d92cbf4e7b55b2c2a776", size = 262058 },
+    { url = "https://files.pythonhosted.org/packages/6e/16/efc5f194778bf43e5888209e5cec4b258005d37c613b67ae137df3b89c53/regex-2024.9.11-cp312-cp312-win_amd64.whl", hash = "sha256:9e8719792ca63c6b8340380352c24dcb8cd7ec49dae36e963742a275dfae6009", size = 273526 },
+    { url = "https://files.pythonhosted.org/packages/93/0a/d1c6b9af1ff1e36832fe38d74d5c5bab913f2bdcbbd6bc0e7f3ce8b2f577/regex-2024.9.11-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c157bb447303070f256e084668b702073db99bbb61d44f85d811025fcf38f784", size = 483376 },
+    { url = "https://files.pythonhosted.org/packages/a4/42/5910a050c105d7f750a72dcb49c30220c3ae4e2654e54aaaa0e9bc0584cb/regex-2024.9.11-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4db21ece84dfeefc5d8a3863f101995de646c6cb0536952c321a2650aa202c36", size = 288112 },
+    { url = "https://files.pythonhosted.org/packages/8d/56/0c262aff0e9224fa7ffce47b5458d373f4d3e3ff84e99b5ff0cb15e0b5b2/regex-2024.9.11-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:220e92a30b426daf23bb67a7962900ed4613589bab80382be09b48896d211e92", size = 284608 },
+    { url = "https://files.pythonhosted.org/packages/b9/54/9fe8f9aec5007bbbbce28ba3d2e3eaca425f95387b7d1e84f0d137d25237/regex-2024.9.11-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb1ae19e64c14c7ec1995f40bd932448713d3c73509e82d8cd7744dc00e29e86", size = 795337 },
+    { url = "https://files.pythonhosted.org/packages/b2/e7/6b2f642c3cded271c4f16cc4daa7231be544d30fe2b168e0223724b49a61/regex-2024.9.11-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f47cd43a5bfa48f86925fe26fbdd0a488ff15b62468abb5d2a1e092a4fb10e85", size = 835848 },
+    { url = "https://files.pythonhosted.org/packages/cd/9e/187363bdf5d8c0e4662117b92aa32bf52f8f09620ae93abc7537d96d3311/regex-2024.9.11-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9d4a76b96f398697fe01117093613166e6aa8195d63f1b4ec3f21ab637632963", size = 823503 },
+    { url = "https://files.pythonhosted.org/packages/f8/10/601303b8ee93589f879664b0cfd3127949ff32b17f9b6c490fb201106c4d/regex-2024.9.11-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ea51dcc0835eea2ea31d66456210a4e01a076d820e9039b04ae8d17ac11dee6", size = 797049 },
+    { url = "https://files.pythonhosted.org/packages/ef/1c/ea200f61ce9f341763f2717ab4daebe4422d83e9fd4ac5e33435fd3a148d/regex-2024.9.11-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7aaa315101c6567a9a45d2839322c51c8d6e81f67683d529512f5bcfb99c802", size = 784144 },
+    { url = "https://files.pythonhosted.org/packages/d8/5c/d2429be49ef3292def7688401d3deb11702c13dcaecdc71d2b407421275b/regex-2024.9.11-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c57d08ad67aba97af57a7263c2d9006d5c404d721c5f7542f077f109ec2a4a29", size = 782483 },
+    { url = "https://files.pythonhosted.org/packages/12/d9/cbc30f2ff7164f3b26a7760f87c54bf8b2faed286f60efd80350a51c5b99/regex-2024.9.11-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f8404bf61298bb6f8224bb9176c1424548ee1181130818fcd2cbffddc768bed8", size = 790320 },
+    { url = "https://files.pythonhosted.org/packages/19/1d/43ed03a236313639da5a45e61bc553c8d41e925bcf29b0f8ecff0c2c3f25/regex-2024.9.11-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dd4490a33eb909ef5078ab20f5f000087afa2a4daa27b4c072ccb3cb3050ad84", size = 860435 },
+    { url = "https://files.pythonhosted.org/packages/34/4f/5d04da61c7c56e785058a46349f7285ae3ebc0726c6ea7c5c70600a52233/regex-2024.9.11-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:eee9130eaad130649fd73e5cd92f60e55708952260ede70da64de420cdcad554", size = 859571 },
+    { url = "https://files.pythonhosted.org/packages/12/7f/8398c8155a3c70703a8e91c29532558186558e1aea44144b382faa2a6f7a/regex-2024.9.11-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6a2644a93da36c784e546de579ec1806bfd2763ef47babc1b03d765fe560c9f8", size = 787398 },
+    { url = "https://files.pythonhosted.org/packages/58/3a/f5903977647a9a7e46d5535e9e96c194304aeeca7501240509bde2f9e17f/regex-2024.9.11-cp313-cp313-win32.whl", hash = "sha256:e997fd30430c57138adc06bba4c7c2968fb13d101e57dd5bb9355bf8ce3fa7e8", size = 262035 },
+    { url = "https://files.pythonhosted.org/packages/ff/80/51ba3a4b7482f6011095b3a036e07374f64de180b7d870b704ed22509002/regex-2024.9.11-cp313-cp313-win_amd64.whl", hash = "sha256:042c55879cfeb21a8adacc84ea347721d3d83a159da6acdf1116859e2427c43f", size = 273510 },
 ]
 
 [[package]]
@@ -4092,17 +4337,30 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d7/25/dd878a121fcfdf38f52850f11c512e13ec87c2ea72385933818e5b6c15ce/requests_file-2.1.0-py2.py3-none-any.whl", hash = "sha256:cf270de5a4c5874e84599fc5778303d496c10ae5e870bfa378818f35d21bda5c", size = 4244 },
 ]
 
+[[package]]
+name = "requests-toolbelt"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481 },
+]
+
 [[package]]
 name = "rich"
-version = "13.8.0"
+version = "13.9.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py" },
     { name = "pygments" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/cf/60/5959113cae0ce512cf246a6871c623117330105a0d5f59b4e26138f2c9cc/rich-13.8.0.tar.gz", hash = "sha256:a5ac1f1cd448ade0d59cc3356f7db7a7ccda2c8cbae9c7a90c28ff463d3e91f4", size = 222072 }
+sdist = { url = "https://files.pythonhosted.org/packages/d9/e9/cf9ef5245d835065e6673781dbd4b8911d352fb770d56cf0879cf11b7ee1/rich-13.9.3.tar.gz", hash = "sha256:bc1e01b899537598cf02579d2b9f4a415104d3fc439313a7a2c165d76557a08e", size = 222889 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/d9/c2a126eeae791e90ea099d05cb0515feea3688474b978343f3cdcfe04523/rich-13.8.0-py3-none-any.whl", hash = "sha256:2e85306a063b9492dffc86278197a60cbece75bcb766022f3436f567cae11bdc", size = 241597 },
+    { url = "https://files.pythonhosted.org/packages/9a/e2/10e9819cf4a20bd8ea2f5dabafc2e6bf4a78d6a0965daeb60a4b34d1c11f/rich-13.9.3-py3-none-any.whl", hash = "sha256:9836f5096eb2172c9e77df411c1b009bace4193d6a481d534fea75ebba758283", size = 242157 },
 ]
 
 [[package]]
@@ -4258,7 +4516,7 @@ wheels = [
 
 [[package]]
 name = "selenium"
-version = "4.24.0"
+version = "4.25.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
@@ -4268,18 +4526,18 @@ dependencies = [
     { name = "urllib3", extra = ["socks"] },
     { name = "websocket-client" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ee/ba/02f65b140f47c85a9d52c67cb19417ec8c97eb46547c3aa93f2b077fa276/selenium-4.24.0.tar.gz", hash = "sha256:88281e5b5b90fe231868905d5ea745b9ee5e30db280b33498cc73fb0fa06d571", size = 952221 }
+sdist = { url = "https://files.pythonhosted.org/packages/0e/5a/d3735b189b91715fd0f5a9b8d55e2605061309849470e96ab830f02cba40/selenium-4.25.0.tar.gz", hash = "sha256:95d08d3b82fb353f3c474895154516604c7f0e6a9a565ae6498ef36c9bac6921", size = 957765 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/5aac23e57d61707f91914506902e621632de8dc56b60446459901469b9e2/selenium-4.24.0-py3-none-any.whl", hash = "sha256:42c23f60753d5415b261b236cecbd69bd4eb5271e1563915f546b443cb6b71c6", size = 9579812 },
+    { url = "https://files.pythonhosted.org/packages/aa/85/fa44f23dd5d5066a72f7c4304cce4b5ff9a6e7fd92431a48b2c63fbf63ec/selenium-4.25.0-py3-none-any.whl", hash = "sha256:3798d2d12b4a570bc5790163ba57fef10b2afee958bf1d80f2a3cf07c4141f33", size = 9693127 },
 ]
 
 [[package]]
 name = "setuptools"
-version = "74.0.0"
+version = "75.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6a/21/8fd457d5a979109603e0e460c73177c3a9b6b7abcd136d0146156da95895/setuptools-74.0.0.tar.gz", hash = "sha256:a85e96b8be2b906f3e3e789adec6a9323abf79758ecfa3065bd740d81158b11e", size = 1389536 }
+sdist = { url = "https://files.pythonhosted.org/packages/07/37/b31be7e4b9f13b59cde9dcaeff112d401d49e0dc5b37ed4a9fc8fb12f409/setuptools-75.2.0.tar.gz", hash = "sha256:753bb6ebf1f465a1912e19ed1d41f403a79173a9acf66a42e7e6aec45c3c16ec", size = 1350308 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/df/b5/168cec9a10bf93b60b8f9af7f4e61d526e31e1aad8b9be0e30837746d700/setuptools-74.0.0-py3-none-any.whl", hash = "sha256:0274581a0037b638b9fc1c6883cc71c0210865aaa76073f7882376b641b84e8f", size = 1301729 },
+    { url = "https://files.pythonhosted.org/packages/31/2d/90165d51ecd38f9a02c6832198c13a4e48652485e2ccf863ebb942c531b6/setuptools-75.2.0-py3-none-any.whl", hash = "sha256:a7fcb66f68b4d9e8e66b42f9876150a3371558f98fa32222ffaa5bced76406f8", size = 1249825 },
 ]
 
 [[package]]
@@ -4379,20 +4637,20 @@ wheels = [
 
 [[package]]
 name = "speechrecognition"
-version = "3.10.4"
+version = "3.11.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "requests" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/75/0a/52111a3dc0a8b554da0037532ed6cd1d06057d74ada865ec4fe2e4400c47/speechrecognition-3.10.4.tar.gz", hash = "sha256:986bafcf61f14625c2f3cea6a471838edd379ed68aeed7b8f3c0fb41e21f1125", size = 32850542 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/3d/bf00cd546c028f54c9d3271e04c2231b958b243d4c5faa7227e32fce48cc/speechrecognition-3.11.0.tar.gz", hash = "sha256:a5ecc0bb61d7d9bf0ca70427cd4fea07c38e26c647b5577137596033677b5f34", size = 32851187 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/28/b5e6e769002e46a5edef16871884721d4b68da31dbd4509db6ea50f8b224/SpeechRecognition-3.10.4-py2.py3-none-any.whl", hash = "sha256:723b8155692a8ed11a30013f15f89a3e57c5dc8bc73c8cb024bf9bd14c21fba5", size = 32841246 },
+    { url = "https://files.pythonhosted.org/packages/42/eb/1c355b5d94e8944cc02aabbcd3c9121eb00cfd6b44867eabc5888c8ec5f9/SpeechRecognition-3.11.0-py2.py3-none-any.whl", hash = "sha256:a5be29ae95852969045c3c0d1dc0ed49cf48246d899a39591abbc75ff17ccb86", size = 32845885 },
 ]
 
 [[package]]
 name = "sphinx"
-version = "8.0.2"
+version = "8.1.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "alabaster" },
@@ -4413,14 +4671,14 @@ dependencies = [
     { name = "sphinxcontrib-serializinghtml" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/25/a7/3cc3d6dcad70aba2e32a3ae8de5a90026a0a2fdaaa0756925e3a120249b6/sphinx-8.0.2.tar.gz", hash = "sha256:0cce1ddcc4fd3532cf1dd283bc7d886758362c5c1de6598696579ce96d8ffa5b", size = 8189041 }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4d/61/2ad169c6ff1226b46e50da0e44671592dbc6d840a52034a0193a99b28579/sphinx-8.0.2-py3-none-any.whl", hash = "sha256:56173572ae6c1b9a38911786e206a110c9749116745873feae4f9ce88e59391d", size = 3498950 },
+    { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125 },
 ]
 
 [[package]]
 name = "sphinx-autobuild"
-version = "2024.4.16"
+version = "2024.10.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama" },
@@ -4430,9 +4688,9 @@ dependencies = [
     { name = "watchfiles" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d2/bc/8016eee9ffb86069ae7e658c136bad31a9854b476a212492b5aab4d4d5f6/sphinx_autobuild-2024.4.16.tar.gz", hash = "sha256:1c0ed37a1970eed197f9c5a66d65759e7c4e4cba7b5a5d77940752bf1a59f2c7", size = 12892 }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/2c/155e1de2c1ba96a72e5dba152c509a8b41e047ee5c2def9e9f0d812f8be7/sphinx_autobuild-2024.10.3.tar.gz", hash = "sha256:248150f8f333e825107b6d4b86113ab28fa51750e5f9ae63b59dc339be951fb1", size = 14023 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/de/1d005ba60b4b754d6e05079a479f16a8f6e08c1ec4f8d80288238502b4b6/sphinx_autobuild-2024.4.16-py3-none-any.whl", hash = "sha256:f2522779d30fcbf0253e09714f274ce8c608cb6ebcd67922b1c54de59faba702", size = 11222 },
+    { url = "https://files.pythonhosted.org/packages/18/c0/eba125db38c84d3c74717008fd3cb5000b68cd7e2cbafd1349c6a38c3d3b/sphinx_autobuild-2024.10.3-py3-none-any.whl", hash = "sha256:158e16c36f9d633e613c9aaf81c19b0fc458ca78b112533b20dafcda430d60fa", size = 11908 },
 ]
 
 [[package]]
@@ -4537,39 +4795,47 @@ sdist = { url = "https://files.pythonhosted.org/packages/70/fc/a2a4cc112c467f899
 
 [[package]]
 name = "sqlalchemy"
-version = "2.0.32"
+version = "2.0.36"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "greenlet", marker = "(python_full_version < '3.13' and platform_machine == 'AMD64') or (python_full_version < '3.13' and platform_machine == 'WIN32') or (python_full_version < '3.13' and platform_machine == 'aarch64') or (python_full_version < '3.13' and platform_machine == 'amd64') or (python_full_version < '3.13' and platform_machine == 'ppc64le') or (python_full_version < '3.13' and platform_machine == 'win32') or (python_full_version < '3.13' and platform_machine == 'x86_64')" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/af/6f/967e987683908af816aa3072c1a6997ac9933cf38d66b0474fb03f253323/SQLAlchemy-2.0.32.tar.gz", hash = "sha256:c1b88cc8b02b6a5f0efb0345a03672d4c897dc7d92585176f88c67346f565ea8", size = 9546691 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b8/f4/487eaff0bc01352662be8d9b975d0850dc3e8bd282918e073cff5a73421d/SQLAlchemy-2.0.32-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0c9045ecc2e4db59bfc97b20516dfdf8e41d910ac6fb667ebd3a79ea54084619", size = 2087564 },
-    { url = "https://files.pythonhosted.org/packages/91/8a/509557a8e43cf55bad70843f2de48c5247c34d47a812c04e41be33351861/SQLAlchemy-2.0.32-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1467940318e4a860afd546ef61fefb98a14d935cd6817ed07a228c7f7c62f389", size = 2078758 },
-    { url = "https://files.pythonhosted.org/packages/e0/cb/b1ecd40bcbbba6ca8f35047b53a940eceda36acc9afa0db4cb0d8addd81a/SQLAlchemy-2.0.32-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5954463675cb15db8d4b521f3566a017c8789222b8316b1e6934c811018ee08b", size = 3061235 },
-    { url = "https://files.pythonhosted.org/packages/3b/94/db0bc142f448627638a2962afae54c520697119c0d6e23ebd36a7c472c8f/SQLAlchemy-2.0.32-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:167e7497035c303ae50651b351c28dc22a40bb98fbdb8468cdc971821b1ae533", size = 3069497 },
-    { url = "https://files.pythonhosted.org/packages/e6/cf/bf90dc56ce347697d8c549875c555f783b96406bc723de6e462490bfe880/SQLAlchemy-2.0.32-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b27dfb676ac02529fb6e343b3a482303f16e6bc3a4d868b73935b8792edb52d0", size = 3025552 },
-    { url = "https://files.pythonhosted.org/packages/22/fb/393cb374013c819096f486c12596c9e8b8944b53d85e96fbca9fe7b1f14a/SQLAlchemy-2.0.32-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bf2360a5e0f7bd75fa80431bf8ebcfb920c9f885e7956c7efde89031695cafb8", size = 3051018 },
-    { url = "https://files.pythonhosted.org/packages/6d/3b/80c35cbacbbcf56bbb2befbb9e06b7e9c5f6b4a5b0cc07579d85504e5284/SQLAlchemy-2.0.32-cp310-cp310-win32.whl", hash = "sha256:306fe44e754a91cd9d600a6b070c1f2fadbb4a1a257b8781ccf33c7067fd3e4d", size = 2059441 },
-    { url = "https://files.pythonhosted.org/packages/e8/86/989f4b4c47da0d9b152465f6623b6a6415179b4e6bb967f08199bdad98eb/SQLAlchemy-2.0.32-cp310-cp310-win_amd64.whl", hash = "sha256:99db65e6f3ab42e06c318f15c98f59a436f1c78179e6a6f40f529c8cc7100b22", size = 2083917 },
-    { url = "https://files.pythonhosted.org/packages/fc/a9/e3bd92004095ed6796ea4ac5fdd9606b1e53117ef5b90ae79ac3fc6e225e/SQLAlchemy-2.0.32-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:21b053be28a8a414f2ddd401f1be8361e41032d2ef5884b2f31d31cb723e559f", size = 2088752 },
-    { url = "https://files.pythonhosted.org/packages/a9/34/b97f4458eefbdead7ee5ce69cbf3591574c5ba44162dbe52c4386818623f/SQLAlchemy-2.0.32-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b178e875a7a25b5938b53b006598ee7645172fccafe1c291a706e93f48499ff5", size = 2079150 },
-    { url = "https://files.pythonhosted.org/packages/6b/b5/95ff12f5d4eb7813dd5a59ccc8e3c68d4683fedf59801b40704593c3b757/SQLAlchemy-2.0.32-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:723a40ee2cc7ea653645bd4cf024326dea2076673fc9d3d33f20f6c81db83e1d", size = 3197551 },
-    { url = "https://files.pythonhosted.org/packages/ca/af/379f8695ab751acf61868b0098c8d66e2b2ad8b11d9939d5144c82d05bc5/SQLAlchemy-2.0.32-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:295ff8689544f7ee7e819529633d058bd458c1fd7f7e3eebd0f9268ebc56c2a0", size = 3197551 },
-    { url = "https://files.pythonhosted.org/packages/ff/0c/5feaea51f23b5f008f16f9dbf7eec18ee5b9b8eb2875d6e367f52daf633e/SQLAlchemy-2.0.32-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:49496b68cd190a147118af585173ee624114dfb2e0297558c460ad7495f9dfe2", size = 3134583 },
-    { url = "https://files.pythonhosted.org/packages/cc/83/4eca3604f9049a2b92a9ffb818ea1cc8186f722e539a6feee58f931bad34/SQLAlchemy-2.0.32-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:acd9b73c5c15f0ec5ce18128b1fe9157ddd0044abc373e6ecd5ba376a7e5d961", size = 3154911 },
-    { url = "https://files.pythonhosted.org/packages/3d/56/485ad322f148a8b70060e03b5f130e714f95d839b5e50315e5c5efd1fc05/SQLAlchemy-2.0.32-cp311-cp311-win32.whl", hash = "sha256:9365a3da32dabd3e69e06b972b1ffb0c89668994c7e8e75ce21d3e5e69ddef28", size = 2059047 },
-    { url = "https://files.pythonhosted.org/packages/bb/8c/4548ae42b4ab7f3fe9f1aeb4b1f28ea795485ca44840cb0f3f57aa8ecfcc/SQLAlchemy-2.0.32-cp311-cp311-win_amd64.whl", hash = "sha256:8bd63d051f4f313b102a2af1cbc8b80f061bf78f3d5bd0843ff70b5859e27924", size = 2084480 },
-    { url = "https://files.pythonhosted.org/packages/06/95/88beb07aa61c611829c9ce950f349adcf00065c1bb313090c20d80a520ca/SQLAlchemy-2.0.32-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6bab3db192a0c35e3c9d1560eb8332463e29e5507dbd822e29a0a3c48c0a8d92", size = 2087267 },
-    { url = "https://files.pythonhosted.org/packages/11/93/0b28f9d261af927eef3df472e5bbf144fb33e062de770b2c312bb516702b/SQLAlchemy-2.0.32-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:19d98f4f58b13900d8dec4ed09dd09ef292208ee44cc9c2fe01c1f0a2fe440e9", size = 2077732 },
-    { url = "https://files.pythonhosted.org/packages/84/50/1ce1dec4b1cce8f1163c2c58bb1588ac5076c3dbc4bb1d3eab70e798fdd4/SQLAlchemy-2.0.32-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3cd33c61513cb1b7371fd40cf221256456d26a56284e7d19d1f0b9f1eb7dd7e8", size = 3227230 },
-    { url = "https://files.pythonhosted.org/packages/9d/b8/aa822988d390cf06afa3c69d86a3a38bba79b51385207cd7cd99d0be17bb/SQLAlchemy-2.0.32-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d6ba0497c1d066dd004e0f02a92426ca2df20fac08728d03f67f6960271feec", size = 3238118 },
-    { url = "https://files.pythonhosted.org/packages/c3/d7/7a65172ed2713acf0262a65392dfcf05ca2b7a67c988ebad425eba9b3843/SQLAlchemy-2.0.32-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2b6be53e4fde0065524f1a0a7929b10e9280987b320716c1509478b712a7688c", size = 3173610 },
-    { url = "https://files.pythonhosted.org/packages/a9/0f/8da0613e3f0b095ef423802943ed4b98242370736034ed5043a43c46c3d4/SQLAlchemy-2.0.32-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:916a798f62f410c0b80b63683c8061f5ebe237b0f4ad778739304253353bc1cb", size = 3200224 },
-    { url = "https://files.pythonhosted.org/packages/50/ef/973e0bbf2be5c12e34dca92139ca100f51ba078e36c3c06fd1dc8480c209/SQLAlchemy-2.0.32-cp312-cp312-win32.whl", hash = "sha256:31983018b74908ebc6c996a16ad3690301a23befb643093fcfe85efd292e384d", size = 2057626 },
-    { url = "https://files.pythonhosted.org/packages/db/5f/440c324aae82a2ce892ac0fe1d114b9dc9f04e934e8f0762574876a168b5/SQLAlchemy-2.0.32-cp312-cp312-win_amd64.whl", hash = "sha256:4363ed245a6231f2e2957cccdda3c776265a75851f4753c60f3004b90e69bfeb", size = 2083167 },
-    { url = "https://files.pythonhosted.org/packages/99/1b/045185a9f6481d926a451aafaa0d07c98f19ac7abe730dff9630c9ead4fa/SQLAlchemy-2.0.32-py3-none-any.whl", hash = "sha256:e567a8793a692451f706b363ccf3c45e056b67d90ead58c3bc9471af5d212202", size = 1878765 },
+sdist = { url = "https://files.pythonhosted.org/packages/50/65/9cbc9c4c3287bed2499e05033e207473504dc4df999ce49385fb1f8b058a/sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5", size = 9574485 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/72/14ab694b8b3f0e35ef5beb74a8fea2811aa791ba1611c44dc90cdf46af17/SQLAlchemy-2.0.36-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:59b8f3adb3971929a3e660337f5dacc5942c2cdb760afcabb2614ffbda9f9f72", size = 2092604 },
+    { url = "https://files.pythonhosted.org/packages/1e/59/333fcbca58b79f5b8b61853d6137530198823392151fa8fd9425f367519e/SQLAlchemy-2.0.36-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:37350015056a553e442ff672c2d20e6f4b6d0b2495691fa239d8aa18bb3bc908", size = 2083796 },
+    { url = "https://files.pythonhosted.org/packages/6c/a0/ec3c188d2b0c1bc742262e76408d44104598d7247c23f5b06bb97ee21bfa/SQLAlchemy-2.0.36-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8318f4776c85abc3f40ab185e388bee7a6ea99e7fa3a30686580b209eaa35c08", size = 3066165 },
+    { url = "https://files.pythonhosted.org/packages/07/15/68ef91de5b8b7f80fb2d2b3b31ed42180c6227fe0a701aed9d01d34f98ec/SQLAlchemy-2.0.36-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c245b1fbade9c35e5bd3b64270ab49ce990369018289ecfde3f9c318411aaa07", size = 3074428 },
+    { url = "https://files.pythonhosted.org/packages/e2/4c/9dfea5e63b87325eef6d9cdaac913459aa6a157a05a05ea6ff20004aee8e/SQLAlchemy-2.0.36-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:69f93723edbca7342624d09f6704e7126b152eaed3cdbb634cb657a54332a3c5", size = 3030477 },
+    { url = "https://files.pythonhosted.org/packages/16/a5/fcfde8e74ea5f683b24add22463bfc21e431d4a5531c8a5b55bc6fbea164/SQLAlchemy-2.0.36-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f9511d8dd4a6e9271d07d150fb2f81874a3c8c95e11ff9af3a2dfc35fe42ee44", size = 3055942 },
+    { url = "https://files.pythonhosted.org/packages/3c/ee/c22c415a771d791ae99146d72ffdb20e43625acd24835ea7fc157436d59f/SQLAlchemy-2.0.36-cp310-cp310-win32.whl", hash = "sha256:c3f3631693003d8e585d4200730616b78fafd5a01ef8b698f6967da5c605b3fa", size = 2064960 },
+    { url = "https://files.pythonhosted.org/packages/aa/af/ad9c25cadc79bd851bdb9d82b68af9bdb91ff05f56d0da2f8a654825974f/SQLAlchemy-2.0.36-cp310-cp310-win_amd64.whl", hash = "sha256:a86bfab2ef46d63300c0f06936bd6e6c0105faa11d509083ba8f2f9d237fb5b5", size = 2089078 },
+    { url = "https://files.pythonhosted.org/packages/00/4e/5a67963fd7cbc1beb8bd2152e907419f4c940ef04600b10151a751fe9e06/SQLAlchemy-2.0.36-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fd3a55deef00f689ce931d4d1b23fa9f04c880a48ee97af488fd215cf24e2a6c", size = 2093782 },
+    { url = "https://files.pythonhosted.org/packages/b3/24/30e33b6389ebb5a17df2a4243b091bc709fb3dfc9a48c8d72f8e037c943d/SQLAlchemy-2.0.36-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4f5e9cd989b45b73bd359f693b935364f7e1f79486e29015813c338450aa5a71", size = 2084180 },
+    { url = "https://files.pythonhosted.org/packages/10/1e/70e9ed2143a27065246be40f78637ad5160ea0f5fd32f8cab819a31ff54d/SQLAlchemy-2.0.36-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0ddd9db6e59c44875211bc4c7953a9f6638b937b0a88ae6d09eb46cced54eff", size = 3202469 },
+    { url = "https://files.pythonhosted.org/packages/b4/5f/95e0ed74093ac3c0db6acfa944d4d8ac6284ef5e1136b878a327ea1f975a/SQLAlchemy-2.0.36-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2519f3a5d0517fc159afab1015e54bb81b4406c278749779be57a569d8d1bb0d", size = 3202464 },
+    { url = "https://files.pythonhosted.org/packages/91/95/2cf9b85a6bc2ee660e40594dffe04e777e7b8617fd0c6d77a0f782ea96c9/SQLAlchemy-2.0.36-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59b1ee96617135f6e1d6f275bbe988f419c5178016f3d41d3c0abb0c819f75bb", size = 3139508 },
+    { url = "https://files.pythonhosted.org/packages/92/ea/f0c01bc646456e4345c0fb5a3ddef457326285c2dc60435b0eb96b61bf31/SQLAlchemy-2.0.36-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:39769a115f730d683b0eb7b694db9789267bcd027326cccc3125e862eb03bfd8", size = 3159837 },
+    { url = "https://files.pythonhosted.org/packages/a6/93/c8edbf153ee38fe529773240877bf1332ed95328aceef6254288f446994e/SQLAlchemy-2.0.36-cp311-cp311-win32.whl", hash = "sha256:66bffbad8d6271bb1cc2f9a4ea4f86f80fe5e2e3e501a5ae2a3dc6a76e604e6f", size = 2064529 },
+    { url = "https://files.pythonhosted.org/packages/b1/03/d12b7c1d36fd80150c1d52e121614cf9377dac99e5497af8d8f5b2a8db64/SQLAlchemy-2.0.36-cp311-cp311-win_amd64.whl", hash = "sha256:23623166bfefe1487d81b698c423f8678e80df8b54614c2bf4b4cfcd7c711959", size = 2089874 },
+    { url = "https://files.pythonhosted.org/packages/b8/bf/005dc47f0e57556e14512d5542f3f183b94fde46e15ff1588ec58ca89555/SQLAlchemy-2.0.36-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7b64e6ec3f02c35647be6b4851008b26cff592a95ecb13b6788a54ef80bbdd4", size = 2092378 },
+    { url = "https://files.pythonhosted.org/packages/94/65/f109d5720779a08e6e324ec89a744f5f92c48bd8005edc814bf72fbb24e5/SQLAlchemy-2.0.36-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:46331b00096a6db1fdc052d55b101dbbfc99155a548e20a0e4a8e5e4d1362855", size = 2082778 },
+    { url = "https://files.pythonhosted.org/packages/60/f6/d9aa8c49c44f9b8c9b9dada1f12fa78df3d4c42aa2de437164b83ee1123c/SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdf3386a801ea5aba17c6410dd1dc8d39cf454ca2565541b5ac42a84e1e28f53", size = 3232191 },
+    { url = "https://files.pythonhosted.org/packages/8a/ab/81d4514527c068670cb1d7ab62a81a185df53a7c379bd2a5636e83d09ede/SQLAlchemy-2.0.36-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac9dfa18ff2a67b09b372d5db8743c27966abf0e5344c555d86cc7199f7ad83a", size = 3243044 },
+    { url = "https://files.pythonhosted.org/packages/35/b4/f87c014ecf5167dc669199cafdb20a7358ff4b1d49ce3622cc48571f811c/SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:90812a8933df713fdf748b355527e3af257a11e415b613dd794512461eb8a686", size = 3178511 },
+    { url = "https://files.pythonhosted.org/packages/ea/09/badfc9293bc3ccba6ede05e5f2b44a760aa47d84da1fc5a326e963e3d4d9/SQLAlchemy-2.0.36-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1bc330d9d29c7f06f003ab10e1eaced295e87940405afe1b110f2eb93a233588", size = 3205147 },
+    { url = "https://files.pythonhosted.org/packages/c8/60/70e681de02a13c4b27979b7b78da3058c49bacc9858c89ba672e030f03f2/SQLAlchemy-2.0.36-cp312-cp312-win32.whl", hash = "sha256:79d2e78abc26d871875b419e1fd3c0bca31a1cb0043277d0d850014599626c2e", size = 2062709 },
+    { url = "https://files.pythonhosted.org/packages/b7/ed/f6cd9395e41bfe47dd253d74d2dfc3cab34980d4e20c8878cb1117306085/SQLAlchemy-2.0.36-cp312-cp312-win_amd64.whl", hash = "sha256:b544ad1935a8541d177cb402948b94e871067656b3a0b9e91dbec136b06a2ff5", size = 2088433 },
+    { url = "https://files.pythonhosted.org/packages/78/5c/236398ae3678b3237726819b484f15f5c038a9549da01703a771f05a00d6/SQLAlchemy-2.0.36-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b5cc79df7f4bc3d11e4b542596c03826063092611e481fcf1c9dfee3c94355ef", size = 2087651 },
+    { url = "https://files.pythonhosted.org/packages/a8/14/55c47420c0d23fb67a35af8be4719199b81c59f3084c28d131a7767b0b0b/SQLAlchemy-2.0.36-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3c01117dd36800f2ecaa238c65365b7b16497adc1522bf84906e5710ee9ba0e8", size = 2078132 },
+    { url = "https://files.pythonhosted.org/packages/3d/97/1e843b36abff8c4a7aa2e37f9bea364f90d021754c2de94d792c2d91405b/SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9bc633f4ee4b4c46e7adcb3a9b5ec083bf1d9a97c1d3854b92749d935de40b9b", size = 3164559 },
+    { url = "https://files.pythonhosted.org/packages/7b/c5/07f18a897b997f6d6b234fab2bf31dccf66d5d16a79fe329aefc95cd7461/SQLAlchemy-2.0.36-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e46ed38affdfc95d2c958de328d037d87801cfcbea6d421000859e9789e61c2", size = 3177897 },
+    { url = "https://files.pythonhosted.org/packages/b3/cd/e16f3cbefd82b5c40b33732da634ec67a5f33b587744c7ab41699789d492/SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b2985c0b06e989c043f1dc09d4fe89e1616aadd35392aea2844f0458a989eacf", size = 3111289 },
+    { url = "https://files.pythonhosted.org/packages/15/85/5b8a3b0bc29c9928aa62b5c91fcc8335f57c1de0a6343873b5f372e3672b/SQLAlchemy-2.0.36-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a121d62ebe7d26fec9155f83f8be5189ef1405f5973ea4874a26fab9f1e262c", size = 3139491 },
+    { url = "https://files.pythonhosted.org/packages/a1/95/81babb6089938680dfe2cd3f88cd3fd39cccd1543b7cb603b21ad881bff1/SQLAlchemy-2.0.36-cp313-cp313-win32.whl", hash = "sha256:0572f4bd6f94752167adfd7c1bed84f4b240ee6203a95e05d1e208d488d0d436", size = 2060439 },
+    { url = "https://files.pythonhosted.org/packages/c1/ce/5f7428df55660d6879d0522adc73a3364970b5ef33ec17fa125c5dbcac1d/SQLAlchemy-2.0.36-cp313-cp313-win_amd64.whl", hash = "sha256:8c78ac40bde930c60e0f78b3cd184c580f89456dd87fc08f9e3ee3ce8765ce88", size = 2084574 },
+    { url = "https://files.pythonhosted.org/packages/b8/49/21633706dd6feb14cd3f7935fc00b60870ea057686035e1a99ae6d9d9d53/SQLAlchemy-2.0.36-py3-none-any.whl", hash = "sha256:fddbe92b4760c6f5d48162aef14824add991aeda8ddadb3c31d56eb15ca69f8e", size = 1883787 },
 ]
 
 [package.optional-dependencies]
@@ -4606,14 +4872,14 @@ wheels = [
 
 [[package]]
 name = "starlette"
-version = "0.38.2"
+version = "0.41.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/43/e2/d49a94ecb665b3a1c34b40c78165a737abc384fcabc843ccb14a3bd3dc37/starlette-0.38.2.tar.gz", hash = "sha256:c7c0441065252160993a1a37cf2a73bb64d271b17303e0b0c1eb7191cfb12d75", size = 2844770 }
+sdist = { url = "https://files.pythonhosted.org/packages/78/53/c3a36690a923706e7ac841f649c64f5108889ab1ec44218dac45771f252a/starlette-0.41.0.tar.gz", hash = "sha256:39cbd8768b107d68bfe1ff1672b38a2c38b49777de46d2a592841d58e3bf7c2a", size = 2573755 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c1/60/d976da9998e4f4a99e297cda09d61ce305919ea94cbeeb476dba4fece098/starlette-0.38.2-py3-none-any.whl", hash = "sha256:4ec6a59df6bbafdab5f567754481657f7ed90dc9d69b0c9ff017907dd54faeff", size = 72020 },
+    { url = "https://files.pythonhosted.org/packages/35/c6/a4443bfabf5629129512ca0e07866c4c3c094079ba4e9b2551006927253c/starlette-0.41.0-py3-none-any.whl", hash = "sha256:a0193a3c413ebc9c78bff1c3546a45bb8c8bcb4a84cae8747d650a65bd37210a", size = 73216 },
 ]
 
 [[package]]
@@ -4636,16 +4902,16 @@ wheels = [
 
 [[package]]
 name = "tavily-python"
-version = "0.4.0"
+version = "0.5.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
     { name = "requests" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/67/bd/be3bdd5daa430b273a20dd5538a2a69e69e2da4b4ebdaea0ef3aee2b9c6d/tavily_python-0.4.0.tar.gz", hash = "sha256:e4517041dd135f171858d7e65a7cae085597871bbdc1a13d27990acb536e55c3", size = 15963 }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/50/7f4acafe72ffd10d3578ddec76f993af5af81504bc7315ea54862f2705b9/tavily_python-0.5.0.tar.gz", hash = "sha256:2c60b88203b630e1b37fc711913a1090ced6719b3f21089f25ec06e9e1602822", size = 16455 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/04/13e657e010a1257c56a2e52a0032ce1abd993b75553ddf838b26d7abe75c/tavily_python-0.4.0-py3-none-any.whl", hash = "sha256:b3fd0d7102bb34f0dfb0fd24378e2029504a9836ffe7f07c013824105d9f6a5a", size = 13850 },
+    { url = "https://files.pythonhosted.org/packages/90/99/05776f7150a5b3f8d853377144a3a634131964c0fce38307537674a9a674/tavily_python-0.5.0-py3-none-any.whl", hash = "sha256:e874f6a04a56cdda80a505fe0b4f5d61d25372bd52a83e6773926fb297dcaa29", size = 14361 },
 ]
 
 [[package]]
@@ -4659,11 +4925,11 @@ wheels = [
 
 [[package]]
 name = "termcolor"
-version = "2.4.0"
+version = "2.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/10/56/d7d66a84f96d804155f6ff2873d065368b25a07222a6fd51c4f24ef6d764/termcolor-2.4.0.tar.gz", hash = "sha256:aab9e56047c8ac41ed798fa36d892a37aca6b3e9159f3e0c24bc64a9b3ac7b7a", size = 12664 }
+sdist = { url = "https://files.pythonhosted.org/packages/37/72/88311445fd44c455c7d553e61f95412cf89054308a1aa2434ab835075fc5/termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f", size = 13057 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d9/5f/8c716e47b3a50cbd7c146f45881e11d9414def768b7cd9c5e6650ec2a80a/termcolor-2.4.0-py3-none-any.whl", hash = "sha256:9297c0df9c99445c2412e832e882a7884038a25617c60cea2ad69488d4040d63", size = 7719 },
+    { url = "https://files.pythonhosted.org/packages/7f/be/df630c387a0a054815d60be6a97eb4e8f17385d5d6fe660e1c02750062b4/termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8", size = 7755 },
 ]
 
 [[package]]
@@ -4677,32 +4943,34 @@ wheels = [
 
 [[package]]
 name = "textual"
-version = "0.78.0"
+version = "0.85.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "markdown-it-py", extra = ["linkify", "plugins"] },
+    { name = "platformdirs" },
     { name = "rich" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/65/0feb87888b582d4d6cd8ab5cf23f36e711894db33d91a4282311c05fc870/textual-0.78.0.tar.gz", hash = "sha256:421f508b0d41ea0b8ecf273bf83f0d19376667eb0a87f70575252395d90ab315", size = 1354115 }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/ef/d498d5eb07ebe63299517bbee7e4be2fe8e1b4f0835763446cef1c4eaed0/textual-0.85.0.tar.gz", hash = "sha256:645c0fd0b4f61cd19383df78a1acd4f3b555e2c514cfa2f454e20692dffc10a0", size = 1461202 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/68/0b99efe3f61d0b65de3b1f0db6889c2386db88a4d6b8ca2ed2adc5982f77/textual-0.78.0-py3-none-any.whl", hash = "sha256:c9d3c7dc467c37ee2e54a0283ac2c85dac35e4fc949518ed054a65b8e3e9b822", size = 574745 },
+    { url = "https://files.pythonhosted.org/packages/9c/d5/0f35e93d1343fd8a4a1571c104dd6f0a9d038aa89d203146f22b9beed725/textual-0.85.0-py3-none-any.whl", hash = "sha256:8e75d023f06b242fb88233926dfb7801792f867643493096dd45dd216dc950f3", size = 614318 },
 ]
 
 [[package]]
 name = "textual-dev"
-version = "1.5.1"
+version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
     { name = "click" },
     { name = "msgpack" },
     { name = "textual" },
+    { name = "textual-serve" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3e/ff/d328747676a6a00e8b031c1a537deca1ba2aea3d9f8ea1e0e3ab9e8e8786/textual_dev-1.5.1.tar.gz", hash = "sha256:e0366ab6f42c128d7daa37a7c418e61fe7aa83731983da990808e4bf2de922a1", size = 25219 }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/85/93a28974fd75aa941b0aac415fc430bf693a91b219a25dc9447f1bd83338/textual_dev-1.6.1.tar.gz", hash = "sha256:0d0d4523a09566bae56eb9ebc4fcbb09069d0f335448e6b9b10dd2d805606bd8", size = 25624 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/dc/ac0e741e5b089b6bb7f128bfda62aced7946221c498b51fec6d138df4f8e/textual_dev-1.5.1-py3-none-any.whl", hash = "sha256:bb37dd769ae6b67e1422aa97f6d6ef952e0a6d2aafe08327449e8bdd70474776", size = 26414 },
+    { url = "https://files.pythonhosted.org/packages/6b/aa/c89ce57be40847eebab57184a7223735ac56ee2063400c363a74d5e7a18e/textual_dev-1.6.1-py3-none-any.whl", hash = "sha256:de93279da6dd0772be88a83e494be1bc895df0a0c3e47bcd48fa1acb1a83a34b", size = 26853 },
 ]
 
 [[package]]
@@ -4719,37 +4987,56 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/43/56/c0514dcfdb2b67333bf4e653ca9cf0fda51004932d3b246bf835376cbaba/textual_imageview-0.1.1-py3-none-any.whl", hash = "sha256:335c8043e2f1f735b1b2ec1753a743d6762578175cd2cedae3ce67e2694800a4", size = 8875 },
 ]
 
+[[package]]
+name = "textual-serve"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "aiohttp-jinja2" },
+    { name = "jinja2" },
+    { name = "rich" },
+    { name = "textual" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/18/6c/57248070f525ea8a9a02d9f58dc2747c609b615b0bda1306aaeb80a233bd/textual_serve-1.1.1.tar.gz", hash = "sha256:71c662472c462e5e368defc660ee6e8eae3bfda88ca40c050c55474686eb0c54", size = 445957 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/07/a9/01d35770fde8d889e1fe28b726188cf28801e57afd369c614cd2bc100ee4/textual_serve-1.1.1-py3-none-any.whl", hash = "sha256:568782f1c0e60e3f7039d9121e1cb5c2f4ca1aaf6d6bd7aeb833d5763a534cb2", size = 445034 },
+]
+
 [[package]]
 name = "tiktoken"
-version = "0.7.0"
+version = "0.8.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "regex" },
     { name = "requests" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/4a/abaec53e93e3ef37224a4dd9e2fc6bb871e7a538c2b6b9d2a6397271daf4/tiktoken-0.7.0.tar.gz", hash = "sha256:1077266e949c24e0291f6c350433c6f0971365ece2b173a23bc3b9f9defef6b6", size = 33437 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/96/10/28d59d43d72a0ebd4211371d0bf10c935cdecbb62b812ae04c58bfc37d96/tiktoken-0.7.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:485f3cc6aba7c6b6ce388ba634fbba656d9ee27f766216f45146beb4ac18b25f", size = 961465 },
-    { url = "https://files.pythonhosted.org/packages/f8/0c/d4125348dedd1f8f38e3f85245e7fc38858ffc77c9b7edfb762a8191ba0b/tiktoken-0.7.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e54be9a2cd2f6d6ffa3517b064983fb695c9a9d8aa7d574d1ef3c3f931a99225", size = 906849 },
-    { url = "https://files.pythonhosted.org/packages/b9/ab/f9c7675747f259d133d66065106cf732a7c2bef6043062fbca8e011f7f4d/tiktoken-0.7.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79383a6e2c654c6040e5f8506f3750db9ddd71b550c724e673203b4f6b4b4590", size = 1048795 },
-    { url = "https://files.pythonhosted.org/packages/e7/8c/7d1007557b343d5cf18349802e94d3a14397121e9105b4661f8cd753f9bf/tiktoken-0.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d4511c52caacf3c4981d1ae2df85908bd31853f33d30b345c8b6830763f769c", size = 1080866 },
-    { url = "https://files.pythonhosted.org/packages/72/40/61d6354cb64a563fce475a2907039be9fe809ca5f801213856353b01a35b/tiktoken-0.7.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13c94efacdd3de9aff824a788353aa5749c0faee1fbe3816df365ea450b82311", size = 1092776 },
-    { url = "https://files.pythonhosted.org/packages/f2/6c/83ca40527d072739f0704b9f59b325786c444ca63672a77cb69adc8181f7/tiktoken-0.7.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8e58c7eb29d2ab35a7a8929cbeea60216a4ccdf42efa8974d8e176d50c9a3df5", size = 1142591 },
-    { url = "https://files.pythonhosted.org/packages/ec/1f/a5d72755118e9e1b62cdf3ef9138eb83d49088f3cb37a9540025c81c0e75/tiktoken-0.7.0-cp310-cp310-win_amd64.whl", hash = "sha256:21a20c3bd1dd3e55b91c1331bf25f4af522c525e771691adbc9a69336fa7f702", size = 798864 },
-    { url = "https://files.pythonhosted.org/packages/22/eb/57492b2568eea1d546da5cc1ae7559d924275280db80ba07e6f9b89a914b/tiktoken-0.7.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:10c7674f81e6e350fcbed7c09a65bca9356eaab27fb2dac65a1e440f2bcfe30f", size = 961468 },
-    { url = "https://files.pythonhosted.org/packages/30/ef/e07dbfcb2f85c84abaa1b035a9279575a8da0236305491dc22ae099327f7/tiktoken-0.7.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:084cec29713bc9d4189a937f8a35dbdfa785bd1235a34c1124fe2323821ee93f", size = 907005 },
-    { url = "https://files.pythonhosted.org/packages/ea/9b/f36db825b1e9904c3a2646439cb9923fc1e09208e2e071c6d9dd64ead131/tiktoken-0.7.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:811229fde1652fedcca7c6dfe76724d0908775b353556d8a71ed74d866f73f7b", size = 1049183 },
-    { url = "https://files.pythonhosted.org/packages/61/b4/b80d1fe33015e782074e96bbbf4108ccd283b8deea86fb43c15d18b7c351/tiktoken-0.7.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86b6e7dc2e7ad1b3757e8a24597415bafcfb454cebf9a33a01f2e6ba2e663992", size = 1080830 },
-    { url = "https://files.pythonhosted.org/packages/2a/40/c66ff3a21af6d62a7e0ff428d12002c4e0389f776d3ff96dcaa0bb354eee/tiktoken-0.7.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1063c5748be36344c7e18c7913c53e2cca116764c2080177e57d62c7ad4576d1", size = 1092967 },
-    { url = "https://files.pythonhosted.org/packages/2e/80/f4c9e255ff236e6a69ce44b927629cefc1b63d3a00e2d1c9ed540c9492d2/tiktoken-0.7.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:20295d21419bfcca092644f7e2f2138ff947a6eb8cfc732c09cc7d76988d4a89", size = 1142682 },
-    { url = "https://files.pythonhosted.org/packages/b1/10/c04b4ff592a5f46b28ebf4c2353f735c02ae7f0ce1b165d00748ced6467e/tiktoken-0.7.0-cp311-cp311-win_amd64.whl", hash = "sha256:959d993749b083acc57a317cbc643fb85c014d055b2119b739487288f4e5d1cb", size = 799009 },
-    { url = "https://files.pythonhosted.org/packages/1d/46/4cdda4186ce900608f522da34acf442363346688c71b938a90a52d7b84cc/tiktoken-0.7.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:71c55d066388c55a9c00f61d2c456a6086673ab7dec22dd739c23f77195b1908", size = 960446 },
-    { url = "https://files.pythonhosted.org/packages/b6/30/09ced367d280072d7a3e21f34263dfbbf6378661e7a0f6414e7c18971083/tiktoken-0.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:09ed925bccaa8043e34c519fbb2f99110bd07c6fd67714793c21ac298e449410", size = 906652 },
-    { url = "https://files.pythonhosted.org/packages/e6/7b/c949e4954441a879a67626963dff69096e3c774758b9f2bb0853f7b4e1e7/tiktoken-0.7.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03c6c40ff1db0f48a7b4d2dafeae73a5607aacb472fa11f125e7baf9dce73704", size = 1047904 },
-    { url = "https://files.pythonhosted.org/packages/50/81/1842a22f15586072280364c2ab1e40835adaf64e42fe80e52aff921ee021/tiktoken-0.7.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d20b5c6af30e621b4aca094ee61777a44118f52d886dbe4f02b70dfe05c15350", size = 1079836 },
-    { url = "https://files.pythonhosted.org/packages/6d/87/51a133a3d5307cf7ae3754249b0faaa91d3414b85c3d36f80b54d6817aa6/tiktoken-0.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d427614c3e074004efa2f2411e16c826f9df427d3c70a54725cae860f09e4bf4", size = 1092472 },
-    { url = "https://files.pythonhosted.org/packages/a5/1f/c93517dc6d3b2c9e988b8e24f87a8b2d4a4ab28920a3a3f3ea338397ae0c/tiktoken-0.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8c46d7af7b8c6987fac9b9f61041b452afe92eb087d29c9ce54951280f899a97", size = 1141881 },
-    { url = "https://files.pythonhosted.org/packages/bf/4b/48ca098cb580c099b5058bf62c4cb5e90ca6130fa43ef4df27088536245b/tiktoken-0.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:0bc603c30b9e371e7c4c7935aba02af5994a909fc3c0fe66e7004070858d3f8f", size = 799281 },
+sdist = { url = "https://files.pythonhosted.org/packages/37/02/576ff3a6639e755c4f70997b2d315f56d6d71e0d046f4fb64cb81a3fb099/tiktoken-0.8.0.tar.gz", hash = "sha256:9ccbb2740f24542534369c5635cfd9b2b3c2490754a78ac8831d99f89f94eeb2", size = 35107 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c9/ba/a35fad753bbca8ba0cc1b0f3402a70256a110ced7ac332cf84ba89fc87ab/tiktoken-0.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b07e33283463089c81ef1467180e3e00ab00d46c2c4bbcef0acab5f771d6695e", size = 1039905 },
+    { url = "https://files.pythonhosted.org/packages/91/05/13dab8fd7460391c387b3e69e14bf1e51ff71fe0a202cd2933cc3ea93fb6/tiktoken-0.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9269348cb650726f44dd3bbb3f9110ac19a8dcc8f54949ad3ef652ca22a38e21", size = 982417 },
+    { url = "https://files.pythonhosted.org/packages/e9/98/18ec4a8351a6cf4537e40cd6e19a422c10cce1ef00a2fcb716e0a96af58b/tiktoken-0.8.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e13f37bc4ef2d012731e93e0fef21dc3b7aea5bb9009618de9a4026844e560", size = 1144915 },
+    { url = "https://files.pythonhosted.org/packages/2e/28/cf3633018cbcc6deb7805b700ccd6085c9a5a7f72b38974ee0bffd56d311/tiktoken-0.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f13d13c981511331eac0d01a59b5df7c0d4060a8be1e378672822213da51e0a2", size = 1177221 },
+    { url = "https://files.pythonhosted.org/packages/57/81/8a5be305cbd39d4e83a794f9e80c7f2c84b524587b7feb27c797b2046d51/tiktoken-0.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6b2ddbc79a22621ce8b1166afa9f9a888a664a579350dc7c09346a3b5de837d9", size = 1237398 },
+    { url = "https://files.pythonhosted.org/packages/dc/da/8d1cc3089a83f5cf11c2e489332752981435280285231924557350523a59/tiktoken-0.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:d8c2d0e5ba6453a290b86cd65fc51fedf247e1ba170191715b049dac1f628005", size = 884215 },
+    { url = "https://files.pythonhosted.org/packages/f6/1e/ca48e7bfeeccaf76f3a501bd84db1fa28b3c22c9d1a1f41af9fb7579c5f6/tiktoken-0.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d622d8011e6d6f239297efa42a2657043aaed06c4f68833550cac9e9bc723ef1", size = 1039700 },
+    { url = "https://files.pythonhosted.org/packages/8c/f8/f0101d98d661b34534769c3818f5af631e59c36ac6d07268fbfc89e539ce/tiktoken-0.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2efaf6199717b4485031b4d6edb94075e4d79177a172f38dd934d911b588d54a", size = 982413 },
+    { url = "https://files.pythonhosted.org/packages/ac/3c/2b95391d9bd520a73830469f80a96e3790e6c0a5ac2444f80f20b4b31051/tiktoken-0.8.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5637e425ce1fc49cf716d88df3092048359a4b3bbb7da762840426e937ada06d", size = 1144242 },
+    { url = "https://files.pythonhosted.org/packages/01/c4/c4a4360de845217b6aa9709c15773484b50479f36bb50419c443204e5de9/tiktoken-0.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fb0e352d1dbe15aba082883058b3cce9e48d33101bdaac1eccf66424feb5b47", size = 1176588 },
+    { url = "https://files.pythonhosted.org/packages/f8/a3/ef984e976822cd6c2227c854f74d2e60cf4cd6fbfca46251199914746f78/tiktoken-0.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:56edfefe896c8f10aba372ab5706b9e3558e78db39dd497c940b47bf228bc419", size = 1237261 },
+    { url = "https://files.pythonhosted.org/packages/1e/86/eea2309dc258fb86c7d9b10db536434fc16420feaa3b6113df18b23db7c2/tiktoken-0.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:326624128590def898775b722ccc327e90b073714227175ea8febbc920ac0a99", size = 884537 },
+    { url = "https://files.pythonhosted.org/packages/c1/22/34b2e136a6f4af186b6640cbfd6f93400783c9ef6cd550d9eab80628d9de/tiktoken-0.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:881839cfeae051b3628d9823b2e56b5cc93a9e2efb435f4cf15f17dc45f21586", size = 1039357 },
+    { url = "https://files.pythonhosted.org/packages/04/d2/c793cf49c20f5855fd6ce05d080c0537d7418f22c58e71f392d5e8c8dbf7/tiktoken-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fe9399bdc3f29d428f16a2f86c3c8ec20be3eac5f53693ce4980371c3245729b", size = 982616 },
+    { url = "https://files.pythonhosted.org/packages/b3/a1/79846e5ef911cd5d75c844de3fa496a10c91b4b5f550aad695c5df153d72/tiktoken-0.8.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9a58deb7075d5b69237a3ff4bb51a726670419db6ea62bdcd8bd80c78497d7ab", size = 1144011 },
+    { url = "https://files.pythonhosted.org/packages/26/32/e0e3a859136e95c85a572e4806dc58bf1ddf651108ae8b97d5f3ebe1a244/tiktoken-0.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2908c0d043a7d03ebd80347266b0e58440bdef5564f84f4d29fb235b5df3b04", size = 1175432 },
+    { url = "https://files.pythonhosted.org/packages/c7/89/926b66e9025b97e9fbabeaa59048a736fe3c3e4530a204109571104f921c/tiktoken-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:294440d21a2a51e12d4238e68a5972095534fe9878be57d905c476017bff99fc", size = 1236576 },
+    { url = "https://files.pythonhosted.org/packages/45/e2/39d4aa02a52bba73b2cd21ba4533c84425ff8786cc63c511d68c8897376e/tiktoken-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:d8f3192733ac4d77977432947d563d7e1b310b96497acd3c196c9bddb36ed9db", size = 883824 },
+    { url = "https://files.pythonhosted.org/packages/e3/38/802e79ba0ee5fcbf240cd624143f57744e5d411d2e9d9ad2db70d8395986/tiktoken-0.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:02be1666096aff7da6cbd7cdaa8e7917bfed3467cd64b38b1f112e96d3b06a24", size = 1039648 },
+    { url = "https://files.pythonhosted.org/packages/b1/da/24cdbfc302c98663fbea66f5866f7fa1048405c7564ab88483aea97c3b1a/tiktoken-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94ff53c5c74b535b2cbf431d907fc13c678bbd009ee633a2aca269a04389f9a", size = 982763 },
+    { url = "https://files.pythonhosted.org/packages/e4/f0/0ecf79a279dfa41fc97d00adccf976ecc2556d3c08ef3e25e45eb31f665b/tiktoken-0.8.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b231f5e8982c245ee3065cd84a4712d64692348bc609d84467c57b4b72dcbc5", size = 1144417 },
+    { url = "https://files.pythonhosted.org/packages/ab/d3/155d2d4514f3471a25dc1d6d20549ef254e2aa9bb5b1060809b1d3b03d3a/tiktoken-0.8.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4177faa809bd55f699e88c96d9bb4635d22e3f59d635ba6fd9ffedf7150b9953", size = 1175108 },
+    { url = "https://files.pythonhosted.org/packages/19/eb/5989e16821ee8300ef8ee13c16effc20dfc26c777d05fbb6825e3c037b81/tiktoken-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5376b6f8dc4753cd81ead935c5f518fa0fbe7e133d9e25f648d8c4dabdd4bad7", size = 1236520 },
+    { url = "https://files.pythonhosted.org/packages/40/59/14b20465f1d1cb89cfbc96ec27e5617b2d41c79da12b5e04e96d689be2a7/tiktoken-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:18228d624807d66c87acd8f25fc135665617cab220671eb65b50f5d70fa51f69", size = 883849 },
 ]
 
 [[package]]
@@ -4775,74 +5062,74 @@ wheels = [
 
 [[package]]
 name = "tokenize-rt"
-version = "6.0.0"
+version = "6.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/09/6257dabdeab5097d72c5d874f29b33cd667ec411af6667922d84f85b79b5/tokenize_rt-6.0.0.tar.gz", hash = "sha256:b9711bdfc51210211137499b5e355d3de5ec88a85d2025c520cbb921b5194367", size = 5360 }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/0a/5854d8ced8c1e00193d1353d13db82d7f813f99bd5dcb776ce3e2a4c0d19/tokenize_rt-6.1.0.tar.gz", hash = "sha256:e8ee836616c0877ab7c7b54776d2fefcc3bde714449a206762425ae114b53c86", size = 5506 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5c/c2/44486862562c6902778ccf88001ad5ea3f8da5c030c638cac8be72f65b40/tokenize_rt-6.0.0-py2.py3-none-any.whl", hash = "sha256:d4ff7ded2873512938b4f8cbb98c9b07118f01d30ac585a30d7a88353ca36d22", size = 5869 },
+    { url = "https://files.pythonhosted.org/packages/87/ba/576aac29b10dfa49a6ce650001d1bb31f81e734660555eaf144bfe5b8995/tokenize_rt-6.1.0-py2.py3-none-any.whl", hash = "sha256:d706141cdec4aa5f358945abe36b911b8cbdc844545da99e811250c0cee9b6fc", size = 6015 },
 ]
 
 [[package]]
 name = "tokenizers"
-version = "0.20.0"
+version = "0.20.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/02/3a/508a4875f69e12b08fb3dabfc746039fe763838ff45d6e42229ed09a41c2/tokenizers-0.20.0.tar.gz", hash = "sha256:39d7acc43f564c274085cafcd1dae9d36f332456de1a31970296a6b8da4eac8d", size = 337421 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0d/47/88f92fb433fe2fb59b35bbce28455095bcb7b40fff385223b1e7818cec38/tokenizers-0.20.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:6cff5c5e37c41bc5faa519d6f3df0679e4b37da54ea1f42121719c5e2b4905c0", size = 2624575 },
-    { url = "https://files.pythonhosted.org/packages/fc/e5/74c6ab076de7d2d4d347e8781086117889d202628dfd5f5fba8ebefb1ea2/tokenizers-0.20.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:62a56bf75c27443432456f4ca5ca055befa95e25be8a28141cc495cac8ae4d6d", size = 2515759 },
-    { url = "https://files.pythonhosted.org/packages/4e/f5/1087cb5100e704dce9a1419d6f3e8ac843c98efa11579c3287ddb036b476/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68cc7de6a63f09c4a86909c2597b995aa66e19df852a23aea894929c74369929", size = 2892020 },
-    { url = "https://files.pythonhosted.org/packages/35/07/7004003098e3d442bba9b9821b78f34043248bdf6a78433846944b7d9a61/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:053c37ecee482cc958fdee53af3c6534286a86f5d35aac476f7c246830e53ae5", size = 2754734 },
-    { url = "https://files.pythonhosted.org/packages/d0/61/9f3def0db2db72d8da6c4c318481a35c5c71172dad54ff3813f765ab2a45/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3d7074aaabc151a6363fa03db5493fc95b423b2a1874456783989e96d541c7b6", size = 3009897 },
-    { url = "https://files.pythonhosted.org/packages/c1/98/f4a9a18a4e2e254c6ed253b3e5344d8f48760d3af6813df4415446db1b4c/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a11435780f2acd89e8fefe5e81cecf01776f6edb9b3ac95bcb76baee76b30b90", size = 3032295 },
-    { url = "https://files.pythonhosted.org/packages/87/43/52b096d5aacb3eb698f1b791e8a6c1b7ecd39b17724c38312804b79429fa/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9a81cd2712973b007d84268d45fc3f6f90a79c31dfe7f1925e6732f8d2959987", size = 3328639 },
-    { url = "https://files.pythonhosted.org/packages/fc/7e/794850f99752d1811952722c18652a5c0125b0ef595d9ed069d00da9a5db/tokenizers-0.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7dfd796ab9d909f76fb93080e1c7c8309f196ecb316eb130718cd5e34231c69", size = 2936169 },
-    { url = "https://files.pythonhosted.org/packages/ea/3d/d573173b0cd78cd64e95b5c8f268f3a619877bc6a484b649d98af4de24bf/tokenizers-0.20.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:8029ad2aa8cb00605c9374566034c1cc1b15130713e0eb5afcef6cface8255c9", size = 8965441 },
-    { url = "https://files.pythonhosted.org/packages/27/cb/76636123a5bc550c48aa8048def1ae3d86421723be2cca8f195f464c20f6/tokenizers-0.20.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ca4d54260ebe97d59dfa9a30baa20d0c4dd9137d99a8801700055c561145c24e", size = 9284485 },
-    { url = "https://files.pythonhosted.org/packages/32/16/5eaa1405e15ca91a9e0f6c07963cd91f48daf8f999ff731b589078a4caa1/tokenizers-0.20.0-cp310-none-win32.whl", hash = "sha256:95ee16b57cec11b86a7940174ec5197d506439b0f415ab3859f254b1dffe9df0", size = 2125655 },
-    { url = "https://files.pythonhosted.org/packages/63/90/84534f81ff1453a1bcc049b03ea6820ca7ab497519b79b129d7297bb4e60/tokenizers-0.20.0-cp310-none-win_amd64.whl", hash = "sha256:0a61a11e93eeadbf02aea082ffc75241c4198e0608bbbac4f65a9026851dcf37", size = 2326217 },
-    { url = "https://files.pythonhosted.org/packages/a4/f6/ae042eeae413bae9af5adceed7fe6f30fb0abc9868a55916d4e07c8ea1fb/tokenizers-0.20.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6636b798b3c4d6c9b1af1a918bd07c867808e5a21c64324e95318a237e6366c3", size = 2625296 },
-    { url = "https://files.pythonhosted.org/packages/62/8b/dab4d716e9a00c1581443213283c9fdfdb982cdad6ecc046bae9c7e42fc8/tokenizers-0.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ec603e42eaf499ffd58b9258162add948717cf21372458132f14e13a6bc7172", size = 2516726 },
-    { url = "https://files.pythonhosted.org/packages/95/1e/800e0896ea43ab86d70cfc6ed6a30d6aefcab498eff49db79cc92e08e1fe/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cce124264903a8ea6f8f48e1cc7669e5ef638c18bd4ab0a88769d5f92debdf7f", size = 2891801 },
-    { url = "https://files.pythonhosted.org/packages/02/80/22ceab06d120df5b589f993248bceef177a932024ae8ee033ec3da5cc87f/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07bbeba0231cf8de07aa6b9e33e9779ff103d47042eeeb859a8c432e3292fb98", size = 2753762 },
-    { url = "https://files.pythonhosted.org/packages/22/7c/02431f0711162ab3994e4099b9ece4b6a00755e3180bf5dfe70da0c13836/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:06c0ca8397b35d38b83a44a9c6929790c1692957d88541df061cb34d82ebbf08", size = 3010928 },
-    { url = "https://files.pythonhosted.org/packages/bc/14/193b7e58017e9592799498686df718c5f68bfb72205d3075ce9cdd441db7/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ca6557ac3b83d912dfbb1f70ab56bd4b0594043916688e906ede09f42e192401", size = 3032435 },
-    { url = "https://files.pythonhosted.org/packages/71/ae/c7fc7a614ce78cab7b8f82f7a24a074837cbc7e0086960cbe4801b2b3c83/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2a5ad94c9e80ac6098328bee2e3264dbced4c6faa34429994d473f795ec58ef4", size = 3328437 },
-    { url = "https://files.pythonhosted.org/packages/a5/0e/e4421e6b8c8b3ae093bef22faa28c50d7dbd654f661edc5f5880a93dbf10/tokenizers-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b5c7f906ee6bec30a9dc20268a8b80f3b9584de1c9f051671cb057dc6ce28f6", size = 2936532 },
-    { url = "https://files.pythonhosted.org/packages/b9/08/ac9c8fe9c1f5b4ef89bcbf543cda890e76c2ea1c2e957bf77fd5fcf72b6c/tokenizers-0.20.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:31e087e9ee1b8f075b002bfee257e858dc695f955b43903e1bb4aa9f170e37fe", size = 8965273 },
-    { url = "https://files.pythonhosted.org/packages/fb/71/b9626f9f5a33dd1d80bb6d3721f0a4b0b48ced0c702e65aad5c8c7c1ae7e/tokenizers-0.20.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c3124fb6f3346cb3d8d775375d3b429bf4dcfc24f739822702009d20a4297990", size = 9283768 },
-    { url = "https://files.pythonhosted.org/packages/ba/78/70f79f939385579bb25f14cb14ab0eaa49e46a7d099577c2e08e3c3597d8/tokenizers-0.20.0-cp311-none-win32.whl", hash = "sha256:a4bb8b40ba9eefa621fdcabf04a74aa6038ae3be0c614c6458bd91a4697a452f", size = 2126085 },
-    { url = "https://files.pythonhosted.org/packages/c0/3c/9228601e180b177755fd9f35cbb229c13f1919a55f07a602b1bd7d716470/tokenizers-0.20.0-cp311-none-win_amd64.whl", hash = "sha256:2b709d371f1fe60a28ef0c5c67815952d455ca7f34dbe7197eaaed3cc54b658e", size = 2327670 },
-    { url = "https://files.pythonhosted.org/packages/ce/d4/152f9964cee16b43b9147212e925793df1a469324b29b4c7a6cb60280c99/tokenizers-0.20.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:15c81a17d0d66f4987c6ca16f4bea7ec253b8c7ed1bb00fdc5d038b1bb56e714", size = 2613552 },
-    { url = "https://files.pythonhosted.org/packages/6e/99/594b518d44ba2b099753816a9c0c33dbdcf77cc3ec5b256690f70d7431c2/tokenizers-0.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6a531cdf1fb6dc41c984c785a3b299cb0586de0b35683842a3afbb1e5207f910", size = 2513918 },
-    { url = "https://files.pythonhosted.org/packages/24/fa/77f0cf9b3c662b4de18953fb06126c424059f4b09ca2d1b720beabc6afde/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:06caabeb4587f8404e0cd9d40f458e9cba3e815c8155a38e579a74ff3e2a4301", size = 2892465 },
-    { url = "https://files.pythonhosted.org/packages/2d/e6/59abfc09f1dc23a47fd03dd8e3bf3fce67d9be2b8ba15a73c9a86b5a646c/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8768f964f23f5b9f50546c0369c75ab3262de926983888bbe8b98be05392a79c", size = 2750862 },
-    { url = "https://files.pythonhosted.org/packages/0f/b2/f212ca05c1b246b9429905c18a4d68abacf2a35214eceedb1d65c6c37831/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:626403860152c816f97b649fd279bd622c3d417678c93b4b1a8909b6380b69a8", size = 3012971 },
-    { url = "https://files.pythonhosted.org/packages/16/0b/099f5e5b97e8323837a5828f6d21f4bb2a3b529507dc19bd274e48e15825/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c1b88fa9e5ff062326f4bf82681da5a96fca7104d921a6bd7b1e6fcf224af26", size = 3038445 },
-    { url = "https://files.pythonhosted.org/packages/62/7c/4e3cb25dc1c5eea6053752f55007071da6b33a96021e0cea4b45b6ef0908/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d7e559436a07dc547f22ce1101f26d8b2fad387e28ec8e7e1e3b11695d681d8", size = 3329352 },
-    { url = "https://files.pythonhosted.org/packages/32/20/a8fe63317d4f3c015cbd5b6dec0ce08e2722685ca836ad4a44dec53d000f/tokenizers-0.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e48afb75e50449848964e4a67b0da01261dd3aa8df8daecf10db8fd7f5b076eb", size = 2938786 },
-    { url = "https://files.pythonhosted.org/packages/06/e8/78f1c0f356d0a6e4e4e450e2419ace1918bfab875100c3047021a8261ba0/tokenizers-0.20.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:baf5d0e1ff44710a95eefc196dd87666ffc609fd447c5e5b68272a7c3d342a1d", size = 8967350 },
-    { url = "https://files.pythonhosted.org/packages/e6/eb/3a1edfc1ffb876ffc1f668c8fa2b2ffb57edf8e9188af49218cf41f9cd9f/tokenizers-0.20.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e5e56df0e8ed23ba60ae3848c3f069a0710c4b197218fe4f89e27eba38510768", size = 9284785 },
-    { url = "https://files.pythonhosted.org/packages/00/75/426a93399ba5e6e879215e1abb696adb83b1e2a98d65b47b8ba4262b3d17/tokenizers-0.20.0-cp312-none-win32.whl", hash = "sha256:ec53e5ecc142a82432f9c6c677dbbe5a2bfee92b8abf409a9ecb0d425ee0ce75", size = 2125012 },
-    { url = "https://files.pythonhosted.org/packages/a5/45/9c19187645401ec30884379ada74aa6e71fb5eaf20485a82ea37a0fd3659/tokenizers-0.20.0-cp312-none-win_amd64.whl", hash = "sha256:f18661ece72e39c0dfaa174d6223248a15b457dbd4b0fc07809b8e6d3ca1a234", size = 2314154 },
-    { url = "https://files.pythonhosted.org/packages/cd/99/dba2f18ba180aefddb65852d2cea69de607232f4cf1d999e789899d56c19/tokenizers-0.20.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:d68e15f1815357b059ec266062340c343ea7f98f7f330602df81ffa3474b6122", size = 2626438 },
-    { url = "https://files.pythonhosted.org/packages/79/e6/eb28c3c7d23f3feaa9fb6ae16ff313210474b3c9f81689afe6d132915da0/tokenizers-0.20.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:23f9ecec637b9bc80da5f703808d29ed5329e56b5aa8d791d1088014f48afadc", size = 2517016 },
-    { url = "https://files.pythonhosted.org/packages/18/2f/35f7fdbf1ae6fa3d0348531596a63651fdb117ff367e3dfe8a6be5f31f5a/tokenizers-0.20.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f830b318ee599e3d0665b3e325f85bc75ee2d2ca6285f52e439dc22b64691580", size = 2890784 },
-    { url = "https://files.pythonhosted.org/packages/97/10/7b74d7e5663f886d058df470f14fd492078533a5aee52bf1553eed83a49d/tokenizers-0.20.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3dc750def789cb1de1b5a37657919545e1d9ffa667658b3fa9cb7862407a1b8", size = 3007139 },
-    { url = "https://files.pythonhosted.org/packages/77/5a/a59c9f97000fce432e3728fbe32c23cf3dd9933255d76166101c2b12a916/tokenizers-0.20.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e26e6c755ae884c2ea6135cd215bdd0fccafe4ee62405014b8c3cd19954e3ab9", size = 2933499 },
-    { url = "https://files.pythonhosted.org/packages/bd/7a/fde367e46596855e172c466655fc416d98be6c7ae792afdb5315ca38bed0/tokenizers-0.20.0-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:a1158c7174f427182e08baa2a8ded2940f2b4a3e94969a85cc9cfd16004cbcea", size = 8964991 },
-    { url = "https://files.pythonhosted.org/packages/9f/fa/075959c7d901a55b2a3198d0ecfbc624c553f5ff8027bc4fac0aa6bab70a/tokenizers-0.20.0-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:6324826287a3fc198898d3dcf758fe4a8479e42d6039f4c59e2cedd3cf92f64e", size = 9284502 },
+sdist = { url = "https://files.pythonhosted.org/packages/d7/fb/373b66ba58cbf5eda371480e4e051d8892ea1433a73f1f92c48657a699a6/tokenizers-0.20.1.tar.gz", hash = "sha256:84edcc7cdeeee45ceedb65d518fffb77aec69311c9c8e30f77ad84da3025f002", size = 339552 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/72/d2/3c05efeeccefa833b82038ce49ee736756eed10ab66fc723ce423a747b0e/tokenizers-0.20.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:439261da7c0a5c88bda97acb284d49fbdaf67e9d3b623c0bfd107512d22787a9", size = 2673220 },
+    { url = "https://files.pythonhosted.org/packages/24/d4/a529aa06db71600c1688210ce035cbff637ece919dcaca599c9235ad832d/tokenizers-0.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:03dae629d99068b1ea5416d50de0fea13008f04129cc79af77a2a6392792d93c", size = 2563056 },
+    { url = "https://files.pythonhosted.org/packages/25/e2/5046ad3b0426548b37c96cc4262a7f2ba6ac9593ee10be69effc78a91764/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b61f561f329ffe4b28367798b89d60c4abf3f815d37413b6352bc6412a359867", size = 2943369 },
+    { url = "https://files.pythonhosted.org/packages/5f/f0/c1ed45ff90088eba4f15eca9763b5e439cb86b71fc9e66a827318b61e44d/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ec870fce1ee5248a10be69f7a8408a234d6f2109f8ea827b4f7ecdbf08c9fd15", size = 2827000 },
+    { url = "https://files.pythonhosted.org/packages/22/09/6e0a378a35f215b40ae1c04b4d0fe43e9ddfaf3a08a2b7d7fab8953a6587/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d388d1ea8b7447da784e32e3b86a75cce55887e3b22b31c19d0b186b1c677800", size = 3090881 },
+    { url = "https://files.pythonhosted.org/packages/cf/03/801e91d41e2134a32089af2d382a6c40b3d8b932b42fa96443d77258ab28/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:299c85c1d21135bc01542237979bf25c32efa0d66595dd0069ae259b97fb2dbe", size = 3096826 },
+    { url = "https://files.pythonhosted.org/packages/2a/39/3d11780b82d9ba4d8fda093daa48622ed5f2616d6ac8cb638ac290d39d95/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e96f6c14c9752bb82145636b614d5a78e9cde95edfbe0a85dad0dd5ddd6ec95c", size = 3417666 },
+    { url = "https://files.pythonhosted.org/packages/4b/35/326b9642307a53b3d9ae145b5c7f157aae9ecaa930888f920124412e0bd2/tokenizers-0.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc9e95ad49c932b80abfbfeaf63b155761e695ad9f8a58c52a47d962d76e310f", size = 2984468 },
+    { url = "https://files.pythonhosted.org/packages/db/b2/5e45632799d816291de4d04149decf19cf6c2faf42bb99574d80050c87bd/tokenizers-0.20.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f22dee205329a636148c325921c73cf3e412e87d31f4d9c3153b302a0200057b", size = 8981675 },
+    { url = "https://files.pythonhosted.org/packages/df/f7/8c0ec102f0a723d09347ff6cd617c7e5e8d44efd342305f52a7fcd3e30e2/tokenizers-0.20.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a2ffd9a8895575ac636d44500c66dffaef133823b6b25067604fa73bbc5ec09d", size = 9300378 },
+    { url = "https://files.pythonhosted.org/packages/e8/54/22825bc3d00ae8a801314a6d96e7e83c180b626a40299179073364c7eac7/tokenizers-0.20.1-cp310-none-win32.whl", hash = "sha256:2847843c53f445e0f19ea842a4e48b89dd0db4e62ba6e1e47a2749d6ec11f50d", size = 2203820 },
+    { url = "https://files.pythonhosted.org/packages/7a/da/c7728bb6be0ccfbd5662f054ee28d8ba7883558cc9fcd102e6cdce07bbbf/tokenizers-0.20.1-cp310-none-win_amd64.whl", hash = "sha256:f9aa93eacd865f2798b9e62f7ce4533cfff4f5fbd50c02926a78e81c74e432cd", size = 2384778 },
+    { url = "https://files.pythonhosted.org/packages/61/9a/be5f00cd37ad4fab0e5d1dbf31404a66ac2c1c33973beda9fc8e248a37ab/tokenizers-0.20.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4a717dcb08f2dabbf27ae4b6b20cbbb2ad7ed78ce05a829fae100ff4b3c7ff15", size = 2673182 },
+    { url = "https://files.pythonhosted.org/packages/26/a2/92af8a5f19d0e8bc480759a9975489ebd429b94a81ad46e1422c7927f246/tokenizers-0.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3f84dad1ff1863c648d80628b1b55353d16303431283e4efbb6ab1af56a75832", size = 2562556 },
+    { url = "https://files.pythonhosted.org/packages/2d/ca/f3a294ed89f2a1b900fba072ef4cb5331d4f156e2d5ea2d34f60160ef5bd/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:929c8f3afa16a5130a81ab5079c589226273ec618949cce79b46d96e59a84f61", size = 2943343 },
+    { url = "https://files.pythonhosted.org/packages/31/88/740a6a069e997dc3e96941083fe3264162f4d198a5e5841acb625f84adbd/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d10766473954397e2d370f215ebed1cc46dcf6fd3906a2a116aa1d6219bfedc3", size = 2825954 },
+    { url = "https://files.pythonhosted.org/packages/ff/71/b220deba78e42e483e2856c9cc83a8352c7c5d7322dad61eed4e1ca09c49/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9300fac73ddc7e4b0330acbdda4efaabf74929a4a61e119a32a181f534a11b47", size = 3091324 },
+    { url = "https://files.pythonhosted.org/packages/fe/f4/4302dce958ce0e7f2d85a4725cebe6b02161c2d82990a89317580e17469a/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0ecaf7b0e39caeb1aa6dd6e0975c405716c82c1312b55ac4f716ef563a906969", size = 3098587 },
+    { url = "https://files.pythonhosted.org/packages/7e/0f/9136bc0ea492d29f1d72217c6231dc584bccd3ba41dde12d4a85c75eb12a/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5170be9ec942f3d1d317817ced8d749b3e1202670865e4fd465e35d8c259de83", size = 3414366 },
+    { url = "https://files.pythonhosted.org/packages/09/6c/1b573998fe3f0e18ac5d434e43966de2d225d6837f099ce0df7df4274c87/tokenizers-0.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef3f1ae08fa9aea5891cbd69df29913e11d3841798e0bfb1ff78b78e4e7ea0a4", size = 2984510 },
+    { url = "https://files.pythonhosted.org/packages/d3/92/e5b80e42c24e564ac892c9135e4b9ec34bbcd6cdf0cc7a04735c44fe2ced/tokenizers-0.20.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ee86d4095d3542d73579e953c2e5e07d9321af2ffea6ecc097d16d538a2dea16", size = 8982324 },
+    { url = "https://files.pythonhosted.org/packages/d0/42/c287d28ebcb3ba4f712e7a58d8f170a7b569528acf2d2a8fd1f684c24c0c/tokenizers-0.20.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:86dcd08da163912e17b27bbaba5efdc71b4fbffb841530fdb74c5707f3c49216", size = 9301853 },
+    { url = "https://files.pythonhosted.org/packages/ea/48/7d4ac79588b5b1c3651b753b0a1bdd1343d81af57be18138dfdb304a710a/tokenizers-0.20.1-cp311-none-win32.whl", hash = "sha256:9af2dc4ee97d037bc6b05fa4429ddc87532c706316c5e11ce2f0596dfcfa77af", size = 2201968 },
+    { url = "https://files.pythonhosted.org/packages/f1/95/f1b56f4b1fbd54bd7f170aa64258d0650500e9f45de217ffe4d4663809b6/tokenizers-0.20.1-cp311-none-win_amd64.whl", hash = "sha256:899152a78b095559c287b4c6d0099469573bb2055347bb8154db106651296f39", size = 2384963 },
+    { url = "https://files.pythonhosted.org/packages/8e/8d/a051f979f955c6717099718054d7f51fea0a92d807a7d078a48f2684e54f/tokenizers-0.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:407ab666b38e02228fa785e81f7cf79ef929f104bcccf68a64525a54a93ceac9", size = 2667300 },
+    { url = "https://files.pythonhosted.org/packages/99/c3/2132487ca51148392f0d1ed7f35c23179f67d66fd64c233ff50f091258b4/tokenizers-0.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f13a2d16032ebc8bd812eb8099b035ac65887d8f0c207261472803b9633cf3e", size = 2556581 },
+    { url = "https://files.pythonhosted.org/packages/f4/6e/9dfd1afcfd38fcc5b3a84bca54c33025561f7cab8ea375fa88f03407adc1/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e98eee4dca22849fbb56a80acaa899eec5b72055d79637dd6aa15d5e4b8628c9", size = 2937857 },
+    { url = "https://files.pythonhosted.org/packages/28/51/92e3b25eb41be7fd65219c832c4ff61bf5c8cc1c3d0543e9a117d63a0876/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47c1bcdd61e61136087459cb9e0b069ff23b5568b008265e5cbc927eae3387ce", size = 2823012 },
+    { url = "https://files.pythonhosted.org/packages/f7/59/185ff0bb35d46d88613e87bd76b03989ef8537ebf4f39876bddf9bed2fc1/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:128c1110e950534426e2274837fc06b118ab5f2fa61c3436e60e0aada0ccfd67", size = 3086473 },
+    { url = "https://files.pythonhosted.org/packages/a4/2a/da72c32446ad7f3e6e5cb3c625222a5b9b0bc10b50456f6cb79f6230ae1f/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e2e2d47a819d2954f2c1cd0ad51bb58ffac6f53a872d5d82d65d79bf76b9896d", size = 3101655 },
+    { url = "https://files.pythonhosted.org/packages/cf/7d/c895f076e552cb39ea0491f62ff6551cb3e60323a7496017182bd57cc314/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bdd67a0e3503a9a7cf8bc5a4a49cdde5fa5bada09a51e4c7e1c73900297539bd", size = 3405410 },
+    { url = "https://files.pythonhosted.org/packages/24/59/664121cb41b4f738479e2e1271013a2a7c9160955922536fb723a9c690b7/tokenizers-0.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:689b93d2e26d04da337ac407acec8b5d081d8d135e3e5066a88edd5bdb5aff89", size = 2977249 },
+    { url = "https://files.pythonhosted.org/packages/d4/ab/ceb7bdb3394431e92b18123faef9862877009f61377bfa45ffe5135747a5/tokenizers-0.20.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0c6a796ddcd9a19ad13cf146997cd5895a421fe6aec8fd970d69f9117bddb45c", size = 8989781 },
+    { url = "https://files.pythonhosted.org/packages/bb/37/eaa072b848471d31ae3df6e6d5be5ae594ed5fe39ca921e65cabf193dbde/tokenizers-0.20.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3ea919687aa7001a8ff1ba36ac64f165c4e89035f57998fa6cedcfd877be619d", size = 9304427 },
+    { url = "https://files.pythonhosted.org/packages/41/ff/4aeb924d09f6561209b57af9123a0a28fa69472cc71ee40415f036253203/tokenizers-0.20.1-cp312-none-win32.whl", hash = "sha256:6d3ac5c1f48358ffe20086bf065e843c0d0a9fce0d7f0f45d5f2f9fba3609ca5", size = 2195986 },
+    { url = "https://files.pythonhosted.org/packages/7e/ba/18bf6a7ad04f8225b71aa862b57188748d1d81e268de4a9aac1aed237246/tokenizers-0.20.1-cp312-none-win_amd64.whl", hash = "sha256:b0874481aea54a178f2bccc45aa2d0c99cd3f79143a0948af6a9a21dcc49173b", size = 2377984 },
+    { url = "https://files.pythonhosted.org/packages/4b/9e/cf0911565ae302e4e4ed3d53bba28f2db75a9418f4e89e2434246723f01a/tokenizers-0.20.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:48689da7a395df41114f516208d6550e3e905e1239cc5ad386686d9358e9cef0", size = 2666975 },
+    { url = "https://files.pythonhosted.org/packages/37/98/8221a62aed679aefcbc1793ed8bb33f1e060f8b7d95bb20809db1b5c0e0e/tokenizers-0.20.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:712f90ea33f9bd2586b4a90d697c26d56d0a22fd3c91104c5858c4b5b6489a79", size = 2557365 },
+    { url = "https://files.pythonhosted.org/packages/97/e3/167ca1981b3f512030a28f591b8ef786585b625d45f0fbf1c42723474ecd/tokenizers-0.20.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:359eceb6a620c965988fc559cebc0a98db26713758ec4df43fb76d41486a8ed5", size = 2940885 },
+    { url = "https://files.pythonhosted.org/packages/c1/e6/ec76a7761eb7ba3cf95e2485cb2e7999a8eb0900d771616c0efa61beb1cd/tokenizers-0.20.1-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0d3caf244ce89d24c87545aafc3448be15870096e796c703a0d68547187192e1", size = 3092338 },
+    { url = "https://files.pythonhosted.org/packages/9c/2c/9f04aa030ba8994d478ab35464f8c541aad264556811f12afce9369cc0d3/tokenizers-0.20.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03b03cf8b9a32254b1bf8a305fb95c6daf1baae0c1f93b27f2b08c9759f41dee", size = 2981389 },
+    { url = "https://files.pythonhosted.org/packages/cb/f7/79a74f8c54d1232ddbd68967ce56a00cc9589a31b94bee4cf9f34af91ace/tokenizers-0.20.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:218e5a3561561ea0f0ef1559c6d95b825308dbec23fb55b70b92589e7ff2e1e8", size = 8986321 },
+    { url = "https://files.pythonhosted.org/packages/d4/f2/ea998aaf69966a87f92e31db7cba887125994bb9cd9a4dfcc83ac202d446/tokenizers-0.20.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f40df5e0294a95131cc5f0e0eb91fe86d88837abfbee46b9b3610b09860195a7", size = 9300207 },
 ]
 
 [[package]]
 name = "tomli"
-version = "2.0.1"
+version = "2.0.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c0/3f/d7af728f075fb08564c5949a9c95e44352e23dee646869fa104a3b2060a3/tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f", size = 15164 }
+sdist = { url = "https://files.pythonhosted.org/packages/35/b9/de2a5c0144d7d75a57ff355c0c24054f965b2dc3036456ae03a51ea6264b/tomli-2.0.2.tar.gz", hash = "sha256:d46d457a85337051c36524bc5349dd91b1877838e2979ac5ced3e710ed8a60ed", size = 16096 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/97/75/10a9ebee3fd790d20926a90a2547f0bf78f371b2f13aa822c759680ca7b9/tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc", size = 12757 },
+    { url = "https://files.pythonhosted.org/packages/cf/db/ce8eda256fa131af12e0a76d481711abe4681b6923c27efb9a255c9e4594/tomli-2.0.2-py3-none-any.whl", hash = "sha256:2ebe24485c53d303f690b0ec092806a085f07af5a5aa1464f3931eec36caaa38", size = 13237 },
 ]
 
 [[package]]
@@ -4886,7 +5173,7 @@ wheels = [
 
 [[package]]
 name = "trio"
-version = "0.26.2"
+version = "0.27.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
@@ -4897,9 +5184,9 @@ dependencies = [
     { name = "sniffio" },
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/03/ab0e9509be0c6465e2773768ec25ee0cb8053c0b91471ab3854bbf2294b2/trio-0.26.2.tar.gz", hash = "sha256:0346c3852c15e5c7d40ea15972c4805689ef2cb8b5206f794c9c19450119f3a4", size = 561156 }
+sdist = { url = "https://files.pythonhosted.org/packages/17/d1/a83dee5be404da7afe5a71783a33b8907bacb935a6dc8c69ab785e4a3eed/trio-0.27.0.tar.gz", hash = "sha256:1dcc95ab1726b2da054afea8fd761af74bad79bd52381b84eae408e983c76831", size = 568064 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1c/70/efa56ce2271c44a7f4f43533a0477e6854a0948e9f7b76491de1fd3be7c9/trio-0.26.2-py3-none-any.whl", hash = "sha256:c5237e8133eb0a1d72f09a971a55c28ebe69e351c783fc64bc37db8db8bbe1d0", size = 475996 },
+    { url = "https://files.pythonhosted.org/packages/3c/83/ec3196c360afffbc5b342ead48d1eb7393dd74fa70bca75d33905a86f211/trio-0.27.0-py3-none-any.whl", hash = "sha256:68eabbcf8f457d925df62da780eff15ff5dc68fd6b367e2dde59f7aaf2a0b884", size = 481734 },
 ]
 
 [[package]]
@@ -4964,32 +5251,32 @@ wheels = [
 
 [[package]]
 name = "types-protobuf"
-version = "5.27.0.20240626"
+version = "5.28.0.20240924"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4b/ab/4fe7579d3d64b3ae1def9c8fc57b8633e05edb506517a0b797f3f15c1bc4/types-protobuf-5.27.0.20240626.tar.gz", hash = "sha256:683ba14043bade6785e3f937a7498f243b37881a91ac8d81b9202ecf8b191e9c", size = 54215 }
+sdist = { url = "https://files.pythonhosted.org/packages/90/c3/217fe2c6a4b8ed75c5ecbd27ae8dedd7bc8e8728ac4b29d16005d3a3aba2/types-protobuf-5.28.0.20240924.tar.gz", hash = "sha256:d181af8a256e5a91ce8d5adb53496e880efd9144c7d54483e3653332b60296f0", size = 54324 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/39/07/7d978dfd97592aa7c9a33f634e38b95ae81099ccf11b3ef97674477a03e4/types_protobuf-5.27.0.20240626-py3-none-any.whl", hash = "sha256:688e8f7e8d9295db26bc560df01fb731b27a25b77cbe4c1ce945647f7024f5c1", size = 68752 },
+    { url = "https://files.pythonhosted.org/packages/61/2b/98bfe67a73b15964513b471ce10b610ab0df28825900e0e7517b2bf23952/types_protobuf-5.28.0.20240924-py3-none-any.whl", hash = "sha256:5cecf612ccdefb7dc95f7a51fb502902f20fc2e6681cd500184aaa1b3931d6a7", size = 68761 },
 ]
 
 [[package]]
 name = "types-python-dateutil"
-version = "2.9.0.20240821"
+version = "2.9.0.20241003"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/23/11/aae06ddb6a90cf8ba078be6dbe47f904d2efdf451f9859248b436c945ca4/types-python-dateutil-2.9.0.20240821.tar.gz", hash = "sha256:9649d1dcb6fef1046fb18bebe9ea2aa0028b160918518c34589a46045f6ebd98", size = 9122 }
+sdist = { url = "https://files.pythonhosted.org/packages/31/f8/f6ee4c803a7beccffee21bb29a71573b39f7037c224843eff53e5308c16e/types-python-dateutil-2.9.0.20241003.tar.gz", hash = "sha256:58cb85449b2a56d6684e41aeefb4c4280631246a0da1a719bdbe6f3fb0317446", size = 9210 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/ba/2a4750156272f180f8209f87656ae92e0aeb14f9864976aa90cbd9f21eda/types_python_dateutil-2.9.0.20240821-py3-none-any.whl", hash = "sha256:f5889fcb4e63ed4aaa379b44f93c32593d50b9a94c9a60a0c854d8cc3511cd57", size = 9668 },
+    { url = "https://files.pythonhosted.org/packages/35/d6/ba5f61958f358028f2e2ba1b8e225b8e263053bd57d3a79e2d2db64c807b/types_python_dateutil-2.9.0.20241003-py3-none-any.whl", hash = "sha256:250e1d8e80e7bbc3a6c99b907762711d1a1cdd00e978ad39cb5940f6f0a87f3d", size = 9693 },
 ]
 
 [[package]]
 name = "types-requests"
-version = "2.32.0.20240712"
+version = "2.32.0.20241016"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5e/9e/7663eb27c33568b8fc20ccdaf2a1ce53a9530c42a7cceb9f552a6ff4a1d8/types-requests-2.32.0.20240712.tar.gz", hash = "sha256:90c079ff05e549f6bf50e02e910210b98b8ff1ebdd18e19c873cd237737c1358", size = 17896 }
+sdist = { url = "https://files.pythonhosted.org/packages/fa/3c/4f2a430c01a22abd49a583b6b944173e39e7d01b688190a5618bd59a2e22/types-requests-2.32.0.20241016.tar.gz", hash = "sha256:0d9cad2f27515d0e3e3da7134a1b6f28fb97129d86b867f24d9c726452634d95", size = 18065 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/30/4d/cbed87a6912fbd9259ce23a5d4aa1de9816edf75eec6ed9a757c00906c8e/types_requests-2.32.0.20240712-py3-none-any.whl", hash = "sha256:f754283e152c752e46e70942fa2a146b5bc70393522257bb85bd1ef7e019dcc3", size = 15816 },
+    { url = "https://files.pythonhosted.org/packages/d7/01/485b3026ff90e5190b5e24f1711522e06c79f4a56c8f4b95848ac072e20f/types_requests-2.32.0.20241016-py3-none-any.whl", hash = "sha256:4195d62d6d3e043a4eaaf08ff8a62184584d2e8684e9d2aa178c7915a7da3747", size = 15836 },
 ]
 
 [[package]]
@@ -5025,11 +5312,11 @@ wheels = [
 
 [[package]]
 name = "tzdata"
-version = "2024.1"
+version = "2024.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/74/5b/e025d02cb3b66b7b76093404392d4b44343c69101cc85f4d180dd5784717/tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd", size = 190559 }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/65/58/f9c9e6be752e9fcb8b6a0ee9fb87e6e7a1f6bcab2cdc73f02bb7ba91ada0/tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252", size = 345370 },
+    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 },
 ]
 
 [[package]]
@@ -5052,11 +5339,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.2.2"
+version = "2.2.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/6d/fa469ae21497ddc8bc93e5877702dca7cb8f911e337aca7452b5724f1bb6/urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168", size = 292266 }
+sdist = { url = "https://files.pythonhosted.org/packages/ed/63/22ba4ebfe7430b76388e7cd448d5478814d3032121827c12a2cc287e2260/urllib3-2.2.3.tar.gz", hash = "sha256:e7d814a81dad81e6caf2ec9fdedb284ecc9c73076b62654547cc64ccdcae26e9", size = 300677 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/1c/89ffc63a9605b583d5df2be791a27bc1a42b7c32bab68d3c8f2f73a98cd4/urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472", size = 121444 },
+    { url = "https://files.pythonhosted.org/packages/ce/d9/5f4c13cecde62396b0d3fe530a50ccea91e7dfc1ccf0e09c228841bb5ba8/urllib3-2.2.3-py3-none-any.whl", hash = "sha256:ca899ca043dcb1bafa3e262d73aa25c465bfb49e0bd9dd5d59f1d0acba2f8fac", size = 126338 },
 ]
 
 [package.optional-dependencies]
@@ -5066,16 +5353,16 @@ socks = [
 
 [[package]]
 name = "uvicorn"
-version = "0.30.6"
+version = "0.32.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "h11" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5a/01/5e637e7aa9dd031be5376b9fb749ec20b86f5a5b6a49b87fabd374d5fa9f/uvicorn-0.30.6.tar.gz", hash = "sha256:4b15decdda1e72be08209e860a1e10e92439ad5b97cf44cc945fcbee66fc5788", size = 42825 }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/fc/1d785078eefd6945f3e5bab5c076e4230698046231eb0f3747bc5c8fa992/uvicorn-0.32.0.tar.gz", hash = "sha256:f78b36b143c16f54ccdb8190d0a26b5f1901fe5a3c777e1ab29f26391af8551e", size = 77564 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f5/8e/cdc7d6263db313030e4c257dd5ba3909ebc4e4fb53ad62d5f09b1a2f5458/uvicorn-0.30.6-py3-none-any.whl", hash = "sha256:65fd46fe3fda5bdc1b03b94eb634923ff18cd35b2f084813ea79d1f103f711b5", size = 62835 },
+    { url = "https://files.pythonhosted.org/packages/eb/14/78bd0e95dd2444b6caacbca2b730671d4295ccb628ef58b81bee903629df/uvicorn-0.32.0-py3-none-any.whl", hash = "sha256:60b8f3a5ac027dcd31448f411ced12b5ef452c646f76f02f8cc3f25d8d26fd82", size = 63723 },
 ]
 
 [[package]]
@@ -5163,61 +5450,61 @@ wheels = [
 
 [[package]]
 name = "websockets"
-version = "13.0.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8f/1c/78687e0267b09412409ac134f10fd14d14ac6475da892a8b09a02d0f6ae2/websockets-13.0.1.tar.gz", hash = "sha256:4d6ece65099411cfd9a48d13701d7438d9c34f479046b34c50ff60bb8834e43e", size = 149769 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/bd/224fd6c4c0d60645444bb77cabf3633a6c14a47e2d03cdbc2136486c51f7/websockets-13.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:1841c9082a3ba4a05ea824cf6d99570a6a2d8849ef0db16e9c826acb28089e8f", size = 150946 },
-    { url = "https://files.pythonhosted.org/packages/44/5b/16f06fa678432d0cdbc55477bb6f0215c42b31615948bd63a884c294e0a5/websockets-13.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c5870b4a11b77e4caa3937142b650fbbc0914a3e07a0cf3131f35c0587489c1c", size = 148600 },
-    { url = "https://files.pythonhosted.org/packages/5a/33/c57b4ecdd26510ffcda37d30073097f1e9015b316fe21b513360bf2d8ee2/websockets-13.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f1d3d1f2eb79fe7b0fb02e599b2bf76a7619c79300fc55f0b5e2d382881d4f7f", size = 148853 },
-    { url = "https://files.pythonhosted.org/packages/71/a3/6a8a0e86c44fc39fab83fc6b946f9f7d53e5be6824916450dac637937086/websockets-13.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15c7d62ee071fa94a2fc52c2b472fed4af258d43f9030479d9c4a2de885fd543", size = 157935 },
-    { url = "https://files.pythonhosted.org/packages/a0/58/ba14373234d2b7cce48031f7bd05ab2d23a11ffa0d35c3348d5729fa0527/websockets-13.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6724b554b70d6195ba19650fef5759ef11346f946c07dbbe390e039bcaa7cc3d", size = 156949 },
-    { url = "https://files.pythonhosted.org/packages/7d/8a/8e2319207bae70156d0505bf91e192de015ee91ccc5b1afb406bb7db3819/websockets-13.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56a952fa2ae57a42ba7951e6b2605e08a24801a4931b5644dfc68939e041bc7f", size = 157260 },
-    { url = "https://files.pythonhosted.org/packages/03/cd/31ff415c4b0dc3c185bd87c412affdc5fab42c700b04d02b380bfb789310/websockets-13.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:17118647c0ea14796364299e942c330d72acc4b248e07e639d34b75067b3cdd8", size = 157661 },
-    { url = "https://files.pythonhosted.org/packages/e8/58/a95d1dc6f589cbbfca0918d160ff27c920ab2e94637b750591c6f226cf27/websockets-13.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:64a11aae1de4c178fa653b07d90f2fb1a2ed31919a5ea2361a38760192e1858b", size = 157078 },
-    { url = "https://files.pythonhosted.org/packages/ce/02/207f49e1c22c8fad9e6353815de698e778d365609801dc2387e01e0f94a2/websockets-13.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0617fd0b1d14309c7eab6ba5deae8a7179959861846cbc5cb528a7531c249448", size = 157027 },
-    { url = "https://files.pythonhosted.org/packages/3b/aa/e59d994712635e9e6bc883471e12cc493e3a704e4e22e9d4a59ff1491161/websockets-13.0.1-cp310-cp310-win32.whl", hash = "sha256:11f9976ecbc530248cf162e359a92f37b7b282de88d1d194f2167b5e7ad80ce3", size = 151776 },
-    { url = "https://files.pythonhosted.org/packages/7b/f9/83bc78788d6ce5492fa44133708584a885080aa7c790be2532f326948115/websockets-13.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:c3c493d0e5141ec055a7d6809a28ac2b88d5b878bb22df8c621ebe79a61123d0", size = 152206 },
-    { url = "https://files.pythonhosted.org/packages/20/95/e002ec55688b751d3c9cc131c1960af7e440d95e1954c441535b9da2bf36/websockets-13.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:699ba9dd6a926f82a277063603fc8d586b89f4cb128efc353b749b641fcddda7", size = 150948 },
-    { url = "https://files.pythonhosted.org/packages/62/6b/85fb8c13b278db7d45e27ff6ee0db3009b0fadef7c37c85e6cb4a0fbf08e/websockets-13.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cf2fae6d85e5dc384bf846f8243ddaa9197f3a1a70044f59399af001fd1f51d4", size = 148599 },
-    { url = "https://files.pythonhosted.org/packages/e8/2e/c80cafbab86f8c399ba8323efff298b7062055724146391443d266e9c49b/websockets-13.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:52aed6ef21a0f1a2a5e310fb5c42d7555e9c5855476bbd7173c3aa3d8a0302f2", size = 148851 },
-    { url = "https://files.pythonhosted.org/packages/2e/67/631d4b1f28fef6f12730c0cbe982203a9d6814768c2ab1e0a352d9a07a97/websockets-13.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8eb2b9a318542153674c6e377eb8cb9ca0fc011c04475110d3477862f15d29f0", size = 158509 },
-    { url = "https://files.pythonhosted.org/packages/9b/e8/ba740eab2a9c5b903ea94d9a2a448db63f0a296265aee976d17abf734758/websockets-13.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5df891c86fe68b2c38da55b7aea7095beca105933c697d719f3f45f4220a5e0e", size = 157507 },
-    { url = "https://files.pythonhosted.org/packages/f8/4e/ffa2f1aad2da67e483fb7bad6c69f80c786f4e85d1942a39d7b275b084ed/websockets-13.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fac2d146ff30d9dd2fcf917e5d147db037a5c573f0446c564f16f1f94cf87462", size = 157881 },
-    { url = "https://files.pythonhosted.org/packages/c0/85/0cbfe7b0e0dd3d885cd87b0523c6690ae7369feaf3aab5a23e95bdb4fefa/websockets-13.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b8ac5b46fd798bbbf2ac6620e0437c36a202b08e1f827832c4bf050da081b501", size = 158187 },
-    { url = "https://files.pythonhosted.org/packages/39/29/d9df0a1daedebefaeea88fb8071539604df09fd0f1bfb73bf58333aa3eb6/websockets-13.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:46af561eba6f9b0848b2c9d2427086cabadf14e0abdd9fde9d72d447df268418", size = 157626 },
-    { url = "https://files.pythonhosted.org/packages/7d/9a/f88e186059f6b89f8bb08461d9fda7a26940b7b8897c7d7f02aead40b7e4/websockets-13.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b5a06d7f60bc2fc378a333978470dfc4e1415ee52f5f0fce4f7853eb10c1e9df", size = 157575 },
-    { url = "https://files.pythonhosted.org/packages/cf/e4/ecdb8352ebab2e44c10b9d6f50008f95e30bb0a7ef0e6b66cb475d539d74/websockets-13.0.1-cp311-cp311-win32.whl", hash = "sha256:556e70e4f69be1082e6ef26dcb70efcd08d1850f5d6c5f4f2bcb4e397e68f01f", size = 151779 },
-    { url = "https://files.pythonhosted.org/packages/12/40/46967d00640e6c3231b73d310617927a11c91bcc044dd5a0860a3c457c33/websockets-13.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:67494e95d6565bf395476e9d040037ff69c8b3fa356a886b21d8422ad86ae075", size = 152206 },
-    { url = "https://files.pythonhosted.org/packages/4e/51/23ed2d239f1c3087c1431d41cfd159865df0bc35bb0c89973e3b6a0fff9b/websockets-13.0.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:f9c9e258e3d5efe199ec23903f5da0eeaad58cf6fccb3547b74fd4750e5ac47a", size = 150953 },
-    { url = "https://files.pythonhosted.org/packages/57/8d/814a7ef62b916b0f39108ad2e4d9b4cb0f8c640f8c30202fb63041598ada/websockets-13.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:6b41a1b3b561f1cba8321fb32987552a024a8f67f0d05f06fcf29f0090a1b956", size = 148610 },
-    { url = "https://files.pythonhosted.org/packages/ad/8b/a378d21124011737e0e490a8a6ef778914b03e50c8d938de2f2170a20dbd/websockets-13.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f73e676a46b0fe9426612ce8caeca54c9073191a77c3e9d5c94697aef99296af", size = 148849 },
-    { url = "https://files.pythonhosted.org/packages/46/d2/814a61226af313c1bc289cfe3a10f87bf426b6f2d9df0f927c47afab7612/websockets-13.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f613289f4a94142f914aafad6c6c87903de78eae1e140fa769a7385fb232fdf", size = 158772 },
-    { url = "https://files.pythonhosted.org/packages/a1/7e/5987299eb7e131216c9027b05a65f149cbc2bde7c582e694d9eed6ec3d40/websockets-13.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f52504023b1480d458adf496dc1c9e9811df4ba4752f0bc1f89ae92f4f07d0c", size = 157724 },
-    { url = "https://files.pythonhosted.org/packages/94/6e/eaf95894042ba8a05a125fe8bcf9ee3572fef6edbcbf49478f4991c027cc/websockets-13.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:139add0f98206cb74109faf3611b7783ceafc928529c62b389917a037d4cfdf4", size = 158152 },
-    { url = "https://files.pythonhosted.org/packages/ce/ba/a1315d569cc2dadaafda74a9cea16ab5d68142525937f1994442d969b306/websockets-13.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:47236c13be337ef36546004ce8c5580f4b1150d9538b27bf8a5ad8edf23ccfab", size = 158442 },
-    { url = "https://files.pythonhosted.org/packages/90/9b/59866695cfd05e785c90932fef3dae4682eb4e06e7076b7c53478f25faad/websockets-13.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c44ca9ade59b2e376612df34e837013e2b273e6c92d7ed6636d0556b6f4db93d", size = 157823 },
-    { url = "https://files.pythonhosted.org/packages/9b/47/20af68a313b6453d2d094ccc497b7232e8475175d234e3e5bef5088521e5/websockets-13.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9bbc525f4be3e51b89b2a700f5746c2a6907d2e2ef4513a8daafc98198b92237", size = 157818 },
-    { url = "https://files.pythonhosted.org/packages/f8/bb/60aaedc80e388e978617dda1ff38788780c6b0f6e462b85368cb934131a5/websockets-13.0.1-cp312-cp312-win32.whl", hash = "sha256:3624fd8664f2577cf8de996db3250662e259bfbc870dd8ebdcf5d7c6ac0b5185", size = 151785 },
-    { url = "https://files.pythonhosted.org/packages/16/2e/e47692f569e1be2e66c1dbc5e85ea4d2cc93b80027fbafa28ae8b0dee52c/websockets-13.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0513c727fb8adffa6d9bf4a4463b2bade0186cbd8c3604ae5540fae18a90cb99", size = 152214 },
-    { url = "https://files.pythonhosted.org/packages/46/37/d8ef4b68684d1fa368a5c64be466db07fc58b68163bc2496db2d4cc208ff/websockets-13.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1ee4cc030a4bdab482a37462dbf3ffb7e09334d01dd37d1063be1136a0d825fa", size = 150962 },
-    { url = "https://files.pythonhosted.org/packages/95/49/78aeb3af08ec9887a9065e85cef9d7e199d6c6261fcd39eec087f3a62328/websockets-13.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dbb0b697cc0655719522406c059eae233abaa3243821cfdfab1215d02ac10231", size = 148621 },
-    { url = "https://files.pythonhosted.org/packages/31/0d/dc9b7cec8deaee452092a631ccda894bd7098859f71dd7639b4b5b9c615c/websockets-13.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:acbebec8cb3d4df6e2488fbf34702cbc37fc39ac7abf9449392cefb3305562e9", size = 148853 },
-    { url = "https://files.pythonhosted.org/packages/16/bf/734cbd815d7bc94cffe35c934f4e08b619bf3b47df1c6c7af21c1d35bcfe/websockets-13.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63848cdb6fcc0bf09d4a155464c46c64ffdb5807ede4fb251da2c2692559ce75", size = 158741 },
-    { url = "https://files.pythonhosted.org/packages/af/9b/756f89b12fee8931785531a314e6f087b21774a7f8c60878e597c684f91b/websockets-13.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:872afa52a9f4c414d6955c365b6588bc4401272c629ff8321a55f44e3f62b553", size = 157690 },
-    { url = "https://files.pythonhosted.org/packages/d3/37/31f97132d2262e666b797e250879ca833eab55115f88043b3952a2840eb8/websockets-13.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e70fec7c54aad4d71eae8e8cab50525e899791fc389ec6f77b95312e4e9920", size = 158132 },
-    { url = "https://files.pythonhosted.org/packages/41/ce/59c8d44e148c002fec506a9527504fb4281676e2e75c2ee5a58180f1b99a/websockets-13.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e82db3756ccb66266504f5a3de05ac6b32f287faacff72462612120074103329", size = 158490 },
-    { url = "https://files.pythonhosted.org/packages/1a/74/5b31ce0f318b902c0d70c031f8e1228ba1a4d95a46b2a24a2a5ac17f9cf0/websockets-13.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4e85f46ce287f5c52438bb3703d86162263afccf034a5ef13dbe4318e98d86e7", size = 157879 },
-    { url = "https://files.pythonhosted.org/packages/0d/a7/6eac4f04177644bbc98deb98d11770cc7fbc216f6f67ab187c150540fd52/websockets-13.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f3fea72e4e6edb983908f0db373ae0732b275628901d909c382aae3b592589f2", size = 157873 },
-    { url = "https://files.pythonhosted.org/packages/72/f6/b8b30a3b134dfdb4ccd1694befa48fddd43783957c988a1dab175732af33/websockets-13.0.1-cp313-cp313-win32.whl", hash = "sha256:254ecf35572fca01a9f789a1d0f543898e222f7b69ecd7d5381d8d8047627bdb", size = 151782 },
-    { url = "https://files.pythonhosted.org/packages/3e/88/d94ccc006c69583168aa9dd73b3f1885c8931f2c676f4bdd8cbfae91c7b6/websockets-13.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:ca48914cdd9f2ccd94deab5bcb5ac98025a5ddce98881e5cce762854a5de330b", size = 152212 },
-    { url = "https://files.pythonhosted.org/packages/ae/d8/9d0e5c836f89147aa769b72e2d82217ae1c17ffd5f375de8d785e1e16870/websockets-13.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:faef9ec6354fe4f9a2c0bbb52fb1ff852effc897e2a4501e25eb3a47cb0a4f89", size = 148629 },
-    { url = "https://files.pythonhosted.org/packages/9c/ff/005a440db101d298b42cc7565579ed55a7e12ccc0c6ea0491e53bb073930/websockets-13.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:03d3f9ba172e0a53e37fa4e636b86cc60c3ab2cfee4935e66ed1d7acaa4625ad", size = 148863 },
-    { url = "https://files.pythonhosted.org/packages/9f/06/44d7c7d48e0beaecbacaf0020eafccd490741e496622da6b2a5626fe6689/websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d450f5a7a35662a9b91a64aefa852f0c0308ee256122f5218a42f1d13577d71e", size = 150226 },
-    { url = "https://files.pythonhosted.org/packages/48/6f/861ba99aa3c5cb54412c3870d5549e466d82d2f7c440b435e23ca6496865/websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3f55b36d17ac50aa8a171b771e15fbe1561217510c8768af3d546f56c7576cdc", size = 149833 },
-    { url = "https://files.pythonhosted.org/packages/8d/a0/9fb50648f69ed341e30096356a815c89c4f9daef24a32e9754dbdc3de8a8/websockets-13.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14b9c006cac63772b31abbcd3e3abb6228233eec966bf062e89e7fa7ae0b7333", size = 149778 },
-    { url = "https://files.pythonhosted.org/packages/f1/ba/48b5b8343e6f62a8a809ffe987d4d7c911cedcb1b8353f3da615f2609893/websockets-13.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b79915a1179a91f6c5f04ece1e592e2e8a6bd245a0e45d12fd56b2b59e559a32", size = 152259 },
-    { url = "https://files.pythonhosted.org/packages/fd/bd/d34c4b7918453506d2149208b175368738148ffc4ba256d7fd8708956732/websockets-13.0.1-py3-none-any.whl", hash = "sha256:b80f0c51681c517604152eb6a572f5a9378f877763231fddb883ba2f968e8817", size = 145262 },
+version = "13.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e2/73/9223dbc7be3dcaf2a7bbf756c351ec8da04b1fa573edaf545b95f6b0c7fd/websockets-13.1.tar.gz", hash = "sha256:a3b3366087c1bc0a2795111edcadddb8b3b59509d5db5d7ea3fdd69f954a8878", size = 158549 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/94/d15dbfc6a5eb636dbc754303fba18208f2e88cf97e733e1d64fb9cb5c89e/websockets-13.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f48c749857f8fb598fb890a75f540e3221d0976ed0bf879cf3c7eef34151acee", size = 157815 },
+    { url = "https://files.pythonhosted.org/packages/30/02/c04af33f4663945a26f5e8cf561eb140c35452b50af47a83c3fbcfe62ae1/websockets-13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c7e72ce6bda6fb9409cc1e8164dd41d7c91466fb599eb047cfda72fe758a34a7", size = 155466 },
+    { url = "https://files.pythonhosted.org/packages/35/e8/719f08d12303ea643655e52d9e9851b2dadbb1991d4926d9ce8862efa2f5/websockets-13.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f779498eeec470295a2b1a5d97aa1bc9814ecd25e1eb637bd9d1c73a327387f6", size = 155716 },
+    { url = "https://files.pythonhosted.org/packages/91/e1/14963ae0252a8925f7434065d25dcd4701d5e281a0b4b460a3b5963d2594/websockets-13.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4676df3fe46956fbb0437d8800cd5f2b6d41143b6e7e842e60554398432cf29b", size = 164806 },
+    { url = "https://files.pythonhosted.org/packages/ec/fa/ab28441bae5e682a0f7ddf3d03440c0c352f930da419301f4a717f675ef3/websockets-13.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7affedeb43a70351bb811dadf49493c9cfd1ed94c9c70095fd177e9cc1541fa", size = 163810 },
+    { url = "https://files.pythonhosted.org/packages/44/77/dea187bd9d16d4b91566a2832be31f99a40d0f5bfa55eeb638eb2c3bc33d/websockets-13.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1971e62d2caa443e57588e1d82d15f663b29ff9dfe7446d9964a4b6f12c1e700", size = 164125 },
+    { url = "https://files.pythonhosted.org/packages/cf/d9/3af14544e83f1437eb684b399e6ba0fa769438e869bf5d83d74bc197fae8/websockets-13.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5f2e75431f8dc4a47f31565a6e1355fb4f2ecaa99d6b89737527ea917066e26c", size = 164532 },
+    { url = "https://files.pythonhosted.org/packages/1c/8a/6d332eabe7d59dfefe4b8ba6f46c8c5fabb15b71c8a8bc3d2b65de19a7b6/websockets-13.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:58cf7e75dbf7e566088b07e36ea2e3e2bd5676e22216e4cad108d4df4a7402a0", size = 163948 },
+    { url = "https://files.pythonhosted.org/packages/1a/91/a0aeadbaf3017467a1ee03f8fb67accdae233fe2d5ad4b038c0a84e357b0/websockets-13.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c90d6dec6be2c7d03378a574de87af9b1efea77d0c52a8301dd831ece938452f", size = 163898 },
+    { url = "https://files.pythonhosted.org/packages/71/31/a90fb47c63e0ae605be914b0b969d7c6e6ffe2038cd744798e4b3fbce53b/websockets-13.1-cp310-cp310-win32.whl", hash = "sha256:730f42125ccb14602f455155084f978bd9e8e57e89b569b4d7f0f0c17a448ffe", size = 158706 },
+    { url = "https://files.pythonhosted.org/packages/93/ca/9540a9ba80da04dc7f36d790c30cae4252589dbd52ccdc92e75b0be22437/websockets-13.1-cp310-cp310-win_amd64.whl", hash = "sha256:5993260f483d05a9737073be197371940c01b257cc45ae3f1d5d7adb371b266a", size = 159141 },
+    { url = "https://files.pythonhosted.org/packages/b2/f0/cf0b8a30d86b49e267ac84addbebbc7a48a6e7bb7c19db80f62411452311/websockets-13.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:61fc0dfcda609cda0fc9fe7977694c0c59cf9d749fbb17f4e9483929e3c48a19", size = 157813 },
+    { url = "https://files.pythonhosted.org/packages/bf/e7/22285852502e33071a8cf0ac814f8988480ec6db4754e067b8b9d0e92498/websockets-13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ceec59f59d092c5007e815def4ebb80c2de330e9588e101cf8bd94c143ec78a5", size = 155469 },
+    { url = "https://files.pythonhosted.org/packages/68/d4/c8c7c1e5b40ee03c5cc235955b0fb1ec90e7e37685a5f69229ad4708dcde/websockets-13.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c1dca61c6db1166c48b95198c0b7d9c990b30c756fc2923cc66f68d17dc558fd", size = 155717 },
+    { url = "https://files.pythonhosted.org/packages/c9/e4/c50999b9b848b1332b07c7fd8886179ac395cb766fda62725d1539e7bc6c/websockets-13.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:308e20f22c2c77f3f39caca508e765f8725020b84aa963474e18c59accbf4c02", size = 165379 },
+    { url = "https://files.pythonhosted.org/packages/bc/49/4a4ad8c072f18fd79ab127650e47b160571aacfc30b110ee305ba25fffc9/websockets-13.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:62d516c325e6540e8a57b94abefc3459d7dab8ce52ac75c96cad5549e187e3a7", size = 164376 },
+    { url = "https://files.pythonhosted.org/packages/af/9b/8c06d425a1d5a74fd764dd793edd02be18cf6fc3b1ccd1f29244ba132dc0/websockets-13.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87c6e35319b46b99e168eb98472d6c7d8634ee37750d7693656dc766395df096", size = 164753 },
+    { url = "https://files.pythonhosted.org/packages/d5/5b/0acb5815095ff800b579ffc38b13ab1b915b317915023748812d24e0c1ac/websockets-13.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5f9fee94ebafbc3117c30be1844ed01a3b177bb6e39088bc6b2fa1dc15572084", size = 165051 },
+    { url = "https://files.pythonhosted.org/packages/30/93/c3891c20114eacb1af09dedfcc620c65c397f4fd80a7009cd12d9457f7f5/websockets-13.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7c1e90228c2f5cdde263253fa5db63e6653f1c00e7ec64108065a0b9713fa1b3", size = 164489 },
+    { url = "https://files.pythonhosted.org/packages/28/09/af9e19885539759efa2e2cd29b8b3f9eecef7ecefea40d46612f12138b36/websockets-13.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6548f29b0e401eea2b967b2fdc1c7c7b5ebb3eeb470ed23a54cd45ef078a0db9", size = 164438 },
+    { url = "https://files.pythonhosted.org/packages/b6/08/6f38b8e625b3d93de731f1d248cc1493327f16cb45b9645b3e791782cff0/websockets-13.1-cp311-cp311-win32.whl", hash = "sha256:c11d4d16e133f6df8916cc5b7e3e96ee4c44c936717d684a94f48f82edb7c92f", size = 158710 },
+    { url = "https://files.pythonhosted.org/packages/fb/39/ec8832ecb9bb04a8d318149005ed8cee0ba4e0205835da99e0aa497a091f/websockets-13.1-cp311-cp311-win_amd64.whl", hash = "sha256:d04f13a1d75cb2b8382bdc16ae6fa58c97337253826dfe136195b7f89f661557", size = 159137 },
+    { url = "https://files.pythonhosted.org/packages/df/46/c426282f543b3c0296cf964aa5a7bb17e984f58dde23460c3d39b3148fcf/websockets-13.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9d75baf00138f80b48f1eac72ad1535aac0b6461265a0bcad391fc5aba875cfc", size = 157821 },
+    { url = "https://files.pythonhosted.org/packages/aa/85/22529867010baac258da7c45848f9415e6cf37fef00a43856627806ffd04/websockets-13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9b6f347deb3dcfbfde1c20baa21c2ac0751afaa73e64e5b693bb2b848efeaa49", size = 155480 },
+    { url = "https://files.pythonhosted.org/packages/29/2c/bdb339bfbde0119a6e84af43ebf6275278698a2241c2719afc0d8b0bdbf2/websockets-13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de58647e3f9c42f13f90ac7e5f58900c80a39019848c5547bc691693098ae1bd", size = 155715 },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/8612029ea04c5c22bf7af2fd3d63876c4eaeef9b97e86c11972a43aa0e6c/websockets-13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1b54689e38d1279a51d11e3467dd2f3a50f5f2e879012ce8f2d6943f00e83f0", size = 165647 },
+    { url = "https://files.pythonhosted.org/packages/56/04/1681ed516fa19ca9083f26d3f3a302257e0911ba75009533ed60fbb7b8d1/websockets-13.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf1781ef73c073e6b0f90af841aaf98501f975d306bbf6221683dd594ccc52b6", size = 164592 },
+    { url = "https://files.pythonhosted.org/packages/38/6f/a96417a49c0ed132bb6087e8e39a37db851c70974f5c724a4b2a70066996/websockets-13.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d23b88b9388ed85c6faf0e74d8dec4f4d3baf3ecf20a65a47b836d56260d4b9", size = 165012 },
+    { url = "https://files.pythonhosted.org/packages/40/8b/fccf294919a1b37d190e86042e1a907b8f66cff2b61e9befdbce03783e25/websockets-13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3c78383585f47ccb0fcf186dcb8a43f5438bd7d8f47d69e0b56f71bf431a0a68", size = 165311 },
+    { url = "https://files.pythonhosted.org/packages/c1/61/f8615cf7ce5fe538476ab6b4defff52beb7262ff8a73d5ef386322d9761d/websockets-13.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d6d300f8ec35c24025ceb9b9019ae9040c1ab2f01cddc2bcc0b518af31c75c14", size = 164692 },
+    { url = "https://files.pythonhosted.org/packages/5c/f1/a29dd6046d3a722d26f182b783a7997d25298873a14028c4760347974ea3/websockets-13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a9dcaf8b0cc72a392760bb8755922c03e17a5a54e08cca58e8b74f6902b433cf", size = 164686 },
+    { url = "https://files.pythonhosted.org/packages/0f/99/ab1cdb282f7e595391226f03f9b498f52109d25a2ba03832e21614967dfa/websockets-13.1-cp312-cp312-win32.whl", hash = "sha256:2f85cf4f2a1ba8f602298a853cec8526c2ca42a9a4b947ec236eaedb8f2dc80c", size = 158712 },
+    { url = "https://files.pythonhosted.org/packages/46/93/e19160db48b5581feac8468330aa11b7292880a94a37d7030478596cc14e/websockets-13.1-cp312-cp312-win_amd64.whl", hash = "sha256:38377f8b0cdeee97c552d20cf1865695fcd56aba155ad1b4ca8779a5b6ef4ac3", size = 159145 },
+    { url = "https://files.pythonhosted.org/packages/51/20/2b99ca918e1cbd33c53db2cace5f0c0cd8296fc77558e1908799c712e1cd/websockets-13.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a9ab1e71d3d2e54a0aa646ab6d4eebfaa5f416fe78dfe4da2839525dc5d765c6", size = 157828 },
+    { url = "https://files.pythonhosted.org/packages/b8/47/0932a71d3d9c0e9483174f60713c84cee58d62839a143f21a2bcdbd2d205/websockets-13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b9d7439d7fab4dce00570bb906875734df13d9faa4b48e261c440a5fec6d9708", size = 155487 },
+    { url = "https://files.pythonhosted.org/packages/a9/60/f1711eb59ac7a6c5e98e5637fef5302f45b6f76a2c9d64fd83bbb341377a/websockets-13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:327b74e915cf13c5931334c61e1a41040e365d380f812513a255aa804b183418", size = 155721 },
+    { url = "https://files.pythonhosted.org/packages/6a/e6/ba9a8db7f9d9b0e5f829cf626ff32677f39824968317223605a6b419d445/websockets-13.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:325b1ccdbf5e5725fdcb1b0e9ad4d2545056479d0eee392c291c1bf76206435a", size = 165609 },
+    { url = "https://files.pythonhosted.org/packages/c1/22/4ec80f1b9c27a0aebd84ccd857252eda8418ab9681eb571b37ca4c5e1305/websockets-13.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:346bee67a65f189e0e33f520f253d5147ab76ae42493804319b5716e46dddf0f", size = 164556 },
+    { url = "https://files.pythonhosted.org/packages/27/ac/35f423cb6bb15600438db80755609d27eda36d4c0b3c9d745ea12766c45e/websockets-13.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91a0fa841646320ec0d3accdff5b757b06e2e5c86ba32af2e0815c96c7a603c5", size = 164993 },
+    { url = "https://files.pythonhosted.org/packages/31/4e/98db4fd267f8be9e52e86b6ee4e9aa7c42b83452ea0ea0672f176224b977/websockets-13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:18503d2c5f3943e93819238bf20df71982d193f73dcecd26c94514f417f6b135", size = 165360 },
+    { url = "https://files.pythonhosted.org/packages/3f/15/3f0de7cda70ffc94b7e7024544072bc5b26e2c1eb36545291abb755d8cdb/websockets-13.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a9cd1af7e18e5221d2878378fbc287a14cd527fdd5939ed56a18df8a31136bb2", size = 164745 },
+    { url = "https://files.pythonhosted.org/packages/a1/6e/66b6b756aebbd680b934c8bdbb6dcb9ce45aad72cde5f8a7208dbb00dd36/websockets-13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:70c5be9f416aa72aab7a2a76c90ae0a4fe2755c1816c153c1a2bcc3333ce4ce6", size = 164732 },
+    { url = "https://files.pythonhosted.org/packages/35/c6/12e3aab52c11aeb289e3dbbc05929e7a9d90d7a9173958477d3ef4f8ce2d/websockets-13.1-cp313-cp313-win32.whl", hash = "sha256:624459daabeb310d3815b276c1adef475b3e6804abaf2d9d2c061c319f7f187d", size = 158709 },
+    { url = "https://files.pythonhosted.org/packages/41/d8/63d6194aae711d7263df4498200c690a9c39fb437ede10f3e157a6343e0d/websockets-13.1-cp313-cp313-win_amd64.whl", hash = "sha256:c518e84bb59c2baae725accd355c8dc517b4a3ed8db88b4bc93c78dae2974bf2", size = 159144 },
+    { url = "https://files.pythonhosted.org/packages/2d/75/6da22cb3ad5b8c606963f9a5f9f88656256fecc29d420b4b2bf9e0c7d56f/websockets-13.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5dd6da9bec02735931fccec99d97c29f47cc61f644264eb995ad6c0c27667238", size = 155499 },
+    { url = "https://files.pythonhosted.org/packages/c0/ba/22833d58629088fcb2ccccedfae725ac0bbcd713319629e97125b52ac681/websockets-13.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:2510c09d8e8df777177ee3d40cd35450dc169a81e747455cc4197e63f7e7bfe5", size = 155737 },
+    { url = "https://files.pythonhosted.org/packages/95/54/61684fe22bdb831e9e1843d972adadf359cf04ab8613285282baea6a24bb/websockets-13.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1c3cf67185543730888b20682fb186fc8d0fa6f07ccc3ef4390831ab4b388d9", size = 157095 },
+    { url = "https://files.pythonhosted.org/packages/fc/f5/6652fb82440813822022a9301a30afde85e5ff3fb2aebb77f34aabe2b4e8/websockets-13.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bcc03c8b72267e97b49149e4863d57c2d77f13fae12066622dc78fe322490fe6", size = 156701 },
+    { url = "https://files.pythonhosted.org/packages/67/33/ae82a7b860fa8a08aba68818bdf7ff61f04598aa5ab96df4cd5a3e418ca4/websockets-13.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:004280a140f220c812e65f36944a9ca92d766b6cc4560be652a0a3883a79ed8a", size = 156654 },
+    { url = "https://files.pythonhosted.org/packages/63/0b/a1b528d36934f833e20f6da1032b995bf093d55cb416b9f2266f229fb237/websockets-13.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e2620453c075abeb0daa949a292e19f56de518988e079c36478bacf9546ced23", size = 159192 },
+    { url = "https://files.pythonhosted.org/packages/56/27/96a5cd2626d11c8280656c6c71d8ab50fe006490ef9971ccd154e0c42cd2/websockets-13.1-py3-none-any.whl", hash = "sha256:a9a396a6ad26130cdae92ae10c36af09d9bfe6cafe69670fd3b6da9b07b4044f", size = 152134 },
 ]
 
 [[package]]
@@ -5301,60 +5588,80 @@ wheels = [
 
 [[package]]
 name = "yarl"
-version = "1.9.4"
+version = "1.16.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "idna" },
     { name = "multidict" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e0/ad/bedcdccbcbf91363fd425a948994f3340924145c2bc8ccb296f4a1e52c28/yarl-1.9.4.tar.gz", hash = "sha256:566db86717cf8080b99b58b083b773a908ae40f06681e87e589a976faf8246bf", size = 141869 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/27/cda5a927df3a894eddfee4efacdd230c2d8486e322fc672194fd651f82c5/yarl-1.9.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a8c1df72eb746f4136fe9a2e72b0c9dc1da1cbd23b5372f94b5820ff8ae30e0e", size = 129061 },
-    { url = "https://files.pythonhosted.org/packages/d5/fc/40b85bea1f5686092ea37f472c94c023d6347266852ffd55baa01c40f596/yarl-1.9.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3a6ed1d525bfb91b3fc9b690c5a21bb52de28c018530ad85093cc488bee2dd2", size = 81246 },
-    { url = "https://files.pythonhosted.org/packages/81/c6/06938036ea48fa74521713499fba1459b0eb60af9b9afbe8e0e9e1a96c36/yarl-1.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c38c9ddb6103ceae4e4498f9c08fac9b590c5c71b0370f98714768e22ac6fa66", size = 79176 },
-    { url = "https://files.pythonhosted.org/packages/30/b5/215d586d5cb17ca9748d7a2d597c07147f210c0c0785257492094d083b65/yarl-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9e09c9d74f4566e905a0b8fa668c58109f7624db96a2171f21747abc7524234", size = 297669 },
-    { url = "https://files.pythonhosted.org/packages/dd/90/2958ae9f2e12084d616eef95b6a48c8e6d96448add04367c20dc53a33ff2/yarl-1.9.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8477c1ee4bd47c57d49621a062121c3023609f7a13b8a46953eb6c9716ca392", size = 311909 },
-    { url = "https://files.pythonhosted.org/packages/0b/58/dd3c69651381a57ac991dba54b20ae2da359eb4b03a661e71c451d6525c6/yarl-1.9.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5ff2c858f5f6a42c2a8e751100f237c5e869cbde669a724f2062d4c4ef93551", size = 308690 },
-    { url = "https://files.pythonhosted.org/packages/c3/a0/0ade1409d184cbc9e85acd403a386a7c0563b92ff0f26d138ff9e86e48b4/yarl-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:357495293086c5b6d34ca9616a43d329317feab7917518bc97a08f9e55648455", size = 301580 },
-    { url = "https://files.pythonhosted.org/packages/6d/a1/db0bdf8cc48515e9c02daf04ae2916fc27ce6498eca21432fc9ffa63f71b/yarl-1.9.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54525ae423d7b7a8ee81ba189f131054defdb122cde31ff17477951464c1691c", size = 291231 },
-    { url = "https://files.pythonhosted.org/packages/b2/4f/796b0c73e9ff30a1047a7ee3390e157ab8424d4401b9f32a2624013a5b39/yarl-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:801e9264d19643548651b9db361ce3287176671fb0117f96b5ac0ee1c3530d53", size = 301079 },
-    { url = "https://files.pythonhosted.org/packages/0b/a3/7774786ec6e2dca0bb38b286f12a11af97957546e5fbcce71752a8d2cf07/yarl-1.9.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e516dc8baf7b380e6c1c26792610230f37147bb754d6426462ab115a02944385", size = 295202 },
-    { url = "https://files.pythonhosted.org/packages/70/a9/ef6d69ce9a4e82080290bcb6db735bb8a6d6db92f2bbb92b6951bde97e7c/yarl-1.9.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:7d5aaac37d19b2904bb9dfe12cdb08c8443e7ba7d2852894ad448d4b8f442863", size = 311784 },
-    { url = "https://files.pythonhosted.org/packages/44/ae/fdbc9965ef69e650c3b5b04d60badef90ff0cde21a30770f0700e148b12f/yarl-1.9.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:54beabb809ffcacbd9d28ac57b0db46e42a6e341a030293fb3185c409e626b8b", size = 311134 },
-    { url = "https://files.pythonhosted.org/packages/cc/2a/abbaf1460becba856e163f2a1274f5d34b1969d476da8e68a8fc2aeb5661/yarl-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bac8d525a8dbc2a1507ec731d2867025d11ceadcb4dd421423a5d42c56818541", size = 304584 },
-    { url = "https://files.pythonhosted.org/packages/a3/73/dd7ced8d9731bd2ef4fdff5da23ce2f772ca04e8ddee886a6b15248d9e65/yarl-1.9.4-cp310-cp310-win32.whl", hash = "sha256:7855426dfbddac81896b6e533ebefc0af2f132d4a47340cee6d22cac7190022d", size = 70175 },
-    { url = "https://files.pythonhosted.org/packages/31/d4/2085272a5ccf87af74d4e02787c242c5d60367840a4637b2835565264302/yarl-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:848cd2a1df56ddbffeb375535fb62c9d1645dde33ca4d51341378b3f5954429b", size = 76402 },
-    { url = "https://files.pythonhosted.org/packages/12/65/4c7f3676209a569405c9f0f492df2bc3a387c253f5d906e36944fdd12277/yarl-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:35a2b9396879ce32754bd457d31a51ff0a9d426fd9e0e3c33394bf4b9036b099", size = 132836 },
-    { url = "https://files.pythonhosted.org/packages/3b/c5/81e3dbf5271ab1510860d2ae7a704ef43f93f7cb9326bf7ebb1949a7260b/yarl-1.9.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c7d56b293cc071e82532f70adcbd8b61909eec973ae9d2d1f9b233f3d943f2c", size = 83215 },
-    { url = "https://files.pythonhosted.org/packages/20/3d/7dabf580dfc0b588e48830486b488858122b10a61f33325e0d7cf1d6180b/yarl-1.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d8a1c6c0be645c745a081c192e747c5de06e944a0d21245f4cf7c05e457c36e0", size = 81237 },
-    { url = "https://files.pythonhosted.org/packages/38/45/7c669999f5d350f4f8f74369b94e0f6705918eee18e38610bfe44af93d4f/yarl-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b3c1ffe10069f655ea2d731808e76e0f452fc6c749bea04781daf18e6039525", size = 324181 },
-    { url = "https://files.pythonhosted.org/packages/50/49/aa04effe2876cced8867bf9d89b620acf02b733c62adfe22a8218c35d70b/yarl-1.9.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:549d19c84c55d11687ddbd47eeb348a89df9cb30e1993f1b128f4685cd0ebbf8", size = 339412 },
-    { url = "https://files.pythonhosted.org/packages/7d/95/4310771fb9c71599d8466f43347ac18fafd501621e65b93f4f4f16899b1d/yarl-1.9.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7409f968456111140c1c95301cadf071bd30a81cbd7ab829169fb9e3d72eae9", size = 337973 },
-    { url = "https://files.pythonhosted.org/packages/9f/ea/94ad7d8299df89844e666e4aa8a0e9b88e02416cd6a7dd97969e9eae5212/yarl-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e23a6d84d9d1738dbc6e38167776107e63307dfc8ad108e580548d1f2c587f42", size = 328126 },
-    { url = "https://files.pythonhosted.org/packages/6d/be/9d4885e2725f5860833547c9e4934b6e0f44a355b24ffc37957264761e3e/yarl-1.9.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8b889777de69897406c9fb0b76cdf2fd0f31267861ae7501d93003d55f54fbe", size = 316677 },
-    { url = "https://files.pythonhosted.org/packages/4a/70/5c744d67cad3d093e233cb02f37f2830cb89abfcbb7ad5b5af00ff21d14d/yarl-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:03caa9507d3d3c83bca08650678e25364e1843b484f19986a527630ca376ecce", size = 324243 },
-    { url = "https://files.pythonhosted.org/packages/c2/80/8b38d8fed958ac37afb8b81a54bf4f767b107e2c2004dab165edb58fc51b/yarl-1.9.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4e9035df8d0880b2f1c7f5031f33f69e071dfe72ee9310cfc76f7b605958ceb9", size = 318099 },
-    { url = "https://files.pythonhosted.org/packages/59/50/715bbc7bda65291f9295e757f67854206f4d8be9746d39187724919ac14d/yarl-1.9.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:c0ec0ed476f77db9fb29bca17f0a8fcc7bc97ad4c6c1d8959c507decb22e8572", size = 334924 },
-    { url = "https://files.pythonhosted.org/packages/a8/af/ca9962488027576d7162878a1864cbb1275d298af986ce96bdfd4807d7b2/yarl-1.9.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:ee04010f26d5102399bd17f8df8bc38dc7ccd7701dc77f4a68c5b8d733406958", size = 335060 },
-    { url = "https://files.pythonhosted.org/packages/28/c7/249a3a903d500ca7369eb542e2847a14f12f249638dcc10371db50cd17ff/yarl-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:49a180c2e0743d5d6e0b4d1a9e5f633c62eca3f8a86ba5dd3c471060e352ca98", size = 326689 },
-    { url = "https://files.pythonhosted.org/packages/ec/0c/f02dd0b875a7a460f95dc7cf18983ed43c693283d6ab92e0ad71b9e0de8f/yarl-1.9.4-cp311-cp311-win32.whl", hash = "sha256:81eb57278deb6098a5b62e88ad8281b2ba09f2f1147c4767522353eaa6260b31", size = 70407 },
-    { url = "https://files.pythonhosted.org/packages/27/41/945ae9a80590e4fb0be166863c6e63d75e4b35789fa3a61ff1dbdcdc220f/yarl-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:d1d2532b340b692880261c15aee4dc94dd22ca5d61b9db9a8a361953d36410b1", size = 76719 },
-    { url = "https://files.pythonhosted.org/packages/7b/cd/a921122610dedfed94e494af18e85aae23e93274c00ca464cfc591c8f4fb/yarl-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0d2454f0aef65ea81037759be5ca9947539667eecebca092733b2eb43c965a81", size = 129561 },
-    { url = "https://files.pythonhosted.org/packages/7c/a0/887c93020c788f249c24eaab288c46e5fed4d2846080eaf28ed3afc36e8d/yarl-1.9.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:44d8ffbb9c06e5a7f529f38f53eda23e50d1ed33c6c869e01481d3fafa6b8142", size = 81595 },
-    { url = "https://files.pythonhosted.org/packages/54/99/ed3c92c38f421ba6e36caf6aa91c34118771d252dce800118fa2f44d7962/yarl-1.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aaaea1e536f98754a6e5c56091baa1b6ce2f2700cc4a00b0d49eca8dea471074", size = 79400 },
-    { url = "https://files.pythonhosted.org/packages/ea/45/65801be625ef939acc8b714cf86d4a198c0646e80dc8970359d080c47204/yarl-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3777ce5536d17989c91696db1d459574e9a9bd37660ea7ee4d3344579bb6f129", size = 317397 },
-    { url = "https://files.pythonhosted.org/packages/06/91/9696601a8ba674c8f0c15035cc9e94ca31f541330364adcfd5a399f598bf/yarl-1.9.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fc5fc1eeb029757349ad26bbc5880557389a03fa6ada41703db5e068881e5f2", size = 327246 },
-    { url = "https://files.pythonhosted.org/packages/da/3e/bf25177b3618889bf067aacf01ef54e910cd569d14e2f84f5e7bec23bb82/yarl-1.9.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea65804b5dc88dacd4a40279af0cdadcfe74b3e5b4c897aa0d81cf86927fee78", size = 327321 },
-    { url = "https://files.pythonhosted.org/packages/28/1c/bdb3411467b805737dd2720b85fd082e49f59bf0cc12dc1dfcc80ab3d274/yarl-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa102d6d280a5455ad6a0f9e6d769989638718e938a6a0a2ff3f4a7ff8c62cc4", size = 322424 },
-    { url = "https://files.pythonhosted.org/packages/41/e9/53bc89f039df2824a524a2aa03ee0bfb8f0585b08949e7521f5eab607085/yarl-1.9.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09efe4615ada057ba2d30df871d2f668af661e971dfeedf0c159927d48bbeff0", size = 310868 },
-    { url = "https://files.pythonhosted.org/packages/79/cd/a78c3b0304a4a970b5ae3993f4f5f649443bc8bfa5622f244aed44c810ed/yarl-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:008d3e808d03ef28542372d01057fd09168419cdc8f848efe2804f894ae03e51", size = 323452 },
-    { url = "https://files.pythonhosted.org/packages/2e/5e/1c78eb05ae0efae08498fd7ab939435a29f12c7f161732e7fe327e5b8ca1/yarl-1.9.4-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6f5cb257bc2ec58f437da2b37a8cd48f666db96d47b8a3115c29f316313654ff", size = 313554 },
-    { url = "https://files.pythonhosted.org/packages/04/e0/0029563a8434472697aebb269fdd2ffc8a19e3840add1d5fa169ec7c56e3/yarl-1.9.4-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:992f18e0ea248ee03b5a6e8b3b4738850ae7dbb172cc41c966462801cbf62cf7", size = 331029 },
-    { url = "https://files.pythonhosted.org/packages/de/1b/7e6b1ad42ccc0ed059066a7ae2b6fd4bce67795d109a99ccce52e9824e96/yarl-1.9.4-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0e9d124c191d5b881060a9e5060627694c3bdd1fe24c5eecc8d5d7d0eb6faabc", size = 333839 },
-    { url = "https://files.pythonhosted.org/packages/85/8a/c364d6e2eeb4e128a5ee9a346fc3a09aa76739c0c4e2a7305989b54f174b/yarl-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3986b6f41ad22988e53d5778f91855dc0399b043fc8946d4f2e68af22ee9ff10", size = 328251 },
-    { url = "https://files.pythonhosted.org/packages/ec/9d/0da94b33b9fb89041e10f95a14a55b0fef36c60b6a1d5ff85a0c2ecb1a97/yarl-1.9.4-cp312-cp312-win32.whl", hash = "sha256:4b21516d181cd77ebd06ce160ef8cc2a5e9ad35fb1c5930882baff5ac865eee7", size = 70195 },
-    { url = "https://files.pythonhosted.org/packages/c5/f4/2fdc5a11503bc61818243653d836061c9ce0370e2dd9ac5917258a007675/yarl-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a9bd00dc3bc395a662900f33f74feb3e757429e545d831eef5bb280252631984", size = 76397 },
-    { url = "https://files.pythonhosted.org/packages/4d/05/4d79198ae568a92159de0f89e710a8d19e3fa267b719a236582eee921f4a/yarl-1.9.4-py3-none-any.whl", hash = "sha256:928cecb0ef9d5a7946eb6ff58417ad2fe9375762382f1bf5c55e61645f2c43ad", size = 31638 },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/52/e9766cc6c2eab7dd1e9749c52c9879317500b46fb97d4105223f86679f93/yarl-1.16.0.tar.gz", hash = "sha256:b6f687ced5510a9a2474bbae96a4352e5ace5fa34dc44a217b0537fec1db00b4", size = 176548 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/30/00b17348655202e4bd24f8d79cd062888e5d3bdbf2ba726615c5d21b54a5/yarl-1.16.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32468f41242d72b87ab793a86d92f885355bcf35b3355aa650bfa846a5c60058", size = 140016 },
+    { url = "https://files.pythonhosted.org/packages/a5/15/9b7b85b72b81f180689257b2bb6e54d5d0764a399679aa06d5dec8ca6e2e/yarl-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:234f3a3032b505b90e65b5bc6652c2329ea7ea8855d8de61e1642b74b4ee65d2", size = 92953 },
+    { url = "https://files.pythonhosted.org/packages/31/41/91848bbb76789336d3b786ff144030001b5027b17729b3afa32da668f5b0/yarl-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a0296040e5cddf074c7f5af4a60f3fc42c0237440df7bcf5183be5f6c802ed5", size = 90793 },
+    { url = "https://files.pythonhosted.org/packages/6c/99/f1ada764e350ab054e14902f3f68589a7d77469ac47fbc512aa1a78a2f35/yarl-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de6c14dd7c7c0badba48157474ea1f03ebee991530ba742d381b28d4f314d6f3", size = 313155 },
+    { url = "https://files.pythonhosted.org/packages/75/fd/998ccdb489ca97d9073d882265203a2fae4c5bff30eb9b8a0bbbed7aef2b/yarl-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b140e532fe0266003c936d017c1ac301e72ee4a3fd51784574c05f53718a55d8", size = 328624 },
+    { url = "https://files.pythonhosted.org/packages/2d/5d/395bbae1f509f64e6d26b7ffffff178d70c5480f15af735dfb0afb8f0dc5/yarl-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:019f5d58093402aa8f6661e60fd82a28746ad6d156f6c5336a70a39bd7b162b9", size = 325163 },
+    { url = "https://files.pythonhosted.org/packages/1d/25/65601d336189d122483f5ff0276b08278fa4778f833458cfcac5c6eddc87/yarl-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c42998fd1cbeb53cd985bff0e4bc25fbe55fd6eb3a545a724c1012d69d5ec84", size = 318076 },
+    { url = "https://files.pythonhosted.org/packages/50/bb/0c9692ec457c1ed023654a9fba6d0c69a20c79b56275d972f6a24ab18547/yarl-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c7c30fb38c300fe8140df30a046a01769105e4cf4282567a29b5cdb635b66c4", size = 309551 },
+    { url = "https://files.pythonhosted.org/packages/a5/2f/d0ced2050a203241a3f2e05c5bb86038b071f216897defd824dd85333f9e/yarl-1.16.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e49e0fd86c295e743fd5be69b8b0712f70a686bc79a16e5268386c2defacaade", size = 317678 },
+    { url = "https://files.pythonhosted.org/packages/46/93/b7359aa2bd0567eca72491cd20059744ed6ee00f08cd58c861243f656a90/yarl-1.16.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:b9ca7b9147eb1365c8bab03c003baa1300599575effad765e0b07dd3501ea9af", size = 317003 },
+    { url = "https://files.pythonhosted.org/packages/87/18/77ef4d45d19ecafad0f7c07d5cf13a757a90122383494bc5a3e8ee68e2f2/yarl-1.16.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:27e11db3f1e6a51081a981509f75617b09810529de508a181319193d320bc5c7", size = 322795 },
+    { url = "https://files.pythonhosted.org/packages/28/a9/b38880bf79665d1c8a3d4c09d6f7a686a50f8c74caf07603a2b8e5314038/yarl-1.16.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8994c42f4ca25df5380ddf59f315c518c81df6a68fed5bb0c159c6cb6b92f120", size = 337022 },
+    { url = "https://files.pythonhosted.org/packages/e9/79/865788b297fc17117e3ff6ea74d5f864185085d61adc3364444732095254/yarl-1.16.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:542fa8e09a581bcdcbb30607c7224beff3fdfb598c798ccd28a8184ffc18b7eb", size = 338357 },
+    { url = "https://files.pythonhosted.org/packages/bd/5e/c5cba528448f73c7035c9d3c07261b54312d8caa8372eeeff5e1f07e43ec/yarl-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2bd6a51010c7284d191b79d3b56e51a87d8e1c03b0902362945f15c3d50ed46b", size = 330470 },
+    { url = "https://files.pythonhosted.org/packages/1a/e4/90757595d81ec328ad94afa62d0724903a6c72b76e0ee9c9af9d8a399dd2/yarl-1.16.0-cp310-cp310-win32.whl", hash = "sha256:178ccb856e265174a79f59721031060f885aca428983e75c06f78aa24b91d929", size = 82967 },
+    { url = "https://files.pythonhosted.org/packages/01/5a/b82ec5e7557b0d938b9475cbb5dcbb1f98c8601101188d79e423dc215cd0/yarl-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:fe8bba2545427418efc1929c5c42852bdb4143eb8d0a46b09de88d1fe99258e7", size = 89159 },
+    { url = "https://files.pythonhosted.org/packages/0a/00/b29affe83de95e403f8a2a669b5a33f1e7dfe686264008100052eb0b05fd/yarl-1.16.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d8643975a0080f361639787415a038bfc32d29208a4bf6b783ab3075a20b1ef3", size = 140120 },
+    { url = "https://files.pythonhosted.org/packages/3f/22/bcc9799950281a5d4f646536854839ccdbb965e900827ef0750680f81faf/yarl-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:676d96bafc8c2d0039cea0cd3fd44cee7aa88b8185551a2bb93354668e8315c2", size = 92956 },
+    { url = "https://files.pythonhosted.org/packages/33/0f/1b76d853d9d921d68bd9991648be17d34e7ac51e2e20e7658f8ee7e2e2ad/yarl-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d9525f03269e64310416dbe6c68d3b23e5d34aaa8f47193a1c45ac568cecbc49", size = 90891 },
+    { url = "https://files.pythonhosted.org/packages/61/19/3666d990c24aae98c748e2c262adc9b3a71e38834df007ac5317f4bbd789/yarl-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b37d5ec034e668b22cf0ce1074d6c21fd2a08b90d11b1b73139b750a8b0dd97", size = 338857 },
+    { url = "https://files.pythonhosted.org/packages/a0/3d/54acbb3cdfcfea03d6a3535cff1e060a2de23e419a4e3955c9661171b8a8/yarl-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4f32c4cb7386b41936894685f6e093c8dfaf0960124d91fe0ec29fe439e201d0", size = 354005 },
+    { url = "https://files.pythonhosted.org/packages/15/98/cd9fe3938422c88775c94578a6c145aca89ff8368ff64e6032213ac12403/yarl-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5b8e265a0545637492a7e12fd7038370d66c9375a61d88c5567d0e044ded9202", size = 351195 },
+    { url = "https://files.pythonhosted.org/packages/e2/13/b6eff6ea1667aee948ecd6b1c8fb6473234f8e48f49af97be93251869c51/yarl-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:789a3423f28a5fff46fbd04e339863c169ece97c827b44de16e1a7a42bc915d2", size = 342789 },
+    { url = "https://files.pythonhosted.org/packages/fe/05/d98e65ea74a7e44bb033b2cf5bcc16edc1d5212bdc5ca7fbb5e380d89f8e/yarl-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f1d1f45e3e8d37c804dca99ab3cf4ab3ed2e7a62cd82542924b14c0a4f46d243", size = 336478 },
+    { url = "https://files.pythonhosted.org/packages/7d/47/43de2e94b75f36d84733a35c807d0e33aaf084e98f32e2cbc685102f4ba4/yarl-1.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:621280719c4c5dad4c1391160a9b88925bb8b0ff6a7d5af3224643024871675f", size = 346008 },
+    { url = "https://files.pythonhosted.org/packages/e2/de/9c2f900ec5e2f2e20329cfe7dcd9452e326d08cb5ecd098c2d4e9987b65c/yarl-1.16.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ed097b26f18a1f5ff05f661dc36528c5f6735ba4ce8c9645e83b064665131349", size = 343745 },
+    { url = "https://files.pythonhosted.org/packages/56/cd/b014dce22e37b77caa37f998c6c47434fd78d01e7be07119629f369f5ee1/yarl-1.16.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:2f1fe2b2e3ee418862f5ebc0c0083c97f6f6625781382f828f6d4e9b614eba9b", size = 349705 },
+    { url = "https://files.pythonhosted.org/packages/07/17/bb191a26f7189423964e008ccb5146ce5258454ef3979f9d4c6860d282c7/yarl-1.16.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:87dd10bc0618991c66cee0cc65fa74a45f4ecb13bceec3c62d78ad2e42b27a16", size = 360767 },
+    { url = "https://files.pythonhosted.org/packages/19/09/7d777369e151991b708a5b35280ea7444621d65af5f0545bcdce5d840867/yarl-1.16.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:4199db024b58a8abb2cfcedac7b1292c3ad421684571aeb622a02f242280e8d6", size = 364755 },
+    { url = "https://files.pythonhosted.org/packages/00/32/7558997d1d2e53dab15f6db5db49fc6b412b63ede3cb8314e5dd7cff14fe/yarl-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:99a9dcd4b71dd5f5f949737ab3f356cfc058c709b4f49833aeffedc2652dac56", size = 357087 },
+    { url = "https://files.pythonhosted.org/packages/28/20/c49a95a30c57224e5fb0fc83235295684b041300ce508b71821cb042527d/yarl-1.16.0-cp311-cp311-win32.whl", hash = "sha256:a9394c65ae0ed95679717d391c862dece9afacd8fa311683fc8b4362ce8a410c", size = 83030 },
+    { url = "https://files.pythonhosted.org/packages/75/e3/2a746721d6f32886d9bafccdb80174349f180ccae0a287f25ba4312a2618/yarl-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:5b9101f528ae0f8f65ac9d64dda2bb0627de8a50344b2f582779f32fda747c1d", size = 89616 },
+    { url = "https://files.pythonhosted.org/packages/3a/be/82f696c8ce0395c37f62b955202368086e5cc114d5bb9cb1b634cff5e01d/yarl-1.16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4ffb7c129707dd76ced0a4a4128ff452cecf0b0e929f2668ea05a371d9e5c104", size = 141230 },
+    { url = "https://files.pythonhosted.org/packages/38/60/45caaa748b53c4b0964f899879fcddc41faa4e0d12c6f0ae3311e8c151ff/yarl-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1a5e9d8ce1185723419c487758d81ac2bde693711947032cce600ca7c9cda7d6", size = 93515 },
+    { url = "https://files.pythonhosted.org/packages/54/bd/33aaca2f824dc1d630729e16e313797e8b24c8f7b6803307e5394274e443/yarl-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d743e3118b2640cef7768ea955378c3536482d95550222f908f392167fe62059", size = 91441 },
+    { url = "https://files.pythonhosted.org/packages/af/fa/1ce8ca85489925aabdb8d2e7bbeaf74e7d3e6ac069779d6d6b9c7c62a8ed/yarl-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26768342f256e6e3c37533bf9433f5f15f3e59e3c14b2409098291b3efaceacb", size = 330871 },
+    { url = "https://files.pythonhosted.org/packages/f1/2a/a8110a225e498b87315827f8b61d24de35f86041834cf8c9c5544380c46b/yarl-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d1b0796168b953bca6600c5f97f5ed407479889a36ad7d17183366260f29a6b9", size = 340641 },
+    { url = "https://files.pythonhosted.org/packages/d0/64/20cd1cb1f60b3ff49e7d75c1a2083352e7c5939368aafa960712c9e53797/yarl-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:858728086914f3a407aa7979cab743bbda1fe2bdf39ffcd991469a370dd7414d", size = 340245 },
+    { url = "https://files.pythonhosted.org/packages/77/a8/7f38bbefb22eb925a68ad1d8193b05f51515614a6c0ebcadf26e9ae5e5ad/yarl-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5570e6d47bcb03215baf4c9ad7bf7c013e56285d9d35013541f9ac2b372593e7", size = 336054 },
+    { url = "https://files.pythonhosted.org/packages/b4/a6/ac633ea3ea0c4eb1057e6800db1d077e77493b4b3449a4a97b2fbefadef4/yarl-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66ea8311422a7ba1fc79b4c42c2baa10566469fe5a78500d4e7754d6e6db8724", size = 324405 },
+    { url = "https://files.pythonhosted.org/packages/93/cd/4fc87ce9b0df7afb610ffb904f4aef25f59e0ad40a49da19a475facf98b7/yarl-1.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:649bddcedee692ee8a9b7b6e38582cb4062dc4253de9711568e5620d8707c2a3", size = 342235 },
+    { url = "https://files.pythonhosted.org/packages/9f/bc/38bae4b716da1206849d88e167d3d2c5695ae9b418a3915220947593e5ca/yarl-1.16.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3a91654adb7643cb21b46f04244c5a315a440dcad63213033826549fa2435f71", size = 340835 },
+    { url = "https://files.pythonhosted.org/packages/dc/0f/b9efbc0075916a450cbad41299dff3bdd3393cb1d8378bb831c4a6a836e1/yarl-1.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b439cae82034ade094526a8f692b9a2b5ee936452de5e4c5f0f6c48df23f8604", size = 344323 },
+    { url = "https://files.pythonhosted.org/packages/87/6d/dc483ea1574005f14ef4c5f5f726cf60327b07ac83bd417d98db23e5285f/yarl-1.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:571f781ae8ac463ce30bacebfaef2c6581543776d5970b2372fbe31d7bf31a07", size = 355112 },
+    { url = "https://files.pythonhosted.org/packages/10/22/3b7c3728d26b3cc295c51160ae4e2612ab7d3f9df30beece44bf72861730/yarl-1.16.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:aa7943f04f36d6cafc0cf53ea89824ac2c37acbdb4b316a654176ab8ffd0f968", size = 361506 },
+    { url = "https://files.pythonhosted.org/packages/ad/8d/b7b5d43cf22a020b564ddf7502d83df150d797e34f18f6bf5fe0f12cbd91/yarl-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1a5cf32539373ff39d97723e39a9283a7277cbf1224f7aef0c56c9598b6486c3", size = 355746 },
+    { url = "https://files.pythonhosted.org/packages/d9/a6/a2098bf3f09d38eb540b2b192e180d9d41c2ff64b692783db2188f0a55e3/yarl-1.16.0-cp312-cp312-win32.whl", hash = "sha256:a5b6c09b9b4253d6a208b0f4a2f9206e511ec68dce9198e0fbec4f160137aa67", size = 82675 },
+    { url = "https://files.pythonhosted.org/packages/ed/a6/0a54b382cfc336e772b72681d6816a99222dc2d21876e649474973b8d244/yarl-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:1208ca14eed2fda324042adf8d6c0adf4a31522fa95e0929027cd487875f0240", size = 88986 },
+    { url = "https://files.pythonhosted.org/packages/57/56/eef0a7050fcd11d70c536453f014d4b2dfd83fb934c9857fa1a912832405/yarl-1.16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5ace0177520bd4caa99295a9b6fb831d0e9a57d8e0501a22ffaa61b4c024283", size = 139373 },
+    { url = "https://files.pythonhosted.org/packages/3f/b2/88eb9e98c5a4549606ebf673cba0d701f13ec855021b781f8e3fd7c04190/yarl-1.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7118bdb5e3ed81acaa2095cba7ec02a0fe74b52a16ab9f9ac8e28e53ee299732", size = 92759 },
+    { url = "https://files.pythonhosted.org/packages/95/1d/c3b794ef82a3b1894a9f8fc1012b073a85464b95c646ac217e8013137ea3/yarl-1.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38fec8a2a94c58bd47c9a50a45d321ab2285ad133adefbbadf3012c054b7e656", size = 90573 },
+    { url = "https://files.pythonhosted.org/packages/7f/35/39a5dcbf7ef320607bcfd1c0498ce348181b97627c3901139b429d806cf1/yarl-1.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8791d66d81ee45866a7bb15a517b01a2bcf583a18ebf5d72a84e6064c417e64b", size = 332461 },
+    { url = "https://files.pythonhosted.org/packages/36/29/2a468c8b44aa750d0f3416bc24d58464237b402388a8f03091a58537274a/yarl-1.16.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1cf936ba67bc6c734f3aa1c01391da74ab7fc046a9f8bbfa230b8393b90cf472", size = 343045 },
+    { url = "https://files.pythonhosted.org/packages/91/6a/002300c86ed7ef3cd5ac890a0e17101aee06c64abe2e43f9dad85bc32c70/yarl-1.16.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1aab176dd55b59f77a63b27cffaca67d29987d91a5b615cbead41331e6b7428", size = 344592 },
+    { url = "https://files.pythonhosted.org/packages/ea/69/ca4228e0f560f0c5817e0ebd789690c78ab17e6a876b38a5d000889b2f63/yarl-1.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:995d0759004c08abd5d1b81300a91d18c8577c6389300bed1c7c11675105a44d", size = 338127 },
+    { url = "https://files.pythonhosted.org/packages/81/df/32eea6e5199f7298ec15cf708895f35a7d2899177ed556e6bdf6819462aa/yarl-1.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1bc22e00edeb068f71967ab99081e9406cd56dbed864fc3a8259442999d71552", size = 326127 },
+    { url = "https://files.pythonhosted.org/packages/9a/11/1a888df53acd3d1d4b8dc803e0c8ed4a4b6cabc2abe19e4de31aa6b86857/yarl-1.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:35b4f7842154176523e0a63c9b871168c69b98065d05a4f637fce342a6a2693a", size = 345219 },
+    { url = "https://files.pythonhosted.org/packages/34/88/44fd8b372c4c50c010e66c62bfb34e67d6bd217c973599e0ee03f74e74ec/yarl-1.16.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:7ace71c4b7a0c41f317ae24be62bb61e9d80838d38acb20e70697c625e71f120", size = 339742 },
+    { url = "https://files.pythonhosted.org/packages/ee/c8/eaa53bd40db61265cec09d3c432d8bcd8ab9fd3a9fc5b0afdd13ab27b4a8/yarl-1.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8f639e3f5795a6568aa4f7d2ac6057c757dcd187593679f035adbf12b892bb00", size = 344695 },
+    { url = "https://files.pythonhosted.org/packages/1b/8f/b00aa91bd3bc8ef41781b13ac967c9c5c2e3ca0c516cffdd15ac035a1839/yarl-1.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e8be3aff14f0120ad049121322b107f8a759be76a6a62138322d4c8a337a9e2c", size = 353617 },
+    { url = "https://files.pythonhosted.org/packages/f1/88/8e86a28a840b8dc30c880fdde127f9610c56e55796a2cc969949b4a60fe7/yarl-1.16.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:122d8e7986043d0549e9eb23c7fd23be078be4b70c9eb42a20052b3d3149c6f2", size = 359911 },
+    { url = "https://files.pythonhosted.org/packages/ee/61/9d59f7096fd72d5f68168ed8134773982ee48a8cb4009ecb34344e064999/yarl-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0fd9c227990f609c165f56b46107d0bc34553fe0387818c42c02f77974402c36", size = 358847 },
+    { url = "https://files.pythonhosted.org/packages/f7/25/c323097b066a2b5a554f77e27a35bc067aebfcd3a001a0a3a6bc14190460/yarl-1.16.0-cp313-cp313-win32.whl", hash = "sha256:595ca5e943baed31d56b33b34736461a371c6ea0038d3baec399949dd628560b", size = 308302 },
+    { url = "https://files.pythonhosted.org/packages/52/76/ca2c3de3511a127fc4124723e7ccc641aef5e0ec56c66d25dbd11f19ab84/yarl-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:921b81b8d78f0e60242fb3db615ea3f368827a76af095d5a69f1c3366db3f596", size = 314035 },
+    { url = "https://files.pythonhosted.org/packages/fb/f7/87a32867ddc1a9817018bfd6109ee57646a543acf0d272843d8393e575f9/yarl-1.16.0-py3-none-any.whl", hash = "sha256:e6980a558d8461230c457218bd6c92dfc1d10205548215c2c21d79dc8d0a96f3", size = 43746 },
 ]
 
 [[package]]
@@ -5371,9 +5678,9 @@ wheels = [
 
 [[package]]
 name = "zipp"
-version = "3.20.1"
+version = "3.20.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d3/8b/1239a3ef43a0d0ebdca623fb6413bc7702c321400c5fdd574f0b7aa0fbb4/zipp-3.20.1.tar.gz", hash = "sha256:c22b14cc4763c5a5b04134207736c107db42e9d3ef2d9779d465f5f1bcba572b", size = 23848 }
+sdist = { url = "https://files.pythonhosted.org/packages/54/bf/5c0000c44ebc80123ecbdddba1f5dcd94a5ada602a9c225d84b5aaa55e86/zipp-3.20.2.tar.gz", hash = "sha256:bc9eb26f4506fda01b81bcde0ca78103b6e62f991b381fec825435c836edbc29", size = 24199 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/07/9e/c96f7a4cd0bf5625bb409b7e61e99b1130dc63a98cb8b24aeabae62d43e8/zipp-3.20.1-py3-none-any.whl", hash = "sha256:9960cd8967c8f85a56f920d5d507274e74f9ff813a0ab8889a5b5be2daf44064", size = 8988 },
+    { url = "https://files.pythonhosted.org/packages/62/8b/5ba542fa83c90e09eac972fc9baca7a88e7e7ca4b221a89251954019308b/zipp-3.20.2-py3-none-any.whl", hash = "sha256:a817ac80d6cf4b23bf7f2828b7cabf326f15a001bea8b1f9b49631780ba28350", size = 9200 },
 ]

From a626d7cf18e1a8e2fac47158291ee5176cf80bd9 Mon Sep 17 00:00:00 2001
From: Leonardo Pinheiro 
Date: Sun, 27 Oct 2024 15:13:52 +1000
Subject: [PATCH 038/173] replace assertion with valueerror (#3974)

Co-authored-by: Leonardo Pinheiro 
---
 .../src/autogen_core/components/tools/_function_tool.py        | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py b/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
index 131cea748358..e537deeba9c6 100644
--- a/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
+++ b/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
@@ -46,5 +46,6 @@ async def run(self, args: BaseModel, cancellation_token: CancellationToken) -> A
                 cancellation_token.link_future(future)
                 result = await future
 
-        assert isinstance(result, self.return_type())
+        if not isinstance(result, self.return_type()):
+            raise ValueError(f"Expected return type {self.return_type()}, got {type(result)}")
         return result

From c06f8d3aa3d8849157443265e50810be3dc3778d Mon Sep 17 00:00:00 2001
From: Will <48752207+Ucoming@users.noreply.github.com>
Date: Mon, 28 Oct 2024 23:17:49 +0800
Subject: [PATCH 039/173] Update agents.ipynb (#3979)

a mistake about in User Guide sector
---
 .../src/user-guide/agentchat-user-guide/tutorial/agents.ipynb   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index f905d7618678..b6da9dd8801b 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -230,7 +230,7 @@
     "\n",
     "A common example is an agent that can be part of a team but primarily is driven by human input. Other examples include agents that respond with specific text, tool or function calls. \n",
     "\n",
-    "In the example below we show hot to implement a `UserProxyAgent` - an agent that asks the user to enter some text and then returns that message as a response.  "
+    "In the example below we show how to implement a `UserProxyAgent` - an agent that asks the user to enter some text and then returns that message as a response.  "
    ]
   },
   {

From 0052e8179ddc67cbf7a203d378609d41514acb3b Mon Sep 17 00:00:00 2001
From: Mohammad Mazraeh 
Date: Mon, 28 Oct 2024 16:59:58 +0000
Subject: [PATCH 040/173] Add sample distributed group chat notebook (#3759)

* first notebook for distributed rock, paper and scissors

* add distributed group chat notebook

* fix formatting

* fix pipeline issues

* fix formatting issue

* promote distributed group chat notebook into a multiple files

* fix docs

* fix docs

* fix pyright

* Apply suggestions from code review

Add PR review suggestions

Co-authored-by: Eric Zhu 

* improving group chat manager from round robin to LLM based

Signed-off-by: Mohammad Mazraeh 

* remove lfs file to fix

Signed-off-by: Mohammad Mazraeh 

* add gut back using lfs

Signed-off-by: Mohammad Mazraeh 

* re-add gif using lfs

Signed-off-by: Mohammad Mazraeh 

* remove gitattributes

Signed-off-by: Mohammad Mazraeh 

* redo git lfs add

---------

Signed-off-by: Mohammad Mazraeh 
Co-authored-by: Ryan Sweet 
Co-authored-by: Eric Zhu 
---
 .../framework/distributed-agent-runtime.ipynb |  12 ++
 .../distributed-group-chat/.gitattributes     |   1 +
 .../samples/distributed-group-chat/README.md  |  96 ++++++++++++
 .../samples/distributed-group-chat/_agents.py | 138 ++++++++++++++++++
 .../samples/distributed-group-chat/_types.py  |  49 +++++++
 .../samples/distributed-group-chat/_utils.py  |  34 +++++
 .../distributed-group-chat/config.yaml        |  28 ++++
 .../samples/distributed-group-chat/run.sh     |  26 ++++
 .../run_editor_agent.py                       |  45 ++++++
 .../run_group_chat_manager.py                 |  64 ++++++++
 .../distributed-group-chat/run_host.py        |  23 +++
 .../run_writer_agent.py                       |  45 ++++++
 12 files changed, 561 insertions(+)
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/README.md
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/_agents.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/_types.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/_utils.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/config.yaml
 create mode 100755 python/packages/autogen-core/samples/distributed-group-chat/run.sh
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/run_host.py
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
index fde32e69ca4f..29034112376f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
@@ -178,6 +178,18 @@
     "# To keep the host service running until a termination signal (e.g., SIGTERM)\n",
     "# await host.stop_when_signal()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Next Steps\n",
+    "To see complete examples of using distributed runtime, please take a look at the following samples:\n",
+    "\n",
+    "- [Distributed Workers](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/worker)  \n",
+    "- [Distributed Semantic Router](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/semantic_router)  \n",
+    "- [Distributed Group Chat](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/distributed_group_chat)  \n"
+   ]
   }
  ],
  "metadata": {
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes b/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
new file mode 100644
index 000000000000..6884bd468147
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
@@ -0,0 +1 @@
+distributed_group_chat.gif filter=lfs diff=lfs merge=lfs -text
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/README.md b/python/packages/autogen-core/samples/distributed-group-chat/README.md
new file mode 100644
index 000000000000..b62085ae9bdd
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/README.md
@@ -0,0 +1,96 @@
+# Distributed Group Chat
+
+from autogen_core.application import WorkerAgentRuntimeHost
+
+This example runs a gRPC server using [WorkerAgentRuntimeHost](../../src/autogen_core/application/_worker_runtime_host.py) and instantiates three distributed runtimes using [WorkerAgentRuntime](../../src/autogen_core/application/_worker_runtime.py). These runtimes connect to the gRPC server as hosts and facilitate a round-robin distributed group chat. This example leverages the [Azure OpenAI Service](https://azure.microsoft.com/en-us/products/ai-services/openai-service) to implement writer and editor LLM agents. Agents are instructed to provide concise answers, as the primary goal of this example is to showcase the distributed runtime rather than the quality of agent responses.
+
+## Setup
+
+### Setup Python Environment
+
+You should run this project using the same virtual environment created for it. Instructions are provided in the [README](../../../../../../../../README.md).
+
+### General Configuration
+
+In the `config.yaml` file, you can configure the `client_config` section to connect the code to the Azure OpenAI Service.
+
+### Authentication
+
+The recommended method for authentication is through Azure Active Directory (AAD), as explained in [Model Clients - Azure AI](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/framework/model-clients.html#azure-openai). This example works with both the AAD approach (recommended) and by providing the `api_key` in the `config.yaml` file.
+
+## Run
+
+### Run Through Scripts
+
+The [run.sh](./run.sh) file provides commands to run the host and agents using [tmux](https://github.com/tmux/tmux/wiki). The steps for this approach are:
+
+1. Install tmux.
+2. Activate the Python environment: `source .venv/bin/activate`.
+3. Run the bash script: `./run.sh`.
+
+Here is a screen recording of the execution:
+
+![Distributed Group Chat Sample Run](./distributed_group_chat.gif)
+
+**Note**: Some `asyncio.sleep` commands have been added to the example code to make the `./run.sh` execution look sequential and visually easy to follow. In practice, these lines are not necessary.
+
+### Run Individual Files
+
+If you prefer to run Python files individually, follow these steps. Note that each step must be run in a different terminal process, and the virtual environment should be activated using `source .venv/bin/activate`.
+
+1. `python run_host.py`: Starts the host and listens for agent connections.
+2. `python run_editor.py`: Starts the editor agent and connects it to the host.
+3. `python run_writer.py`: Starts the writer agent and connects it to the host.
+4. `python run_group_chat_manager.py`: Starts the group chat manager and sends a message to initiate the writer agent.
+
+## What's Going On?
+
+The general flow of this example is as follows:
+
+1. The Group Chat Manager sends a `RequestToSpeak` request to the `writer_agent`.
+2. The `writer_agent` writes a short sentence into the group chat topic.
+3. The `editor_agent` receives the message in the group chat topic and updates its memory.
+4. The Group Chat Manager receives the message sent by the writer into the group chat simultaneously and sends the next participant, the `editor_agent`, a `RequestToSpeak` message.
+5. The `editor_agent` sends its feedback to the group chat topic.
+6. The `writer_agent` receives the feedback and updates its memory.
+7. The Group Chat Manager receives the message simultaneously and repeats the loop from step 1.
+
+Here is an illustration of the system developed in this example:
+
+```mermaid
+graph TD;
+    subgraph Host
+        A1[GRPC Server]
+        wt[Writer Topic]
+        et[Editor Topic]
+        gct[Group Chat Topic]
+    end
+
+    subgraph Distributed Writer Runtime
+        writer_agent[Writer Agent] --> A1
+        wt -.->|2 - Subscription| writer_agent
+        gct -.->|4 - Subscription| writer_agent
+        writer_agent -.->|3 - Publish: Group Chat Message| gct
+    end
+
+    subgraph Distributed Editor Runtime
+        editor_agent[Editor Agent] --> A1
+        et -.->|6 - Subscription| editor_agent
+        gct -.->|4 - Subscription| editor_agent
+        editor_agent -.->|7 - Publish: Group Chat Message| gct
+    end
+
+    subgraph Distributed Group Chat Manager Runtime
+        group_chat_manager[Group Chat Manager Agent] --> A1
+        gct -.->|4 - Subscription| group_chat_manager
+        group_chat_manager -.->|1 - Request To Speak| wt
+        group_chat_manager -.->|5 - Request To Speak| et
+    end
+
+    style wt fill:#beb2c3,color:#000
+    style et fill:#beb2c3,color:#000
+    style gct fill:#beb2c3,color:#000
+    style writer_agent fill:#b7c4d7,color:#000
+    style editor_agent fill:#b7c4d7,color:#000
+    style group_chat_manager fill:#b7c4d7,color:#000
+```
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/_agents.py b/python/packages/autogen-core/samples/distributed-group-chat/_agents.py
new file mode 100644
index 000000000000..968fd3b6667c
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/_agents.py
@@ -0,0 +1,138 @@
+from typing import List
+
+from _types import GroupChatMessage, RequestToSpeak
+from autogen_core.base import MessageContext
+from autogen_core.components import DefaultTopicId, RoutedAgent, message_handler
+from autogen_core.components.models import (
+    AssistantMessage,
+    ChatCompletionClient,
+    LLMMessage,
+    SystemMessage,
+    UserMessage,
+)
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+class BaseGroupChatAgent(RoutedAgent):
+    """A group chat participant using an LLM."""
+
+    def __init__(
+        self,
+        description: str,
+        group_chat_topic_type: str,
+        model_client: ChatCompletionClient,
+        system_message: str,
+    ) -> None:
+        super().__init__(description=description)
+        self._group_chat_topic_type = group_chat_topic_type
+        self._model_client = model_client
+        self._system_message = SystemMessage(system_message)
+        self._chat_history: List[LLMMessage] = []
+
+    @message_handler
+    async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:
+        self._chat_history.extend(
+            [
+                UserMessage(content=f"Transferred to {message.body.source}", source="system"),  # type: ignore[union-attr]
+                message.body,
+            ]
+        )
+
+    @message_handler
+    async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:
+        self._chat_history.append(
+            UserMessage(content=f"Transferred to {self.id.type}, adopt the persona immediately.", source="system")
+        )
+        completion = await self._model_client.create([self._system_message] + self._chat_history)
+        assert isinstance(completion.content, str)
+        self._chat_history.append(AssistantMessage(content=completion.content, source=self.id.type))
+        Console().print(Markdown(f"**{self.id.type}**: {completion.content}\n"))
+
+        await self.publish_message(
+            GroupChatMessage(body=UserMessage(content=completion.content, source=self.id.type)),
+            topic_id=DefaultTopicId(type=self._group_chat_topic_type),
+        )
+
+
+class GroupChatManager(RoutedAgent):
+    def __init__(
+        self,
+        model_client: ChatCompletionClient,
+        participant_topic_types: List[str],
+        participant_descriptions: List[str],
+        max_rounds: int = 3,
+    ) -> None:
+        super().__init__("Group chat manager")
+        self._model_client = model_client
+        self._num_rounds = 0
+        self._participant_topic_types = participant_topic_types
+        self._chat_history: List[GroupChatMessage] = []
+        self._max_rounds = max_rounds
+        self.console = Console()
+        self._participant_descriptions = participant_descriptions
+        self._previous_participant_topic_type: str | None = None
+
+    @message_handler
+    async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:
+        assert isinstance(message.body, UserMessage)
+
+        self._chat_history.append(message.body)  # type: ignore[reportargumenttype]
+
+        # Format message history.
+        messages: List[str] = []
+        for msg in self._chat_history:
+            if isinstance(msg.content, str):  # type: ignore[attr-defined]
+                messages.append(f"{msg.source}: {msg.content}")  # type: ignore[attr-defined]
+            elif isinstance(msg.content, list):  # type: ignore[attr-defined]
+                messages.append(f"{msg.source}: {', '.join(msg.content)}")  # type: ignore[attr-defined,reportUnknownArgumentType]
+        history = "\n".join(messages)
+        # Format roles.
+        roles = "\n".join(
+            [
+                f"{topic_type}: {description}".strip()
+                for topic_type, description in zip(
+                    self._participant_topic_types, self._participant_descriptions, strict=True
+                )
+                if topic_type != self._previous_participant_topic_type
+            ]
+        )
+        participants = str(
+            [
+                topic_type
+                for topic_type in self._participant_topic_types
+                if topic_type != self._previous_participant_topic_type
+            ]
+        )
+
+        selector_prompt = f"""You are in a role play game. The following roles are available:
+{roles}.
+Read the following conversation. Then select the next role from {participants} to play. Only return the role.
+
+{history}
+
+Read the above conversation. Then select the next role from {participants} to play. if you think it's enough talking (for example they have talked for {self._max_rounds} rounds), return 'FINISH'.
+"""
+        system_message = SystemMessage(selector_prompt)
+        completion = await self._model_client.create([system_message], cancellation_token=ctx.cancellation_token)
+        assert isinstance(completion.content, str)
+
+        if completion.content.upper() == "FINISH":
+            self.console.print(
+                Markdown(
+                    f"\n{'-'*80}\n Manager ({id(self)}): I think it's enough iterations on the story! Thanks for collaborating!"
+                )
+            )
+            return
+
+        selected_topic_type: str
+        for topic_type in self._participant_topic_types:
+            if topic_type.lower() in completion.content.lower():
+                selected_topic_type = topic_type
+                self._previous_participant_topic_type = selected_topic_type
+                self.console.print(
+                    Markdown(f"\n{'-'*80}\n Manager ({id(self)}): Asking `{selected_topic_type}` to speak")
+                )
+                await self.publish_message(RequestToSpeak(), DefaultTopicId(type=selected_topic_type))
+                return
+        raise ValueError(f"Invalid role selected: {completion.content}")
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/_types.py b/python/packages/autogen-core/samples/distributed-group-chat/_types.py
new file mode 100644
index 000000000000..343c264f1823
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/_types.py
@@ -0,0 +1,49 @@
+from autogen_core.components.models import (
+    LLMMessage,
+)
+from autogen_core.components.models.config import AzureOpenAIClientConfiguration
+from pydantic import BaseModel
+
+
+class GroupChatMessage(BaseModel):
+    """Implements a sample message sent by an LLM agent"""
+
+    body: LLMMessage
+
+
+class RequestToSpeak(BaseModel):
+    """Message type for agents to speak"""
+
+    pass
+
+
+# Define Host configuration model
+class HostConfig(BaseModel):
+    hostname: str
+    port: int
+
+    @property
+    def address(self) -> str:
+        return f"{self.hostname}:{self.port}"
+
+
+# Define GroupChatManager configuration model
+class GroupChatManagerConfig(BaseModel):
+    topic_type: str
+    max_rounds: int
+
+
+# Define WriterAgent configuration model
+class ChatAgentConfig(BaseModel):
+    topic_type: str
+    description: str
+    system_message: str
+
+
+# Define the overall AppConfig model
+class AppConfig(BaseModel):
+    host: HostConfig
+    group_chat_manager: GroupChatManagerConfig
+    writer_agent: ChatAgentConfig
+    editor_agent: ChatAgentConfig
+    client_config: AzureOpenAIClientConfiguration = None  # type: ignore[assignment] # This was required to do custom instantiation in `load_config``
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/_utils.py b/python/packages/autogen-core/samples/distributed-group-chat/_utils.py
new file mode 100644
index 000000000000..737bb8bda517
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/_utils.py
@@ -0,0 +1,34 @@
+import os
+from typing import Any, Iterable, Type
+
+import yaml
+from _types import AppConfig
+from autogen_core.base import MessageSerializer, try_get_known_serializers_for_type
+from autogen_core.components.models.config import AzureOpenAIClientConfiguration
+from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+
+
+def load_config(file_path: str = os.path.join(os.path.dirname(__file__), "config.yaml")) -> AppConfig:
+    model_client = {}
+    with open(file_path, "r") as file:
+        config_data = yaml.safe_load(file)
+        model_client = config_data["client_config"]
+        del config_data["client_config"]
+        app_config = AppConfig(**config_data)
+    # This was required as it couldn't automatically instantiate AzureOpenAIClientConfiguration
+
+    aad_params = {}
+    if len(model_client.get("api_key", "")) == 0:
+        aad_params["azure_ad_token_provider"] = get_bearer_token_provider(
+            DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
+        )
+
+    app_config.client_config = AzureOpenAIClientConfiguration(**model_client, **aad_params)  # type: ignore[typeddict-item]
+    return app_config
+
+
+def get_serializers(types: Iterable[Type[Any]]) -> list[MessageSerializer[Any]]:
+    serializers = []
+    for type in types:
+        serializers.extend(try_get_known_serializers_for_type(type))  # type: ignore
+    return serializers  # type: ignore [reportUnknownVariableType]
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/config.yaml b/python/packages/autogen-core/samples/distributed-group-chat/config.yaml
new file mode 100644
index 000000000000..26eaf5b3b38f
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/config.yaml
@@ -0,0 +1,28 @@
+host:
+  hostname: "localhost"
+  port: 50060
+
+group_chat_manager:
+  topic_type: "group_chat"
+  max_rounds: 7
+
+writer_agent:
+  topic_type: "Writer"
+  description: "Writer for creating any text content."
+  system_message: "You are a one sentence Writer and provide one line content each time"
+
+editor_agent:
+  topic_type: "Editor"
+  description: "Editor for planning and reviewing the content."
+  system_message: "You are an Editor. You provide just max 10 words as feedback on writers content."
+
+client_config:
+  model: "gpt-4o"
+  azure_endpoint: "https://{your-custom-endpoint}.openai.azure.com"
+  azure_deployment: "{your-azure-deployment}"
+  api_version: "2024-08-01-preview"
+  api_key: ""
+  model_capabilities:
+    vision: True
+    function_calling: True
+    json_output: True
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run.sh b/python/packages/autogen-core/samples/distributed-group-chat/run.sh
new file mode 100755
index 000000000000..615ca0189669
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# # Start a new tmux session named 'distributed_group_chat'
+tmux new-session -d -s distributed_group_chat
+
+# # Split the terminal into 2 vertical panes
+tmux split-window -h
+
+# # Split the left pane horizontally
+tmux select-pane -t distributed_group_chat:0.0
+tmux split-window -v 
+
+# # Split the right pane horizontally
+tmux select-pane -t distributed_group_chat:0.2
+tmux split-window -v 
+
+# Select the first pane to start
+tmux select-pane -t distributed_group_chat:0.0
+
+# Activate the virtual environment and run the scripts in each pane
+tmux send-keys -t distributed_group_chat:0.0 "python run_host.py" C-m
+tmux send-keys -t distributed_group_chat:0.2 "python run_writer_agent.py" C-m
+tmux send-keys -t distributed_group_chat:0.3 "python run_editor_agent.py" C-m
+tmux send-keys -t distributed_group_chat:0.1 "python run_group_chat_manager.py" C-m
+
+# # Attach to the session
+tmux attach-session -t distributed_group_chat
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py b/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
new file mode 100644
index 000000000000..8d72b631d1f8
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
@@ -0,0 +1,45 @@
+import asyncio
+import warnings
+
+from _agents import BaseGroupChatAgent
+from _types import AppConfig, GroupChatMessage, RequestToSpeak
+from _utils import get_serializers, load_config
+from autogen_core.application import WorkerAgentRuntime
+from autogen_core.components import (
+    TypeSubscription,
+)
+from autogen_core.components.models._openai_client import AzureOpenAIChatCompletionClient
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+async def main(config: AppConfig):
+    editor_agent_runtime = WorkerAgentRuntime(host_address=config.host.address)
+    editor_agent_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
+    await asyncio.sleep(4)
+    Console().print(Markdown("Starting **`Editor Agent`**"))
+    editor_agent_runtime.start()
+
+    editor_agent_type = await BaseGroupChatAgent.register(
+        editor_agent_runtime,
+        config.editor_agent.topic_type,
+        lambda: BaseGroupChatAgent(
+            description=config.editor_agent.description,
+            group_chat_topic_type=config.group_chat_manager.topic_type,
+            system_message=config.editor_agent.system_message,
+            model_client=AzureOpenAIChatCompletionClient(**config.client_config),
+        ),
+    )
+    await editor_agent_runtime.add_subscription(
+        TypeSubscription(topic_type=config.editor_agent.topic_type, agent_type=editor_agent_type.type)
+    )
+    await editor_agent_runtime.add_subscription(
+        TypeSubscription(topic_type=config.group_chat_manager.topic_type, agent_type=editor_agent_type.type)
+    )
+
+    await editor_agent_runtime.stop_when_signal()
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
+    asyncio.run(main(load_config()))
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py b/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
new file mode 100644
index 000000000000..41f5a91a050b
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
@@ -0,0 +1,64 @@
+import asyncio
+import warnings
+
+from _agents import GroupChatManager
+from _types import AppConfig, GroupChatMessage, RequestToSpeak
+from _utils import get_serializers, load_config
+from autogen_core.application import WorkerAgentRuntime
+from autogen_core.components import (
+    TypeSubscription,
+)
+from autogen_core.components._default_topic import DefaultTopicId
+from autogen_core.components.models import (
+    UserMessage,
+)
+from autogen_ext.models import AzureOpenAIChatCompletionClient
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+async def main(config: AppConfig):
+    # Add group chat manager runtime
+    group_chat_manager_runtime = WorkerAgentRuntime(host_address=config.host.address)
+
+    group_chat_manager_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
+    await asyncio.sleep(1)
+    Console().print(Markdown("Starting **`Group Chat Manager`**"))
+    group_chat_manager_runtime.start()
+
+    group_chat_manager_type = await GroupChatManager.register(
+        group_chat_manager_runtime,
+        "group_chat_manager",
+        lambda: GroupChatManager(
+            model_client=AzureOpenAIChatCompletionClient(**config.client_config),
+            participant_topic_types=[config.writer_agent.topic_type, config.editor_agent.topic_type],
+            participant_descriptions=[config.writer_agent.description, config.editor_agent.description],
+            max_rounds=config.group_chat_manager.max_rounds,
+        ),
+    )
+
+    await group_chat_manager_runtime.add_subscription(
+        TypeSubscription(topic_type=config.group_chat_manager.topic_type, agent_type=group_chat_manager_type.type)
+    )
+
+    # This is a simple way to make sure first message gets send after all of the agents have joined
+    await asyncio.sleep(5)
+    user_message: str = "Please write a one line story about the gingerbread in halloween!"
+    Console().print(f"Simulating User input in group chat topic:\n\t'{user_message}'")
+    await group_chat_manager_runtime.publish_message(
+        GroupChatMessage(
+            body=UserMessage(
+                content=user_message,
+                source="User",
+            )
+        ),
+        DefaultTopicId(type=config.group_chat_manager.topic_type),
+    )
+
+    await group_chat_manager_runtime.stop_when_signal()
+    Console().print("Manager left the chat!")
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
+    asyncio.run(main(load_config()))
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_host.py b/python/packages/autogen-core/samples/distributed-group-chat/run_host.py
new file mode 100644
index 000000000000..726d7022e91d
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_host.py
@@ -0,0 +1,23 @@
+import asyncio
+
+from _types import HostConfig
+from _utils import load_config
+from autogen_core.application import WorkerAgentRuntimeHost
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+# TODO: Use config.yaml
+async def main(host_config: HostConfig):
+    host = WorkerAgentRuntimeHost(address=host_config.address)
+    host.start()
+
+    console = Console()
+    console.print(
+        Markdown(f"**`Distributed Host`** is now running and listening for connection at **`{host_config.address}`**")
+    )
+    await host.stop_when_signal()
+
+
+if __name__ == "__main__":
+    asyncio.run(main(load_config().host))
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py b/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py
new file mode 100644
index 000000000000..041fe5728905
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py
@@ -0,0 +1,45 @@
+import asyncio
+import warnings
+
+from _agents import BaseGroupChatAgent
+from _types import AppConfig, GroupChatMessage, RequestToSpeak
+from _utils import get_serializers, load_config
+from autogen_core.application import WorkerAgentRuntime
+from autogen_core.components import (
+    TypeSubscription,
+)
+from autogen_ext.models import AzureOpenAIChatCompletionClient
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+async def main(config: AppConfig) -> None:
+    writer_agent_runtime = WorkerAgentRuntime(host_address=config.host.address)
+    writer_agent_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
+    await asyncio.sleep(3)
+    Console().print(Markdown("Starting **`Writer Agent`**"))
+
+    writer_agent_runtime.start()
+    writer_agent_type = await BaseGroupChatAgent.register(
+        writer_agent_runtime,
+        config.writer_agent.topic_type,
+        lambda: BaseGroupChatAgent(
+            description=config.writer_agent.description,
+            group_chat_topic_type=config.group_chat_manager.topic_type,
+            system_message=config.writer_agent.system_message,
+            model_client=AzureOpenAIChatCompletionClient(**config.client_config),
+        ),
+    )
+    await writer_agent_runtime.add_subscription(
+        TypeSubscription(topic_type=config.writer_agent.topic_type, agent_type=writer_agent_type.type)
+    )
+    await writer_agent_runtime.add_subscription(
+        TypeSubscription(topic_type=config.group_chat_manager.topic_type, agent_type=config.writer_agent.topic_type)
+    )
+
+    await writer_agent_runtime.stop_when_signal()
+
+
+if __name__ == "__main__":
+    warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
+    asyncio.run(main(load_config()))

From fda85e1295fd78ee0308ef57eaf6a8c55db642f1 Mon Sep 17 00:00:00 2001
From: Ikko Eltociear Ashimine 
Date: Tue, 29 Oct 2024 07:03:02 +0900
Subject: [PATCH 041/173] [.Net] update GeminiChatAgent.cs (#3608)

multipe -> multiple

Co-authored-by: Xiaoyun Zhang 
---
 dotnet/src/AutoGen.Gemini/GeminiChatAgent.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dotnet/src/AutoGen.Gemini/GeminiChatAgent.cs b/dotnet/src/AutoGen.Gemini/GeminiChatAgent.cs
index 07f8467abf90..fd9b40e6bec3 100644
--- a/dotnet/src/AutoGen.Gemini/GeminiChatAgent.cs
+++ b/dotnet/src/AutoGen.Gemini/GeminiChatAgent.cs
@@ -251,7 +251,7 @@ private GenerateContentRequest BuildChatRequest(IEnumerable messages,
         }
 
         // merge tools into one tool
-        // because multipe tools are currently not supported by Gemini
+        // because multiple tools are currently not supported by Gemini
         // see https://github.com/googleapis/python-aiplatform/issues/3771
         var aggregatedTool = new Tool
         {

From 6925cd436a3d4fd990d233739d3d1a2988046b3c Mon Sep 17 00:00:00 2001
From: Xiaoyun Zhang 
Date: Mon, 28 Oct 2024 17:01:03 -0700
Subject: [PATCH 042/173] mitigate dotnet interactive blocking issue (#3982)

Co-authored-by: Ryan Sweet 
---
 dotnet/AutoGen.sln                            | 51 ++++++++++---------
 .../DotnetInteractiveServiceTest.cs           | 10 +---
 2 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index b93ba566156f..1106ebf844f7 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -71,57 +71,59 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		spelling.dic = spelling.dic
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Agents", "src\Microsoft.AutoGen\Agents\Microsoft.AutoGen.Agents.csproj", "{FD87BD33-4616-460B-AC85-A412BA08BB78}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Agents", "src\Microsoft.AutoGen\Agents\Microsoft.AutoGen.Agents.csproj", "{FD87BD33-4616-460B-AC85-A412BA08BB78}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Abstractions", "src\Microsoft.AutoGen\Abstractions\Microsoft.AutoGen.Abstractions.csproj", "{E0C991D9-0DB8-471C-ADC9-5FB16E2A0106}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Abstractions", "src\Microsoft.AutoGen\Abstractions\Microsoft.AutoGen.Abstractions.csproj", "{E0C991D9-0DB8-471C-ADC9-5FB16E2A0106}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Extensions.SemanticKernel", "src\Microsoft.AutoGen\Extensions\SemanticKernel\Microsoft.AutoGen.Extensions.SemanticKernel.csproj", "{952827D4-8D4C-4327-AE4D-E8D25811EF35}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Extensions.SemanticKernel", "src\Microsoft.AutoGen\Extensions\SemanticKernel\Microsoft.AutoGen.Extensions.SemanticKernel.csproj", "{952827D4-8D4C-4327-AE4D-E8D25811EF35}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Extensions.CloudEvents", "src\Microsoft.AutoGen\Extensions\CloudEvents\Microsoft.AutoGen.Extensions.CloudEvents.csproj", "{21C9EC49-E848-4EAE-932F-0862D44F7A80}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Extensions.CloudEvents", "src\Microsoft.AutoGen\Extensions\CloudEvents\Microsoft.AutoGen.Extensions.CloudEvents.csproj", "{21C9EC49-E848-4EAE-932F-0862D44F7A80}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Runtime", "src\Microsoft.AutoGen\Runtime\Microsoft.AutoGen.Runtime.csproj", "{A905E29A-7110-497F-ADC5-2CE2A148FEA0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Runtime", "src\Microsoft.AutoGen\Runtime\Microsoft.AutoGen.Runtime.csproj", "{A905E29A-7110-497F-ADC5-2CE2A148FEA0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.ServiceDefaults", "src\Microsoft.AutoGen\ServiceDefaults\Microsoft.AutoGen.ServiceDefaults.csproj", "{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.ServiceDefaults", "src\Microsoft.AutoGen\ServiceDefaults\Microsoft.AutoGen.ServiceDefaults.csproj", "{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AgentChat", "AgentChat", "{668726B9-77BC-45CF-B576-0F0773BF1615}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Anthropic.Samples", "samples\AutoGen.Anthropic.Samples\AutoGen.Anthropic.Samples.csproj", "{84020C4A-933A-4693-9889-1B99304A7D76}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Anthropic.Samples", "samples\AutoGen.Anthropic.Samples\AutoGen.Anthropic.Samples.csproj", "{84020C4A-933A-4693-9889-1B99304A7D76}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.BasicSample", "samples\AutoGen.BasicSamples\AutoGen.BasicSample.csproj", "{5777515F-4053-42F9-AF2B-95D8D0F5384A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.BasicSample", "samples\AutoGen.BasicSamples\AutoGen.BasicSample.csproj", "{5777515F-4053-42F9-AF2B-95D8D0F5384A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Gemini.Sample", "samples\AutoGen.Gemini.Sample\AutoGen.Gemini.Sample.csproj", "{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Gemini.Sample", "samples\AutoGen.Gemini.Sample\AutoGen.Gemini.Sample.csproj", "{2E895A70-DF17-4C6C-BB84-F83B07C75AAD}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.Ollama.Sample", "samples\AutoGen.Ollama.Sample\AutoGen.Ollama.Sample.csproj", "{20DA47F2-F6C4-4503-B9D4-420994E28EF0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.Ollama.Sample", "samples\AutoGen.Ollama.Sample\AutoGen.Ollama.Sample.csproj", "{20DA47F2-F6C4-4503-B9D4-420994E28EF0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.OpenAI.Sample", "samples\AutoGen.OpenAI.Sample\AutoGen.OpenAI.Sample.csproj", "{1F86E48B-8674-4C20-A3BE-9431049A5BEC}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.OpenAI.Sample", "samples\AutoGen.OpenAI.Sample\AutoGen.OpenAI.Sample.csproj", "{1F86E48B-8674-4C20-A3BE-9431049A5BEC}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.SemanticKernel.Sample", "samples\AutoGen.SemanticKernel.Sample\AutoGen.SemanticKernel.Sample.csproj", "{CB8824F5-9475-451F-87E8-F2AEF2490A12}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.SemanticKernel.Sample", "samples\AutoGen.SemanticKernel.Sample\AutoGen.SemanticKernel.Sample.csproj", "{CB8824F5-9475-451F-87E8-F2AEF2490A12}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AutoGen.WebAPI.Sample", "samples\AutoGen.WebAPI.Sample\AutoGen.WebAPI.Sample.csproj", "{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGen.WebAPI.Sample", "samples\AutoGen.WebAPI.Sample\AutoGen.WebAPI.Sample.csproj", "{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "DevTeam", "DevTeam", "{05B9C173-6441-4DCA-9AC4-E897EF75F331}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.AgentHost", "samples\dev-team\DevTeam.AgentHost\DevTeam.AgentHost.csproj", "{462A357B-7BB9-4927-A9FD-4FB7675898E9}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.AgentHost", "samples\dev-team\DevTeam.AgentHost\DevTeam.AgentHost.csproj", "{462A357B-7BB9-4927-A9FD-4FB7675898E9}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Agents", "samples\dev-team\DevTeam.Agents\DevTeam.Agents.csproj", "{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Agents", "samples\dev-team\DevTeam.Agents\DevTeam.Agents.csproj", "{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.AppHost", "samples\dev-team\DevTeam.AppHost\DevTeam.AppHost.csproj", "{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.AppHost", "samples\dev-team\DevTeam.AppHost\DevTeam.AppHost.csproj", "{63280C12-3BE3-4C4E-805E-584CDC6BC1F5}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Backend", "samples\dev-team\DevTeam.Backend\DevTeam.Backend.csproj", "{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Backend", "samples\dev-team\DevTeam.Backend\DevTeam.Backend.csproj", "{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DevTeam.Shared", "samples\dev-team\DevTeam.Shared\DevTeam.Shared.csproj", "{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DevTeam.Shared", "samples\dev-team\DevTeam.Shared\DevTeam.Shared.csproj", "{01F5D7C3-41EB-409C-9B77-A945C07FA7E8}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Hello", "Hello", "{7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Backend", "samples\Hello\Backend\Backend.csproj", "{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Backend", "samples\Hello\Backend\Backend.csproj", "{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hello.AppHost", "samples\Hello\Hello.AppHost\Hello.AppHost.csproj", "{09A373A0-8169-409F-8C37-3FBC1654B122}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Hello.AppHost", "samples\Hello\Hello.AppHost\Hello.AppHost.csproj", "{09A373A0-8169-409F-8C37-3FBC1654B122}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAIAgents", "samples\Hello\HelloAIAgents\HelloAIAgents.csproj", "{A20B9894-F352-4338-872A-F215A241D43D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAIAgents", "samples\Hello\HelloAIAgents\HelloAIAgents.csproj", "{A20B9894-F352-4338-872A-F215A241D43D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAgent", "samples\Hello\HelloAgent\HelloAgent.csproj", "{8F7560CF-EEBB-4333-A69F-838CA40FD85D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAgent", "samples\Hello\HelloAgent\HelloAgent.csproj", "{8F7560CF-EEBB-4333-A69F-838CA40FD85D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AIModelClientHostingExtensions", "src\Microsoft.AutoGen\Extensions\AIModelClientHostingExtensions\AIModelClientHostingExtensions.csproj", "{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AIModelClientHostingExtensions", "src\Microsoft.AutoGen\Extensions\AIModelClientHostingExtensions\AIModelClientHostingExtensions.csproj", "{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sample", "sample", "{686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -373,6 +375,7 @@ Global
 		{21C9EC49-E848-4EAE-932F-0862D44F7A80} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
+		{668726B9-77BC-45CF-B576-0F0773BF1615} = {686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}
 		{84020C4A-933A-4693-9889-1B99304A7D76} = {668726B9-77BC-45CF-B576-0F0773BF1615}
 		{5777515F-4053-42F9-AF2B-95D8D0F5384A} = {668726B9-77BC-45CF-B576-0F0773BF1615}
 		{2E895A70-DF17-4C6C-BB84-F83B07C75AAD} = {668726B9-77BC-45CF-B576-0F0773BF1615}
@@ -380,11 +383,13 @@ Global
 		{1F86E48B-8674-4C20-A3BE-9431049A5BEC} = {668726B9-77BC-45CF-B576-0F0773BF1615}
 		{CB8824F5-9475-451F-87E8-F2AEF2490A12} = {668726B9-77BC-45CF-B576-0F0773BF1615}
 		{4385AFCF-AB4A-49B2-BEBA-D33C950E1EE6} = {668726B9-77BC-45CF-B576-0F0773BF1615}
+		{05B9C173-6441-4DCA-9AC4-E897EF75F331} = {686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}
 		{462A357B-7BB9-4927-A9FD-4FB7675898E9} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
 		{83BBB833-A2F0-4A4D-BA1B-8229FC9BCD4F} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
 		{63280C12-3BE3-4C4E-805E-584CDC6BC1F5} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
 		{EDA3EF83-FC7F-4BCF-945D-B893620EE4B1} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
 		{01F5D7C3-41EB-409C-9B77-A945C07FA7E8} = {05B9C173-6441-4DCA-9AC4-E897EF75F331}
+		{7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45} = {686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}
 		{C428C6E5-B0E5-4DA6-B0F7-43013D2ECE69} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{09A373A0-8169-409F-8C37-3FBC1654B122} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{A20B9894-F352-4338-872A-F215A241D43D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
diff --git a/dotnet/test/AutoGen.DotnetInteractive.Tests/DotnetInteractiveServiceTest.cs b/dotnet/test/AutoGen.DotnetInteractive.Tests/DotnetInteractiveServiceTest.cs
index efb82662e926..1d2becb7d84e 100644
--- a/dotnet/test/AutoGen.DotnetInteractive.Tests/DotnetInteractiveServiceTest.cs
+++ b/dotnet/test/AutoGen.DotnetInteractive.Tests/DotnetInteractiveServiceTest.cs
@@ -24,7 +24,8 @@ public DotnetInteractiveServiceTest(ITestOutputHelper output)
         }
 
         _interactiveService = new InteractiveService(_workingDir);
-        _interactiveService.StartAsync(_workingDir, default).Wait();
+        var isRunning = _interactiveService.StartAsync(_workingDir, default).Result;
+        isRunning.Should().BeTrue();
     }
 
     public void Dispose()
@@ -35,13 +36,6 @@ public void Dispose()
     [Fact]
     public async Task ItRunCSharpCodeSnippetTestsAsync()
     {
-        var cts = new CancellationTokenSource();
-        var isRunning = await _interactiveService.StartAsync(_workingDir, cts.Token);
-
-        isRunning.Should().BeTrue();
-
-        _interactiveService.IsRunning().Should().BeTrue();
-
         // test code snippet
         var hello_world = @"
 Console.WriteLine(""hello world"");

From 14846a3e84b4bbc6b019f67d7e28ebc83c47a986 Mon Sep 17 00:00:00 2001
From: Ryan Sweet 
Date: Mon, 28 Oct 2024 17:28:36 -0700
Subject: [PATCH 043/173] first draft of stateful persistence grains for each
 agent....  (#3954)

* adds Orleans persistence for AgentState
---
 dotnet/AutoGen.sln                            |   7 +
 .../HelloAgentState/HelloAgentState.csproj    |  21 +++
 .../samples/Hello/HelloAgentState/Program.cs  |  75 ++++++++++
 .../samples/Hello/HelloAgentState/README.md   | 138 ++++++++++++++++++
 .../{AgentState.cs => ChatState.cs}           |   5 +-
 .../Abstractions/MessageExtensions.cs         |  22 ++-
 .../Microsoft.AutoGen.Abstractions.csproj     |   1 -
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs |  14 +-
 .../Microsoft.AutoGen/Agents/AgentClient.cs   |  12 +-
 .../Microsoft.AutoGen/Agents/AgentContext.cs  |  11 +-
 .../Agents/AgentWorkerRuntime.cs              |  25 +++-
 .../Agents/Agents/AIAgent/InferenceAgent.cs   |   3 +-
 .../Agents/Agents/AIAgent/SKAiAgent.cs        |   1 +
 .../IOAgent/ConsoleAgent/ConsoleAgent.cs      |   2 +-
 .../Agents/IOAgent/FileAgent/FileAgent.cs     |   2 +-
 .../Agents/Agents/IOAgent/IOAgent.cs          |   8 +-
 .../Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs |   2 +-
 .../Microsoft.AutoGen/Agents/IAgentBase.cs    |  22 +++
 .../Microsoft.AutoGen/Agents/IAgentContext.cs |   2 +
 .../Runtime/AgentStateGrain.cs                |  20 ---
 .../Runtime/AgentWorkerHostingExtensions.cs   |  35 ++---
 .../Runtime/IAgentStateGrain.cs               |   7 -
 .../Runtime/IWorkerAgentGrain.cs              |   9 ++
 .../Runtime/IWorkerGateway.cs                 |   2 +
 .../Runtime/Microsoft.AutoGen.Runtime.csproj  |   9 ++
 .../Runtime/OrleansRuntimeHostingExtenions.cs |  85 +++++++++++
 .../Runtime/WorkerAgentGrain.cs               |  31 ++++
 .../Runtime/WorkerGateway.cs                  |  12 ++
 .../Runtime/WorkerGatewayService.cs           |  14 ++
 protos/agent_worker.proto                     |  23 +++
 .../_worker_runtime_host_servicer.py          |  14 ++
 .../application/protos/agent_worker_pb2.py    |  16 +-
 .../application/protos/agent_worker_pb2.pyi   |  76 ++++++++++
 .../protos/agent_worker_pb2_grpc.py           |  66 +++++++++
 .../protos/agent_worker_pb2_grpc.pyi          |  34 +++++
 35 files changed, 749 insertions(+), 77 deletions(-)
 create mode 100644 dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
 create mode 100644 dotnet/samples/Hello/HelloAgentState/Program.cs
 create mode 100644 dotnet/samples/Hello/HelloAgentState/README.md
 rename dotnet/src/Microsoft.AutoGen/Abstractions/{AgentState.cs => ChatState.cs} (65%)
 create mode 100644 dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Runtime/AgentStateGrain.cs
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Runtime/IAgentStateGrain.cs
 create mode 100644 dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
 create mode 100644 dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
 create mode 100644 dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 1106ebf844f7..83147d38dc7b 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -125,6 +125,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AIModelClientHostingExtensi
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sample", "sample", "{686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAgentState", "samples\Hello\HelloAgentState\HelloAgentState.csproj", "{64EF61E7-00A6-4E5E-9808-62E10993A0E5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -335,6 +337,10 @@ Global
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -395,6 +401,7 @@ Global
 		{A20B9894-F352-4338-872A-F215A241D43D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{8F7560CF-EEBB-4333-A69F-838CA40FD85D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
+		{64EF61E7-00A6-4E5E-9808-62E10993A0E5} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {93384647-528D-46C8-922C-8DB36A382F0B}
diff --git a/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj b/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
new file mode 100644
index 000000000000..eb2ba96d6644
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
@@ -0,0 +1,21 @@
+
+
+  
+    
+    
+    
+  
+
+  
+    
+    
+  
+
+  
+    Exe
+    net8.0
+    enable
+    enable
+  
+
+
diff --git a/dotnet/samples/Hello/HelloAgentState/Program.cs b/dotnet/samples/Hello/HelloAgentState/Program.cs
new file mode 100644
index 000000000000..6880bdd61679
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgentState/Program.cs
@@ -0,0 +1,75 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using Microsoft.AutoGen.Abstractions;
+using Microsoft.AutoGen.Agents;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+
+// send a message to the agent
+var app = await AgentsApp.PublishMessageAsync("HelloAgents", new NewMessageReceived
+{
+    Message = "World"
+}, local: false);
+
+await app.WaitForShutdownAsync();
+
+namespace Hello
+{
+    [TopicSubscription("HelloAgents")]
+    public class HelloAgent(
+        IAgentContext context,
+        [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
+            context,
+            typeRegistry),
+            ISayHello,
+            IHandle,
+            IHandle
+    {
+        private AgentState? State { get; set; }
+        public async Task Handle(NewMessageReceived item)
+        {
+            var response = await SayHello(item.Message).ConfigureAwait(false);
+            var evt = new Output
+            {
+                Message = response
+            }.ToCloudEvent(this.AgentId.Key);
+            var entry = "We said hello to " + item.Message;
+            await Store(new AgentState
+            {
+                AgentId = this.AgentId,
+                TextData = entry
+            }).ConfigureAwait(false);
+            await PublishEvent(evt).ConfigureAwait(false);
+            var goodbye = new ConversationClosed
+            {
+                UserId = this.AgentId.Key,
+                UserMessage = "Goodbye"
+            }.ToCloudEvent(this.AgentId.Key);
+            await PublishEvent(goodbye).ConfigureAwait(false);
+        }
+        public async Task Handle(ConversationClosed item)
+        {
+            State = await Read(this.AgentId).ConfigureAwait(false);
+            var read = State?.TextData ?? "No state data found";
+            var goodbye = $"{read}\n*********************  {item.UserId} said {item.UserMessage}  ************************";
+            var evt = new Output
+            {
+                Message = goodbye
+            }.ToCloudEvent(this.AgentId.Key);
+            await PublishEvent(evt).ConfigureAwait(false);
+            //sleep
+            await Task.Delay(10000).ConfigureAwait(false);
+            await AgentsApp.ShutdownAsync().ConfigureAwait(false);
+
+        }
+        public async Task SayHello(string ask)
+        {
+            var response = $"\n\n\n\n***************Hello {ask}**********************\n\n\n\n";
+            return response;
+        }
+    }
+    public interface ISayHello
+    {
+        public Task SayHello(string ask);
+    }
+}
diff --git a/dotnet/samples/Hello/HelloAgentState/README.md b/dotnet/samples/Hello/HelloAgentState/README.md
new file mode 100644
index 000000000000..06c4883182c9
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgentState/README.md
@@ -0,0 +1,138 @@
+# AutoGen 0.4 .NET Hello World Sample
+
+This [sample](Program.cs) demonstrates how to create a simple .NET console application that listens for an event and then orchestrates a series of actions in response.
+
+## Prerequisites
+
+To run this sample, you'll need: [.NET 8.0](https://dotnet.microsoft.com/en-us/) or later.
+Also recommended is the [GitHub CLI](https://cli.github.com/).
+
+## Instructions to run the sample
+
+```bash
+# Clone the repository
+gh repo clone microsoft/autogen
+cd dotnet/samples/Hello
+dotnet run
+```
+
+## Key Concepts
+
+This sample illustrates how to create your own agent that inherits from a base agent and listens for an event. It also shows how to use the SDK's App Runtime locally to start the agent and send messages.
+
+Flow Diagram:
+
+```mermaid
+%%{init: {'theme':'forest'}}%%
+graph LR;
+    A[Main] --> |"PublishEvent(NewMessage('World'))"| B{"Handle(NewMessageReceived item)"}
+    B --> |"PublishEvent(Output('***Hello, World***'))"| C[ConsoleAgent]
+    C --> D{"WriteConsole()"}
+    B --> |"PublishEvent(ConversationClosed('Goodbye'))"| E{"Handle(ConversationClosed item)"}
+    B --> |"PublishEvent(Output('***Goodbye***'))"| C
+    E --> F{"Shutdown()"}
+
+```
+
+### Writing Event Handlers
+
+The heart of an autogen application are the event handlers. Agents select a ```TopicSubscription``` to listen for events on a specific topic. When an event is received, the agent's event handler is called with the event data.
+
+Within that event handler you may optionally *emit* new events, which are then sent to the event bus for other agents to process. The EventTypes are declared gRPC ProtoBuf messages that are used to define the schema of the event.  The default protos are available via the ```Microsoft.AutoGen.Abstractions;``` namespace and are defined in [autogen/protos](/autogen/protos). The EventTypes are registered in the agent's constructor using the ```IHandle``` interface.
+
+```csharp
+TopicSubscription("HelloAgents")]
+public class HelloAgent(
+    IAgentContext context,
+    [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
+        context,
+        typeRegistry),
+        ISayHello,
+        IHandle,
+        IHandle
+{
+    public async Task Handle(NewMessageReceived item)
+    {
+        var response = await SayHello(item.Message).ConfigureAwait(false);
+        var evt = new Output
+        {
+            Message = response
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(evt).ConfigureAwait(false);
+        var goodbye = new ConversationClosed
+        {
+            UserId = this.AgentId.Key,
+            UserMessage = "Goodbye"
+        }.ToCloudEvent(this.AgentId.Key);
+        await PublishEvent(goodbye).ConfigureAwait(false);
+    }
+```
+
+### Inheritance and Composition
+
+This sample also illustrates inheritance in AutoGen. The `HelloAgent` class inherits from `ConsoleAgent`, which is a base class that provides a `WriteConsole` method.
+
+### Starting the Application Runtime
+
+AuotoGen provides a flexible runtime ```Microsoft.AutoGen.Agents.App``` that can be started in a variety of ways. The `Program.cs` file demonstrates how to start the runtime locally and send a message to the agent all in one go using the ```App.PublishMessageAsync``` method.
+
+```csharp
+// send a message to the agent
+var app = await App.PublishMessageAsync("HelloAgents", new NewMessageReceived
+{
+    Message = "World"
+}, local: true);
+
+await App.RuntimeApp!.WaitForShutdownAsync();
+await app.WaitForShutdownAsync();
+```
+
+### Sending Messages
+
+The set of possible Messages is defined in gRPC ProtoBuf specs. These are then turned into C# classes by the gRPC tools. You can define your own Message types by creating a new .proto file in your project and including the gRPC tools in your ```.csproj``` file:
+
+```proto
+syntax = "proto3";
+package devteam;
+option csharp_namespace = "DevTeam.Shared";
+message NewAsk {
+  string org = 1;
+  string repo = 2;
+  string ask = 3;
+  int64 issue_number = 4;
+}
+message ReadmeRequested {
+   string org = 1;
+   string repo = 2;
+   int64 issue_number = 3;
+   string ask = 4;
+}
+```
+
+```xml
+  
+    
+    
+    
+  
+```
+
+You can send messages using the [```Microsoft.AutoGen.Agents``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
+
+### Managing State
+
+There is a simple API for persisting agent state.
+
+```csharp
+            await Store(new AgentState 
+            {
+                AgentId = this.AgentId,
+                TextData = entry
+            }).ConfigureAwait(false);
+```
+
+which can be read back using Read:
+
+```csharp
+            State = await Read(this.AgentId).ConfigureAwait(false);
+```
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/AgentState.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
similarity index 65%
rename from dotnet/src/Microsoft.AutoGen/Abstractions/AgentState.cs
rename to dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
index 53093bc9b9d2..8185c153d9d0 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/AgentState.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
@@ -1,6 +1,9 @@
+using Google.Protobuf;
+
 namespace Microsoft.AutoGen.Abstractions;
 
-public class AgentState where T : class, new()
+public class ChatState
+     where T : IMessage, new()
 {
     public List History { get; set; } = new();
     public T Data { get; set; } = new();
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
index 724a706b102e..5fa09ae218b2 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
@@ -16,9 +16,29 @@ public static CloudEvent ToCloudEvent(this T message, string source) where T
 
         };
     }
-
     public static T FromCloudEvent(this CloudEvent cloudEvent) where T : IMessage, new()
     {
         return cloudEvent.ProtoData.Unpack();
     }
+    public static AgentState ToAgentState(this T state, AgentId agentId, string eTag) where T : IMessage
+    {
+        return new AgentState
+        {
+            ProtoData = Any.Pack(state),
+            AgentId = agentId,
+            ETag = eTag
+        };
+    }
+
+    public static T FromAgentState(this AgentState state) where T : IMessage, new()
+    {
+        if (state.HasTextData == true)
+        {
+            if (typeof(T) == typeof(AgentState))
+            {
+                return (T)(IMessage)state;
+            }
+        }
+        return state.ProtoData.Unpack();
+    }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/Microsoft.AutoGen.Abstractions.csproj b/dotnet/src/Microsoft.AutoGen/Abstractions/Microsoft.AutoGen.Abstractions.csproj
index fe480940cbda..52f933e19595 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/Microsoft.AutoGen.Abstractions.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/Microsoft.AutoGen.Abstractions.csproj
@@ -14,7 +14,6 @@
     
     
     
-    
   
 
   
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index 6307988a46c5..62779f8366c7 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -108,7 +108,16 @@ await this.InvokeWithActivityAsync(
                 break;
         }
     }
-
+    protected async Task Store(AgentState state)
+    {
+        await _context.Store(state).ConfigureAwait(false);
+        return;
+    }
+    protected async Task Read(AgentId agentId) where T : IMessage, new()
+    {
+        var agentstate = await _context.Read(agentId).ConfigureAwait(false);
+        return agentstate.FromAgentState();
+    }
     private void OnResponseCore(RpcResponse response)
     {
         var requestId = response.RequestId;
@@ -186,7 +195,6 @@ static async ((AgentBase Agent, RpcRequest Request, TaskCompletionSource logger, AgentWorkerRuntime runtime, DistributedContextPropagator distributedContextPropagator,
     [FromKeyedServices("EventTypes")] EventTypes eventTypes)
     : AgentBase(new ClientContext(logger, runtime, distributedContextPropagator), eventTypes)
 {
     public async ValueTask PublishEventAsync(CloudEvent evt) => await PublishEvent(evt);
     public async ValueTask SendRequestAsync(AgentId target, string method, Dictionary parameters) => await RequestAsync(target, method, parameters);
-
     public async ValueTask PublishEventAsync(string topic, IMessage evt)
     {
         await PublishEventAsync(evt.ToCloudEvent(topic)).ConfigureAwait(false);
@@ -23,12 +21,10 @@ private sealed class ClientContext(ILogger logger, AgentWorkerRunti
         public AgentBase? AgentInstance { get; set; }
         public ILogger Logger { get; } = logger;
         public DistributedContextPropagator DistributedContextPropagator { get; } = distributedContextPropagator;
-
         public async ValueTask PublishEventAsync(CloudEvent @event)
         {
             await runtime.PublishEvent(@event).ConfigureAwait(false);
         }
-
         public async ValueTask SendRequestAsync(AgentBase agent, RpcRequest request)
         {
             await runtime.SendRequest(AgentInstance!, request).ConfigureAwait(false);
@@ -38,5 +34,13 @@ public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse respons
         {
             await runtime.SendResponse(response).ConfigureAwait(false);
         }
+        public ValueTask Store(AgentState value)
+        {
+            throw new NotImplementedException();
+        }
+        public ValueTask Read(AgentId agentId)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
index 43d1137c8615..779cc86a608a 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
@@ -12,20 +12,25 @@ internal sealed class AgentContext(AgentId agentId, AgentWorkerRuntime runtime,
     public ILogger Logger { get; } = logger;
     public AgentBase? AgentInstance { get; set; }
     public DistributedContextPropagator DistributedContextPropagator { get; } = distributedContextPropagator;
-
     public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse response)
     {
         response.RequestId = request.RequestId;
         await _runtime.SendResponse(response);
     }
-
     public async ValueTask SendRequestAsync(AgentBase agent, RpcRequest request)
     {
         await _runtime.SendRequest(agent, request);
     }
-
     public async ValueTask PublishEventAsync(CloudEvent @event)
     {
         await _runtime.PublishEvent(@event);
     }
+    public async ValueTask Store(AgentState value)
+    {
+        await _runtime.Store(value);
+    }
+    public async ValueTask Read(AgentId agentId)
+    {
+        return await _runtime.Read(agentId);
+    }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
index d0df48f71bff..f335881fc09b 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
@@ -84,7 +84,6 @@ private async Task RunReadPump()
                             request.Agent.ReceiveMessage(message);
                             break;
                         case Message.MessageOneofCase.CloudEvent:
-                            // TODO: Reimplement
 
                             // HACK: Send the message to an instance of each agent type
                             // where AgentId = (namespace: event.Namespace, name: agentType)
@@ -323,10 +322,32 @@ public async Task StopAsync(CancellationToken cancellationToken)
             _channel?.Dispose();
         }
     }
-
     public ValueTask SendRequest(RpcRequest request)
     {
         throw new NotImplementedException();
     }
+    public ValueTask Store(AgentState value)
+    {
+        var agentId = value.AgentId ?? throw new InvalidOperationException("AgentId is required when saving AgentState.");
+        var response = _client.SaveState(value);
+        if (!response.Success)
+        {
+            throw new InvalidOperationException($"Error saving AgentState for AgentId {agentId}.");
+        }
+        return ValueTask.CompletedTask;
+    }
+    public async ValueTask Read(AgentId agentId)
+    {
+        var response = await _client.GetStateAsync(agentId);
+        //        if (response.Success && response.AgentState.AgentId is not null) - why is success always false?
+        if (response.AgentState.AgentId is not null)
+        {
+            return response.AgentState;
+        }
+        else
+        {
+            throw new KeyNotFoundException($"Failed to read AgentState for {agentId}.");
+        }
+    }
 }
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
index e1f932fa6642..15c4fc095fa6 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
@@ -1,6 +1,7 @@
+using Google.Protobuf;
 using Microsoft.Extensions.AI;
 namespace Microsoft.AutoGen.Agents.Client;
-public abstract class InferenceAgent : AgentBase where T : class, new()
+public abstract class InferenceAgent : AgentBase where T : IMessage, new()
 {
     protected IChatClient ChatClient { get; }
     public InferenceAgent(
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
index 84bd2f821906..becd2c208fa6 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
@@ -40,6 +40,7 @@ public virtual async Task CallFunction(string template, KernelArguments
         var function = _kernel.CreateFunctionFromPrompt(template, promptSettings);
         var result = (await _kernel.InvokeAsync(function, arguments).ConfigureAwait(true)).ToString();
         AddToHistory(result, ChatUserType.Agent);
+        //await Store(_state.Data.ToAgentState(AgentId,""));//TODO add eTag
         return result;
     }
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
index c6e9f4392da9..2df6c7965031 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
@@ -3,7 +3,7 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public abstract class ConsoleAgent : IOAgent,
+public abstract class ConsoleAgent : IOAgent,
         IUseConsole,
         IHandle,
         IHandle
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
index f8bf4630428b..2149a32d23cc 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
@@ -10,7 +10,7 @@ public abstract class FileAgent(
     [FromKeyedServices("EventTypes")] EventTypes typeRegistry,
     string inputPath = "input.txt",
     string outputPath = "output.txt"
-    ) : IOAgent(context, typeRegistry),
+    ) : IOAgent(context, typeRegistry),
         IUseFiles,
         IHandle,
         IHandle
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
index 7d1438720377..fc0f49733176 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
@@ -2,16 +2,12 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public abstract class IOAgent : AgentBase where T : class, new()
+public abstract class IOAgent : AgentBase
 {
-    protected AgentState _state;
     public string _route = "base";
-
-    public IOAgent(IAgentContext context, EventTypes typeRegistry) : base(context, typeRegistry)
+    protected IOAgent(IAgentContext context, EventTypes eventTypes) : base(context, eventTypes)
     {
-        _state = new();
     }
-
     public virtual async Task Handle(Input item)
     {
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
index 47d107d63da7..418ef8d5ab0e 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public abstract class WebAPIAgent : IOAgent,
+public abstract class WebAPIAgent : IOAgent,
         IUseWebAPI,
         IHandle,
         IHandle
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
new file mode 100644
index 000000000000..122dff2c6270
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
@@ -0,0 +1,22 @@
+using Microsoft.AutoGen.Abstractions;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AutoGen.Agents
+{
+    public interface IAgentBase
+    {
+        // Properties
+        string AgentId { get; }
+        ILogger Logger { get; }
+        IAgentContext Context { get; }
+
+        // Methods
+        Task CallHandler(CloudEvent item);
+        Task HandleRequest(RpcRequest request);
+        Task Start();
+        Task ReceiveMessage(Message message);
+        Task Store(AgentState state);
+        Task Read(AgentId agentId);
+        Task PublishEvent(CloudEvent item);
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs
index a7911e37e51b..0dfa78b36e9f 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs
@@ -10,6 +10,8 @@ public interface IAgentContext
     AgentBase? AgentInstance { get; set; }
     DistributedContextPropagator DistributedContextPropagator { get; }
     ILogger Logger { get; }
+    ValueTask Store(AgentState value);
+    ValueTask Read(AgentId agentId);
     ValueTask SendResponseAsync(RpcRequest request, RpcResponse response);
     ValueTask SendRequestAsync(AgentBase agent, RpcRequest request);
     ValueTask PublishEventAsync(CloudEvent @event);
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/AgentStateGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/AgentStateGrain.cs
deleted file mode 100644
index d717e26f46f1..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Runtime/AgentStateGrain.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-namespace Microsoft.AutoGen.Runtime;
-
-internal sealed class AgentStateGrain([PersistentState("state", "agent-state")] IPersistentState> state) : Grain, IAgentStateGrain
-{
-    public ValueTask<(Dictionary State, string ETag)> ReadStateAsync()
-    {
-        return new((state.State, state.Etag));
-    }
-
-    public async ValueTask WriteStateAsync(Dictionary value, string eTag)
-    {
-        if (string.Equals(state.Etag, eTag, StringComparison.Ordinal))
-        {
-            state.State = value;
-            await state.WriteStateAsync();
-        }
-
-        return state.Etag;
-    }
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
index 48e911f351ef..447b527417a5 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
@@ -5,19 +5,27 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
-using Orleans.Serialization;
 
 namespace Microsoft.AutoGen.Runtime;
 
 public static class AgentWorkerHostingExtensions
 {
-    public static IHostApplicationBuilder AddAgentService(this IHostApplicationBuilder builder)
+    public static WebApplicationBuilder AddAgentService(this WebApplicationBuilder builder, bool local = false)
     {
+        if (local)
+        {
+            //TODO: make configuration more flexible
+            builder.WebHost.ConfigureKestrel(serverOptions =>
+                        {
+                            serverOptions.ListenLocalhost(5001, listenOptions =>
+                            {
+                                listenOptions.Protocols = HttpProtocols.Http2;
+                                listenOptions.UseHttps();
+                            });
+                        });
+        }
         builder.Services.AddGrpc();
-        builder.Services.AddSerializer(serializer => serializer.AddProtobufSerializer());
-
-        // Ensure Orleans is added before the hosted service to guarantee that it starts first.
-        builder.UseOrleans();
+        builder.AddOrleans(local);
         builder.Services.TryAddSingleton(DistributedContextPropagator.Current);
         builder.Services.AddSingleton();
         builder.Services.AddSingleton(sp => sp.GetRequiredService());
@@ -27,22 +35,9 @@ public static IHostApplicationBuilder AddAgentService(this IHostApplicationBuild
 
     public static WebApplicationBuilder AddLocalAgentService(this WebApplicationBuilder builder)
     {
-        builder.WebHost.ConfigureKestrel(serverOptions =>
-                        {
-                            serverOptions.ListenLocalhost(5001, listenOptions =>
-                            {
-                                listenOptions.Protocols = HttpProtocols.Http2;
-                                listenOptions.UseHttps();
-                            });
-                        });
-        builder.AddAgentService();
-        builder.UseOrleans(siloBuilder =>
-        {
-            siloBuilder.UseLocalhostClustering(); ;
-        });
+        builder.AddAgentService(local: true);
         return builder;
     }
-
     public static WebApplication MapAgentService(this WebApplication app)
     {
         app.MapGrpcService();
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IAgentStateGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IAgentStateGrain.cs
deleted file mode 100644
index b5ece3ad6fa5..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Runtime/IAgentStateGrain.cs
+++ /dev/null
@@ -1,7 +0,0 @@
-namespace Microsoft.AutoGen.Runtime;
-
-internal interface IAgentStateGrain : IGrainWithStringKey
-{
-    ValueTask<(Dictionary State, string ETag)> ReadStateAsync();
-    ValueTask WriteStateAsync(Dictionary state, string eTag);
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
new file mode 100644
index 000000000000..ce93b9a41efd
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
@@ -0,0 +1,9 @@
+using Microsoft.AutoGen.Abstractions;
+
+namespace Microsoft.AutoGen.Runtime;
+
+internal interface IWorkerAgentGrain : IGrainWithStringKey
+{
+    ValueTask ReadStateAsync();
+    ValueTask WriteStateAsync(AgentState state, string eTag);
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
index c48c0fa8a6ca..ec63cdcc8874 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
@@ -7,4 +7,6 @@ public interface IWorkerGateway : IGrainObserver
 {
     ValueTask InvokeRequest(RpcRequest request);
     ValueTask BroadcastEvent(CloudEvent evt);
+    ValueTask Store(AgentState value);
+    ValueTask Read(AgentId agentId);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/Microsoft.AutoGen.Runtime.csproj b/dotnet/src/Microsoft.AutoGen/Runtime/Microsoft.AutoGen.Runtime.csproj
index 37e1bd292681..40a240c2f699 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/Microsoft.AutoGen.Runtime.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/Microsoft.AutoGen.Runtime.csproj
@@ -21,6 +21,15 @@
 		
 		
 		
+		
+		
+		
+		
+		
+		
+		
+		
+
 	
 
 
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs b/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
new file mode 100644
index 000000000000..3f980cf85d36
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
@@ -0,0 +1,85 @@
+using System.Configuration;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using Orleans.Configuration;
+using Orleans.Serialization;
+
+namespace Microsoft.AutoGen.Runtime;
+
+public static class OrleansRuntimeHostingExtenions
+{
+    public static WebApplicationBuilder AddOrleans(this WebApplicationBuilder builder, bool local = false)
+    {
+
+        builder.Services.AddSerializer(serializer => serializer.AddProtobufSerializer());
+        // Ensure Orleans is added before the hosted service to guarantee that it starts first.
+        //TODO: make all of this configurable
+        builder.Host.UseOrleans(siloBuilder =>
+        {
+            // Development mode or local mode uses in-memory storage and streams
+            if (builder.Environment.IsDevelopment() || local)
+            {
+                siloBuilder.UseLocalhostClustering()
+                       .AddMemoryStreams("StreamProvider")
+                       .AddMemoryGrainStorage("PubSubStore")
+                       .AddMemoryGrainStorage("AgentStateStore");
+
+                siloBuilder.UseInMemoryReminderService();
+                siloBuilder.UseDashboard(x => x.HostSelf = true);
+
+                siloBuilder.UseInMemoryReminderService();
+            }
+            else
+            {
+                var cosmosDbconnectionString = builder.Configuration.GetValue("Orleans:CosmosDBConnectionString") ??
+                    throw new ConfigurationErrorsException(
+                        "Orleans:CosmosDBConnectionString is missing from configuration. This is required for persistence in production environments.");
+                siloBuilder.Configure(options =>
+                {
+                    //TODO: make this configurable
+                    options.ClusterId = "AutoGen-cluster";
+                    options.ServiceId = "AutoGen-cluster";
+                });
+                siloBuilder.Configure(options =>
+                {
+                    options.ResponseTimeout = TimeSpan.FromMinutes(3);
+                    options.SystemResponseTimeout = TimeSpan.FromMinutes(3);
+                });
+                siloBuilder.Configure(options =>
+               {
+                   options.ResponseTimeout = TimeSpan.FromMinutes(3);
+               });
+                siloBuilder.UseCosmosClustering(o =>
+                    {
+                        o.ConfigureCosmosClient(cosmosDbconnectionString);
+                        o.ContainerName = "AutoGen";
+                        o.DatabaseName = "clustering";
+                        o.IsResourceCreationEnabled = true;
+                    });
+
+                siloBuilder.UseCosmosReminderService(o =>
+                {
+                    o.ConfigureCosmosClient(cosmosDbconnectionString);
+                    o.ContainerName = "AutoGen";
+                    o.DatabaseName = "reminders";
+                    o.IsResourceCreationEnabled = true;
+                });
+                siloBuilder.AddCosmosGrainStorage(
+                    name: "AgentStateStore",
+                    configureOptions: o =>
+                    {
+                        o.ConfigureCosmosClient(cosmosDbconnectionString);
+                        o.ContainerName = "AutoGen";
+                        o.DatabaseName = "persistence";
+                        o.IsResourceCreationEnabled = true;
+                    });
+                //TODO: replace with EventHub
+                siloBuilder
+              .AddMemoryStreams("StreamProvider")
+              .AddMemoryGrainStorage("PubSubStore");
+            }
+        });
+        return builder;
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs
new file mode 100644
index 000000000000..3bbe7d78cd5b
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs
@@ -0,0 +1,31 @@
+using Microsoft.AutoGen.Abstractions;
+
+namespace Microsoft.AutoGen.Runtime;
+
+internal sealed class WorkerAgentGrain([PersistentState("state", "AgentStateStore")] IPersistentState state) : Grain, IWorkerAgentGrain
+{
+    public async ValueTask WriteStateAsync(AgentState newState, string eTag)
+    {
+        // etags for optimistic concurrency control
+        // if the Etag is null, its a new state
+        // if the passed etag is null or empty, we should not check the current state's Etag - caller doesnt care
+        // if both etags are set, they should match or it means that the state has changed since the last read. 
+        if ((string.IsNullOrEmpty(state.Etag)) || (string.IsNullOrEmpty(eTag)) || (string.Equals(state.Etag, eTag, StringComparison.Ordinal)))
+        {
+            state.State = newState;
+            await state.WriteStateAsync();
+        }
+        else
+        {
+            //TODO - this is probably not the correct behavior to just throw - I presume we want to somehow let the caller know that the state has changed and they need to re-read it
+            throw new ArgumentException(
+                "The provided ETag does not match the current ETag. The state has been modified by another request.");
+        }
+        return state.Etag;
+    }
+
+    public ValueTask ReadStateAsync()
+    {
+        return ValueTask.FromResult(state.State);
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
index 6cb26bc1c710..6d549ef7270f 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
@@ -37,6 +37,7 @@ public WorkerGateway(IClusterClient clusterClient, ILogger logger
 
     public async ValueTask BroadcastEvent(CloudEvent evt)
     {
+        // TODO: filter the workers that receive the event
         var tasks = new List(_workers.Count);
         foreach (var (_, connection) in _workers)
         {
@@ -211,7 +212,18 @@ private static async Task InvokeRequestDelegate(WorkerProcessConnection connecti
             await connection.ResponseStream.WriteAsync(new Message { Response = new RpcResponse { RequestId = request.RequestId, Error = ex.Message } });
         }
     }
+    public async ValueTask Store(AgentState value)
+    {
+        var agentId = value.AgentId ?? throw new ArgumentNullException(nameof(value.AgentId));
+        var agentState = _clusterClient.GetGrain($"{agentId.Type}:{agentId.Key}");
+        await agentState.WriteStateAsync(value, value.ETag);
+    }
 
+    public async ValueTask Read(AgentId agentId)
+    {
+        var agentState = _clusterClient.GetGrain($"{agentId.Type}:{agentId.Key}");
+        return await agentState.ReadStateAsync();
+    }
     /*
     private async ValueTask SubscribeToTopic(WorkerProcessConnection connection, RpcRequest request)
     {
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
index b817bc04925b..8600aa5fd233 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
@@ -21,4 +21,18 @@ public override async Task OpenChannel(IAsyncStreamReader requestStream
             throw;
         }
     }
+    public override async Task GetState(AgentId request, ServerCallContext context)
+    {
+        var state = await agentWorker.Read(request);
+        return new GetStateResponse { AgentState = state };
+    }
+
+    public override async Task SaveState(AgentState request, ServerCallContext context)
+    {
+        await agentWorker.Store(request);
+        return new SaveStateResponse
+        {
+            Success = true // TODO: Implement error handling
+        };
+    }
 }
diff --git a/protos/agent_worker.proto b/protos/agent_worker.proto
index ec472923be32..7b0b5245dd3e 100644
--- a/protos/agent_worker.proto
+++ b/protos/agent_worker.proto
@@ -82,6 +82,29 @@ message AddSubscriptionResponse {
 
 service AgentRpc {
     rpc OpenChannel (stream Message) returns (stream Message);
+    rpc GetState(AgentId) returns (GetStateResponse);
+    rpc SaveState(AgentState) returns (SaveStateResponse);
+}
+
+message AgentState {
+  AgentId agent_id = 1;
+  string eTag = 2;
+  oneof  data {
+    bytes binary_data = 3;
+    string text_data = 4;
+    google.protobuf.Any proto_data = 5;
+  }
+}
+
+message GetStateResponse {
+	AgentState agent_state = 1;
+	bool success = 2;
+    optional string error = 3;
+}
+
+message SaveStateResponse {
+	bool success = 1;
+    optional string error = 2;
 }
 
 message Message {
diff --git a/python/packages/autogen-core/src/autogen_core/application/_worker_runtime_host_servicer.py b/python/packages/autogen-core/src/autogen_core/application/_worker_runtime_host_servicer.py
index 9308edbcd8db..1ed794c35f29 100644
--- a/python/packages/autogen-core/src/autogen_core/application/_worker_runtime_host_servicer.py
+++ b/python/packages/autogen-core/src/autogen_core/application/_worker_runtime_host_servicer.py
@@ -243,3 +243,17 @@ async def _process_add_subscription_request(
                 )
             case None:
                 logger.warning("Received empty subscription message")
+
+    async def GetState(  # type: ignore
+        self,
+        request: agent_worker_pb2.AgentId,
+        context: grpc.aio.ServicerContext[agent_worker_pb2.AgentId, agent_worker_pb2.GetStateResponse],
+    ) -> agent_worker_pb2.GetStateResponse:  # type: ignore
+        raise NotImplementedError("Method not implemented!")
+
+    async def SaveState(  # type: ignore
+        self,
+        request: agent_worker_pb2.AgentState,
+        context: grpc.aio.ServicerContext[agent_worker_pb2.AgentId, agent_worker_pb2.SaveStateResponse],
+    ) -> agent_worker_pb2.SaveStateResponse:  # type: ignore
+        raise NotImplementedError("Method not implemented!")
diff --git a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.py b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.py
index cfbc0522b856..0637e866c4de 100644
--- a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.py
+++ b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.py
@@ -16,7 +16,7 @@
 from google.protobuf import any_pb2 as google_dot_protobuf_dot_any__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12\x61gent_worker.proto\x12\x06\x61gents\x1a\x10\x63loudevent.proto\x1a\x19google/protobuf/any.proto\"\'\n\x07TopicId\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0e\n\x06source\x18\x02 \x01(\t\"$\n\x07\x41gentId\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0b\n\x03key\x18\x02 \x01(\t\"E\n\x07Payload\x12\x11\n\tdata_type\x18\x01 \x01(\t\x12\x19\n\x11\x64\x61ta_content_type\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\x89\x02\n\nRpcRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12$\n\x06source\x18\x02 \x01(\x0b\x32\x0f.agents.AgentIdH\x00\x88\x01\x01\x12\x1f\n\x06target\x18\x03 \x01(\x0b\x32\x0f.agents.AgentId\x12\x0e\n\x06method\x18\x04 \x01(\t\x12 \n\x07payload\x18\x05 \x01(\x0b\x32\x0f.agents.Payload\x12\x32\n\x08metadata\x18\x06 \x03(\x0b\x32 .agents.RpcRequest.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\t\n\x07_source\"\xb8\x01\n\x0bRpcResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12 \n\x07payload\x18\x02 \x01(\x0b\x32\x0f.agents.Payload\x12\r\n\x05\x65rror\x18\x03 \x01(\t\x12\x33\n\x08metadata\x18\x04 \x03(\x0b\x32!.agents.RpcResponse.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xe4\x01\n\x05\x45vent\x12\x12\n\ntopic_type\x18\x01 \x01(\t\x12\x14\n\x0ctopic_source\x18\x02 \x01(\t\x12$\n\x06source\x18\x03 \x01(\x0b\x32\x0f.agents.AgentIdH\x00\x88\x01\x01\x12 \n\x07payload\x18\x04 \x01(\x0b\x32\x0f.agents.Payload\x12-\n\x08metadata\x18\x05 \x03(\x0b\x32\x1b.agents.Event.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\t\n\x07_source\"<\n\x18RegisterAgentTypeRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"^\n\x19RegisterAgentTypeResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x12\n\x05\x65rror\x18\x03 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\":\n\x10TypeSubscription\x12\x12\n\ntopic_type\x18\x01 \x01(\t\x12\x12\n\nagent_type\x18\x02 \x01(\t\"T\n\x0cSubscription\x12\x34\n\x10typeSubscription\x18\x01 \x01(\x0b\x32\x18.agents.TypeSubscriptionH\x00\x42\x0e\n\x0csubscription\"X\n\x16\x41\x64\x64SubscriptionRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12*\n\x0csubscription\x18\x02 \x01(\x0b\x32\x14.agents.Subscription\"\\\n\x17\x41\x64\x64SubscriptionResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x12\n\x05\x65rror\x18\x03 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\"\xc6\x03\n\x07Message\x12%\n\x07request\x18\x01 \x01(\x0b\x32\x12.agents.RpcRequestH\x00\x12\'\n\x08response\x18\x02 \x01(\x0b\x32\x13.agents.RpcResponseH\x00\x12\x1e\n\x05\x65vent\x18\x03 \x01(\x0b\x32\r.agents.EventH\x00\x12\x44\n\x18registerAgentTypeRequest\x18\x04 \x01(\x0b\x32 .agents.RegisterAgentTypeRequestH\x00\x12\x46\n\x19registerAgentTypeResponse\x18\x05 \x01(\x0b\x32!.agents.RegisterAgentTypeResponseH\x00\x12@\n\x16\x61\x64\x64SubscriptionRequest\x18\x06 \x01(\x0b\x32\x1e.agents.AddSubscriptionRequestH\x00\x12\x42\n\x17\x61\x64\x64SubscriptionResponse\x18\x07 \x01(\x0b\x32\x1f.agents.AddSubscriptionResponseH\x00\x12,\n\ncloudEvent\x18\x08 \x01(\x0b\x32\x16.cloudevent.CloudEventH\x00\x42\t\n\x07message2?\n\x08\x41gentRpc\x12\x33\n\x0bOpenChannel\x12\x0f.agents.Message\x1a\x0f.agents.Message(\x01\x30\x01\x42!\xaa\x02\x1eMicrosoft.AutoGen.Abstractionsb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x12\x61gent_worker.proto\x12\x06\x61gents\x1a\x10\x63loudevent.proto\x1a\x19google/protobuf/any.proto\"\'\n\x07TopicId\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0e\n\x06source\x18\x02 \x01(\t\"$\n\x07\x41gentId\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x0b\n\x03key\x18\x02 \x01(\t\"E\n\x07Payload\x12\x11\n\tdata_type\x18\x01 \x01(\t\x12\x19\n\x11\x64\x61ta_content_type\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\x89\x02\n\nRpcRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12$\n\x06source\x18\x02 \x01(\x0b\x32\x0f.agents.AgentIdH\x00\x88\x01\x01\x12\x1f\n\x06target\x18\x03 \x01(\x0b\x32\x0f.agents.AgentId\x12\x0e\n\x06method\x18\x04 \x01(\t\x12 \n\x07payload\x18\x05 \x01(\x0b\x32\x0f.agents.Payload\x12\x32\n\x08metadata\x18\x06 \x03(\x0b\x32 .agents.RpcRequest.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\t\n\x07_source\"\xb8\x01\n\x0bRpcResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12 \n\x07payload\x18\x02 \x01(\x0b\x32\x0f.agents.Payload\x12\r\n\x05\x65rror\x18\x03 \x01(\t\x12\x33\n\x08metadata\x18\x04 \x03(\x0b\x32!.agents.RpcResponse.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xe4\x01\n\x05\x45vent\x12\x12\n\ntopic_type\x18\x01 \x01(\t\x12\x14\n\x0ctopic_source\x18\x02 \x01(\t\x12$\n\x06source\x18\x03 \x01(\x0b\x32\x0f.agents.AgentIdH\x00\x88\x01\x01\x12 \n\x07payload\x18\x04 \x01(\x0b\x32\x0f.agents.Payload\x12-\n\x08metadata\x18\x05 \x03(\x0b\x32\x1b.agents.Event.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x42\t\n\x07_source\"<\n\x18RegisterAgentTypeRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0c\n\x04type\x18\x02 \x01(\t\"^\n\x19RegisterAgentTypeResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x12\n\x05\x65rror\x18\x03 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\":\n\x10TypeSubscription\x12\x12\n\ntopic_type\x18\x01 \x01(\t\x12\x12\n\nagent_type\x18\x02 \x01(\t\"T\n\x0cSubscription\x12\x34\n\x10typeSubscription\x18\x01 \x01(\x0b\x32\x18.agents.TypeSubscriptionH\x00\x42\x0e\n\x0csubscription\"X\n\x16\x41\x64\x64SubscriptionRequest\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12*\n\x0csubscription\x18\x02 \x01(\x0b\x32\x14.agents.Subscription\"\\\n\x17\x41\x64\x64SubscriptionResponse\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x12\n\x05\x65rror\x18\x03 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\"\x9d\x01\n\nAgentState\x12!\n\x08\x61gent_id\x18\x01 \x01(\x0b\x32\x0f.agents.AgentId\x12\x0c\n\x04\x65Tag\x18\x02 \x01(\t\x12\x15\n\x0b\x62inary_data\x18\x03 \x01(\x0cH\x00\x12\x13\n\ttext_data\x18\x04 \x01(\tH\x00\x12*\n\nproto_data\x18\x05 \x01(\x0b\x32\x14.google.protobuf.AnyH\x00\x42\x06\n\x04\x64\x61ta\"j\n\x10GetStateResponse\x12\'\n\x0b\x61gent_state\x18\x01 \x01(\x0b\x32\x12.agents.AgentState\x12\x0f\n\x07success\x18\x02 \x01(\x08\x12\x12\n\x05\x65rror\x18\x03 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\"B\n\x11SaveStateResponse\x12\x0f\n\x07success\x18\x01 \x01(\x08\x12\x12\n\x05\x65rror\x18\x02 \x01(\tH\x00\x88\x01\x01\x42\x08\n\x06_error\"\xc6\x03\n\x07Message\x12%\n\x07request\x18\x01 \x01(\x0b\x32\x12.agents.RpcRequestH\x00\x12\'\n\x08response\x18\x02 \x01(\x0b\x32\x13.agents.RpcResponseH\x00\x12\x1e\n\x05\x65vent\x18\x03 \x01(\x0b\x32\r.agents.EventH\x00\x12\x44\n\x18registerAgentTypeRequest\x18\x04 \x01(\x0b\x32 .agents.RegisterAgentTypeRequestH\x00\x12\x46\n\x19registerAgentTypeResponse\x18\x05 \x01(\x0b\x32!.agents.RegisterAgentTypeResponseH\x00\x12@\n\x16\x61\x64\x64SubscriptionRequest\x18\x06 \x01(\x0b\x32\x1e.agents.AddSubscriptionRequestH\x00\x12\x42\n\x17\x61\x64\x64SubscriptionResponse\x18\x07 \x01(\x0b\x32\x1f.agents.AddSubscriptionResponseH\x00\x12,\n\ncloudEvent\x18\x08 \x01(\x0b\x32\x16.cloudevent.CloudEventH\x00\x42\t\n\x07message2\xb2\x01\n\x08\x41gentRpc\x12\x33\n\x0bOpenChannel\x12\x0f.agents.Message\x1a\x0f.agents.Message(\x01\x30\x01\x12\x35\n\x08GetState\x12\x0f.agents.AgentId\x1a\x18.agents.GetStateResponse\x12:\n\tSaveState\x12\x12.agents.AgentState\x1a\x19.agents.SaveStateResponseB!\xaa\x02\x1eMicrosoft.AutoGen.Abstractionsb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -60,8 +60,14 @@
   _globals['_ADDSUBSCRIPTIONREQUEST']._serialized_end=1303
   _globals['_ADDSUBSCRIPTIONRESPONSE']._serialized_start=1305
   _globals['_ADDSUBSCRIPTIONRESPONSE']._serialized_end=1397
-  _globals['_MESSAGE']._serialized_start=1400
-  _globals['_MESSAGE']._serialized_end=1854
-  _globals['_AGENTRPC']._serialized_start=1856
-  _globals['_AGENTRPC']._serialized_end=1919
+  _globals['_AGENTSTATE']._serialized_start=1400
+  _globals['_AGENTSTATE']._serialized_end=1557
+  _globals['_GETSTATERESPONSE']._serialized_start=1559
+  _globals['_GETSTATERESPONSE']._serialized_end=1665
+  _globals['_SAVESTATERESPONSE']._serialized_start=1667
+  _globals['_SAVESTATERESPONSE']._serialized_end=1733
+  _globals['_MESSAGE']._serialized_start=1736
+  _globals['_MESSAGE']._serialized_end=2190
+  _globals['_AGENTRPC']._serialized_start=2193
+  _globals['_AGENTRPC']._serialized_end=2371
 # @@protoc_insertion_point(module_scope)
diff --git a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.pyi b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.pyi
index 6c57fa8a9fcd..522124ab8891 100644
--- a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.pyi
+++ b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2.pyi
@@ -6,6 +6,7 @@ isort:skip_file
 import builtins
 import cloudevent_pb2
 import collections.abc
+import google.protobuf.any_pb2
 import google.protobuf.descriptor
 import google.protobuf.internal.containers
 import google.protobuf.message
@@ -333,6 +334,81 @@ class AddSubscriptionResponse(google.protobuf.message.Message):
 
 global___AddSubscriptionResponse = AddSubscriptionResponse
 
+@typing.final
+class AgentState(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    AGENT_ID_FIELD_NUMBER: builtins.int
+    ETAG_FIELD_NUMBER: builtins.int
+    BINARY_DATA_FIELD_NUMBER: builtins.int
+    TEXT_DATA_FIELD_NUMBER: builtins.int
+    PROTO_DATA_FIELD_NUMBER: builtins.int
+    eTag: builtins.str
+    binary_data: builtins.bytes
+    text_data: builtins.str
+    @property
+    def agent_id(self) -> global___AgentId: ...
+    @property
+    def proto_data(self) -> google.protobuf.any_pb2.Any: ...
+    def __init__(
+        self,
+        *,
+        agent_id: global___AgentId | None = ...,
+        eTag: builtins.str = ...,
+        binary_data: builtins.bytes = ...,
+        text_data: builtins.str = ...,
+        proto_data: google.protobuf.any_pb2.Any | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["agent_id", b"agent_id", "binary_data", b"binary_data", "data", b"data", "proto_data", b"proto_data", "text_data", b"text_data"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["agent_id", b"agent_id", "binary_data", b"binary_data", "data", b"data", "eTag", b"eTag", "proto_data", b"proto_data", "text_data", b"text_data"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["data", b"data"]) -> typing.Literal["binary_data", "text_data", "proto_data"] | None: ...
+
+global___AgentState = AgentState
+
+@typing.final
+class GetStateResponse(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    AGENT_STATE_FIELD_NUMBER: builtins.int
+    SUCCESS_FIELD_NUMBER: builtins.int
+    ERROR_FIELD_NUMBER: builtins.int
+    success: builtins.bool
+    error: builtins.str
+    @property
+    def agent_state(self) -> global___AgentState: ...
+    def __init__(
+        self,
+        *,
+        agent_state: global___AgentState | None = ...,
+        success: builtins.bool = ...,
+        error: builtins.str | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_error", b"_error", "agent_state", b"agent_state", "error", b"error"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_error", b"_error", "agent_state", b"agent_state", "error", b"error", "success", b"success"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_error", b"_error"]) -> typing.Literal["error"] | None: ...
+
+global___GetStateResponse = GetStateResponse
+
+@typing.final
+class SaveStateResponse(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    SUCCESS_FIELD_NUMBER: builtins.int
+    ERROR_FIELD_NUMBER: builtins.int
+    success: builtins.bool
+    error: builtins.str
+    def __init__(
+        self,
+        *,
+        success: builtins.bool = ...,
+        error: builtins.str | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_error", b"_error", "error", b"error"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_error", b"_error", "error", b"error", "success", b"success"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_error", b"_error"]) -> typing.Literal["error"] | None: ...
+
+global___SaveStateResponse = SaveStateResponse
+
 @typing.final
 class Message(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
diff --git a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.py b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.py
index d561618a2cec..fc27021587f6 100644
--- a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.py
+++ b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.py
@@ -19,6 +19,16 @@ def __init__(self, channel):
                 request_serializer=agent__worker__pb2.Message.SerializeToString,
                 response_deserializer=agent__worker__pb2.Message.FromString,
                 )
+        self.GetState = channel.unary_unary(
+                '/agents.AgentRpc/GetState',
+                request_serializer=agent__worker__pb2.AgentId.SerializeToString,
+                response_deserializer=agent__worker__pb2.GetStateResponse.FromString,
+                )
+        self.SaveState = channel.unary_unary(
+                '/agents.AgentRpc/SaveState',
+                request_serializer=agent__worker__pb2.AgentState.SerializeToString,
+                response_deserializer=agent__worker__pb2.SaveStateResponse.FromString,
+                )
 
 
 class AgentRpcServicer(object):
@@ -30,6 +40,18 @@ def OpenChannel(self, request_iterator, context):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def GetState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def SaveState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_AgentRpcServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -38,6 +60,16 @@ def add_AgentRpcServicer_to_server(servicer, server):
                     request_deserializer=agent__worker__pb2.Message.FromString,
                     response_serializer=agent__worker__pb2.Message.SerializeToString,
             ),
+            'GetState': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetState,
+                    request_deserializer=agent__worker__pb2.AgentId.FromString,
+                    response_serializer=agent__worker__pb2.GetStateResponse.SerializeToString,
+            ),
+            'SaveState': grpc.unary_unary_rpc_method_handler(
+                    servicer.SaveState,
+                    request_deserializer=agent__worker__pb2.AgentState.FromString,
+                    response_serializer=agent__worker__pb2.SaveStateResponse.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'agents.AgentRpc', rpc_method_handlers)
@@ -64,3 +96,37 @@ def OpenChannel(request_iterator,
             agent__worker__pb2.Message.FromString,
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/agents.AgentRpc/GetState',
+            agent__worker__pb2.AgentId.SerializeToString,
+            agent__worker__pb2.GetStateResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def SaveState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/agents.AgentRpc/SaveState',
+            agent__worker__pb2.AgentState.SerializeToString,
+            agent__worker__pb2.SaveStateResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
diff --git a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.pyi b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.pyi
index 1642ca2af10f..bf6bc1ba2d64 100644
--- a/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.pyi
+++ b/python/packages/autogen-core/src/autogen_core/application/protos/agent_worker_pb2_grpc.pyi
@@ -24,12 +24,32 @@ class AgentRpcStub:
         agent_worker_pb2.Message,
     ]
 
+    GetState: grpc.UnaryUnaryMultiCallable[
+        agent_worker_pb2.AgentId,
+        agent_worker_pb2.GetStateResponse,
+    ]
+
+    SaveState: grpc.UnaryUnaryMultiCallable[
+        agent_worker_pb2.AgentState,
+        agent_worker_pb2.SaveStateResponse,
+    ]
+
 class AgentRpcAsyncStub:
     OpenChannel: grpc.aio.StreamStreamMultiCallable[
         agent_worker_pb2.Message,
         agent_worker_pb2.Message,
     ]
 
+    GetState: grpc.aio.UnaryUnaryMultiCallable[
+        agent_worker_pb2.AgentId,
+        agent_worker_pb2.GetStateResponse,
+    ]
+
+    SaveState: grpc.aio.UnaryUnaryMultiCallable[
+        agent_worker_pb2.AgentState,
+        agent_worker_pb2.SaveStateResponse,
+    ]
+
 class AgentRpcServicer(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def OpenChannel(
@@ -38,4 +58,18 @@ class AgentRpcServicer(metaclass=abc.ABCMeta):
         context: _ServicerContext,
     ) -> typing.Union[collections.abc.Iterator[agent_worker_pb2.Message], collections.abc.AsyncIterator[agent_worker_pb2.Message]]: ...
 
+    @abc.abstractmethod
+    def GetState(
+        self,
+        request: agent_worker_pb2.AgentId,
+        context: _ServicerContext,
+    ) -> typing.Union[agent_worker_pb2.GetStateResponse, collections.abc.Awaitable[agent_worker_pb2.GetStateResponse]]: ...
+
+    @abc.abstractmethod
+    def SaveState(
+        self,
+        request: agent_worker_pb2.AgentState,
+        context: _ServicerContext,
+    ) -> typing.Union[agent_worker_pb2.SaveStateResponse, collections.abc.Awaitable[agent_worker_pb2.SaveStateResponse]]: ...
+
 def add_AgentRpcServicer_to_server(servicer: AgentRpcServicer, server: typing.Union[grpc.Server, grpc.aio.Server]) -> None: ...

From eb4b1f856e5df5d25a84f1bbb2ac1d461a5dba17 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 29 Oct 2024 08:04:14 -0700
Subject: [PATCH 044/173] Ability to generate handoff message from
 AssistantAgent (#3968)

* Ability to generate handoff message from AssistantAgent

* Fix mypy

* Validation

---------

Co-authored-by: Victor Dibia 
---
 .../src/autogen_agentchat/agents/__init__.py  |   3 +-
 .../agents/_assistant_agent.py                | 151 ++++++++++++++++--
 .../src/autogen_agentchat/messages.py         |   5 +-
 .../teams/_group_chat/_swarm_group_chat.py    |  37 ++++-
 .../tests/test_assistant_agent.py             |  60 ++++++-
 .../tests/test_group_chat.py                  |  88 +++++++++-
 .../framework/model-clients.ipynb             |   7 +-
 7 files changed, 326 insertions(+), 25 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index 2f32588604e9..7eb35962b5c4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -1,4 +1,4 @@
-from ._assistant_agent import AssistantAgent
+from ._assistant_agent import AssistantAgent, Handoff
 from ._base_chat_agent import BaseChatAgent
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
@@ -7,6 +7,7 @@
 __all__ = [
     "BaseChatAgent",
     "AssistantAgent",
+    "Handoff",
     "CodeExecutorAgent",
     "CodingAssistantAgent",
     "ToolUseAssistantAgent",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 6523b6d4260f..11e243afb348 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -1,7 +1,7 @@
 import asyncio
 import json
 import logging
-from typing import Any, Awaitable, Callable, List, Sequence
+from typing import Any, Awaitable, Callable, Dict, List, Sequence
 
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
@@ -15,11 +15,12 @@
     UserMessage,
 )
 from autogen_core.components.tools import FunctionTool, Tool
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from .. import EVENT_LOGGER_NAME
 from ..messages import (
     ChatMessage,
+    HandoffMessage,
     StopMessage,
     TextMessage,
 )
@@ -31,6 +32,9 @@
 class ToolCallEvent(BaseModel):
     """A tool call event."""
 
+    source: str
+    """The source of the event."""
+
     tool_calls: List[FunctionCall]
     """The tool call message."""
 
@@ -40,12 +44,58 @@ class ToolCallEvent(BaseModel):
 class ToolCallResultEvent(BaseModel):
     """A tool call result event."""
 
+    source: str
+    """The source of the event."""
+
     tool_call_results: List[FunctionExecutionResult]
     """The tool call result message."""
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
+class Handoff(BaseModel):
+    """Handoff configuration for :class:`AssistantAgent`."""
+
+    target: str
+    """The name of the target agent to handoff to."""
+
+    description: str = Field(default=None)
+    """The description of the handoff such as the condition under which it should happen and the target agent's ability.
+    If not provided, it is generated from the target agent's name."""
+
+    name: str = Field(default=None)
+    """The name of this handoff configuration. If not provided, it is generated from the target agent's name."""
+
+    message: str = Field(default=None)
+    """The message to the target agent.
+    If not provided, it is generated from the target agent's name."""
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_defaults(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if values.get("description") is None:
+            values["description"] = f"Handoff to {values['target']}."
+        if values.get("name") is None:
+            values["name"] = f"transfer_to_{values['target']}".lower()
+        else:
+            name = values["name"]
+            if not isinstance(name, str):
+                raise ValueError(f"Handoff name must be a string: {values['name']}")
+            # Check if name is a valid identifier.
+            if not name.isidentifier():
+                raise ValueError(f"Handoff name must be a valid identifier: {values['name']}")
+        if values.get("message") is None:
+            values["message"] = (
+                f"Transferred to {values['target']}, adopting the role of {values['target']} immediately."
+            )
+        return values
+
+    @property
+    def handoff_tool(self) -> Tool:
+        """Create a handoff tool from this handoff configuration."""
+        return FunctionTool(lambda: self.message, name=self.name, description=self.description)
+
+
 class AssistantAgent(BaseChatAgent):
     """An agent that provides assistance with tool use.
 
@@ -55,8 +105,52 @@ class AssistantAgent(BaseChatAgent):
         name (str): The name of the agent.
         model_client (ChatCompletionClient): The model client to use for inference.
         tools (List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]] | None, optional): The tools to register with the agent.
+        handoffs (List[Handoff | str] | None, optional): The handoff configurations for the agent, allowing it to transfer to other agents by responding with a HandoffMessage.
+            If a handoff is a string, it should represent the target agent's name.
         description (str, optional): The description of the agent.
         system_message (str, optional): The system message for the model.
+
+    Raises:
+        ValueError: If tool names are not unique.
+        ValueError: If handoff names are not unique.
+        ValueError: If handoff names are not unique from tool names.
+
+    Examples:
+
+        The following example demonstrates how to create an assistant agent with
+        a model client and generate a response to a simple task.
+
+        .. code-block:: python
+
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.task import MaxMessageTermination
+
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+            agent = AssistantAgent(name="assistant", model_client=model_client)
+
+            await agent.run("What is the capital of France?", termination_condition=MaxMessageTermination(2))
+
+
+        The following example demonstrates how to create an assistant agent with
+        a model client and a tool, and generate a response to a simple task using the tool.
+
+        .. code-block:: python
+
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.task import MaxMessageTermination
+
+
+            async def get_current_time() -> str:
+                return "The current time is 12:00 PM."
+
+
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+            agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
+
+            await agent.run("What is the current time?", termination_condition=MaxMessageTermination(3))
+
     """
 
     def __init__(
@@ -65,6 +159,7 @@ def __init__(
         model_client: ChatCompletionClient,
         *,
         tools: List[Tool | Callable[..., Any] | Callable[..., Awaitable[Any]]] | None = None,
+        handoffs: List[Handoff | str] | None = None,
         description: str = "An agent that provides assistance with ability to use tools.",
         system_message: str = "You are a helpful AI assistant. Solve tasks using your tools. Reply with 'TERMINATE' when the task has been completed.",
     ):
@@ -84,33 +179,71 @@ def __init__(
                     self._tools.append(FunctionTool(tool, description=description))
                 else:
                     raise ValueError(f"Unsupported tool type: {type(tool)}")
+        # Check if tool names are unique.
+        tool_names = [tool.name for tool in self._tools]
+        if len(tool_names) != len(set(tool_names)):
+            raise ValueError(f"Tool names must be unique: {tool_names}")
+        # Handoff tools.
+        self._handoff_tools: List[Tool] = []
+        self._handoffs: Dict[str, Handoff] = {}
+        if handoffs is not None:
+            for handoff in handoffs:
+                if isinstance(handoff, str):
+                    handoff = Handoff(target=handoff)
+                if isinstance(handoff, Handoff):
+                    self._handoff_tools.append(handoff.handoff_tool)
+                    self._handoffs[handoff.name] = handoff
+                else:
+                    raise ValueError(f"Unsupported handoff type: {type(handoff)}")
+        # Check if handoff tool names are unique.
+        handoff_tool_names = [tool.name for tool in self._handoff_tools]
+        if len(handoff_tool_names) != len(set(handoff_tool_names)):
+            raise ValueError(f"Handoff names must be unique: {handoff_tool_names}")
+        # Check if handoff tool names not in tool names.
+        if any(name in tool_names for name in handoff_tool_names):
+            raise ValueError(
+                f"Handoff names must be unique from tool names. Handoff names: {handoff_tool_names}; tool names: {tool_names}"
+            )
         self._model_context: List[LLMMessage] = []
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         # Add messages to the model context.
         for msg in messages:
-            # TODO: add special handling for handoff messages
             self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
         # Generate an inference result based on the current model context.
         llm_messages = self._system_messages + self._model_context
-        result = await self._model_client.create(llm_messages, tools=self._tools, cancellation_token=cancellation_token)
+        result = await self._model_client.create(
+            llm_messages, tools=self._tools + self._handoff_tools, cancellation_token=cancellation_token
+        )
 
         # Add the response to the model context.
         self._model_context.append(AssistantMessage(content=result.content, source=self.name))
 
         # Run tool calls until the model produces a string response.
         while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
-            event_logger.debug(ToolCallEvent(tool_calls=result.content))
+            event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
             # Execute the tool calls.
             results = await asyncio.gather(
                 *[self._execute_tool_call(call, cancellation_token) for call in result.content]
             )
-            event_logger.debug(ToolCallResultEvent(tool_call_results=results))
+            event_logger.debug(ToolCallResultEvent(tool_call_results=results, source=self.name))
             self._model_context.append(FunctionExecutionResultMessage(content=results))
+
+            # Detect handoff requests.
+            handoffs: List[Handoff] = []
+            for call in result.content:
+                if call.name in self._handoffs:
+                    handoffs.append(self._handoffs[call.name])
+            if len(handoffs) > 0:
+                if len(handoffs) > 1:
+                    raise ValueError(f"Multiple handoffs detected: {[handoff.name for handoff in handoffs]}")
+                # Respond with a handoff message.
+                return HandoffMessage(content=handoffs[0].message, target=handoffs[0].target, source=self.name)
+
             # Generate an inference result based on the current model context.
             result = await self._model_client.create(
-                self._model_context, tools=self._tools, cancellation_token=cancellation_token
+                self._model_context, tools=self._tools + self._handoff_tools, cancellation_token=cancellation_token
             )
             self._model_context.append(AssistantMessage(content=result.content, source=self.name))
 
@@ -127,9 +260,9 @@ async def _execute_tool_call(
     ) -> FunctionExecutionResult:
         """Execute a tool call and return the result."""
         try:
-            if not self._tools:
+            if not self._tools + self._handoff_tools:
                 raise ValueError("No tools are available.")
-            tool = next((t for t in self._tools if t.name == tool_call.name), None)
+            tool = next((t for t in self._tools + self._handoff_tools if t.name == tool_call.name), None)
             if tool is None:
                 raise ValueError(f"The tool '{tool_call.name}' is not available.")
             arguments = json.loads(tool_call.arguments)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 99bd0c888f0f..505ec3cb8ce5 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -35,8 +35,11 @@ class StopMessage(BaseMessage):
 class HandoffMessage(BaseMessage):
     """A message requesting handoff of a conversation to another agent."""
 
+    target: str
+    """The name of the target agent to handoff to."""
+
     content: str
-    """The agent name to handoff the conversation to."""
+    """The handoff message to the target agent."""
 
 
 ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 4f2d08afc1bf..7c24ac4c197c 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -37,7 +37,7 @@ def __init__(
     async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
         """Select a speaker from the participants based on handoff message."""
         if len(thread) > 0 and isinstance(thread[-1].agent_message, HandoffMessage):
-            self._current_speaker = thread[-1].agent_message.content
+            self._current_speaker = thread[-1].agent_message.target
             if self._current_speaker not in self._participant_topic_types:
                 raise ValueError("The selected speaker in the handoff message is not a participant.")
             event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=self._current_speaker, source=self.id))
@@ -47,7 +47,40 @@ async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
 
 
 class Swarm(BaseGroupChat):
-    """(Experimental) A group chat that selects the next speaker based on handoff message only."""
+    """A group chat team that selects the next speaker based on handoff message only.
+
+    The first participant in the list of participants is the initial speaker.
+    The next speaker is selected based on the :class:`~autogen_agentchat.messages.HandoffMessage` message
+    sent by the current speaker. If no handoff message is sent, the current speaker
+    continues to be the speaker.
+
+    Args:
+        participants (List[ChatAgent]): The agents participating in the group chat. The first agent in the list is the initial speaker.
+
+    Examples:
+
+        .. code-block:: python
+
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.teams import Swarm
+            from autogen_agentchat.task import MaxMessageTermination
+
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+            agent1 = AssistantAgent(
+                "Alice",
+                model_client=model_client,
+                handoffs=["Bob"],
+                system_message="You are Alice and you only answer questions about yourself.",
+            )
+            agent2 = AssistantAgent(
+                "Bob", model_client=model_client, system_message="You are Bob and your birthday is on 1st January."
+            )
+
+            team = Swarm([agent1, agent2])
+            await team.run("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
+    """
 
     def __init__(self, participants: List[ChatAgent]):
         super().__init__(participants, group_chat_manager_class=SwarmGroupChatManager)
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 9a243a5a206e..bff941b90ad0 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -1,10 +1,14 @@
 import asyncio
 import json
+import logging
 from typing import Any, AsyncGenerator, List
 
 import pytest
-from autogen_agentchat.agents import AssistantAgent
-from autogen_agentchat.messages import StopMessage, TextMessage
+from autogen_agentchat import EVENT_LOGGER_NAME
+from autogen_agentchat.agents import AssistantAgent, Handoff
+from autogen_agentchat.logging import FileLogHandler
+from autogen_agentchat.messages import HandoffMessage, StopMessage, TextMessage
+from autogen_core.base import CancellationToken
 from autogen_core.components.tools import FunctionTool
 from autogen_ext.models import OpenAIChatCompletionClient
 from openai.resources.chat.completions import AsyncCompletions
@@ -14,6 +18,10 @@
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall, Function
 from openai.types.completion_usage import CompletionUsage
 
+logger = logging.getLogger(EVENT_LOGGER_NAME)
+logger.setLevel(logging.DEBUG)
+logger.addHandler(FileLogHandler("test_assistant_agent.log"))
+
 
 class _MockChatCompletion:
     def __init__(self, chat_completions: List[ChatCompletion]) -> None:
@@ -107,3 +115,51 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     assert isinstance(result.messages[0], TextMessage)
     assert isinstance(result.messages[1], TextMessage)
     assert isinstance(result.messages[2], StopMessage)
+
+
+@pytest.mark.asyncio
+async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
+    handoff = Handoff(target="agent2")
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id1",
+            choices=[
+                Choice(
+                    finish_reason="tool_calls",
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=None,
+                        tool_calls=[
+                            ChatCompletionMessageToolCall(
+                                id="1",
+                                type="function",
+                                function=Function(
+                                    name=handoff.name,
+                                    arguments=json.dumps({}),
+                                ),
+                            )
+                        ],
+                        role="assistant",
+                    ),
+                )
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+    tool_use_agent = AssistantAgent(
+        "tool_use_agent",
+        model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
+        handoffs=[handoff],
+    )
+    response = await tool_use_agent.on_messages(
+        [TextMessage(content="task", source="user")], cancellation_token=CancellationToken()
+    )
+    assert isinstance(response, HandoffMessage)
+    assert response.target == "agent2"
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 3f3c8a3b8a19..d209de3bdac4 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -10,6 +10,7 @@
     AssistantAgent,
     BaseChatAgent,
     CodeExecutorAgent,
+    Handoff,
 )
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import (
@@ -415,11 +416,11 @@ def __init__(self, name: str, description: str, next_agent: str) -> None:
         self._next_agent = next_agent
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        return HandoffMessage(content=self._next_agent, source=self.name)
+        return HandoffMessage(content=f"Transferred to {self._next_agent}.", target=self._next_agent, source=self.name)
 
 
 @pytest.mark.asyncio
-async def test_swarm() -> None:
+async def test_swarm_handoff() -> None:
     first_agent = _HandOffAgent("first_agent", description="first agent", next_agent="second_agent")
     second_agent = _HandOffAgent("second_agent", description="second agent", next_agent="third_agent")
     third_agent = _HandOffAgent("third_agent", description="third agent", next_agent="first_agent")
@@ -428,8 +429,81 @@ async def test_swarm() -> None:
     result = await team.run("task", termination_condition=MaxMessageTermination(6))
     assert len(result.messages) == 6
     assert result.messages[0].content == "task"
-    assert result.messages[1].content == "third_agent"
-    assert result.messages[2].content == "first_agent"
-    assert result.messages[3].content == "second_agent"
-    assert result.messages[4].content == "third_agent"
-    assert result.messages[5].content == "first_agent"
+    assert result.messages[1].content == "Transferred to third_agent."
+    assert result.messages[2].content == "Transferred to first_agent."
+    assert result.messages[3].content == "Transferred to second_agent."
+    assert result.messages[4].content == "Transferred to third_agent."
+    assert result.messages[5].content == "Transferred to first_agent."
+
+
+@pytest.mark.asyncio
+async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -> None:
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id1",
+            choices=[
+                Choice(
+                    finish_reason="tool_calls",
+                    index=0,
+                    message=ChatCompletionMessage(
+                        content=None,
+                        tool_calls=[
+                            ChatCompletionMessageToolCall(
+                                id="1",
+                                type="function",
+                                function=Function(
+                                    name="handoff_to_agent2",
+                                    arguments=json.dumps({}),
+                                ),
+                            )
+                        ],
+                        role="assistant",
+                    ),
+                )
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="Hello", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(
+                    finish_reason="stop", index=0, message=ChatCompletionMessage(content="TERMINATE", role="assistant")
+                )
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+
+    agnet1 = AssistantAgent(
+        "agent1",
+        model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        handoffs=[Handoff(target="agent2", name="handoff_to_agent2", message="handoff to agent2")],
+    )
+    agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
+    team = Swarm([agnet1, agent2])
+    result = await team.run("task", termination_condition=StopMessageTermination())
+    assert len(result.messages) == 5
+    assert result.messages[0].content == "task"
+    assert result.messages[1].content == "handoff to agent2"
+    assert result.messages[2].content == "Transferred to agent1."
+    assert result.messages[3].content == "Hello"
+    assert result.messages[4].content == "TERMINATE"
diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
index 1e5f5c293ded..2a7f00710e94 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
@@ -32,7 +32,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from autogen_ext.models import OpenAIChatCompletionClient, UserMessage\n",
+    "from autogen_core.components.models import UserMessage\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
     "# Create an OpenAI model client.\n",
     "model_client = OpenAIChatCompletionClient(\n",
@@ -500,7 +501,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "autogen_core",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -514,7 +515,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

From 93733dbd65bc8ef1482ea84c4d482d35030c05bf Mon Sep 17 00:00:00 2001
From: Gerardo Moreno 
Date: Tue, 29 Oct 2024 08:17:34 -0700
Subject: [PATCH 045/173] Run LocalCommandLineCodeExecutor within venv (#3977)

* Run LocalCommandLineCodeExecutor within venv

* Remove create_virtual_env func and add docstring

* Add explanation for LocalCommandLineExecutor docstring example

* Enhance docstring example explanation

---------

Co-authored-by: Eric Zhu 
---
 .../command-line-code-executors.ipynb         | 72 ++++++++++++++++++-
 .../_impl/local_commandline_code_executor.py  | 57 ++++++++++++++-
 .../test_commandline_code_executor.py         | 51 +++++++++++++
 3 files changed, 176 insertions(+), 4 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
index a408cd09dd9c..62de20d958cd 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/command-line-code-executors.ipynb
@@ -136,6 +136,76 @@
     "    )\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Local within a Virtual Environment\n",
+    "\n",
+    "If you want the code to run within a virtual environment created as part of the application’s setup, you can specify a directory for the newly created environment and pass its context to  {py:class}`~autogen_core.components.code_executor.LocalCommandLineCodeExecutor`. This setup allows the executor to use the specified virtual environment consistently throughout the application's lifetime, ensuring isolated dependencies and a controlled runtime environment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CommandLineCodeResult(exit_code=0, output='', code_file='/Users/gziz/Dev/autogen/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/coding/tmp_code_d2a7db48799db3cc785156a11a38822a45c19f3956f02ec69b92e4169ecbf2ca.bash')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import venv\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from autogen_core.base import CancellationToken\n",
+    "from autogen_core.components.code_executor import CodeBlock, LocalCommandLineCodeExecutor\n",
+    "\n",
+    "work_dir = Path(\"coding\")\n",
+    "work_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "venv_dir = work_dir / \".venv\"\n",
+    "venv_builder = venv.EnvBuilder(with_pip=True)\n",
+    "venv_builder.create(venv_dir)\n",
+    "venv_context = venv_builder.ensure_directories(venv_dir)\n",
+    "\n",
+    "local_executor = LocalCommandLineCodeExecutor(work_dir=work_dir, virtual_env_context=venv_context)\n",
+    "await local_executor.execute_code_blocks(\n",
+    "    code_blocks=[\n",
+    "        CodeBlock(language=\"bash\", code=\"pip install matplotlib\"),\n",
+    "    ],\n",
+    "    cancellation_token=CancellationToken(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, the code has executed successfully, and the installation has been isolated to the newly created virtual environment, without affecting our global environment."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -154,7 +224,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/src/autogen_core/components/code_executor/_impl/local_commandline_code_executor.py b/python/packages/autogen-core/src/autogen_core/components/code_executor/_impl/local_commandline_code_executor.py
index f74111ef1eaf..deca8355fbb3 100644
--- a/python/packages/autogen-core/src/autogen_core/components/code_executor/_impl/local_commandline_code_executor.py
+++ b/python/packages/autogen-core/src/autogen_core/components/code_executor/_impl/local_commandline_code_executor.py
@@ -3,12 +3,14 @@
 
 import asyncio
 import logging
+import os
 import sys
 import warnings
 from hashlib import sha256
 from pathlib import Path
 from string import Template
-from typing import Any, Callable, ClassVar, List, Sequence, Union
+from types import SimpleNamespace
+from typing import Any, Callable, ClassVar, List, Optional, Sequence, Union
 
 from typing_extensions import ParamSpec
 
@@ -54,6 +56,36 @@ class LocalCommandLineCodeExecutor(CodeExecutor):
             directory is the current directory ".".
         functions (List[Union[FunctionWithRequirements[Any, A], Callable[..., Any]]]): A list of functions that are available to the code executor. Default is an empty list.
         functions_module (str, optional): The name of the module that will be created to store the functions. Defaults to "functions".
+        virtual_env_context (Optional[SimpleNamespace], optional): The virtual environment context. Defaults to None.
+
+    Example:
+
+    How to use `LocalCommandLineCodeExecutor` with a virtual environment different from the one used to run the autogen application:
+    Set up a virtual environment using the `venv` module, and pass its context to the initializer of `LocalCommandLineCodeExecutor`. This way, the executor will run code within the new environment.
+
+        .. code-block:: python
+
+            import venv
+            from pathlib import Path
+
+            from autogen_core.base import CancellationToken
+            from autogen_core.components.code_executor import CodeBlock, LocalCommandLineCodeExecutor
+
+            work_dir = Path("coding")
+            work_dir.mkdir(exist_ok=True)
+
+            venv_dir = work_dir / ".venv"
+            venv_builder = venv.EnvBuilder(with_pip=True)
+            venv_builder.create(venv_dir)
+            venv_context = venv_builder.ensure_directories(venv_dir)
+
+            local_executor = LocalCommandLineCodeExecutor(work_dir=work_dir, virtual_env_context=venv_context)
+            await local_executor.execute_code_blocks(
+                code_blocks=[
+                    CodeBlock(language="bash", code="pip install matplotlib"),
+                ],
+                cancellation_token=CancellationToken(),
+            )
 
     """
 
@@ -86,6 +118,7 @@ def __init__(
             ]
         ] = [],
         functions_module: str = "functions",
+        virtual_env_context: Optional[SimpleNamespace] = None,
     ):
         if timeout < 1:
             raise ValueError("Timeout must be greater than or equal to 1.")
@@ -110,6 +143,8 @@ def __init__(
         else:
             self._setup_functions_complete = True
 
+        self._virtual_env_context: Optional[SimpleNamespace] = virtual_env_context
+
     def format_functions_for_prompt(self, prompt_template: str = FUNCTION_PROMPT_TEMPLATE) -> str:
         """(Experimental) Format the functions for a prompt.
 
@@ -164,9 +199,14 @@ async def _setup_functions(self, cancellation_token: CancellationToken) -> None:
             cmd_args = ["-m", "pip", "install"]
             cmd_args.extend(required_packages)
 
+            if self._virtual_env_context:
+                py_executable = self._virtual_env_context.env_exe
+            else:
+                py_executable = sys.executable
+
             task = asyncio.create_task(
                 asyncio.create_subprocess_exec(
-                    sys.executable,
+                    py_executable,
                     *cmd_args,
                     cwd=self._work_dir,
                     stdout=asyncio.subprocess.PIPE,
@@ -253,7 +293,17 @@ async def _execute_code_dont_check_setup(
                 f.write(code)
             file_names.append(written_file)
 
-            program = sys.executable if lang.startswith("python") else lang_to_cmd(lang)
+            env = os.environ.copy()
+
+            if self._virtual_env_context:
+                virtual_env_exe_abs_path = os.path.abspath(self._virtual_env_context.env_exe)
+                virtual_env_bin_abs_path = os.path.abspath(self._virtual_env_context.bin_path)
+                env["PATH"] = f"{virtual_env_bin_abs_path}{os.pathsep}{env['PATH']}"
+
+                program = virtual_env_exe_abs_path if lang.startswith("python") else lang_to_cmd(lang)
+            else:
+                program = sys.executable if lang.startswith("python") else lang_to_cmd(lang)
+
             # Wrap in a task to make it cancellable
             task = asyncio.create_task(
                 asyncio.create_subprocess_exec(
@@ -262,6 +312,7 @@ async def _execute_code_dont_check_setup(
                     cwd=self._work_dir,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
+                    env=env,
                 )
             )
             cancellation_token.link_future(task)
diff --git a/python/packages/autogen-core/tests/execution/test_commandline_code_executor.py b/python/packages/autogen-core/tests/execution/test_commandline_code_executor.py
index bb3ff2830958..aff36b216acb 100644
--- a/python/packages/autogen-core/tests/execution/test_commandline_code_executor.py
+++ b/python/packages/autogen-core/tests/execution/test_commandline_code_executor.py
@@ -2,8 +2,11 @@
 # Credit to original authors
 
 import asyncio
+import os
+import shutil
 import sys
 import tempfile
+import venv
 from pathlib import Path
 from typing import AsyncGenerator, TypeAlias
 
@@ -143,3 +146,51 @@ async def test_valid_relative_path(executor_and_temp_dir: ExecutorFixture) -> No
     assert "test.py" in result.code_file
     assert (temp_dir / Path("test.py")).resolve() == Path(result.code_file).resolve()
     assert (temp_dir / Path("test.py")).exists()
+
+
+@pytest.mark.asyncio
+async def test_local_executor_with_custom_venv() -> None:
+    with tempfile.TemporaryDirectory() as temp_dir:
+        env_builder = venv.EnvBuilder(with_pip=True)
+        env_builder.create(temp_dir)
+        env_builder_context = env_builder.ensure_directories(temp_dir)
+
+        executor = LocalCommandLineCodeExecutor(work_dir=temp_dir, virtual_env_context=env_builder_context)
+        code_blocks = [
+            # https://stackoverflow.com/questions/1871549/how-to-determine-if-python-is-running-inside-a-virtualenv
+            CodeBlock(code="import sys; print(sys.prefix != sys.base_prefix)", language="python"),
+        ]
+        cancellation_token = CancellationToken()
+        result = await executor.execute_code_blocks(code_blocks, cancellation_token=cancellation_token)
+
+        assert result.exit_code == 0
+        assert result.output.strip() == "True"
+
+
+@pytest.mark.asyncio
+async def test_local_executor_with_custom_venv_in_local_relative_path() -> None:
+    relative_folder_path = "tmp_dir"
+    try:
+        if not os.path.isdir(relative_folder_path):
+            os.mkdir(relative_folder_path)
+
+        env_path = os.path.join(relative_folder_path, ".venv")
+        env_builder = venv.EnvBuilder(with_pip=True)
+        env_builder.create(env_path)
+        env_builder_context = env_builder.ensure_directories(env_path)
+
+        executor = LocalCommandLineCodeExecutor(work_dir=relative_folder_path, virtual_env_context=env_builder_context)
+        code_blocks = [
+            CodeBlock(code="import sys; print(sys.executable)", language="python"),
+        ]
+        cancellation_token = CancellationToken()
+        result = await executor.execute_code_blocks(code_blocks, cancellation_token=cancellation_token)
+
+        assert result.exit_code == 0
+
+        # Check if the expected venv has been used
+        bin_path = os.path.abspath(env_builder_context.bin_path)
+        assert Path(result.output.strip()).parent.samefile(bin_path)
+    finally:
+        if os.path.isdir(relative_folder_path):
+            shutil.rmtree(relative_folder_path)

From bd9c37160514a7845cbd3c2c2c6d05e1b47440b4 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 29 Oct 2024 09:45:57 -0700
Subject: [PATCH 046/173] Add `ResetMessage` to clear the agent state (#3988)

* Reset message to clear agent state

* format and lint
---
 .../src/autogen_agentchat/agents/_assistant_agent.py   |  6 +++++-
 .../src/autogen_agentchat/messages.py                  | 10 +++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 11e243afb348..a94db9e91253 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -21,6 +21,7 @@
 from ..messages import (
     ChatMessage,
     HandoffMessage,
+    ResetMessage,
     StopMessage,
     TextMessage,
 )
@@ -209,7 +210,10 @@ def __init__(
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         # Add messages to the model context.
         for msg in messages:
-            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
+            if isinstance(msg, ResetMessage):
+                self._model_context.clear()
+            else:
+                self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
         # Generate an inference result based on the current model context.
         llm_messages = self._system_messages + self._model_context
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 505ec3cb8ce5..feb8b867c745 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -42,7 +42,14 @@ class HandoffMessage(BaseMessage):
     """The handoff message to the target agent."""
 
 
-ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage
+class ResetMessage(BaseMessage):
+    """A message requesting reset of the recipient's state in the current conversation."""
+
+    content: str
+    """The content for the reset message."""
+
+
+ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage | ResetMessage
 """A message used by agents in a team."""
 
 
@@ -52,5 +59,6 @@ class HandoffMessage(BaseMessage):
     "MultiModalMessage",
     "StopMessage",
     "HandoffMessage",
+    "ResetMessage",
     "ChatMessage",
 ]

From 87bd1de3966a6881b0bdbe147f5775da895e0256 Mon Sep 17 00:00:00 2001
From: Anthony Uphof <44126722+auphof@users.noreply.github.com>
Date: Wed, 30 Oct 2024 12:20:03 +1300
Subject: [PATCH 047/173] Fix: provide valid Prompt and Completion Token usage
 counts from create_stream (#3972)

* Fix: `create_stream` to return valid usage token counts
* documentation

---------

Co-authored-by: Eric Zhu 
---
 .../framework/model-clients.ipynb             | 129 ++++++++++++++++--
 .../components/models/_openai_client.py       |  62 +++++++--
 .../models/_openai/_openai_client.py          |  62 +++++++--
 .../tests/models/test_openai_model_client.py  | 129 ++++++++++++++++--
 4 files changed, 340 insertions(+), 42 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
index 2a7f00710e94..cb17886b964a 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/model-clients.ipynb
@@ -74,6 +74,24 @@
     "print(response.content)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RequestUsage(prompt_tokens=15, completion_tokens=7)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print the response token usage\n",
+    "print(response.usage)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -86,7 +104,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -94,24 +112,26 @@
      "output_type": "stream",
      "text": [
       "Streamed responses:\n",
-      "In a secluded valley where the sun painted the sky with hues of gold, a solitary dragon named Bremora stood guard. Her emerald scales shimmered with an ancient light as she watched over the village below. Unlike her fiery kin, Bremora had no desire for destruction; her soul was bound by a promise to protect.\n",
-      "\n",
-      "Generations ago, a wise elder had befriended Bremora, offering her companionship instead of fear. In gratitude, she vowed to shield the village from calamity. Years passed, and children grew up believing in the legends of a watchful dragon who brought them prosperity and peace.\n",
+      "In the heart of an ancient forest, beneath the shadow of snow-capped peaks, a dragon named Elara lived secretly for centuries. Elara was unlike any dragon from the old tales; her scales shimmered with a deep emerald hue, each scale engraved with symbols of lost wisdom. The villagers in the nearby valley spoke of mysterious lights dancing across the night sky, but none dared venture close enough to solve the enigma.\n",
       "\n",
-      "One summer, an ominous storm threatened the valley, with ravenous winds and torrents of rain. Bremora rose into the tempest, her mighty wings defying the chaos. She channeled her breath—not of fire, but of warmth and tranquility—calming the storm and saving her cherished valley.\n",
+      "One cold winter's eve, a young girl named Lira, brimming with curiosity and armed with the innocence of youth, wandered into Elara’s domain. Instead of fire and fury, she found warmth and a gentle gaze. The dragon shared stories of a world long forgotten and in return, Lira gifted her simple stories of human life, rich in laughter and scent of earth.\n",
       "\n",
-      "When dawn broke and the village emerged unscathed, the people looked to the sky. There, Bremora soared gracefully, a guardian spirit woven into their lives, silently promising her eternal vigilance.\n",
+      "From that night on, the villagers noticed subtle changes—the crops grew taller, and the air seemed sweeter. Elara had infused the valley with ancient magic, a guardian of balance, watching quietly as her new friend thrived under the stars. And so, Lira and Elara’s bond marked the beginning of a timeless friendship that spun tales of hope whispered through the leaves of the ever-verdant forest.\n",
       "\n",
       "------------\n",
       "\n",
       "The complete response:\n",
-      "In a secluded valley where the sun painted the sky with hues of gold, a solitary dragon named Bremora stood guard. Her emerald scales shimmered with an ancient light as she watched over the village below. Unlike her fiery kin, Bremora had no desire for destruction; her soul was bound by a promise to protect.\n",
+      "In the heart of an ancient forest, beneath the shadow of snow-capped peaks, a dragon named Elara lived secretly for centuries. Elara was unlike any dragon from the old tales; her scales shimmered with a deep emerald hue, each scale engraved with symbols of lost wisdom. The villagers in the nearby valley spoke of mysterious lights dancing across the night sky, but none dared venture close enough to solve the enigma.\n",
+      "\n",
+      "One cold winter's eve, a young girl named Lira, brimming with curiosity and armed with the innocence of youth, wandered into Elara’s domain. Instead of fire and fury, she found warmth and a gentle gaze. The dragon shared stories of a world long forgotten and in return, Lira gifted her simple stories of human life, rich in laughter and scent of earth.\n",
+      "\n",
+      "From that night on, the villagers noticed subtle changes—the crops grew taller, and the air seemed sweeter. Elara had infused the valley with ancient magic, a guardian of balance, watching quietly as her new friend thrived under the stars. And so, Lira and Elara’s bond marked the beginning of a timeless friendship that spun tales of hope whispered through the leaves of the ever-verdant forest.\n",
       "\n",
-      "Generations ago, a wise elder had befriended Bremora, offering her companionship instead of fear. In gratitude, she vowed to shield the village from calamity. Years passed, and children grew up believing in the legends of a watchful dragon who brought them prosperity and peace.\n",
       "\n",
-      "One summer, an ominous storm threatened the valley, with ravenous winds and torrents of rain. Bremora rose into the tempest, her mighty wings defying the chaos. She channeled her breath—not of fire, but of warmth and tranquility—calming the storm and saving her cherished valley.\n",
+      "------------\n",
       "\n",
-      "When dawn broke and the village emerged unscathed, the people looked to the sky. There, Bremora soared gracefully, a guardian spirit woven into their lives, silently promising her eternal vigilance.\n"
+      "The token usage was:\n",
+      "RequestUsage(prompt_tokens=0, completion_tokens=0)\n"
      ]
     }
    ],
@@ -133,7 +153,10 @@
     "        # The last response is a CreateResult object with the complete message.\n",
     "        print(\"\\n\\n------------\\n\")\n",
     "        print(\"The complete response:\", flush=True)\n",
-    "        print(response.content, flush=True)"
+    "        print(response.content, flush=True)\n",
+    "        print(\"\\n\\n------------\\n\")\n",
+    "        print(\"The token usage was:\", flush=True)\n",
+    "        print(response.usage, flush=True)"
    ]
   },
   {
@@ -143,7 +166,86 @@
     "```{note}\n",
     "The last response in the streaming response is always the final response\n",
     "of the type {py:class}`~autogen_core.components.models.CreateResult`.\n",
-    "```"
+    "```\n",
+    "\n",
+    "**NB the default usage response is to return zero values**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### A Note on Token usage counts with streaming example\n",
+    "Comparing usage returns in  the above Non Streaming `model_client.create(messages=messages)` vs streaming `model_client.create_stream(messages=messages)` we see differences.\n",
+    "The non streaming response by default returns valid prompt and completion token usage counts. \n",
+    "The streamed response by default returns zero values.\n",
+    "\n",
+    "as documented in the OPENAI API Reference an additional parameter `stream_options` can be specified to return valid usage counts. see [stream_options](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stream_options)\n",
+    "\n",
+    "Only set this when you using streaming ie , using `create_stream` \n",
+    "\n",
+    "to enable this in `create_stream` set `extra_create_args={\"stream_options\": {\"include_usage\": True}},`\n",
+    "\n",
+    "- **Note whilst other API's like LiteLLM also support this, it is not always guarenteed that it is fully supported or correct**\n",
+    "\n",
+    "#### Streaming example with token usage\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Streamed responses:\n",
+      "In a lush, emerald valley hidden by towering peaks, there lived a dragon named Ember. Unlike others of her kind, Ember cherished solitude over treasure, and the songs of the stream over the roar of flames. One misty dawn, a young shepherd stumbled into her sanctuary, lost and frightened. \n",
+      "\n",
+      "Instead of fury, he was met with kindness as Ember extended a wing, guiding him back to safety. In gratitude, the shepherd visited yearly, bringing tales of his world beyond the mountains. Over time, a friendship blossomed, binding man and dragon in shared stories and laughter.\n",
+      "\n",
+      "As the years passed, the legend of Ember the gentle-hearted spread far and wide, forever changing the way dragons were seen in the hearts of many.\n",
+      "\n",
+      "------------\n",
+      "\n",
+      "The complete response:\n",
+      "In a lush, emerald valley hidden by towering peaks, there lived a dragon named Ember. Unlike others of her kind, Ember cherished solitude over treasure, and the songs of the stream over the roar of flames. One misty dawn, a young shepherd stumbled into her sanctuary, lost and frightened. \n",
+      "\n",
+      "Instead of fury, he was met with kindness as Ember extended a wing, guiding him back to safety. In gratitude, the shepherd visited yearly, bringing tales of his world beyond the mountains. Over time, a friendship blossomed, binding man and dragon in shared stories and laughter.\n",
+      "\n",
+      "As the years passed, the legend of Ember the gentle-hearted spread far and wide, forever changing the way dragons were seen in the hearts of many.\n",
+      "\n",
+      "\n",
+      "------------\n",
+      "\n",
+      "The token usage was:\n",
+      "RequestUsage(prompt_tokens=17, completion_tokens=146)\n"
+     ]
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    UserMessage(content=\"Write a very short story about a dragon.\", source=\"user\"),\n",
+    "]\n",
+    "\n",
+    "# Create a stream.\n",
+    "stream = model_client.create_stream(messages=messages, extra_create_args={\"stream_options\": {\"include_usage\": True}})\n",
+    "\n",
+    "# Iterate over the stream and print the responses.\n",
+    "print(\"Streamed responses:\")\n",
+    "async for response in stream:  # type: ignore\n",
+    "    if isinstance(response, str):\n",
+    "        # A partial response is a string.\n",
+    "        print(response, flush=True, end=\"\")\n",
+    "    else:\n",
+    "        # The last response is a CreateResult object with the complete message.\n",
+    "        print(\"\\n\\n------------\\n\")\n",
+    "        print(\"The complete response:\", flush=True)\n",
+    "        print(response.content, flush=True)\n",
+    "        print(\"\\n\\n------------\\n\")\n",
+    "        print(\"The token usage was:\", flush=True)\n",
+    "        print(response.usage, flush=True)"
    ]
   },
   {
@@ -234,7 +336,8 @@
     "from autogen_core.application import SingleThreadedAgentRuntime\n",
     "from autogen_core.base import MessageContext\n",
     "from autogen_core.components import RoutedAgent, message_handler\n",
-    "from autogen_core.components.models import ChatCompletionClient, OpenAIChatCompletionClient, SystemMessage, UserMessage\n",
+    "from autogen_core.components.models import ChatCompletionClient, SystemMessage, UserMessage\n",
+    "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
     "\n",
     "@dataclass\n",
diff --git a/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py b/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
index 2992c8a600c1..813bb59b520f 100644
--- a/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
+++ b/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
@@ -39,6 +39,7 @@
     completion_create_params,
 )
 from openai.types.chat.chat_completion import Choice
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
 from openai.types.shared_params import FunctionDefinition, FunctionParameters
 from pydantic import BaseModel
 from typing_extensions import Unpack
@@ -555,6 +556,31 @@ async def create_stream(
         extra_create_args: Mapping[str, Any] = {},
         cancellation_token: Optional[CancellationToken] = None,
     ) -> AsyncGenerator[Union[str, CreateResult], None]:
+        """
+        Creates an AsyncGenerator that will yield a stream of chat completions based on the provided messages and tools.
+
+        Args:
+            messages (Sequence[LLMMessage]): A sequence of messages to be processed.
+            tools (Sequence[Tool | ToolSchema], optional): A sequence of tools to be used in the completion. Defaults to `[]`.
+            json_output (Optional[bool], optional): If True, the output will be in JSON format. Defaults to None.
+            extra_create_args (Mapping[str, Any], optional): Additional arguments for the creation process. Default to `{}`.
+            cancellation_token (Optional[CancellationToken], optional): A token to cancel the operation. Defaults to None.
+
+        Yields:
+            AsyncGenerator[Union[str, CreateResult], None]: A generator yielding the completion results as they are produced.
+
+        In streaming, the default behaviour is not return token usage counts. See: [OpenAI API reference for possible args](https://platform.openai.com/docs/api-reference/chat/create).
+        However `extra_create_args={"stream_options": {"include_usage": True}}` will (if supported by the accessed API)
+        return a final chunk with usage set to a RequestUsage object having prompt and completion token counts,
+        all preceding chunks will have usage as None. See: [stream_options](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stream_options).
+
+        Other examples of OPENAI supported arguments that can be included in `extra_create_args`:
+            - `temperature` (float): Controls the randomness of the output. Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more focused and deterministic.
+            - `max_tokens` (int): The maximum number of tokens to generate in the completion.
+            - `top_p` (float): An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+            - `frequency_penalty` (float): A value between -2.0 and 2.0 that penalizes new tokens based on their existing frequency in the text so far, decreasing the likelihood of repeated phrases.
+            - `presence_penalty` (float): A value between -2.0 and 2.0 that penalizes new tokens based on whether they appear in the text so far, encouraging the model to talk about new topics.
+        """
         # Make sure all extra_create_args are valid
         extra_create_args_keys = set(extra_create_args.keys())
         if not create_kwargs.issuperset(extra_create_args_keys):
@@ -601,7 +627,8 @@ async def create_stream(
         if cancellation_token is not None:
             cancellation_token.link_future(stream_future)
         stream = await stream_future
-
+        choice: Union[ParsedChoice[Any], ParsedChoice[BaseModel], ChunkChoice] = cast(ChunkChoice, None)
+        chunk = None
         stop_reason = None
         maybe_model = None
         content_deltas: List[str] = []
@@ -614,8 +641,23 @@ async def create_stream(
                 if cancellation_token is not None:
                     cancellation_token.link_future(chunk_future)
                 chunk = await chunk_future
-                choice = chunk.choices[0]
-                stop_reason = choice.finish_reason
+
+                # to process usage chunk in streaming situations
+                # add    stream_options={"include_usage": True} in the initialization of OpenAIChatCompletionClient(...)
+                # However the different api's
+                # OPENAI api usage chunk produces no choices so need to check if there is a choice
+                # liteLLM api usage chunk does produce choices
+                choice = (
+                    chunk.choices[0]
+                    if len(chunk.choices) > 0
+                    else choice
+                    if chunk.usage is not None and stop_reason is not None
+                    else cast(ChunkChoice, None)
+                )
+
+                # for liteLLM chunk usage, do the following hack keeping the pervious chunk.stop_reason (if set).
+                # set the stop_reason for the usage chunk to the prior stop_reason
+                stop_reason = choice.finish_reason if chunk.usage is None and stop_reason is None else stop_reason
                 maybe_model = chunk.model
                 # First try get content
                 if choice.delta.content is not None:
@@ -657,17 +699,21 @@ async def create_stream(
         model = maybe_model or create_args["model"]
         model = model.replace("gpt-35", "gpt-3.5")  # hack for Azure API
 
-        # TODO fix count token
-        prompt_tokens = 0
-        # prompt_tokens = count_token(messages, model=model)
+        if chunk and chunk.usage:
+            prompt_tokens = chunk.usage.prompt_tokens
+        else:
+            prompt_tokens = 0
+
         if stop_reason is None:
             raise ValueError("No stop reason found")
 
         content: Union[str, List[FunctionCall]]
         if len(content_deltas) > 1:
             content = "".join(content_deltas)
-            completion_tokens = 0
-            # completion_tokens = count_token(content, model=model)
+            if chunk and chunk.usage:
+                completion_tokens = chunk.usage.completion_tokens
+            else:
+                completion_tokens = 0
         else:
             completion_tokens = 0
             # TODO: fix assumption that dict values were added in order and actually order by int index
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
index c67b9f3b1075..ee2fc920541c 100644
--- a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
@@ -60,6 +60,7 @@
     completion_create_params,
 )
 from openai.types.chat.chat_completion import Choice
+from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
 from openai.types.shared_params import FunctionDefinition, FunctionParameters
 from pydantic import BaseModel
 from typing_extensions import Unpack
@@ -556,6 +557,31 @@ async def create_stream(
         extra_create_args: Mapping[str, Any] = {},
         cancellation_token: Optional[CancellationToken] = None,
     ) -> AsyncGenerator[Union[str, CreateResult], None]:
+        """
+        Creates an AsyncGenerator that will yield a  stream of chat completions based on the provided messages and tools.
+
+        Args:
+            messages (Sequence[LLMMessage]): A sequence of messages to be processed.
+            tools (Sequence[Tool | ToolSchema], optional): A sequence of tools to be used in the completion. Defaults to `[]`.
+            json_output (Optional[bool], optional): If True, the output will be in JSON format. Defaults to None.
+            extra_create_args (Mapping[str, Any], optional): Additional arguments for the creation process. Default to `{}`.
+            cancellation_token (Optional[CancellationToken], optional): A token to cancel the operation. Defaults to None.
+
+        Yields:
+            AsyncGenerator[Union[str, CreateResult], None]: A generator yielding the completion results as they are produced.
+
+        In streaming, the default behaviour is not return token usage counts. See: [OpenAI API reference for possible args](https://platform.openai.com/docs/api-reference/chat/create).
+        However `extra_create_args={"stream_options": {"include_usage": True}}` will (if supported by the accessed API)
+        return a final chunk with usage set to a RequestUsage object having prompt and completion token counts,
+        all preceding chunks will have usage as None. See: [stream_options](https://platform.openai.com/docs/api-reference/chat/create#chat-create-stream_options).
+
+        Other examples of OPENAI supported arguments that can be included in `extra_create_args`:
+            - `temperature` (float): Controls the randomness of the output. Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more focused and deterministic.
+            - `max_tokens` (int): The maximum number of tokens to generate in the completion.
+            - `top_p` (float): An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass.
+            - `frequency_penalty` (float): A value between -2.0 and 2.0 that penalizes new tokens based on their existing frequency in the text so far, decreasing the likelihood of repeated phrases.
+            - `presence_penalty` (float): A value between -2.0 and 2.0 that penalizes new tokens based on whether they appear in the text so far, encouraging the model to talk about new topics.
+        """
         # Make sure all extra_create_args are valid
         extra_create_args_keys = set(extra_create_args.keys())
         if not create_kwargs.issuperset(extra_create_args_keys):
@@ -602,7 +628,8 @@ async def create_stream(
         if cancellation_token is not None:
             cancellation_token.link_future(stream_future)
         stream = await stream_future
-
+        choice: Union[ParsedChoice[Any], ParsedChoice[BaseModel], ChunkChoice] = cast(ChunkChoice, None)
+        chunk = None
         stop_reason = None
         maybe_model = None
         content_deltas: List[str] = []
@@ -615,8 +642,23 @@ async def create_stream(
                 if cancellation_token is not None:
                     cancellation_token.link_future(chunk_future)
                 chunk = await chunk_future
-                choice = chunk.choices[0]
-                stop_reason = choice.finish_reason
+
+                # to process usage chunk in streaming situations
+                # add    stream_options={"include_usage": True} in the initialization of OpenAIChatCompletionClient(...)
+                # However the different api's
+                # OPENAI api usage chunk produces no choices so need to check if there is a choice
+                # liteLLM api usage chunk does produce choices
+                choice = (
+                    chunk.choices[0]
+                    if len(chunk.choices) > 0
+                    else choice
+                    if chunk.usage is not None and stop_reason is not None
+                    else cast(ChunkChoice, None)
+                )
+
+                # for liteLLM chunk usage, do the following hack keeping the pervious chunk.stop_reason (if set).
+                # set the stop_reason for the usage chunk to the prior stop_reason
+                stop_reason = choice.finish_reason if chunk.usage is None and stop_reason is None else stop_reason
                 maybe_model = chunk.model
                 # First try get content
                 if choice.delta.content is not None:
@@ -658,17 +700,21 @@ async def create_stream(
         model = maybe_model or create_args["model"]
         model = model.replace("gpt-35", "gpt-3.5")  # hack for Azure API
 
-        # TODO fix count token
-        prompt_tokens = 0
-        # prompt_tokens = count_token(messages, model=model)
+        if chunk and chunk.usage:
+            prompt_tokens = chunk.usage.prompt_tokens
+        else:
+            prompt_tokens = 0
+
         if stop_reason is None:
             raise ValueError("No stop reason found")
 
         content: Union[str, List[FunctionCall]]
         if len(content_deltas) > 1:
             content = "".join(content_deltas)
-            completion_tokens = 0
-            # completion_tokens = count_token(content, model=model)
+            if chunk and chunk.usage:
+                completion_tokens = chunk.usage.completion_tokens
+            else:
+                completion_tokens = 0
         else:
             completion_tokens = 0
             # TODO: fix assumption that dict values were added in order and actually order by int index
diff --git a/python/packages/autogen-ext/tests/models/test_openai_model_client.py b/python/packages/autogen-ext/tests/models/test_openai_model_client.py
index f712ef75c5b2..a51e33c0234a 100644
--- a/python/packages/autogen-ext/tests/models/test_openai_model_client.py
+++ b/python/packages/autogen-ext/tests/models/test_openai_model_client.py
@@ -11,6 +11,7 @@
     FunctionExecutionResult,
     FunctionExecutionResultMessage,
     LLMMessage,
+    RequestUsage,
     SystemMessage,
     UserMessage,
 )
@@ -24,28 +25,83 @@
 from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice
 from openai.types.chat.chat_completion_message import ChatCompletionMessage
 from openai.types.completion_usage import CompletionUsage
+from pydantic import BaseModel
+
+
+class MockChunkDefinition(BaseModel):
+    # defining elements for diffentiating mocking chunks
+    chunk_choice: ChunkChoice
+    usage: CompletionUsage | None
 
 
 async def _mock_create_stream(*args: Any, **kwargs: Any) -> AsyncGenerator[ChatCompletionChunk, None]:
     model = resolve_model(kwargs.get("model", "gpt-4o"))
-    chunks = ["Hello", " Another Hello", " Yet Another Hello"]
-    for chunk in chunks:
-        await asyncio.sleep(0.1)
-        yield ChatCompletionChunk(
-            id="id",
-            choices=[
-                ChunkChoice(
-                    finish_reason="stop",
+    mock_chunks_content = ["Hello", " Another Hello", " Yet Another Hello"]
+
+    # The openai api implementations (OpenAI and Litellm) stream chunks of tokens
+    # with content as string, and then at the end a token with stop set and finally if
+    # usage requested with `"stream_options": {"include_usage": True}` a chunk with the usage data
+    mock_chunks = [
+        # generate the list of mock chunk content
+        MockChunkDefinition(
+            chunk_choice=ChunkChoice(
+                finish_reason=None,
+                index=0,
+                delta=ChoiceDelta(
+                    content=mock_chunk_content,
+                    role="assistant",
+                ),
+            ),
+            usage=None,
+        )
+        for mock_chunk_content in mock_chunks_content
+    ] + [
+        # generate the stop chunk
+        MockChunkDefinition(
+            chunk_choice=ChunkChoice(
+                finish_reason="stop",
+                index=0,
+                delta=ChoiceDelta(
+                    content=None,
+                    role="assistant",
+                ),
+            ),
+            usage=None,
+        )
+    ]
+    # generate the usage chunk if configured
+    if kwargs.get("stream_options", {}).get("include_usage") is True:
+        mock_chunks = mock_chunks + [
+            # ---- API differences
+            # OPENAI API does NOT create a choice
+            # LITELLM (proxy) DOES create a choice
+            # Not simulating all the API options, just implementing the LITELLM variant
+            MockChunkDefinition(
+                chunk_choice=ChunkChoice(
+                    finish_reason=None,
                     index=0,
                     delta=ChoiceDelta(
-                        content=chunk,
+                        content=None,
                         role="assistant",
                     ),
-                )
-            ],
+                ),
+                usage=CompletionUsage(prompt_tokens=3, completion_tokens=3, total_tokens=6),
+            )
+        ]
+    elif kwargs.get("stream_options", {}).get("include_usage") is False:
+        pass
+    else:
+        pass
+
+    for mock_chunk in mock_chunks:
+        await asyncio.sleep(0.1)
+        yield ChatCompletionChunk(
+            id="id",
+            choices=[mock_chunk.chunk_choice],
             created=0,
             model=model,
             object="chat.completion.chunk",
+            usage=mock_chunk.usage,
         )
 
 
@@ -95,17 +151,64 @@ async def test_openai_chat_completion_client_create(monkeypatch: pytest.MonkeyPa
 
 
 @pytest.mark.asyncio
-async def test_openai_chat_completion_client_create_stream(monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_openai_chat_completion_client_create_stream_with_usage(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(AsyncCompletions, "create", _mock_create)
+    client = OpenAIChatCompletionClient(model="gpt-4o", api_key="api_key")
+    chunks: List[str | CreateResult] = []
+    async for chunk in client.create_stream(
+        messages=[UserMessage(content="Hello", source="user")],
+        # include_usage not the default of the OPENAI API and must be explicitly set
+        extra_create_args={"stream_options": {"include_usage": True}},
+    ):
+        chunks.append(chunk)
+    assert chunks[0] == "Hello"
+    assert chunks[1] == " Another Hello"
+    assert chunks[2] == " Yet Another Hello"
+    assert isinstance(chunks[-1], CreateResult)
+    assert chunks[-1].content == "Hello Another Hello Yet Another Hello"
+    assert chunks[-1].usage == RequestUsage(prompt_tokens=3, completion_tokens=3)
+
+
+@pytest.mark.asyncio
+async def test_openai_chat_completion_client_create_stream_no_usage_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(AsyncCompletions, "create", _mock_create)
+    client = OpenAIChatCompletionClient(model="gpt-4o", api_key="api_key")
+    chunks: List[str | CreateResult] = []
+    async for chunk in client.create_stream(
+        messages=[UserMessage(content="Hello", source="user")],
+        # include_usage not the default of the OPENAI APIis ,
+        # it can be explicitly set
+        # or just not declared which is the default
+        # extra_create_args={"stream_options": {"include_usage": False}},
+    ):
+        chunks.append(chunk)
+    assert chunks[0] == "Hello"
+    assert chunks[1] == " Another Hello"
+    assert chunks[2] == " Yet Another Hello"
+    assert isinstance(chunks[-1], CreateResult)
+    assert chunks[-1].content == "Hello Another Hello Yet Another Hello"
+    assert chunks[-1].usage == RequestUsage(prompt_tokens=0, completion_tokens=0)
+
+
+@pytest.mark.asyncio
+async def test_openai_chat_completion_client_create_stream_no_usage_explicit(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.setattr(AsyncCompletions, "create", _mock_create)
     client = OpenAIChatCompletionClient(model="gpt-4o", api_key="api_key")
     chunks: List[str | CreateResult] = []
-    async for chunk in client.create_stream(messages=[UserMessage(content="Hello", source="user")]):
+    async for chunk in client.create_stream(
+        messages=[UserMessage(content="Hello", source="user")],
+        # include_usage is not the default of the OPENAI API ,
+        # it can be explicitly set
+        # or just not declared which is the default
+        extra_create_args={"stream_options": {"include_usage": False}},
+    ):
         chunks.append(chunk)
     assert chunks[0] == "Hello"
     assert chunks[1] == " Another Hello"
     assert chunks[2] == " Yet Another Hello"
     assert isinstance(chunks[-1], CreateResult)
     assert chunks[-1].content == "Hello Another Hello Yet Another Hello"
+    assert chunks[-1].usage == RequestUsage(prompt_tokens=0, completion_tokens=0)
 
 
 @pytest.mark.asyncio

From 0f4dd0cc6dd3eea303ad3d2063979b4b9a1aacfc Mon Sep 17 00:00:00 2001
From: Ryan Sweet 
Date: Tue, 29 Oct 2024 16:59:27 -0700
Subject: [PATCH 048/173] Agentbase refactor (#3980)

Remove unused code, refactor AgentBase and AgentWorker/Runtime to use interfaces throughout to enable future implementation of alternate runtimes and separation of the gprpc service from Agent Base (for future in-memory version).
Also adds the missing RegisterAgentResponse methods
---
 dotnet/samples/Hello/HelloAgent/README.md     |  2 +-
 .../samples/Hello/HelloAgentState/README.md   |  2 +-
 .../dev-team/DevTeam.Backend/Program.cs       |  2 +-
 .../Services/GithubWebHookProcessor.cs        |  4 +-
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs | 20 ++++----
 .../Microsoft.AutoGen/Agents/AgentClient.cs   | 46 -------------------
 .../Microsoft.AutoGen/Agents/AgentContext.cs  | 14 +++---
 .../Microsoft.AutoGen/Agents/AgentWorker.cs   | 18 ++++++++
 dotnet/src/Microsoft.AutoGen/Agents/App.cs    |  2 +-
 ...erRuntime.cs => GrpcAgentWorkerRuntime.cs} | 28 ++++++-----
 .../Agents/HostBuilderExtensions.cs           |  8 ++--
 .../Microsoft.AutoGen/Agents/IAgentBase.cs    | 12 ++---
 .../Agents/IAgentWorkerRuntime.cs             |  4 +-
 .../Runtime/WorkerGateway.cs                  | 16 ++++++-
 14 files changed, 83 insertions(+), 95 deletions(-)
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs
 create mode 100644 dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
 rename dotnet/src/Microsoft.AutoGen/Agents/{AgentWorkerRuntime.cs => GrpcAgentWorkerRuntime.cs} (92%)

diff --git a/dotnet/samples/Hello/HelloAgent/README.md b/dotnet/samples/Hello/HelloAgent/README.md
index 795eed07281d..2de64ebaa01b 100644
--- a/dotnet/samples/Hello/HelloAgent/README.md
+++ b/dotnet/samples/Hello/HelloAgent/README.md
@@ -118,4 +118,4 @@ message ReadmeRequested {
   
 ```
 
-You can send messages using the [```Microsoft.AutoGen.Agents.AgentClient``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
+You can send messages using the [```Microsoft.AutoGen.Agents.AgentWorker``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
diff --git a/dotnet/samples/Hello/HelloAgentState/README.md b/dotnet/samples/Hello/HelloAgentState/README.md
index 06c4883182c9..0079005d2450 100644
--- a/dotnet/samples/Hello/HelloAgentState/README.md
+++ b/dotnet/samples/Hello/HelloAgentState/README.md
@@ -117,7 +117,7 @@ message ReadmeRequested {
   
 ```
 
-You can send messages using the [```Microsoft.AutoGen.Agents``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
+You can send messages using the [```Microsoft.AutoGen.Agents.AgentWorker``` class](autogen/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs). Messages are wrapped in [the CloudEvents specification](https://cloudevents.io) and sent to the event bus.
 
 ### Managing State
 
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Program.cs b/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
index d860f4050b47..9de188bdfe8c 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
@@ -23,7 +23,7 @@
     //.AddAgent(nameof(Sandbox))
     .AddAgent(nameof(Hubber));
 
-builder.Services.AddSingleton();
+builder.Services.AddSingleton();
 builder.Services.AddSingleton();
 builder.Services.AddSingleton();
 builder.Services.AddSingleton();
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
index 85b407c4e333..e72b511e2381 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
@@ -10,10 +10,10 @@
 
 namespace DevTeam.Backend;
 
-public sealed class GithubWebHookProcessor(ILogger logger, AgentClient client) : WebhookEventProcessor
+public sealed class GithubWebHookProcessor(ILogger logger, AgentWorker client) : WebhookEventProcessor
 {
     private readonly ILogger _logger = logger;
-    private readonly AgentClient _client = client;
+    private readonly AgentWorker _client = client;
 
     protected override async Task ProcessIssuesWebhookAsync(WebhookHeaders headers, IssuesEvent issuesEvent, IssuesAction action)
     {
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index 62779f8366c7..d4a6ca0f4ee1 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -8,18 +8,17 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public abstract class AgentBase
+public abstract class AgentBase : IAgentBase
 {
     public static readonly ActivitySource s_source = new("AutoGen.Agent");
+    public AgentId AgentId => _context.AgentId;
     private readonly object _lock = new();
     private readonly Dictionary> _pendingRequests = [];
 
     private readonly Channel _mailbox = Channel.CreateUnbounded();
     private readonly IAgentContext _context;
-
-    protected internal AgentId AgentId => _context.AgentId;
     protected internal ILogger Logger => _context.Logger;
-    protected internal IAgentContext Context => _context;
+    public IAgentContext Context => _context;
     protected readonly EventTypes EventTypes;
 
     protected AgentBase(IAgentContext context, EventTypes eventTypes)
@@ -54,7 +53,7 @@ internal Task Start()
         }
     }
 
-    internal void ReceiveMessage(Message message) => _mailbox.Writer.TryWrite(message);
+    public void ReceiveMessage(Message message) => _mailbox.Writer.TryWrite(message);
 
     private async Task RunMessagePump()
     {
@@ -79,7 +78,7 @@ private async Task RunMessagePump()
         }
     }
 
-    private async Task HandleRpcMessage(Message msg)
+    protected internal async Task HandleRpcMessage(Message msg)
     {
         switch (msg.MessageCase)
         {
@@ -108,12 +107,12 @@ await this.InvokeWithActivityAsync(
                 break;
         }
     }
-    protected async Task Store(AgentState state)
+    public async Task Store(AgentState state)
     {
         await _context.Store(state).ConfigureAwait(false);
         return;
     }
-    protected async Task Read(AgentId agentId) where T : IMessage, new()
+    public async Task Read(AgentId agentId) where T : IMessage, new()
     {
         var agentstate = await _context.Read(agentId).ConfigureAwait(false);
         return agentstate.FromAgentState();
@@ -132,7 +131,6 @@ private void OnResponseCore(RpcResponse response)
 
         completion.SetResult(response);
     }
-
     private async Task OnRequestCore(RpcRequest request)
     {
         RpcResponse response;
@@ -193,7 +191,7 @@ static async ((AgentBase Agent, RpcRequest Request, TaskCompletionSource HandleRequest(RpcRequest request) => Task.FromResult(new RpcResponse { Error = "Not implemented" });
+    public virtual Task HandleRequest(RpcRequest request) => Task.FromResult(new RpcResponse { Error = "Not implemented" });
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs
deleted file mode 100644
index 369d717af3b7..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentClient.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Diagnostics;
-using Google.Protobuf;
-using Microsoft.AutoGen.Abstractions;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace Microsoft.AutoGen.Agents;
-public sealed class AgentClient(ILogger logger, AgentWorkerRuntime runtime, DistributedContextPropagator distributedContextPropagator,
-    [FromKeyedServices("EventTypes")] EventTypes eventTypes)
-    : AgentBase(new ClientContext(logger, runtime, distributedContextPropagator), eventTypes)
-{
-    public async ValueTask PublishEventAsync(CloudEvent evt) => await PublishEvent(evt);
-    public async ValueTask SendRequestAsync(AgentId target, string method, Dictionary parameters) => await RequestAsync(target, method, parameters);
-    public async ValueTask PublishEventAsync(string topic, IMessage evt)
-    {
-        await PublishEventAsync(evt.ToCloudEvent(topic)).ConfigureAwait(false);
-    }
-    private sealed class ClientContext(ILogger logger, AgentWorkerRuntime runtime, DistributedContextPropagator distributedContextPropagator) : IAgentContext
-    {
-        public AgentId AgentId { get; } = new AgentId("client", Guid.NewGuid().ToString());
-        public AgentBase? AgentInstance { get; set; }
-        public ILogger Logger { get; } = logger;
-        public DistributedContextPropagator DistributedContextPropagator { get; } = distributedContextPropagator;
-        public async ValueTask PublishEventAsync(CloudEvent @event)
-        {
-            await runtime.PublishEvent(@event).ConfigureAwait(false);
-        }
-        public async ValueTask SendRequestAsync(AgentBase agent, RpcRequest request)
-        {
-            await runtime.SendRequest(AgentInstance!, request).ConfigureAwait(false);
-        }
-
-        public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse response)
-        {
-            await runtime.SendResponse(response).ConfigureAwait(false);
-        }
-        public ValueTask Store(AgentState value)
-        {
-            throw new NotImplementedException();
-        }
-        public ValueTask Read(AgentId agentId)
-        {
-            throw new NotImplementedException();
-        }
-    }
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
index 779cc86a608a..30be1406d3d3 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
@@ -4,9 +4,9 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-internal sealed class AgentContext(AgentId agentId, AgentWorkerRuntime runtime, ILogger logger, DistributedContextPropagator distributedContextPropagator) : IAgentContext
+internal sealed class AgentContext(AgentId agentId, IAgentWorkerRuntime runtime, ILogger logger, DistributedContextPropagator distributedContextPropagator) : IAgentContext
 {
-    private readonly AgentWorkerRuntime _runtime = runtime;
+    private readonly IAgentWorkerRuntime _runtime = runtime;
 
     public AgentId AgentId { get; } = agentId;
     public ILogger Logger { get; } = logger;
@@ -19,18 +19,18 @@ public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse respons
     }
     public async ValueTask SendRequestAsync(AgentBase agent, RpcRequest request)
     {
-        await _runtime.SendRequest(agent, request);
+        await _runtime.SendRequest(agent, request).ConfigureAwait(false);
     }
     public async ValueTask PublishEventAsync(CloudEvent @event)
     {
-        await _runtime.PublishEvent(@event);
+        await _runtime.PublishEvent(@event).ConfigureAwait(false);
     }
     public async ValueTask Store(AgentState value)
     {
-        await _runtime.Store(value);
+        await _runtime.Store(value).ConfigureAwait(false);
     }
-    public async ValueTask Read(AgentId agentId)
+    public ValueTask Read(AgentId agentId)
     {
-        return await _runtime.Read(agentId);
+        return _runtime.Read(agentId);
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
new file mode 100644
index 000000000000..0ba909ac61d5
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
@@ -0,0 +1,18 @@
+using System.Diagnostics;
+using Google.Protobuf;
+using Microsoft.AutoGen.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AutoGen.Agents;
+public sealed class AgentWorker(IAgentWorkerRuntime runtime, DistributedContextPropagator distributedContextPropagator,
+    [FromKeyedServices("EventTypes")] EventTypes eventTypes, ILogger logger)
+    : AgentBase(new AgentContext(new AgentId("client", Guid.NewGuid().ToString()), runtime, logger, distributedContextPropagator), eventTypes)
+{
+    public async ValueTask PublishEventAsync(CloudEvent evt) => await PublishEvent(evt);
+
+    public async ValueTask PublishEventAsync(string topic, IMessage evt)
+    {
+        await PublishEventAsync(evt.ToCloudEvent(topic)).ConfigureAwait(false);
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/App.cs b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
index 00c487ede6fb..be5da1ac5772 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/App.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
@@ -44,7 +44,7 @@ public static async ValueTask PublishMessageAsync(
         {
             await StartAsync(builder, agents, local);
         }
-        var client = Host.Services.GetRequiredService() ?? throw new InvalidOperationException("Host not started");
+        var client = Host.Services.GetRequiredService() ?? throw new InvalidOperationException("Host not started");
         await client.PublishEventAsync(topic, message).ConfigureAwait(false);
         return Host;
     }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
similarity index 92%
rename from dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
rename to dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
index f335881fc09b..b7168b9cb1c6 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
@@ -10,12 +10,12 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public sealed class AgentWorkerRuntime : IHostedService, IDisposable, IAgentWorkerRuntime
+public sealed class GrpcAgentWorkerRuntime : IHostedService, IDisposable, IAgentWorkerRuntime
 {
     private readonly object _channelLock = new();
     private readonly ConcurrentDictionary _agentTypes = new();
-    private readonly ConcurrentDictionary<(string Type, string Key), AgentBase> _agents = new();
-    private readonly ConcurrentDictionary _pendingRequests = new();
+    private readonly ConcurrentDictionary<(string Type, string Key), IAgentBase> _agents = new();
+    private readonly ConcurrentDictionary _pendingRequests = new();
     private readonly Channel _outboundMessagesChannel = Channel.CreateBounded(new BoundedChannelOptions(1024)
     {
         AllowSynchronousContinuations = true,
@@ -26,19 +26,19 @@ public sealed class AgentWorkerRuntime : IHostedService, IDisposable, IAgentWork
     private readonly AgentRpc.AgentRpcClient _client;
     private readonly IServiceProvider _serviceProvider;
     private readonly IEnumerable> _configuredAgentTypes;
-    private readonly ILogger _logger;
+    private readonly ILogger _logger;
     private readonly DistributedContextPropagator _distributedContextPropagator;
     private readonly CancellationTokenSource _shutdownCts;
     private AsyncDuplexStreamingCall? _channel;
     private Task? _readTask;
     private Task? _writeTask;
 
-    public AgentWorkerRuntime(
+    public GrpcAgentWorkerRuntime(
         AgentRpc.AgentRpcClient client,
         IHostApplicationLifetime hostApplicationLifetime,
         IServiceProvider serviceProvider,
         [FromKeyedServices("AgentTypes")] IEnumerable> configuredAgentTypes,
-        ILogger logger,
+        ILogger logger,
         DistributedContextPropagator distributedContextPropagator)
     {
         _client = client;
@@ -83,6 +83,13 @@ private async Task RunReadPump()
                             message.Response.RequestId = request.OriginalRequestId;
                             request.Agent.ReceiveMessage(message);
                             break;
+                        case Message.MessageOneofCase.RegisterAgentTypeResponse:
+                            if (!message.RegisterAgentTypeResponse.Success)
+                            {
+                                throw new InvalidOperationException($"Failed to register agent: '{message.RegisterAgentTypeResponse.Error}'.");
+                            }
+                            break;
+
                         case Message.MessageOneofCase.CloudEvent:
 
                             // HACK: Send the message to an instance of each agent type
@@ -163,7 +170,7 @@ private async Task RunWritePump()
         }
     }
 
-    private AgentBase GetOrActivateAgent(AgentId agentId)
+    private IAgentBase GetOrActivateAgent(AgentId agentId)
     {
         if (!_agents.TryGetValue((agentId.Type, agentId.Key), out var agent))
         {
@@ -197,6 +204,7 @@ await WriteChannelAsync(new Message
                 RegisterAgentTypeRequest = new RegisterAgentTypeRequest
                 {
                     Type = type,
+                    RequestId = Guid.NewGuid().ToString(),
                     //TopicTypes = { topicTypes },
                     //StateType = state?.Name,
                     //Events = { events }
@@ -211,7 +219,7 @@ public async ValueTask SendResponse(RpcResponse response)
         await WriteChannelAsync(new Message { Response = response }).ConfigureAwait(false);
     }
 
-    public async ValueTask SendRequest(AgentBase agent, RpcRequest request)
+    public async ValueTask SendRequest(IAgentBase agent, RpcRequest request)
     {
         _logger.LogInformation("[{AgentId}] Sending request '{Request}'.", agent.AgentId, request);
         var requestId = Guid.NewGuid().ToString();
@@ -322,10 +330,6 @@ public async Task StopAsync(CancellationToken cancellationToken)
             _channel?.Dispose();
         }
     }
-    public ValueTask SendRequest(RpcRequest request)
-    {
-        throw new NotImplementedException();
-    }
     public ValueTask Store(AgentState value)
     {
         var agentId = value.AgentId ?? throw new InvalidOperationException("AgentId is required when saving AgentState.");
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
index 0e29195bff6b..f13756f6ddad 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
@@ -49,9 +49,9 @@ public static AgentApplicationBuilder AddAgentWorker(this IHostApplicationBuilde
             });
         });
         builder.Services.TryAddSingleton(DistributedContextPropagator.Current);
-        builder.Services.AddSingleton();
-        builder.Services.AddSingleton();
-        builder.Services.AddSingleton(sp => sp.GetRequiredService());
+        builder.Services.AddSingleton();
+        builder.Services.AddSingleton(sp => (IHostedService)sp.GetRequiredService());
+        builder.Services.AddSingleton();
         builder.Services.AddKeyedSingleton("EventTypes", (sp, key) =>
         {
             var interfaceType = typeof(IMessage);
@@ -111,7 +111,7 @@ public sealed class AgentTypes(Dictionary types)
                                 .SelectMany(assembly => assembly.GetTypes())
                                 .Where(type => ReflectionHelper.IsSubclassOfGeneric(type, typeof(AgentBase))
                                     && !type.IsAbstract
-                                    && !type.Name.Equals("AgentClient"))
+                                    && !type.Name.Equals("AgentWorker"))
                                 .ToDictionary(type => type.Name, type => type);
 
         return new AgentTypes(agents);
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
index 122dff2c6270..1e5a809ea4d6 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
@@ -1,22 +1,20 @@
+using Google.Protobuf;
 using Microsoft.AutoGen.Abstractions;
-using Microsoft.Extensions.Logging;
 
 namespace Microsoft.AutoGen.Agents
 {
     public interface IAgentBase
     {
         // Properties
-        string AgentId { get; }
-        ILogger Logger { get; }
+        AgentId AgentId { get; }
         IAgentContext Context { get; }
 
         // Methods
         Task CallHandler(CloudEvent item);
         Task HandleRequest(RpcRequest request);
-        Task Start();
-        Task ReceiveMessage(Message message);
+        void ReceiveMessage(Message message);
         Task Store(AgentState state);
-        Task Read(AgentId agentId);
-        Task PublishEvent(CloudEvent item);
+        Task Read(AgentId agentId) where T : IMessage, new();
+        ValueTask PublishEvent(CloudEvent item);
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs
index ee1f6e4e2a13..5c2c7f486402 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs
@@ -6,6 +6,8 @@ namespace Microsoft.AutoGen.Agents;
 public interface IAgentWorkerRuntime
 {
     ValueTask PublishEvent(CloudEvent evt);
-    ValueTask SendRequest(RpcRequest request);
+    ValueTask SendRequest(IAgentBase agent, RpcRequest request);
     ValueTask SendResponse(RpcResponse response);
+    ValueTask Store(AgentState value);
+    ValueTask Read(AgentId agentId);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
index 6d549ef7270f..424c5193a0a0 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
@@ -141,8 +141,22 @@ private async ValueTask RegisterAgentTypeAsync(WorkerProcessConnection connectio
     {
         connection.AddSupportedType(msg.Type);
         _supportedAgentTypes.GetOrAdd(msg.Type, _ => []).Add(connection);
+        var success = false;
+        var error = String.Empty;
 
-        await _gatewayRegistry.RegisterAgentType(msg.Type, _reference);
+        try
+        {
+            await _gatewayRegistry.RegisterAgentType(msg.Type, _reference);
+            success = true;
+        }
+        catch (InvalidOperationException exception)
+        {
+            error = $"Error registering agent type '{msg.Type}'.";
+            _logger.LogWarning(exception, error);
+        }
+        var request_id = msg.RequestId;
+        var response = new RegisterAgentTypeResponse { RequestId = request_id, Success = success, Error = error };
+        await connection.SendMessage(new Message { RegisterAgentTypeResponse = response });
     }
 
     private async ValueTask DispatchEventAsync(CloudEvent evt)

From 75b00e76e1e64527a01c038a1db9baf419733db5 Mon Sep 17 00:00:00 2001
From: Victor Dibia 
Date: Tue, 29 Oct 2024 18:37:26 -0700
Subject: [PATCH 049/173] Agentchat move termination (#3992)

---
 .../autogen_agentchat/task/_terminations.py   |  2 +-
 .../teams/_group_chat/_base_group_chat.py     | 10 ++++--
 .../_group_chat/_round_robin_group_chat.py    |  8 +++--
 .../teams/_group_chat/_selector_group_chat.py |  8 +++--
 .../teams/_group_chat/_swarm_group_chat.py    |  6 ++--
 .../agentchat-user-guide/quickstart.ipynb     | 34 ++++++++-----------
 6 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
index 191e14f8566c..ade11d759b36 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
@@ -48,7 +48,7 @@ async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
         self._message_count += len(messages)
         if self._message_count >= self._max_messages:
             return StopMessage(
-                content=f"Maximal number of messages {self._max_messages} reached, current message count: {self._message_count}",
+                content=f"Maximum number of messages {self._max_messages} reached, current message count: {self._message_count}",
                 source="MaxMessageTermination",
             )
         return None
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 6ee79d4ded0a..f5268a3a9afa 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -28,7 +28,12 @@ class BaseGroupChat(Team, ABC):
     create a subclass of :class:`BaseGroupChat` that uses the group chat manager.
     """
 
-    def __init__(self, participants: List[ChatAgent], group_chat_manager_class: type[BaseGroupChatManager]):
+    def __init__(
+        self,
+        participants: List[ChatAgent],
+        group_chat_manager_class: type[BaseGroupChatManager],
+        termination_condition: TerminationCondition | None = None,
+    ):
         if len(participants) == 0:
             raise ValueError("At least one participant is required.")
         if len(participants) != len(set(participant.name for participant in participants)):
@@ -36,6 +41,7 @@ def __init__(self, participants: List[ChatAgent], group_chat_manager_class: type
         self._participants = participants
         self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
+        self._termination_condition = termination_condition
 
     @abstractmethod
     def _create_group_chat_manager_factory(
@@ -109,7 +115,7 @@ async def run(
                 group_topic_type=group_topic_type,
                 participant_topic_types=participant_topic_types,
                 participant_descriptions=participant_descriptions,
-                termination_condition=termination_condition,
+                termination_condition=termination_condition or self._termination_condition,
             ),
         )
         # Add subscriptions for the group chat manager.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index fff872dd84b6..e8f5f66533f2 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -82,8 +82,12 @@ class RoundRobinGroupChat(BaseGroupChat):
 
     """
 
-    def __init__(self, participants: List[ChatAgent]):
-        super().__init__(participants, group_chat_manager_class=RoundRobinGroupChatManager)
+    def __init__(self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None):
+        super().__init__(
+            participants,
+            termination_condition=termination_condition,
+            group_chat_manager_class=RoundRobinGroupChatManager,
+        )
 
     def _create_group_chat_manager_factory(
         self,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 79f8b60decf4..3cc489daa6b7 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -140,7 +140,8 @@ def _mentioned_agents(self, message_content: str, agent_names: List[str]) -> Dic
                 + re.escape(name.replace("_", r"\_"))
                 + r")(?=\W)"
             )
-            count = len(re.findall(regex, f" {message_content} "))  # Pad the message to help with matching
+            # Pad the message to help with matching
+            count = len(re.findall(regex, f" {message_content} "))
             if count > 0:
                 mentions[name] = count
         return mentions
@@ -184,6 +185,7 @@ def __init__(
         participants: List[ChatAgent],
         model_client: ChatCompletionClient,
         *,
+        termination_condition: TerminationCondition | None = None,
         selector_prompt: str = """You are in a role play game. The following roles are available:
 {roles}.
 Read the following conversation. Then select the next role from {participants} to play. Only return the role.
@@ -194,7 +196,9 @@ def __init__(
 """,
         allow_repeated_speaker: bool = False,
     ):
-        super().__init__(participants, group_chat_manager_class=SelectorGroupChatManager)
+        super().__init__(
+            participants, termination_condition=termination_condition, group_chat_manager_class=SelectorGroupChatManager
+        )
         # Validate the participants.
         if len(participants) < 2:
             raise ValueError("At least two participants are required for SelectorGroupChat.")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 7c24ac4c197c..694584706d01 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -82,8 +82,10 @@ class Swarm(BaseGroupChat):
             await team.run("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
     """
 
-    def __init__(self, participants: List[ChatAgent]):
-        super().__init__(participants, group_chat_manager_class=SwarmGroupChatManager)
+    def __init__(self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None):
+        super().__init__(
+            participants, termination_condition=termination_condition, group_chat_manager_class=SwarmGroupChatManager
+        )
 
     def _create_group_chat_manager_factory(
         self,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index be69005d7a05..52f4b1baa914 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -37,18 +37,18 @@
      "text": [
       "\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-23T12:15:51.582079]:\u001b[0m\n",
+      "\u001b[91m[2024-10-29T15:48:06.329810]:\u001b[0m\n",
       "\n",
       "What is the weather in New York?\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-23T12:15:52.745820], writing_agent:\u001b[0m\n",
+      "\u001b[91m[2024-10-29T15:48:08.085839], weather_agent:\u001b[0m\n",
       "\n",
-      "The weather in New York is currently 73 degrees and sunny. TERMINATE\n",
+      "The weather in New York is 73 degrees and sunny.\n",
       "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-23T12:15:52.746210], Termination:\u001b[0m\n",
+      "\u001b[91m[2024-10-29T15:48:08.086180], Termination:\u001b[0m\n",
       "\n",
-      "Maximal number of messages 1 reached, current message count: 1\n",
-      " TaskResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), StopMessage(source='writing_agent', content='The weather in New York is currently 73 degrees and sunny. TERMINATE')])\n"
+      "Maximum number of messages 2 reached, current message count: 2\n",
+      " TaskResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), TextMessage(source='weather_agent', content='The weather in New York is 73 degrees and sunny.')])\n"
      ]
     }
    ],
@@ -56,13 +56,13 @@
     "import logging\n",
     "\n",
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
-    "from autogen_agentchat.agents import ToolUseAssistantAgent\n",
+    "from autogen_agentchat.agents import AssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
     "from autogen_agentchat.task import MaxMessageTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
-    "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
+    "# set up logging. You can define your own logger\n",
     "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
     "logger.addHandler(ConsoleLogHandler())\n",
     "logger.setLevel(logging.INFO)\n",
@@ -73,22 +73,18 @@
     "    return f\"The weather in {city} is 73 degrees and Sunny.\"\n",
     "\n",
     "\n",
-    "# wrap the tool for use with the agent\n",
-    "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")\n",
-    "\n",
     "# define an agent\n",
-    "weather_agent = ToolUseAssistantAgent(\n",
-    "    name=\"writing_agent\",\n",
+    "weather_agent = AssistantAgent(\n",
+    "    name=\"weather_agent\",\n",
     "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-2024-08-06\"),\n",
-    "    registered_tools=[get_weather_tool],\n",
+    "    tools=[get_weather],\n",
     ")\n",
     "\n",
     "# add the agent to a team\n",
-    "agent_team = RoundRobinGroupChat([weather_agent])\n",
+    "agent_team = RoundRobinGroupChat([weather_agent], termination_condition=MaxMessageTermination(max_messages=2))\n",
     "# Note: if running in a Python file directly you'll need to use asyncio.run(agent_team.run(...)) instead of await agent_team.run(...)\n",
     "result = await agent_team.run(\n",
     "    task=\"What is the weather in New York?\",\n",
-    "    termination_condition=MaxMessageTermination(max_messages=1),\n",
     ")\n",
     "print(\"\\n\", result)"
    ]
@@ -97,7 +93,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The code snippet above introduces two high level concepts in AgentChat: `Agent` and `Team`.  An Agent helps us define what actions are taken when a message is received. Specifically, we use the `ToolUseAssistantAgent` preset - an agent that can be given a function that it can then use to address tasks.  A Team helps us define the rules for how agents interact with each other.  In the  `RoundRobinGroupChat` team, agents receive messages in a sequential round-robin fashion.  "
+    "The code snippet above introduces two high level concepts in AgentChat: `Agent` and `Team`.  An Agent helps us define what actions are taken when a message is received. Specifically, we use the `AssistantAgent` preset - an agent that can be given tools (functions) that it can then use to address tasks.  A Team helps us define the rules for how agents interact with each other.  In the  `RoundRobinGroupChat` team, agents receive messages in a sequential round-robin fashion.  "
    ]
   },
   {
@@ -113,7 +109,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "agnext",
    "language": "python",
    "name": "python3"
   },
@@ -127,7 +123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

From 4a49844996f94770e426c4c940f2a45491361431 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Wed, 30 Oct 2024 05:32:11 -0700
Subject: [PATCH 050/173] `ChatAgent` declares the types of messages it
 produces (#3991)

* `ChatAgent` declares the types of messages it produces
---
 .../src/autogen_agentchat/agents/_assistant_agent.py |  7 +++++++
 .../src/autogen_agentchat/agents/_base_chat_agent.py |  8 +++++++-
 .../autogen_agentchat/agents/_code_executor_agent.py |  5 +++++
 .../src/autogen_agentchat/base/_chat_agent.py        |  7 ++++++-
 .../teams/_group_chat/_chat_agent_container.py       |  5 +++++
 .../teams/_group_chat/_swarm_group_chat.py           |  4 ++++
 .../autogen-agentchat/tests/test_assistant_agent.py  |  1 +
 .../autogen-agentchat/tests/test_group_chat.py       | 12 ++++++++++++
 .../agentchat-user-guide/tutorial/agents.ipynb       |  8 ++++++--
 .../tutorial/selector-group-chat.ipynb               |  8 ++++++--
 10 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index a94db9e91253..a5dece3f62d4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -207,6 +207,13 @@ def __init__(
             )
         self._model_context: List[LLMMessage] = []
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        """The types of messages that the assistant agent produces."""
+        if self._handoffs:
+            return [TextMessage, HandoffMessage, StopMessage]
+        return [TextMessage, StopMessage]
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         # Add messages to the model context.
         for msg in messages:
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index 77bf4c02c470..bc5352867800 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Sequence
+from typing import List, Sequence
 
 from autogen_core.base import CancellationToken
 
@@ -30,6 +30,12 @@ def description(self) -> str:
         describe the agent's capabilities and how to interact with it."""
         return self._description
 
+    @property
+    @abstractmethod
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        """The types of messages that the agent produces."""
+        ...
+
     @abstractmethod
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         """Handle incoming messages and return a response message."""
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
index 07cb45c4d84f..c5c216e52e08 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
@@ -20,6 +20,11 @@ def __init__(
         super().__init__(name=name, description=description)
         self._code_executor = code_executor
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        """The types of messages that the code executor agent produces."""
+        return [TextMessage]
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         # Extract code blocks from the messages.
         code_blocks: List[CodeBlock] = []
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index d82539540628..689f6e6d5e7a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -1,4 +1,4 @@
-from typing import Protocol, Sequence, runtime_checkable
+from typing import List, Protocol, Sequence, runtime_checkable
 
 from autogen_core.base import CancellationToken
 
@@ -24,6 +24,11 @@ def description(self) -> str:
         describe the agent's capabilities and how to interact with it."""
         ...
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        """The types of messages that the agent produces."""
+        ...
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         """Handle incoming messages and return a response message."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index acf5e9d2f467..e2970ffe6376 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -36,6 +36,11 @@ async def handle_content_request(self, message: GroupChatRequestPublishEvent, ct
         to the delegate agent and publish the response."""
         # Pass the messages in the buffer to the delegate agent.
         response = await self._agent.on_messages(self._message_buffer, ctx.cancellation_token)
+        if not any(isinstance(response, msg_type) for msg_type in self._agent.produced_message_types):
+            raise ValueError(
+                f"The agent {self._agent.name} produced an unexpected message type: {type(response)}. "
+                f"Expected one of: {self._agent.produced_message_types}"
+            )
 
         # Publish the response.
         self._message_buffer.clear()
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 694584706d01..872f12e2ba31 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -86,6 +86,10 @@ def __init__(self, participants: List[ChatAgent], termination_condition: Termina
         super().__init__(
             participants, termination_condition=termination_condition, group_chat_manager_class=SwarmGroupChatManager
         )
+        # The first participant must be able to produce handoff messages.
+        first_participant = self._participants[0]
+        if HandoffMessage not in first_participant.produced_message_types:
+            raise ValueError("The first participant must be able to produce a handoff messages.")
 
     def _create_group_chat_manager_factory(
         self,
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index bff941b90ad0..332a7bab15a8 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -158,6 +158,7 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
         tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
         handoffs=[handoff],
     )
+    assert HandoffMessage in tool_use_agent.produced_message_types
     response = await tool_use_agent.on_messages(
         [TextMessage(content="task", source="user")], cancellation_token=CancellationToken()
     )
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index d209de3bdac4..1d04c78b605d 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -62,6 +62,10 @@ def __init__(self, name: str, description: str) -> None:
         super().__init__(name, description)
         self._last_message: str | None = None
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        return [TextMessage]
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         if len(messages) > 0:
             assert isinstance(messages[0], TextMessage)
@@ -78,6 +82,10 @@ def __init__(self, name: str, description: str, *, stop_at: int = 1) -> None:
         self._count = 0
         self._stop_at = stop_at
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        return [TextMessage, StopMessage]
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         self._count += 1
         if self._count < self._stop_at:
@@ -415,6 +423,10 @@ def __init__(self, name: str, description: str, next_agent: str) -> None:
         super().__init__(name, description)
         self._next_agent = next_agent
 
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        return [HandoffMessage]
+
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
         return HandoffMessage(content=f"Transferred to {self._next_agent}.", target=self._next_agent, source=self.name)
 
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index b6da9dd8801b..0e58c2522a5e 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -248,7 +248,7 @@
    ],
    "source": [
     "import asyncio\n",
-    "from typing import Sequence\n",
+    "from typing import List, Sequence\n",
     "\n",
     "from autogen_agentchat.agents import BaseChatAgent\n",
     "from autogen_agentchat.messages import (\n",
@@ -262,6 +262,10 @@
     "    def __init__(self, name: str) -> None:\n",
     "        super().__init__(name, \"A human user.\")\n",
     "\n",
+    "    @property\n",
+    "    def produced_message_types(self) -> List[type[ChatMessage]]:\n",
+    "        return [TextMessage, StopMessage]\n",
+    "\n",
     "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:\n",
     "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
     "        if \"TERMINATE\" in user_input:\n",
@@ -312,7 +316,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index e85715d2baea..f5a5358aae51 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -38,7 +38,7 @@
    "outputs": [],
    "source": [
     "import asyncio\n",
-    "from typing import Sequence\n",
+    "from typing import List, Sequence\n",
     "\n",
     "from autogen_agentchat.agents import (\n",
     "    BaseChatAgent,\n",
@@ -71,6 +71,10 @@
     "    def __init__(self, name: str) -> None:\n",
     "        super().__init__(name, \"A human user.\")\n",
     "\n",
+    "    @property\n",
+    "    def produced_message_types(self) -> List[type[ChatMessage]]:\n",
+    "        return [TextMessage, StopMessage]\n",
+    "\n",
     "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:\n",
     "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
     "        if \"TERMINATE\" in user_input:\n",
@@ -269,7 +273,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

From 51cd5b8d1f62b8d879d53e360c961960f195f4dc Mon Sep 17 00:00:00 2001
From: Ryan Sweet 
Date: Wed, 30 Oct 2024 09:51:01 -0700
Subject: [PATCH 051/173] interface inheritance examples (#3989)

changes to AgentBase and HostBuilderExtensions to enable leveraging handlers from composition (interfaces) vs inheritance... see HelloAgents sample for usage

closes #3928
is related to #3925
---
 dotnet/AutoGen.sln                            |  2 +-
 dotnet/samples/Hello/HelloAgent/Program.cs    |  3 +-
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs | 40 +++++++++++++---
 .../IOAgent/ConsoleAgent/IHandleConsole.cs    | 47 +++++++++++++++++++
 .../Agents/GrpcAgentWorkerRuntime.cs          |  1 +
 .../Agents/HostBuilderExtensions.cs           | 45 ++++++++++++++++++
 6 files changed, 130 insertions(+), 8 deletions(-)
 create mode 100644 dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 83147d38dc7b..4b8ce8ff0142 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -125,7 +125,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AIModelClientHostingExtensi
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sample", "sample", "{686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloAgentState", "samples\Hello\HelloAgentState\HelloAgentState.csproj", "{64EF61E7-00A6-4E5E-9808-62E10993A0E5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAgentState", "samples\Hello\HelloAgentState\HelloAgentState.csproj", "{64EF61E7-00A6-4E5E-9808-62E10993A0E5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/dotnet/samples/Hello/HelloAgent/Program.cs b/dotnet/samples/Hello/HelloAgent/Program.cs
index d378a5b4f781..bccc66dfb9c9 100644
--- a/dotnet/samples/Hello/HelloAgent/Program.cs
+++ b/dotnet/samples/Hello/HelloAgent/Program.cs
@@ -18,10 +18,11 @@ namespace Hello
     [TopicSubscription("HelloAgents")]
     public class HelloAgent(
         IAgentContext context,
-        [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : ConsoleAgent(
+        [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : AgentBase(
             context,
             typeRegistry),
             ISayHello,
+            IHandleConsole,
             IHandle,
             IHandle
     {
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index d4a6ca0f4ee1..cfe2b409133c 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Threading.Channels;
@@ -17,6 +18,8 @@ public abstract class AgentBase : IAgentBase
 
     private readonly Channel _mailbox = Channel.CreateUnbounded();
     private readonly IAgentContext _context;
+    public string Route { get; set; } = "base";
+
     protected internal ILogger Logger => _context.Logger;
     public IAgentContext Context => _context;
     protected readonly EventTypes EventTypes;
@@ -212,14 +215,39 @@ static async ((AgentBase Agent, CloudEvent Event, TaskCompletionSource).MakeGenericType(EventTypes.Types[item.Type]);
-            var methodInfo = genericInterfaceType.GetMethod(nameof(IHandle.Handle)) ?? throw new InvalidOperationException($"Method not found on type {genericInterfaceType.FullName}");
-            return methodInfo.Invoke(this, [payload]) as Task ?? Task.CompletedTask;
+            if (EventTypes.EventsMap[key].Contains(item.Type))
+            {
+                var payload = item.ProtoData.Unpack(EventTypes.TypeRegistry);
+                var convertedPayload = Convert.ChangeType(payload, EventTypes.Types[item.Type]);
+                var genericInterfaceType = typeof(IHandle<>).MakeGenericType(EventTypes.Types[item.Type]);
+
+                MethodInfo methodInfo;
+                try
+                {
+                    // check that our target actually implements this interface, otherwise call the default static
+                    if (genericInterfaceType.IsAssignableFrom(this.GetType()))
+                    {
+                        methodInfo = genericInterfaceType.GetMethod(nameof(IHandle.Handle), BindingFlags.Public | BindingFlags.Instance)
+                                       ?? throw new InvalidOperationException($"Method not found on type {genericInterfaceType.FullName}");
+                        return methodInfo.Invoke(this, [payload]) as Task ?? Task.CompletedTask;
+                    }
+                    else
+                    {
+                        // The error here is we have registered for an event that we do not have code to listen to
+                        throw new InvalidOperationException($"No handler found for event '{item.Type}'; expecting IHandle<{item.Type}> implementation.");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, $"Error invoking method {nameof(IHandle.Handle)}");
+                    throw; // TODO: ?
+                }
+            }
         }
+
         return Task.CompletedTask;
     }
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
new file mode 100644
index 000000000000..739dce125114
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
@@ -0,0 +1,47 @@
+using Microsoft.AutoGen.Abstractions;
+
+namespace Microsoft.AutoGen.Agents
+{
+    public interface IHandleConsole : IHandle, IHandle
+    {
+        string Route { get; }
+        AgentId AgentId { get; }
+        ValueTask PublishEvent(CloudEvent item);
+
+        async Task IHandle.Handle(Output item)
+        {
+            // Assuming item has a property `Message` that we want to write to the console
+            Console.WriteLine(item.Message);
+            await ProcessOutput(item.Message);
+
+            var evt = new OutputWritten
+            {
+                Route = "console"
+            }.ToCloudEvent(AgentId.Key);
+            await PublishEvent(evt);
+        }
+        async Task IHandle.Handle(Input item)
+        {
+            Console.WriteLine("Please enter input:");
+            string content = Console.ReadLine() ?? string.Empty;
+
+            await ProcessInput(content);
+
+            var evt = new InputProcessed
+            {
+                Route = "console"
+            }.ToCloudEvent(AgentId.Key);
+            await PublishEvent(evt);
+        }
+        static Task ProcessOutput(string message)
+        {
+            // Implement your output processing logic here
+            return Task.CompletedTask;
+        }
+        static Task ProcessInput(string message)
+        {
+            // Implement your input processing logic here
+            return Task.FromResult(message);
+        }
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
index b7168b9cb1c6..3a8355166d5b 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
@@ -83,6 +83,7 @@ private async Task RunReadPump()
                             message.Response.RequestId = request.OriginalRequestId;
                             request.Agent.ReceiveMessage(message);
                             break;
+
                         case Message.MessageOneofCase.RegisterAgentTypeResponse:
                             if (!message.RegisterAgentTypeResponse.Success)
                             {
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
index f13756f6ddad..74d19042e980 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
@@ -71,7 +71,52 @@ public static AgentApplicationBuilder AddAgentWorker(this IHostApplicationBuilde
                                                   .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IHandle<>))
                                                   .Select(i => (GetMessageDescriptor(i.GetGenericArguments().First())?.FullName ?? "")).ToHashSet()))
                                     .ToDictionary(item => item.t, item => item.Item2);
+            // if the assembly contains any interfaces of type IHandler, then add all the methods of the interface to the eventsMap
+            var handlersMap = AppDomain.CurrentDomain.GetAssemblies()
+                                    .SelectMany(assembly => assembly.GetTypes())
+                                    .Where(type => ReflectionHelper.IsSubclassOfGeneric(type, typeof(AgentBase)) && !type.IsAbstract)
+                                    .Select(t => (t, t.GetMethods()
+                                                  .Where(m => m.Name == "Handle")
+                                                  .Select(m => (GetMessageDescriptor(m.GetParameters().First().ParameterType)?.FullName ?? "")).ToHashSet()))
+                                    .ToDictionary(item => item.t, item => item.Item2);
+            // get interfaces implemented by the agent and get the methods of the interface if they are named Handle
+            var ifaceHandlersMap = AppDomain.CurrentDomain.GetAssemblies()
+                                    .SelectMany(assembly => assembly.GetTypes())
+                                    .Where(type => ReflectionHelper.IsSubclassOfGeneric(type, typeof(AgentBase)) && !type.IsAbstract)
+                                    .Select(t => t.GetInterfaces()
+                                                  .Select(i => (t, i, i.GetMethods()
+                                                  .Where(m => m.Name == "Handle")
+                                                    .Select(m => (GetMessageDescriptor(m.GetParameters().First().ParameterType)?.FullName ?? ""))
+                                                    //to dictionary of type t and paramter type of the method
+                                                    .ToDictionary(m => m, m => m).Keys.ToHashSet())).ToList());
+            // for each item in ifaceHandlersMap, add the handlers to eventsMap with item as the key 
+            foreach (var item in ifaceHandlersMap)
+            {
+                foreach (var iface in item)
+                {
+                    if (eventsMap.TryGetValue(iface.Item2, out var events))
+                    {
+                        events.UnionWith(iface.Item3);
+                    }
+                    else
+                    {
+                        eventsMap[iface.Item2] = iface.Item3;
+                    }
+                }
+            }
 
+            // merge the handlersMap into the eventsMap
+            foreach (var item in handlersMap)
+            {
+                if (eventsMap.TryGetValue(item.Key, out var events))
+                {
+                    events.UnionWith(item.Value);
+                }
+                else
+                {
+                    eventsMap[item.Key] = item.Value;
+                }
+            }
             return new EventTypes(typeRegistry, types, eventsMap);
         });
         return new AgentApplicationBuilder(builder);

From e63fd17ed52797fff88b142720ff23f4af841569 Mon Sep 17 00:00:00 2001
From: Xiaoyun Zhang 
Date: Wed, 30 Oct 2024 10:05:58 -0700
Subject: [PATCH 052/173] [.Net] use file-scope (#3997)

* use file-scope

* reformat
---
 dotnet/.editorconfig                          |   4 +-
 dotnet/src/AutoGen/API/LLMConfigAPI.cs        |  67 ++--
 .../IOAgent/ConsoleAgent/IHandleConsole.cs    |  71 ++--
 .../Microsoft.AutoGen/Agents/IAgentBase.cs    |  27 +-
 .../AIModelClientHostingExtensions.cs         |  49 ++-
 .../AutoGen.OpenAI.Tests/MathClassTest.cs     | 333 +++++++++--------
 .../AutoGen.OpenAI.V1.Tests/MathClassTest.cs  | 345 +++++++++---------
 .../FunctionCallTemplateEncodingTests.cs      | 125 ++++---
 .../FunctionExample.test.cs                   | 183 +++++-----
 .../FunctionExamples.cs                       | 107 +++---
 dotnet/test/AutoGen.Tests/BasicSampleTest.cs  | 105 +++---
 .../AutoGen.Tests/GroupChat/GraphTests.cs     |  19 +-
 dotnet/test/AutoGen.Tests/SingleAgentTest.cs  | 341 +++++++++--------
 13 files changed, 883 insertions(+), 893 deletions(-)

diff --git a/dotnet/.editorconfig b/dotnet/.editorconfig
index b013b5202b89..6e2b709d881c 100644
--- a/dotnet/.editorconfig
+++ b/dotnet/.editorconfig
@@ -221,13 +221,14 @@ dotnet_diagnostic.IDE0161.severity = warning # Use file-scoped namespace
 
 csharp_style_var_elsewhere = true:suggestion # Prefer 'var' everywhere
 csharp_prefer_simple_using_statement = true:suggestion
-csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_namespace_declarations = file_scoped:warning
 csharp_style_prefer_method_group_conversion = true:silent
 csharp_style_prefer_top_level_statements = true:silent
 csharp_style_prefer_primary_constructors = true:suggestion
 csharp_style_expression_bodied_lambdas = true:silent
 csharp_style_prefer_local_over_anonymous_function = true:suggestion
 dotnet_diagnostic.CA2016.severity = suggestion
+csharp_prefer_static_anonymous_function = true:suggestion
 
 # disable check for generated code
 [*.generated.cs]
@@ -697,6 +698,7 @@ dotnet_style_prefer_compound_assignment = true:suggestion
 dotnet_style_prefer_simplified_interpolation = true:suggestion
 dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion
 dotnet_style_namespace_match_folder = true:suggestion
+dotnet_style_qualification_for_method = false:silent
 
 [**/*.g.cs]
 generated_code = true
diff --git a/dotnet/src/AutoGen/API/LLMConfigAPI.cs b/dotnet/src/AutoGen/API/LLMConfigAPI.cs
index 4f4e7575d8db..656bcb1256a4 100644
--- a/dotnet/src/AutoGen/API/LLMConfigAPI.cs
+++ b/dotnet/src/AutoGen/API/LLMConfigAPI.cs
@@ -5,45 +5,44 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace AutoGen
+namespace AutoGen;
+
+public static class LLMConfigAPI
 {
-    public static class LLMConfigAPI
+    public static IEnumerable GetOpenAIConfigList(
+        string apiKey,
+        IEnumerable? modelIDs = null)
     {
-        public static IEnumerable GetOpenAIConfigList(
-            string apiKey,
-            IEnumerable? modelIDs = null)
+        var models = modelIDs ?? new[]
         {
-            var models = modelIDs ?? new[]
-            {
-                "gpt-3.5-turbo",
-                "gpt-3.5-turbo-16k",
-                "gpt-4",
-                "gpt-4-32k",
-                "gpt-4-0613",
-                "gpt-4-32k-0613",
-                "gpt-4-1106-preview",
-            };
+            "gpt-3.5-turbo",
+            "gpt-3.5-turbo-16k",
+            "gpt-4",
+            "gpt-4-32k",
+            "gpt-4-0613",
+            "gpt-4-32k-0613",
+            "gpt-4-1106-preview",
+        };
 
-            return models.Select(modelId => new OpenAIConfig(apiKey, modelId));
-        }
+        return models.Select(modelId => new OpenAIConfig(apiKey, modelId));
+    }
 
-        public static IEnumerable GetAzureOpenAIConfigList(
-            string endpoint,
-            string apiKey,
-            IEnumerable deploymentNames)
-        {
-            return deploymentNames.Select(deploymentName => new AzureOpenAIConfig(endpoint, deploymentName, apiKey));
-        }
+    public static IEnumerable GetAzureOpenAIConfigList(
+        string endpoint,
+        string apiKey,
+        IEnumerable deploymentNames)
+    {
+        return deploymentNames.Select(deploymentName => new AzureOpenAIConfig(endpoint, deploymentName, apiKey));
+    }
 
-        /// 
-        /// Get a list of LLMConfig objects from a JSON file.
-        /// 
-        internal static IEnumerable ConfigListFromJson(
-            string filePath,
-            IEnumerable? filterModels = null)
-        {
-            // Disable this API from documentation for now.
-            throw new NotImplementedException();
-        }
+    /// 
+    /// Get a list of LLMConfig objects from a JSON file.
+    /// 
+    internal static IEnumerable ConfigListFromJson(
+        string filePath,
+        IEnumerable? filterModels = null)
+    {
+        // Disable this API from documentation for now.
+        throw new NotImplementedException();
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
index 739dce125114..fc9ccae560d7 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
@@ -1,47 +1,46 @@
 using Microsoft.AutoGen.Abstractions;
 
-namespace Microsoft.AutoGen.Agents
+namespace Microsoft.AutoGen.Agents;
+
+public interface IHandleConsole : IHandle, IHandle
 {
-    public interface IHandleConsole : IHandle, IHandle
-    {
-        string Route { get; }
-        AgentId AgentId { get; }
-        ValueTask PublishEvent(CloudEvent item);
+    string Route { get; }
+    AgentId AgentId { get; }
+    ValueTask PublishEvent(CloudEvent item);
 
-        async Task IHandle.Handle(Output item)
-        {
-            // Assuming item has a property `Message` that we want to write to the console
-            Console.WriteLine(item.Message);
-            await ProcessOutput(item.Message);
+    async Task IHandle.Handle(Output item)
+    {
+        // Assuming item has a property `Message` that we want to write to the console
+        Console.WriteLine(item.Message);
+        await ProcessOutput(item.Message);
 
-            var evt = new OutputWritten
-            {
-                Route = "console"
-            }.ToCloudEvent(AgentId.Key);
-            await PublishEvent(evt);
-        }
-        async Task IHandle.Handle(Input item)
+        var evt = new OutputWritten
         {
-            Console.WriteLine("Please enter input:");
-            string content = Console.ReadLine() ?? string.Empty;
+            Route = "console"
+        }.ToCloudEvent(AgentId.Key);
+        await PublishEvent(evt);
+    }
+    async Task IHandle.Handle(Input item)
+    {
+        Console.WriteLine("Please enter input:");
+        string content = Console.ReadLine() ?? string.Empty;
 
-            await ProcessInput(content);
+        await ProcessInput(content);
 
-            var evt = new InputProcessed
-            {
-                Route = "console"
-            }.ToCloudEvent(AgentId.Key);
-            await PublishEvent(evt);
-        }
-        static Task ProcessOutput(string message)
+        var evt = new InputProcessed
         {
-            // Implement your output processing logic here
-            return Task.CompletedTask;
-        }
-        static Task ProcessInput(string message)
-        {
-            // Implement your input processing logic here
-            return Task.FromResult(message);
-        }
+            Route = "console"
+        }.ToCloudEvent(AgentId.Key);
+        await PublishEvent(evt);
+    }
+    static Task ProcessOutput(string message)
+    {
+        // Implement your output processing logic here
+        return Task.CompletedTask;
+    }
+    static Task ProcessInput(string message)
+    {
+        // Implement your input processing logic here
+        return Task.FromResult(message);
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
index 1e5a809ea4d6..cd0f63b4f25e 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
@@ -1,20 +1,19 @@
 using Google.Protobuf;
 using Microsoft.AutoGen.Abstractions;
 
-namespace Microsoft.AutoGen.Agents
+namespace Microsoft.AutoGen.Agents;
+
+public interface IAgentBase
 {
-    public interface IAgentBase
-    {
-        // Properties
-        AgentId AgentId { get; }
-        IAgentContext Context { get; }
+    // Properties
+    AgentId AgentId { get; }
+    IAgentContext Context { get; }
 
-        // Methods
-        Task CallHandler(CloudEvent item);
-        Task HandleRequest(RpcRequest request);
-        void ReceiveMessage(Message message);
-        Task Store(AgentState state);
-        Task Read(AgentId agentId) where T : IMessage, new();
-        ValueTask PublishEvent(CloudEvent item);
-    }
+    // Methods
+    Task CallHandler(CloudEvent item);
+    Task HandleRequest(RpcRequest request);
+    void ReceiveMessage(Message message);
+    Task Store(AgentState state);
+    Task Read(AgentId agentId) where T : IMessage, new();
+    ValueTask PublishEvent(CloudEvent item);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
index 41e91ef1dac1..9d16db45cb9b 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
@@ -1,33 +1,32 @@
 using Microsoft.Extensions.AI;
 
-namespace Microsoft.Extensions.Hosting
+namespace Microsoft.Extensions.Hosting;
+
+public static class AIModelClient
 {
-    public static class AIModelClient
+    public static IHostApplicationBuilder AddChatCompletionService(this IHostApplicationBuilder builder, string serviceName)
     {
-        public static IHostApplicationBuilder AddChatCompletionService(this IHostApplicationBuilder builder, string serviceName)
-        {
-            var pipeline = (ChatClientBuilder pipeline) => pipeline
-            .UseLogging()
-            .UseFunctionInvocation()
-            .UseOpenTelemetry(configure: c => c.EnableSensitiveData = true);
+        var pipeline = (ChatClientBuilder pipeline) => pipeline
+        .UseLogging()
+        .UseFunctionInvocation()
+        .UseOpenTelemetry(configure: c => c.EnableSensitiveData = true);
 
-            if (builder.Configuration[$"{serviceName}:ModelType"] == "ollama")
-            {
-                builder.AddOllamaChatClient(serviceName, pipeline);
-            }
-            else if (builder.Configuration[$"{serviceName}:ModelType"] == "openai" || builder.Configuration[$"{serviceName}:ModelType"] == "azureopenai")
-            {
-                builder.AddOpenAIChatClient(serviceName, pipeline);
-            }
-            else if (builder.Configuration[$"{serviceName}:ModelType"] == "azureaiinference")
-            {
-                builder.AddAzureChatClient(serviceName, pipeline);
-            }
-            else
-            {
-                throw new InvalidOperationException("Did not find a valid model implementation for the given service name ${serviceName}, valid supported implemenation types are ollama, openai, azureopenai, azureaiinference");
-            }
-            return builder;
+        if (builder.Configuration[$"{serviceName}:ModelType"] == "ollama")
+        {
+            builder.AddOllamaChatClient(serviceName, pipeline);
+        }
+        else if (builder.Configuration[$"{serviceName}:ModelType"] == "openai" || builder.Configuration[$"{serviceName}:ModelType"] == "azureopenai")
+        {
+            builder.AddOpenAIChatClient(serviceName, pipeline);
+        }
+        else if (builder.Configuration[$"{serviceName}:ModelType"] == "azureaiinference")
+        {
+            builder.AddAzureChatClient(serviceName, pipeline);
+        }
+        else
+        {
+            throw new InvalidOperationException("Did not find a valid model implementation for the given service name ${serviceName}, valid supported implemenation types are ollama, openai, azureopenai, azureaiinference");
         }
+        return builder;
     }
 }
diff --git a/dotnet/test/AutoGen.OpenAI.Tests/MathClassTest.cs b/dotnet/test/AutoGen.OpenAI.Tests/MathClassTest.cs
index 5af306a2adda..3f255aeb329e 100644
--- a/dotnet/test/AutoGen.OpenAI.Tests/MathClassTest.cs
+++ b/dotnet/test/AutoGen.OpenAI.Tests/MathClassTest.cs
@@ -14,206 +14,205 @@
 using OpenAI;
 using Xunit.Abstractions;
 
-namespace AutoGen.OpenAI.Tests
+namespace AutoGen.OpenAI.Tests;
+
+public partial class MathClassTest
 {
-    public partial class MathClassTest
+    private readonly ITestOutputHelper _output;
+
+    // as of 2024-05-20, aoai return 500 error when round > 1
+    // I'm pretty sure that round > 5 was supported before
+    // So this is probably some wield regression on aoai side
+    // I'll keep this test case here for now, plus setting round to 1
+    // so the test can still pass.
+    // In the future, we should rewind this test case to round > 1 (previously was 5)
+    private int round = 1;
+    public MathClassTest(ITestOutputHelper output)
     {
-        private readonly ITestOutputHelper _output;
-
-        // as of 2024-05-20, aoai return 500 error when round > 1
-        // I'm pretty sure that round > 5 was supported before
-        // So this is probably some wield regression on aoai side
-        // I'll keep this test case here for now, plus setting round to 1
-        // so the test can still pass.
-        // In the future, we should rewind this test case to round > 1 (previously was 5)
-        private int round = 1;
-        public MathClassTest(ITestOutputHelper output)
-        {
-            _output = output;
-        }
+        _output = output;
+    }
 
-        private Task Print(IEnumerable messages, GenerateReplyOptions? option, IAgent agent, CancellationToken ct)
+    private Task Print(IEnumerable messages, GenerateReplyOptions? option, IAgent agent, CancellationToken ct)
+    {
+        try
         {
-            try
-            {
-                var reply = agent.GenerateReplyAsync(messages, option, ct).Result;
+            var reply = agent.GenerateReplyAsync(messages, option, ct).Result;
 
-                _output.WriteLine(reply.FormatMessage());
-                return Task.FromResult(reply);
-            }
-            catch (Exception)
+            _output.WriteLine(reply.FormatMessage());
+            return Task.FromResult(reply);
+        }
+        catch (Exception)
+        {
+            _output.WriteLine("Request failed");
+            _output.WriteLine($"agent name: {agent.Name}");
+            foreach (var message in messages)
             {
-                _output.WriteLine("Request failed");
-                _output.WriteLine($"agent name: {agent.Name}");
-                foreach (var message in messages)
-                {
-                    _output.WriteLine(message.FormatMessage());
-                }
-
-                throw;
+                _output.WriteLine(message.FormatMessage());
             }
 
+            throw;
         }
 
-        [FunctionAttribute]
-        public async Task CreateMathQuestion(string question, int question_index)
-        {
-            return $@"[MATH_QUESTION]
+    }
+
+    [FunctionAttribute]
+    public async Task CreateMathQuestion(string question, int question_index)
+    {
+        return $@"[MATH_QUESTION]
 Question {question_index}:
 {question}
 
 Student, please answer";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task AnswerQuestion(string answer)
-        {
-            return $@"[MATH_ANSWER]
+    [FunctionAttribute]
+    public async Task AnswerQuestion(string answer)
+    {
+        return $@"[MATH_ANSWER]
 The answer is {answer}
 teacher please check answer";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task AnswerIsCorrect(string message)
-        {
-            return $@"[ANSWER_IS_CORRECT]
+    [FunctionAttribute]
+    public async Task AnswerIsCorrect(string message)
+    {
+        return $@"[ANSWER_IS_CORRECT]
 {message}
 please update progress";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task UpdateProgress(int correctAnswerCount)
+    [FunctionAttribute]
+    public async Task UpdateProgress(int correctAnswerCount)
+    {
+        if (correctAnswerCount >= this.round)
         {
-            if (correctAnswerCount >= this.round)
-            {
-                return $@"[UPDATE_PROGRESS]
+            return $@"[UPDATE_PROGRESS]
 {GroupChatExtension.TERMINATE}";
-            }
-            else
-            {
-                return $@"[UPDATE_PROGRESS]
+        }
+        else
+        {
+            return $@"[UPDATE_PROGRESS]
 the number of resolved question is {correctAnswerCount}
 teacher, please create the next math question";
-            }
         }
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task OpenAIAgentMathChatTestAsync()
-        {
-            var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
-            var endPoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
-            var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
-            var openaiClient = new AzureOpenAIClient(new Uri(endPoint), new ApiKeyCredential(key));
-            var teacher = await CreateTeacherAgentAsync(openaiClient, deployName);
-            var student = await CreateStudentAssistantAgentAsync(openaiClient, deployName);
-
-            var adminFunctionMiddleware = new FunctionCallMiddleware(
-                functions: [this.UpdateProgressFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.UpdateProgressFunctionContract.Name, this.UpdateProgressWrapper },
-                });
-            var admin = new OpenAIChatAgent(
-                chatClient: openaiClient.GetChatClient(deployName),
-                name: "Admin",
-                systemMessage: $@"You are admin. You update progress after each question is answered.")
-                .RegisterMessageConnector()
-                .RegisterStreamingMiddleware(adminFunctionMiddleware)
-                .RegisterMiddleware(Print);
-
-            var groupAdmin = new OpenAIChatAgent(
-                chatClient: openaiClient.GetChatClient(deployName),
-                name: "GroupAdmin",
-                systemMessage: "You are group admin. You manage the group chat.")
-                .RegisterMessageConnector()
-                .RegisterMiddleware(Print);
-            await RunMathChatAsync(teacher, student, admin, groupAdmin);
-        }
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task OpenAIAgentMathChatTestAsync()
+    {
+        var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
+        var endPoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
+        var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
+        var openaiClient = new AzureOpenAIClient(new Uri(endPoint), new ApiKeyCredential(key));
+        var teacher = await CreateTeacherAgentAsync(openaiClient, deployName);
+        var student = await CreateStudentAssistantAgentAsync(openaiClient, deployName);
+
+        var adminFunctionMiddleware = new FunctionCallMiddleware(
+            functions: [this.UpdateProgressFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.UpdateProgressFunctionContract.Name, this.UpdateProgressWrapper },
+            });
+        var admin = new OpenAIChatAgent(
+            chatClient: openaiClient.GetChatClient(deployName),
+            name: "Admin",
+            systemMessage: $@"You are admin. You update progress after each question is answered.")
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(adminFunctionMiddleware)
+            .RegisterMiddleware(Print);
+
+        var groupAdmin = new OpenAIChatAgent(
+            chatClient: openaiClient.GetChatClient(deployName),
+            name: "GroupAdmin",
+            systemMessage: "You are group admin. You manage the group chat.")
+            .RegisterMessageConnector()
+            .RegisterMiddleware(Print);
+        await RunMathChatAsync(teacher, student, admin, groupAdmin);
+    }
 
-        private async Task CreateTeacherAgentAsync(OpenAIClient client, string model)
-        {
-            var functionCallMiddleware = new FunctionCallMiddleware(
-                functions: [this.CreateMathQuestionFunctionContract, this.AnswerIsCorrectFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.CreateMathQuestionFunctionContract.Name!, this.CreateMathQuestionWrapper },
-                    { this.AnswerIsCorrectFunctionContract.Name!, this.AnswerIsCorrectWrapper },
-                });
-
-            var teacher = new OpenAIChatAgent(
-                chatClient: client.GetChatClient(model),
-                name: "Teacher",
-                systemMessage: @"You are a preschool math teacher.
+    private async Task CreateTeacherAgentAsync(OpenAIClient client, string model)
+    {
+        var functionCallMiddleware = new FunctionCallMiddleware(
+            functions: [this.CreateMathQuestionFunctionContract, this.AnswerIsCorrectFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.CreateMathQuestionFunctionContract.Name!, this.CreateMathQuestionWrapper },
+                { this.AnswerIsCorrectFunctionContract.Name!, this.AnswerIsCorrectWrapper },
+            });
+
+        var teacher = new OpenAIChatAgent(
+            chatClient: client.GetChatClient(model),
+            name: "Teacher",
+            systemMessage: @"You are a preschool math teacher.
 You create math question and ask student to answer it.
 Then you check if the answer is correct.
 If the answer is wrong, you ask student to fix it")
-                .RegisterMessageConnector()
-                .RegisterStreamingMiddleware(functionCallMiddleware)
-                .RegisterMiddleware(Print);
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(functionCallMiddleware)
+            .RegisterMiddleware(Print);
 
-            return teacher;
-        }
+        return teacher;
+    }
 
-        private async Task CreateStudentAssistantAgentAsync(OpenAIClient client, string model)
-        {
-            var functionCallMiddleware = new FunctionCallMiddleware(
-                functions: [this.AnswerQuestionFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.AnswerQuestionFunctionContract.Name!, this.AnswerQuestionWrapper },
-                });
-            var student = new OpenAIChatAgent(
-                chatClient: client.GetChatClient(model),
-                name: "Student",
-                systemMessage: @"You are a student. You answer math question from teacher.")
-                .RegisterMessageConnector()
-                .RegisterStreamingMiddleware(functionCallMiddleware)
-                .RegisterMiddleware(Print);
-
-            return student;
-        }
+    private async Task CreateStudentAssistantAgentAsync(OpenAIClient client, string model)
+    {
+        var functionCallMiddleware = new FunctionCallMiddleware(
+            functions: [this.AnswerQuestionFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.AnswerQuestionFunctionContract.Name!, this.AnswerQuestionWrapper },
+            });
+        var student = new OpenAIChatAgent(
+            chatClient: client.GetChatClient(model),
+            name: "Student",
+            systemMessage: @"You are a student. You answer math question from teacher.")
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(functionCallMiddleware)
+            .RegisterMiddleware(Print);
+
+        return student;
+    }
 
-        private async Task RunMathChatAsync(IAgent teacher, IAgent student, IAgent admin, IAgent groupAdmin)
-        {
-            var teacher2Student = Transition.Create(teacher, student);
-            var student2Teacher = Transition.Create(student, teacher);
-            var teacher2Admin = Transition.Create(teacher, admin);
-            var admin2Teacher = Transition.Create(admin, teacher);
-            var workflow = new Graph(
-                [
-                    teacher2Student,
-                    student2Teacher,
-                    teacher2Admin,
-                    admin2Teacher,
-                ]);
-            var group = new GroupChat(
-                workflow: workflow,
-                members: [
-                    admin,
-                    teacher,
-                    student,
-                ],
-                admin: groupAdmin);
-
-            var groupChatManager = new GroupChatManager(group);
-            var chatHistory = await admin.InitiateChatAsync(groupChatManager, "teacher, create question", maxRound: 50);
-
-            chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[MATH_QUESTION]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            chatHistory.Where(msg => msg.From == student.Name && msg.GetContent()?.Contains("[MATH_ANSWER]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[ANSWER_IS_CORRECT]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            // check if there's terminate chat message from admin
-            chatHistory.Where(msg => msg.From == admin.Name && msg.IsGroupChatTerminateMessage())
-                    .Count()
-                    .Should().Be(1);
-        }
+    private async Task RunMathChatAsync(IAgent teacher, IAgent student, IAgent admin, IAgent groupAdmin)
+    {
+        var teacher2Student = Transition.Create(teacher, student);
+        var student2Teacher = Transition.Create(student, teacher);
+        var teacher2Admin = Transition.Create(teacher, admin);
+        var admin2Teacher = Transition.Create(admin, teacher);
+        var workflow = new Graph(
+            [
+                teacher2Student,
+                student2Teacher,
+                teacher2Admin,
+                admin2Teacher,
+            ]);
+        var group = new GroupChat(
+            workflow: workflow,
+            members: [
+                admin,
+                teacher,
+                student,
+            ],
+            admin: groupAdmin);
+
+        var groupChatManager = new GroupChatManager(group);
+        var chatHistory = await admin.InitiateChatAsync(groupChatManager, "teacher, create question", maxRound: 50);
+
+        chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[MATH_QUESTION]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        chatHistory.Where(msg => msg.From == student.Name && msg.GetContent()?.Contains("[MATH_ANSWER]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[ANSWER_IS_CORRECT]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        // check if there's terminate chat message from admin
+        chatHistory.Where(msg => msg.From == admin.Name && msg.IsGroupChatTerminateMessage())
+                .Count()
+                .Should().Be(1);
     }
 }
diff --git a/dotnet/test/AutoGen.OpenAI.V1.Tests/MathClassTest.cs b/dotnet/test/AutoGen.OpenAI.V1.Tests/MathClassTest.cs
index 044b7345cd85..0508d3dbeee3 100644
--- a/dotnet/test/AutoGen.OpenAI.V1.Tests/MathClassTest.cs
+++ b/dotnet/test/AutoGen.OpenAI.V1.Tests/MathClassTest.cs
@@ -13,214 +13,213 @@
 using FluentAssertions;
 using Xunit.Abstractions;
 
-namespace AutoGen.OpenAI.V1.Tests
+namespace AutoGen.OpenAI.V1.Tests;
+
+public partial class MathClassTest
 {
-    public partial class MathClassTest
+    private readonly ITestOutputHelper _output;
+
+    // as of 2024-05-20, aoai return 500 error when round > 1
+    // I'm pretty sure that round > 5 was supported before
+    // So this is probably some wield regression on aoai side
+    // I'll keep this test case here for now, plus setting round to 1
+    // so the test can still pass.
+    // In the future, we should rewind this test case to round > 1 (previously was 5)
+    private int round = 1;
+    public MathClassTest(ITestOutputHelper output)
     {
-        private readonly ITestOutputHelper _output;
-
-        // as of 2024-05-20, aoai return 500 error when round > 1
-        // I'm pretty sure that round > 5 was supported before
-        // So this is probably some wield regression on aoai side
-        // I'll keep this test case here for now, plus setting round to 1
-        // so the test can still pass.
-        // In the future, we should rewind this test case to round > 1 (previously was 5)
-        private int round = 1;
-        public MathClassTest(ITestOutputHelper output)
-        {
-            _output = output;
-        }
+        _output = output;
+    }
 
-        private Task Print(IEnumerable messages, GenerateReplyOptions? option, IAgent agent, CancellationToken ct)
+    private Task Print(IEnumerable messages, GenerateReplyOptions? option, IAgent agent, CancellationToken ct)
+    {
+        try
         {
-            try
-            {
-                var reply = agent.GenerateReplyAsync(messages, option, ct).Result;
+            var reply = agent.GenerateReplyAsync(messages, option, ct).Result;
 
-                _output.WriteLine(reply.FormatMessage());
-                return Task.FromResult(reply);
-            }
-            catch (Exception)
+            _output.WriteLine(reply.FormatMessage());
+            return Task.FromResult(reply);
+        }
+        catch (Exception)
+        {
+            _output.WriteLine("Request failed");
+            _output.WriteLine($"agent name: {agent.Name}");
+            foreach (var message in messages)
             {
-                _output.WriteLine("Request failed");
-                _output.WriteLine($"agent name: {agent.Name}");
-                foreach (var message in messages)
+                if (message is IMessage envelope)
                 {
-                    if (message is IMessage envelope)
-                    {
-                        var json = JsonSerializer.Serialize(envelope.Content, new JsonSerializerOptions { WriteIndented = true });
-                        _output.WriteLine(json);
-                    }
+                    var json = JsonSerializer.Serialize(envelope.Content, new JsonSerializerOptions { WriteIndented = true });
+                    _output.WriteLine(json);
                 }
-
-                throw;
             }
 
+            throw;
         }
 
-        [FunctionAttribute]
-        public async Task CreateMathQuestion(string question, int question_index)
-        {
-            return $@"[MATH_QUESTION]
+    }
+
+    [FunctionAttribute]
+    public async Task CreateMathQuestion(string question, int question_index)
+    {
+        return $@"[MATH_QUESTION]
 Question {question_index}:
 {question}
 
 Student, please answer";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task AnswerQuestion(string answer)
-        {
-            return $@"[MATH_ANSWER]
+    [FunctionAttribute]
+    public async Task AnswerQuestion(string answer)
+    {
+        return $@"[MATH_ANSWER]
 The answer is {answer}
 teacher please check answer";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task AnswerIsCorrect(string message)
-        {
-            return $@"[ANSWER_IS_CORRECT]
+    [FunctionAttribute]
+    public async Task AnswerIsCorrect(string message)
+    {
+        return $@"[ANSWER_IS_CORRECT]
 {message}
 please update progress";
-        }
+    }
 
-        [FunctionAttribute]
-        public async Task UpdateProgress(int correctAnswerCount)
+    [FunctionAttribute]
+    public async Task UpdateProgress(int correctAnswerCount)
+    {
+        if (correctAnswerCount >= this.round)
         {
-            if (correctAnswerCount >= this.round)
-            {
-                return $@"[UPDATE_PROGRESS]
+            return $@"[UPDATE_PROGRESS]
 {GroupChatExtension.TERMINATE}";
-            }
-            else
-            {
-                return $@"[UPDATE_PROGRESS]
+        }
+        else
+        {
+            return $@"[UPDATE_PROGRESS]
 the number of resolved question is {correctAnswerCount}
 teacher, please create the next math question";
-            }
         }
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task OpenAIAgentMathChatTestAsync()
-        {
-            var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
-            var endPoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
-            var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
-            var openaiClient = new OpenAIClient(new Uri(endPoint), new Azure.AzureKeyCredential(key));
-            var teacher = await CreateTeacherAgentAsync(openaiClient, deployName);
-            var student = await CreateStudentAssistantAgentAsync(openaiClient, deployName);
-
-            var adminFunctionMiddleware = new FunctionCallMiddleware(
-                functions: [this.UpdateProgressFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.UpdateProgressFunctionContract.Name, this.UpdateProgressWrapper },
-                });
-            var admin = new OpenAIChatAgent(
-                openAIClient: openaiClient,
-                modelName: deployName,
-                name: "Admin",
-                systemMessage: $@"You are admin. You update progress after each question is answered.")
-                .RegisterMessageConnector()
-                .RegisterStreamingMiddleware(adminFunctionMiddleware)
-                .RegisterMiddleware(Print);
-
-            var groupAdmin = new OpenAIChatAgent(
-                openAIClient: openaiClient,
-                modelName: deployName,
-                name: "GroupAdmin",
-                systemMessage: "You are group admin. You manage the group chat.")
-                .RegisterMessageConnector()
-                .RegisterMiddleware(Print);
-            await RunMathChatAsync(teacher, student, admin, groupAdmin);
-        }
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task OpenAIAgentMathChatTestAsync()
+    {
+        var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
+        var endPoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
+        var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
+        var openaiClient = new OpenAIClient(new Uri(endPoint), new Azure.AzureKeyCredential(key));
+        var teacher = await CreateTeacherAgentAsync(openaiClient, deployName);
+        var student = await CreateStudentAssistantAgentAsync(openaiClient, deployName);
+
+        var adminFunctionMiddleware = new FunctionCallMiddleware(
+            functions: [this.UpdateProgressFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.UpdateProgressFunctionContract.Name, this.UpdateProgressWrapper },
+            });
+        var admin = new OpenAIChatAgent(
+            openAIClient: openaiClient,
+            modelName: deployName,
+            name: "Admin",
+            systemMessage: $@"You are admin. You update progress after each question is answered.")
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(adminFunctionMiddleware)
+            .RegisterMiddleware(Print);
+
+        var groupAdmin = new OpenAIChatAgent(
+            openAIClient: openaiClient,
+            modelName: deployName,
+            name: "GroupAdmin",
+            systemMessage: "You are group admin. You manage the group chat.")
+            .RegisterMessageConnector()
+            .RegisterMiddleware(Print);
+        await RunMathChatAsync(teacher, student, admin, groupAdmin);
+    }
 
-        private async Task CreateTeacherAgentAsync(OpenAIClient client, string model)
-        {
-            var functionCallMiddleware = new FunctionCallMiddleware(
-                functions: [this.CreateMathQuestionFunctionContract, this.AnswerIsCorrectFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.CreateMathQuestionFunctionContract.Name!, this.CreateMathQuestionWrapper },
-                    { this.AnswerIsCorrectFunctionContract.Name!, this.AnswerIsCorrectWrapper },
-                });
-
-            var teacher = new OpenAIChatAgent(
-                openAIClient: client,
-                name: "Teacher",
-                systemMessage: @"You are a preschool math teacher.
+    private async Task CreateTeacherAgentAsync(OpenAIClient client, string model)
+    {
+        var functionCallMiddleware = new FunctionCallMiddleware(
+            functions: [this.CreateMathQuestionFunctionContract, this.AnswerIsCorrectFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.CreateMathQuestionFunctionContract.Name!, this.CreateMathQuestionWrapper },
+                { this.AnswerIsCorrectFunctionContract.Name!, this.AnswerIsCorrectWrapper },
+            });
+
+        var teacher = new OpenAIChatAgent(
+            openAIClient: client,
+            name: "Teacher",
+            systemMessage: @"You are a preschool math teacher.
 You create math question and ask student to answer it.
 Then you check if the answer is correct.
 If the answer is wrong, you ask student to fix it",
-                modelName: model)
-                .RegisterMiddleware(Print)
-                .RegisterMiddleware(new OpenAIChatRequestMessageConnector())
-                .RegisterMiddleware(functionCallMiddleware);
+            modelName: model)
+            .RegisterMiddleware(Print)
+            .RegisterMiddleware(new OpenAIChatRequestMessageConnector())
+            .RegisterMiddleware(functionCallMiddleware);
 
-            return teacher;
-        }
+        return teacher;
+    }
 
-        private async Task CreateStudentAssistantAgentAsync(OpenAIClient client, string model)
-        {
-            var functionCallMiddleware = new FunctionCallMiddleware(
-                functions: [this.AnswerQuestionFunctionContract],
-                functionMap: new Dictionary>>
-                {
-                    { this.AnswerQuestionFunctionContract.Name!, this.AnswerQuestionWrapper },
-                });
-            var student = new OpenAIChatAgent(
-                openAIClient: client,
-                name: "Student",
-                modelName: model,
-                systemMessage: @"You are a student. You answer math question from teacher.")
-                .RegisterMessageConnector()
-                .RegisterStreamingMiddleware(functionCallMiddleware)
-                .RegisterMiddleware(Print);
-
-            return student;
-        }
+    private async Task CreateStudentAssistantAgentAsync(OpenAIClient client, string model)
+    {
+        var functionCallMiddleware = new FunctionCallMiddleware(
+            functions: [this.AnswerQuestionFunctionContract],
+            functionMap: new Dictionary>>
+            {
+                { this.AnswerQuestionFunctionContract.Name!, this.AnswerQuestionWrapper },
+            });
+        var student = new OpenAIChatAgent(
+            openAIClient: client,
+            name: "Student",
+            modelName: model,
+            systemMessage: @"You are a student. You answer math question from teacher.")
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(functionCallMiddleware)
+            .RegisterMiddleware(Print);
+
+        return student;
+    }
 
-        private async Task RunMathChatAsync(IAgent teacher, IAgent student, IAgent admin, IAgent groupAdmin)
-        {
-            var teacher2Student = Transition.Create(teacher, student);
-            var student2Teacher = Transition.Create(student, teacher);
-            var teacher2Admin = Transition.Create(teacher, admin);
-            var admin2Teacher = Transition.Create(admin, teacher);
-            var workflow = new Graph(
-                [
-                    teacher2Student,
-                    student2Teacher,
-                    teacher2Admin,
-                    admin2Teacher,
-                ]);
-            var group = new GroupChat(
-                workflow: workflow,
-                members: [
-                    admin,
-                    teacher,
-                    student,
-                ],
-                admin: groupAdmin);
-
-            var groupChatManager = new GroupChatManager(group);
-            var chatHistory = await admin.InitiateChatAsync(groupChatManager, "teacher, create question", maxRound: 50);
-
-            chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[MATH_QUESTION]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            chatHistory.Where(msg => msg.From == student.Name && msg.GetContent()?.Contains("[MATH_ANSWER]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[ANSWER_IS_CORRECT]") is true)
-                    .Count()
-                    .Should().BeGreaterThanOrEqualTo(this.round);
-
-            // check if there's terminate chat message from admin
-            chatHistory.Where(msg => msg.From == admin.Name && msg.IsGroupChatTerminateMessage())
-                    .Count()
-                    .Should().Be(1);
-        }
+    private async Task RunMathChatAsync(IAgent teacher, IAgent student, IAgent admin, IAgent groupAdmin)
+    {
+        var teacher2Student = Transition.Create(teacher, student);
+        var student2Teacher = Transition.Create(student, teacher);
+        var teacher2Admin = Transition.Create(teacher, admin);
+        var admin2Teacher = Transition.Create(admin, teacher);
+        var workflow = new Graph(
+            [
+                teacher2Student,
+                student2Teacher,
+                teacher2Admin,
+                admin2Teacher,
+            ]);
+        var group = new GroupChat(
+            workflow: workflow,
+            members: [
+                admin,
+                teacher,
+                student,
+            ],
+            admin: groupAdmin);
+
+        var groupChatManager = new GroupChatManager(group);
+        var chatHistory = await admin.InitiateChatAsync(groupChatManager, "teacher, create question", maxRound: 50);
+
+        chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[MATH_QUESTION]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        chatHistory.Where(msg => msg.From == student.Name && msg.GetContent()?.Contains("[MATH_ANSWER]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        chatHistory.Where(msg => msg.From == teacher.Name && msg.GetContent()?.Contains("[ANSWER_IS_CORRECT]") is true)
+                .Count()
+                .Should().BeGreaterThanOrEqualTo(this.round);
+
+        // check if there's terminate chat message from admin
+        chatHistory.Where(msg => msg.From == admin.Name && msg.IsGroupChatTerminateMessage())
+                .Count()
+                .Should().Be(1);
     }
 }
diff --git a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
index 8afea917abb8..e82aec06d614 100644
--- a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
+++ b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
@@ -3,85 +3,84 @@
 using AutoGen.SourceGenerator.Template; // Needed for FunctionCallTemplate
 using Xunit; // Needed for Fact and Assert
 
-namespace AutoGen.SourceGenerator.Tests
+namespace AutoGen.SourceGenerator.Tests;
+
+public class FunctionCallTemplateEncodingTests
 {
-    public class FunctionCallTemplateEncodingTests
+    [Fact]
+    public void FunctionDescription_Should_Encode_DoubleQuotes()
     {
-        [Fact]
-        public void FunctionDescription_Should_Encode_DoubleQuotes()
+        // Arrange
+        var functionContracts = new List
         {
-            // Arrange
-            var functionContracts = new List
+            new SourceGeneratorFunctionContract
             {
-                new SourceGeneratorFunctionContract
+                Name = "TestFunction",
+                Description = "This is a \"test\" function",
+                Parameters = new SourceGeneratorParameterContract[]
                 {
-                    Name = "TestFunction",
-                    Description = "This is a \"test\" function",
-                    Parameters = new SourceGeneratorParameterContract[]
+                    new SourceGeneratorParameterContract
                     {
-                        new SourceGeneratorParameterContract
-                        {
-                            Name = "param1",
-                            Description = "This is a \"parameter\" description",
-                            Type = "string",
-                            IsOptional = false
-                        }
-                    },
-                    ReturnType = "void"
-                }
-            };
+                        Name = "param1",
+                        Description = "This is a \"parameter\" description",
+                        Type = "string",
+                        IsOptional = false
+                    }
+                },
+                ReturnType = "void"
+            }
+        };
 
-            var template = new FunctionCallTemplate
-            {
-                NameSpace = "TestNamespace",
-                ClassName = "TestClass",
-                FunctionContracts = functionContracts
-            };
+        var template = new FunctionCallTemplate
+        {
+            NameSpace = "TestNamespace",
+            ClassName = "TestClass",
+            FunctionContracts = functionContracts
+        };
 
-            // Act
-            var result = template.TransformText();
+        // Act
+        var result = template.TransformText();
 
-            // Assert
-            Assert.Contains("Description = @\"This is a \"\"test\"\" function\"", result);
-            Assert.Contains("Description = @\"This is a \"\"parameter\"\" description\"", result);
-        }
+        // Assert
+        Assert.Contains("Description = @\"This is a \"\"test\"\" function\"", result);
+        Assert.Contains("Description = @\"This is a \"\"parameter\"\" description\"", result);
+    }
 
-        [Fact]
-        public void ParameterDescription_Should_Encode_DoubleQuotes()
+    [Fact]
+    public void ParameterDescription_Should_Encode_DoubleQuotes()
+    {
+        // Arrange
+        var functionContracts = new List
         {
-            // Arrange
-            var functionContracts = new List
+            new SourceGeneratorFunctionContract
             {
-                new SourceGeneratorFunctionContract
+                Name = "TestFunction",
+                Description = "This is a test function",
+                Parameters = new SourceGeneratorParameterContract[]
                 {
-                    Name = "TestFunction",
-                    Description = "This is a test function",
-                    Parameters = new SourceGeneratorParameterContract[]
+                    new SourceGeneratorParameterContract
                     {
-                        new SourceGeneratorParameterContract
-                        {
-                            Name = "param1",
-                            Description = "This is a \"parameter\" description",
-                            Type = "string",
-                            IsOptional = false
-                        }
-                    },
-                    ReturnType = "void"
-                }
-            };
+                        Name = "param1",
+                        Description = "This is a \"parameter\" description",
+                        Type = "string",
+                        IsOptional = false
+                    }
+                },
+                ReturnType = "void"
+            }
+        };
 
-            var template = new FunctionCallTemplate
-            {
-                NameSpace = "TestNamespace",
-                ClassName = "TestClass",
-                FunctionContracts = functionContracts
-            };
+        var template = new FunctionCallTemplate
+        {
+            NameSpace = "TestNamespace",
+            ClassName = "TestClass",
+            FunctionContracts = functionContracts
+        };
 
-            // Act
-            var result = template.TransformText();
+        // Act
+        var result = template.TransformText();
 
-            // Assert
-            Assert.Contains("Description = @\"This is a \"\"parameter\"\" description\"", result);
-        }
+        // Assert
+        Assert.Contains("Description = @\"This is a \"\"parameter\"\" description\"", result);
     }
 }
diff --git a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExample.test.cs b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExample.test.cs
index c865554cd055..fd2281e7198d 100644
--- a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExample.test.cs
+++ b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExample.test.cs
@@ -10,122 +10,121 @@
 using OpenAI.Chat;
 using Xunit;
 
-namespace AutoGen.SourceGenerator.Tests
+namespace AutoGen.SourceGenerator.Tests;
+
+public class FunctionExample
 {
-    public class FunctionExample
+    private readonly FunctionExamples functionExamples = new FunctionExamples();
+    private readonly JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
+    {
+        WriteIndented = true,
+    };
+
+    [Fact]
+    public void Add_Test()
     {
-        private readonly FunctionExamples functionExamples = new FunctionExamples();
-        private readonly JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
+        var args = new
         {
-            WriteIndented = true,
+            a = 1,
+            b = 2,
         };
 
-        [Fact]
-        public void Add_Test()
+        this.VerifyFunction(functionExamples.AddWrapper, args, 3);
+        this.VerifyFunctionDefinition(functionExamples.AddFunctionContract.ToChatTool());
+    }
+
+    [Fact]
+    public void Sum_Test()
+    {
+        var args = new
         {
-            var args = new
-            {
-                a = 1,
-                b = 2,
-            };
+            args = new double[] { 1, 2, 3 },
+        };
 
-            this.VerifyFunction(functionExamples.AddWrapper, args, 3);
-            this.VerifyFunctionDefinition(functionExamples.AddFunctionContract.ToChatTool());
-        }
+        this.VerifyFunction(functionExamples.SumWrapper, args, 6.0);
+        this.VerifyFunctionDefinition(functionExamples.SumFunctionContract.ToChatTool());
+    }
 
-        [Fact]
-        public void Sum_Test()
+    [Fact]
+    public async Task DictionaryToString_Test()
+    {
+        var args = new
         {
-            var args = new
+            xargs = new Dictionary
             {
-                args = new double[] { 1, 2, 3 },
-            };
+                { "a", "1" },
+                { "b", "2" },
+            },
+        };
 
-            this.VerifyFunction(functionExamples.SumWrapper, args, 6.0);
-            this.VerifyFunctionDefinition(functionExamples.SumFunctionContract.ToChatTool());
-        }
+        await this.VerifyAsyncFunction(functionExamples.DictionaryToStringAsyncWrapper, args, JsonSerializer.Serialize(args.xargs, jsonSerializerOptions));
+        this.VerifyFunctionDefinition(functionExamples.DictionaryToStringAsyncFunctionContract.ToChatTool());
+    }
 
-        [Fact]
-        public async Task DictionaryToString_Test()
-        {
-            var args = new
-            {
-                xargs = new Dictionary
-                {
-                    { "a", "1" },
-                    { "b", "2" },
-                },
-            };
-
-            await this.VerifyAsyncFunction(functionExamples.DictionaryToStringAsyncWrapper, args, JsonSerializer.Serialize(args.xargs, jsonSerializerOptions));
-            this.VerifyFunctionDefinition(functionExamples.DictionaryToStringAsyncFunctionContract.ToChatTool());
-        }
-
-        [Fact]
-        public async Task TopLevelFunctionExampleAddTestAsync()
+    [Fact]
+    public async Task TopLevelFunctionExampleAddTestAsync()
+    {
+        var example = new TopLevelStatementFunctionExample();
+        var args = new
         {
-            var example = new TopLevelStatementFunctionExample();
-            var args = new
-            {
-                a = 1,
-                b = 2,
-            };
+            a = 1,
+            b = 2,
+        };
 
-            await this.VerifyAsyncFunction(example.AddWrapper, args, "3");
-        }
+        await this.VerifyAsyncFunction(example.AddWrapper, args, "3");
+    }
 
-        [Fact]
-        public async Task FilescopeFunctionExampleAddTestAsync()
+    [Fact]
+    public async Task FilescopeFunctionExampleAddTestAsync()
+    {
+        var example = new FilescopeNamespaceFunctionExample();
+        var args = new
         {
-            var example = new FilescopeNamespaceFunctionExample();
-            var args = new
-            {
-                a = 1,
-                b = 2,
-            };
+            a = 1,
+            b = 2,
+        };
 
-            await this.VerifyAsyncFunction(example.AddWrapper, args, "3");
-        }
+        await this.VerifyAsyncFunction(example.AddWrapper, args, "3");
+    }
 
-        [Fact]
-        public void Query_Test()
+    [Fact]
+    public void Query_Test()
+    {
+        var args = new
         {
-            var args = new
-            {
-                query = "hello",
-                k = 3,
-            };
+            query = "hello",
+            k = 3,
+        };
 
-            this.VerifyFunction(functionExamples.QueryWrapper, args, new[] { "hello", "hello", "hello" });
-            this.VerifyFunctionDefinition(functionExamples.QueryFunctionContract.ToChatTool());
-        }
+        this.VerifyFunction(functionExamples.QueryWrapper, args, new[] { "hello", "hello", "hello" });
+        this.VerifyFunctionDefinition(functionExamples.QueryFunctionContract.ToChatTool());
+    }
 
-        [UseReporter(typeof(DiffReporter))]
-        [UseApprovalSubdirectory("ApprovalTests")]
-        private void VerifyFunctionDefinition(ChatTool function)
+    [UseReporter(typeof(DiffReporter))]
+    [UseApprovalSubdirectory("ApprovalTests")]
+    private void VerifyFunctionDefinition(ChatTool function)
+    {
+        var func = new
         {
-            var func = new
-            {
-                name = function.FunctionName,
-                description = function.FunctionDescription.Replace(Environment.NewLine, ","),
-                parameters = function.FunctionParameters.ToObjectFromJson(options: jsonSerializerOptions),
-            };
+            name = function.FunctionName,
+            description = function.FunctionDescription.Replace(Environment.NewLine, ","),
+            parameters = function.FunctionParameters.ToObjectFromJson(options: jsonSerializerOptions),
+        };
 
-            Approvals.Verify(JsonSerializer.Serialize(func, jsonSerializerOptions));
-        }
+        Approvals.Verify(JsonSerializer.Serialize(func, jsonSerializerOptions));
+    }
 
-        private void VerifyFunction(Func func, U args, T expected)
-        {
-            var str = JsonSerializer.Serialize(args, jsonSerializerOptions);
-            var res = func(str);
-            res.Should().BeEquivalentTo(expected);
-        }
+    private void VerifyFunction(Func func, U args, T expected)
+    {
+        var str = JsonSerializer.Serialize(args, jsonSerializerOptions);
+        var res = func(str);
+        res.Should().BeEquivalentTo(expected);
+    }
 
-        private async Task VerifyAsyncFunction(Func> func, U args, T expected)
-        {
-            var str = JsonSerializer.Serialize(args, jsonSerializerOptions);
-            var res = await func(str);
-            res.Should().BeEquivalentTo(expected);
-        }
+    private async Task VerifyAsyncFunction(Func> func, U args, T expected)
+    {
+        var str = JsonSerializer.Serialize(args, jsonSerializerOptions);
+        var res = await func(str);
+        res.Should().BeEquivalentTo(expected);
     }
 }
diff --git a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExamples.cs b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExamples.cs
index 6487ce1a89da..f4da73cd0f67 100644
--- a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExamples.cs
+++ b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionExamples.cs
@@ -4,67 +4,66 @@
 using System.Text.Json;
 using AutoGen.Core;
 
-namespace AutoGen.SourceGenerator.Tests
+namespace AutoGen.SourceGenerator.Tests;
+
+public partial class FunctionExamples
 {
-    public partial class FunctionExamples
+    /// 
+    /// Add function
+    /// 
+    /// a
+    /// b
+    [FunctionAttribute]
+    public int Add(int a, int b)
     {
-        /// 
-        /// Add function
-        /// 
-        /// a
-        /// b
-        [FunctionAttribute]
-        public int Add(int a, int b)
-        {
-            return a + b;
-        }
+        return a + b;
+    }
 
-        /// 
-        /// Add two numbers.
-        /// 
-        /// The first number.
-        /// The second number.
-        [Function]
-        public Task AddAsync(int a, int b)
-        {
-            return Task.FromResult($"{a} + {b} = {a + b}");
-        }
+    /// 
+    /// Add two numbers.
+    /// 
+    /// The first number.
+    /// The second number.
+    [Function]
+    public Task AddAsync(int a, int b)
+    {
+        return Task.FromResult($"{a} + {b} = {a + b}");
+    }
 
-        /// 
-        /// Sum function
-        /// 
-        /// an array of double values
-        [FunctionAttribute]
-        public double Sum(double[] args)
-        {
-            return args.Sum();
-        }
+    /// 
+    /// Sum function
+    /// 
+    /// an array of double values
+    [FunctionAttribute]
+    public double Sum(double[] args)
+    {
+        return args.Sum();
+    }
 
-        /// 
-        /// DictionaryToString function
-        /// 
-        /// an object of key-value pairs. key is string, value is string
-        [FunctionAttribute]
-        public Task DictionaryToStringAsync(Dictionary xargs)
+    /// 
+    /// DictionaryToString function
+    /// 
+    /// an object of key-value pairs. key is string, value is string
+    [FunctionAttribute]
+    public Task DictionaryToStringAsync(Dictionary xargs)
+    {
+        var res = JsonSerializer.Serialize(xargs, new JsonSerializerOptions
         {
-            var res = JsonSerializer.Serialize(xargs, new JsonSerializerOptions
-            {
-                WriteIndented = true,
-            });
+            WriteIndented = true,
+        });
 
-            return Task.FromResult(res);
-        }
+        return Task.FromResult(res);
+    }
 
-        /// 
-        /// query function
-        /// 
-        /// query, required
-        /// top k, optional, default value is 3
-        /// thresold, optional, default value is 0.5
-        [FunctionAttribute]
-        public string[] Query(string query, int k = 3, float thresold = 0.5f)
-        {
-            return Enumerable.Repeat(query, k).ToArray();
-        }
+    /// 
+    /// query function
+    /// 
+    /// query, required
+    /// top k, optional, default value is 3
+    /// thresold, optional, default value is 0.5
+    [FunctionAttribute]
+    public string[] Query(string query, int k = 3, float thresold = 0.5f)
+    {
+        return Enumerable.Repeat(query, k).ToArray();
     }
 }
diff --git a/dotnet/test/AutoGen.Tests/BasicSampleTest.cs b/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
index 22b4ee056e68..df02bb3dcd0f 100644
--- a/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
+++ b/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
@@ -7,73 +7,72 @@
 using AutoGen.BasicSample;
 using Xunit.Abstractions;
 
-namespace AutoGen.Tests
+namespace AutoGen.Tests;
+
+public class BasicSampleTest
 {
-    public class BasicSampleTest
+    private readonly ITestOutputHelper _output;
+
+    public BasicSampleTest(ITestOutputHelper output)
     {
-        private readonly ITestOutputHelper _output;
+        _output = output;
+        Console.SetOut(new ConsoleWriter(_output));
+    }
 
-        public BasicSampleTest(ITestOutputHelper output)
-        {
-            _output = output;
-            Console.SetOut(new ConsoleWriter(_output));
-        }
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task AssistantAgentTestAsync()
+    {
+        await Example01_AssistantAgent.RunAsync();
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task AssistantAgentTestAsync()
-        {
-            await Example01_AssistantAgent.RunAsync();
-        }
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task TwoAgentMathClassTestAsync()
+    {
+        await Example02_TwoAgent_MathChat.RunAsync();
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task TwoAgentMathClassTestAsync()
-        {
-            await Example02_TwoAgent_MathChat.RunAsync();
-        }
+    [ApiKeyFact("OPENAI_API_KEY")]
+    public async Task AgentFunctionCallTestAsync()
+    {
+        await Example03_Agent_FunctionCall.RunAsync();
+    }
 
-        [ApiKeyFact("OPENAI_API_KEY")]
-        public async Task AgentFunctionCallTestAsync()
-        {
-            await Example03_Agent_FunctionCall.RunAsync();
-        }
+    [ApiKeyFact("MISTRAL_API_KEY")]
+    public async Task MistralClientAgent_TokenCount()
+    {
+        await Example14_MistralClientAgent_TokenCount.RunAsync();
+    }
 
-        [ApiKeyFact("MISTRAL_API_KEY")]
-        public async Task MistralClientAgent_TokenCount()
-        {
-            await Example14_MistralClientAgent_TokenCount.RunAsync();
-        }
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task DynamicGroupChatCalculateFibonacciAsync()
+    {
+        await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunAsync();
+        await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunWorkflowAsync();
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task DynamicGroupChatCalculateFibonacciAsync()
-        {
-            await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunAsync();
-            await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunWorkflowAsync();
-        }
+    [ApiKeyFact("OPENAI_API_KEY")]
+    public async Task DalleAndGPT4VTestAsync()
+    {
+        await Example05_Dalle_And_GPT4V.RunAsync();
+    }
 
-        [ApiKeyFact("OPENAI_API_KEY")]
-        public async Task DalleAndGPT4VTestAsync()
-        {
-            await Example05_Dalle_And_GPT4V.RunAsync();
-        }
+    [ApiKeyFact("OPENAI_API_KEY")]
+    public async Task GPT4ImageMessage()
+    {
+        await Example15_GPT4V_BinaryDataImageMessage.RunAsync();
+    }
 
-        [ApiKeyFact("OPENAI_API_KEY")]
-        public async Task GPT4ImageMessage()
+    public class ConsoleWriter : StringWriter
+    {
+        private ITestOutputHelper output;
+        public ConsoleWriter(ITestOutputHelper output)
         {
-            await Example15_GPT4V_BinaryDataImageMessage.RunAsync();
+            this.output = output;
         }
 
-        public class ConsoleWriter : StringWriter
+        public override void WriteLine(string? m)
         {
-            private ITestOutputHelper output;
-            public ConsoleWriter(ITestOutputHelper output)
-            {
-                this.output = output;
-            }
-
-            public override void WriteLine(string? m)
-            {
-                output.WriteLine(m);
-            }
+            output.WriteLine(m);
         }
     }
 }
diff --git a/dotnet/test/AutoGen.Tests/GroupChat/GraphTests.cs b/dotnet/test/AutoGen.Tests/GroupChat/GraphTests.cs
index 04d7023de56c..6698e42abd02 100644
--- a/dotnet/test/AutoGen.Tests/GroupChat/GraphTests.cs
+++ b/dotnet/test/AutoGen.Tests/GroupChat/GraphTests.cs
@@ -3,18 +3,17 @@
 
 using Xunit;
 
-namespace AutoGen.Tests
+namespace AutoGen.Tests;
+
+public class GraphTests
 {
-    public class GraphTests
+    [Fact]
+    public void GraphTest()
     {
-        [Fact]
-        public void GraphTest()
-        {
-            var graph1 = new Graph();
-            Assert.NotNull(graph1);
+        var graph1 = new Graph();
+        Assert.NotNull(graph1);
 
-            var graph2 = new Graph(null);
-            Assert.NotNull(graph2);
-        }
+        var graph2 = new Graph(null);
+        Assert.NotNull(graph2);
     }
 }
diff --git a/dotnet/test/AutoGen.Tests/SingleAgentTest.cs b/dotnet/test/AutoGen.Tests/SingleAgentTest.cs
index 3303003be222..9b527d83d7e4 100644
--- a/dotnet/test/AutoGen.Tests/SingleAgentTest.cs
+++ b/dotnet/test/AutoGen.Tests/SingleAgentTest.cs
@@ -9,219 +9,218 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace AutoGen.Tests
+namespace AutoGen.Tests;
+
+public partial class SingleAgentTest
 {
-    public partial class SingleAgentTest
+    private ITestOutputHelper _output;
+    public SingleAgentTest(ITestOutputHelper output)
     {
-        private ITestOutputHelper _output;
-        public SingleAgentTest(ITestOutputHelper output)
-        {
-            _output = output;
-        }
+        _output = output;
+    }
 
-        private ILLMConfig CreateAzureOpenAIGPT35TurboConfig()
-        {
-            var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
-            var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
-            var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
-            return new AzureOpenAIConfig(endpoint, deployName, key);
-        }
+    private ILLMConfig CreateAzureOpenAIGPT35TurboConfig()
+    {
+        var key = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY") ?? throw new ArgumentException("AZURE_OPENAI_API_KEY is not set");
+        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ?? throw new ArgumentException("AZURE_OPENAI_ENDPOINT is not set");
+        var deployName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOY_NAME") ?? throw new ArgumentException("AZURE_OPENAI_DEPLOY_NAME is not set");
+        return new AzureOpenAIConfig(endpoint, deployName, key);
+    }
 
-        private ILLMConfig CreateOpenAIGPT4VisionConfig()
-        {
-            var key = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new ArgumentException("OPENAI_API_KEY is not set");
-            return new OpenAIConfig(key, "gpt-4-vision-preview");
-        }
+    private ILLMConfig CreateOpenAIGPT4VisionConfig()
+    {
+        var key = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new ArgumentException("OPENAI_API_KEY is not set");
+        return new OpenAIConfig(key, "gpt-4-vision-preview");
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task AssistantAgentFunctionCallTestAsync()
-        {
-            var config = this.CreateAzureOpenAIGPT35TurboConfig();
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task AssistantAgentFunctionCallTestAsync()
+    {
+        var config = this.CreateAzureOpenAIGPT35TurboConfig();
 
-            var llmConfig = new ConversableAgentConfig
+        var llmConfig = new ConversableAgentConfig
+        {
+            Temperature = 0,
+            FunctionContracts = new[]
             {
-                Temperature = 0,
-                FunctionContracts = new[]
-                {
-                    this.EchoAsyncFunctionContract,
-                },
-                ConfigList = new[]
-                {
-                    config,
-                },
-            };
+                this.EchoAsyncFunctionContract,
+            },
+            ConfigList = new[]
+            {
+                config,
+            },
+        };
 
-            var assistantAgent = new AssistantAgent(
-                name: "assistant",
-                llmConfig: llmConfig);
+        var assistantAgent = new AssistantAgent(
+            name: "assistant",
+            llmConfig: llmConfig);
 
-            await EchoFunctionCallTestAsync(assistantAgent);
-        }
+        await EchoFunctionCallTestAsync(assistantAgent);
+    }
 
-        [Fact]
-        public async Task AssistantAgentDefaultReplyTestAsync()
-        {
-            var assistantAgent = new AssistantAgent(
-                llmConfig: null,
-                name: "assistant",
-                defaultReply: "hello world");
+    [Fact]
+    public async Task AssistantAgentDefaultReplyTestAsync()
+    {
+        var assistantAgent = new AssistantAgent(
+            llmConfig: null,
+            name: "assistant",
+            defaultReply: "hello world");
 
-            var reply = await assistantAgent.SendAsync("hi");
+        var reply = await assistantAgent.SendAsync("hi");
 
-            reply.GetContent().Should().Be("hello world");
-            reply.GetRole().Should().Be(Role.Assistant);
-            reply.From.Should().Be(assistantAgent.Name);
-        }
+        reply.GetContent().Should().Be("hello world");
+        reply.GetRole().Should().Be(Role.Assistant);
+        reply.From.Should().Be(assistantAgent.Name);
+    }
 
-        [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
-        public async Task AssistantAgentFunctionCallSelfExecutionTestAsync()
+    [ApiKeyFact("AZURE_OPENAI_API_KEY", "AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_DEPLOY_NAME")]
+    public async Task AssistantAgentFunctionCallSelfExecutionTestAsync()
+    {
+        var config = this.CreateAzureOpenAIGPT35TurboConfig();
+        var llmConfig = new ConversableAgentConfig
         {
-            var config = this.CreateAzureOpenAIGPT35TurboConfig();
-            var llmConfig = new ConversableAgentConfig
+            FunctionContracts = new[]
             {
-                FunctionContracts = new[]
-                {
-                    this.EchoAsyncFunctionContract,
-                },
-                ConfigList = new[]
-                {
-                    config,
-                },
-            };
-            var assistantAgent = new AssistantAgent(
-                name: "assistant",
-                llmConfig: llmConfig,
-                functionMap: new Dictionary>>
-                {
-                    { nameof(EchoAsync), this.EchoAsyncWrapper },
-                });
+                this.EchoAsyncFunctionContract,
+            },
+            ConfigList = new[]
+            {
+                config,
+            },
+        };
+        var assistantAgent = new AssistantAgent(
+            name: "assistant",
+            llmConfig: llmConfig,
+            functionMap: new Dictionary>>
+            {
+                { nameof(EchoAsync), this.EchoAsyncWrapper },
+            });
 
-            await EchoFunctionCallExecutionTestAsync(assistantAgent);
-        }
+        await EchoFunctionCallExecutionTestAsync(assistantAgent);
+    }
 
-        /// 
-        /// echo when asked.
-        /// 
-        /// message to echo
-        [FunctionAttribute]
-        public async Task EchoAsync(string message)
-        {
-            return $"[ECHO] {message}";
-        }
+    /// 
+    /// echo when asked.
+    /// 
+    /// message to echo
+    [FunctionAttribute]
+    public async Task EchoAsync(string message)
+    {
+        return $"[ECHO] {message}";
+    }
 
-        /// 
-        /// return the label name with hightest inference cost
-        /// 
-        /// 
-        /// 
-        [FunctionAttribute]
-        public async Task GetHighestLabel(string labelName, string color)
-        {
-            return $"[HIGHEST_LABEL] {labelName} {color}";
-        }
+    /// 
+    /// return the label name with hightest inference cost
+    /// 
+    /// 
+    /// 
+    [FunctionAttribute]
+    public async Task GetHighestLabel(string labelName, string color)
+    {
+        return $"[HIGHEST_LABEL] {labelName} {color}";
+    }
 
-        public async Task EchoFunctionCallTestAsync(IAgent agent)
-        {
-            //var message = new TextMessage(Role.System, "You are a helpful AI assistant that call echo function");
-            var helloWorld = new TextMessage(Role.User, "echo Hello world");
+    public async Task EchoFunctionCallTestAsync(IAgent agent)
+    {
+        //var message = new TextMessage(Role.System, "You are a helpful AI assistant that call echo function");
+        var helloWorld = new TextMessage(Role.User, "echo Hello world");
 
-            var reply = await agent.SendAsync(chatHistory: new[] { helloWorld });
+        var reply = await agent.SendAsync(chatHistory: new[] { helloWorld });
 
-            reply.From.Should().Be(agent.Name);
-            reply.GetToolCalls()!.First().FunctionName.Should().Be(nameof(EchoAsync));
-        }
+        reply.From.Should().Be(agent.Name);
+        reply.GetToolCalls()!.First().FunctionName.Should().Be(nameof(EchoAsync));
+    }
 
-        public async Task EchoFunctionCallExecutionTestAsync(IAgent agent)
-        {
-            //var message = new TextMessage(Role.System, "You are a helpful AI assistant that echo whatever user says");
-            var helloWorld = new TextMessage(Role.User, "echo Hello world");
+    public async Task EchoFunctionCallExecutionTestAsync(IAgent agent)
+    {
+        //var message = new TextMessage(Role.System, "You are a helpful AI assistant that echo whatever user says");
+        var helloWorld = new TextMessage(Role.User, "echo Hello world");
 
-            var reply = await agent.SendAsync(chatHistory: new[] { helloWorld });
+        var reply = await agent.SendAsync(chatHistory: new[] { helloWorld });
 
-            reply.GetContent().Should().Be("[ECHO] Hello world");
+        reply.GetContent().Should().Be("[ECHO] Hello world");
+        reply.From.Should().Be(agent.Name);
+        reply.Should().BeOfType();
+    }
+
+    public async Task EchoFunctionCallExecutionStreamingTestAsync(IStreamingAgent agent)
+    {
+        //var message = new TextMessage(Role.System, "You are a helpful AI assistant that echo whatever user says");
+        var helloWorld = new TextMessage(Role.User, "echo Hello world");
+        var option = new GenerateReplyOptions
+        {
+            Temperature = 0,
+        };
+        var replyStream = agent.GenerateStreamingReplyAsync(messages: new[] { helloWorld }, option);
+        var answer = "[ECHO] Hello world";
+        IMessage? finalReply = default;
+        await foreach (var reply in replyStream)
+        {
             reply.From.Should().Be(agent.Name);
-            reply.Should().BeOfType();
+            finalReply = reply;
         }
 
-        public async Task EchoFunctionCallExecutionStreamingTestAsync(IStreamingAgent agent)
+        if (finalReply is ToolCallAggregateMessage aggregateMessage)
         {
-            //var message = new TextMessage(Role.System, "You are a helpful AI assistant that echo whatever user says");
-            var helloWorld = new TextMessage(Role.User, "echo Hello world");
-            var option = new GenerateReplyOptions
-            {
-                Temperature = 0,
-            };
-            var replyStream = agent.GenerateStreamingReplyAsync(messages: new[] { helloWorld }, option);
-            var answer = "[ECHO] Hello world";
-            IMessage? finalReply = default;
-            await foreach (var reply in replyStream)
-            {
-                reply.From.Should().Be(agent.Name);
-                finalReply = reply;
-            }
-
-            if (finalReply is ToolCallAggregateMessage aggregateMessage)
-            {
-                var toolCallResultMessage = aggregateMessage.Message2;
-                toolCallResultMessage.ToolCalls.First().Result.Should().Be(answer);
-                toolCallResultMessage.From.Should().Be(agent.Name);
-                toolCallResultMessage.ToolCalls.First().FunctionName.Should().Be(nameof(EchoAsync));
-            }
-            else
-            {
-                throw new Exception("unexpected message type");
-            }
+            var toolCallResultMessage = aggregateMessage.Message2;
+            toolCallResultMessage.ToolCalls.First().Result.Should().Be(answer);
+            toolCallResultMessage.From.Should().Be(agent.Name);
+            toolCallResultMessage.ToolCalls.First().FunctionName.Should().Be(nameof(EchoAsync));
         }
-
-        public async Task UpperCaseTestAsync(IAgent agent)
+        else
         {
-            var message = new TextMessage(Role.User, "Please convert abcde to upper case.");
+            throw new Exception("unexpected message type");
+        }
+    }
 
-            var reply = await agent.SendAsync(chatHistory: new[] { message });
+    public async Task UpperCaseTestAsync(IAgent agent)
+    {
+        var message = new TextMessage(Role.User, "Please convert abcde to upper case.");
 
-            reply.GetContent().Should().Contain("ABCDE");
-            reply.From.Should().Be(agent.Name);
-        }
+        var reply = await agent.SendAsync(chatHistory: new[] { message });
 
-        public async Task UpperCaseStreamingTestAsync(IStreamingAgent agent)
+        reply.GetContent().Should().Contain("ABCDE");
+        reply.From.Should().Be(agent.Name);
+    }
+
+    public async Task UpperCaseStreamingTestAsync(IStreamingAgent agent)
+    {
+        var message = new TextMessage(Role.User, "Please convert 'hello world' to upper case");
+        var option = new GenerateReplyOptions
         {
-            var message = new TextMessage(Role.User, "Please convert 'hello world' to upper case");
-            var option = new GenerateReplyOptions
-            {
-                Temperature = 0,
-            };
-            var replyStream = agent.GenerateStreamingReplyAsync(messages: new[] { message }, option);
-            var answer = "HELLO WORLD";
-            TextMessage? finalReply = default;
-            await foreach (var reply in replyStream)
+            Temperature = 0,
+        };
+        var replyStream = agent.GenerateStreamingReplyAsync(messages: new[] { message }, option);
+        var answer = "HELLO WORLD";
+        TextMessage? finalReply = default;
+        await foreach (var reply in replyStream)
+        {
+            if (reply is TextMessageUpdate update)
             {
-                if (reply is TextMessageUpdate update)
+                update.From.Should().Be(agent.Name);
+
+                if (finalReply is null)
                 {
-                    update.From.Should().Be(agent.Name);
-
-                    if (finalReply is null)
-                    {
-                        finalReply = new TextMessage(update);
-                    }
-                    else
-                    {
-                        finalReply.Update(update);
-                    }
-
-                    continue;
+                    finalReply = new TextMessage(update);
                 }
-                else if (reply is TextMessage textMessage)
+                else
                 {
-                    finalReply = textMessage;
-                    continue;
+                    finalReply.Update(update);
                 }
 
-                throw new Exception("unexpected message type");
+                continue;
+            }
+            else if (reply is TextMessage textMessage)
+            {
+                finalReply = textMessage;
+                continue;
             }
 
-            finalReply!.Content.Should().Contain(answer);
-            finalReply!.Role.Should().Be(Role.Assistant);
-            finalReply!.From.Should().Be(agent.Name);
+            throw new Exception("unexpected message type");
         }
+
+        finalReply!.Content.Should().Contain(answer);
+        finalReply!.Role.Should().Be(Role.Assistant);
+        finalReply!.From.Should().Be(agent.Name);
     }
 }

From 3d51ab76ae94cfae25ce7c1a3e5d4fe3eb8134bd Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Wed, 30 Oct 2024 10:27:57 -0700
Subject: [PATCH 053/173] Formalize `ChatAgent` response as a dataclass with
 inner messages (#3990)

---
 .../agents/_assistant_agent.py                | 30 ++++++++++---
 .../agents/_base_chat_agent.py                | 25 +++++------
 .../agents/_code_executor_agent.py            |  7 +--
 .../src/autogen_agentchat/base/__init__.py    |  3 +-
 .../src/autogen_agentchat/base/_chat_agent.py | 18 ++++++--
 .../src/autogen_agentchat/base/_task.py       |  4 +-
 .../src/autogen_agentchat/messages.py         | 25 ++++++++++-
 .../teams/_group_chat/_base_group_chat.py     | 28 ++++++------
 .../_group_chat/_chat_agent_container.py      | 19 ++++++--
 .../tests/test_assistant_agent.py             | 13 +++---
 .../tests/test_group_chat.py                  | 43 ++++++++++++-------
 .../tutorial/agents.ipynb                     |  7 +--
 .../tutorial/selector-group-chat.ipynb        |  7 +--
 13 files changed, 157 insertions(+), 72 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index a5dece3f62d4..5414f782f022 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -18,12 +18,16 @@
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from .. import EVENT_LOGGER_NAME
+from ..base import Response
 from ..messages import (
     ChatMessage,
     HandoffMessage,
+    InnerMessage,
     ResetMessage,
     StopMessage,
     TextMessage,
+    ToolCallMessage,
+    ToolCallResultMessages,
 )
 from ._base_chat_agent import BaseChatAgent
 
@@ -214,7 +218,7 @@ def produced_message_types(self) -> List[type[ChatMessage]]:
             return [TextMessage, HandoffMessage, StopMessage]
         return [TextMessage, StopMessage]
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
         # Add messages to the model context.
         for msg in messages:
             if isinstance(msg, ResetMessage):
@@ -222,6 +226,9 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             else:
                 self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
+        # Inner messages.
+        inner_messages: List[InnerMessage] = []
+
         # Generate an inference result based on the current model context.
         llm_messages = self._system_messages + self._model_context
         result = await self._model_client.create(
@@ -234,12 +241,16 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         # Run tool calls until the model produces a string response.
         while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
             event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
+            # Add the tool call message to the output.
+            inner_messages.append(ToolCallMessage(content=result.content, source=self.name))
+
             # Execute the tool calls.
             results = await asyncio.gather(
                 *[self._execute_tool_call(call, cancellation_token) for call in result.content]
             )
             event_logger.debug(ToolCallResultEvent(tool_call_results=results, source=self.name))
             self._model_context.append(FunctionExecutionResultMessage(content=results))
+            inner_messages.append(ToolCallResultMessages(content=results, source=self.name))
 
             # Detect handoff requests.
             handoffs: List[Handoff] = []
@@ -249,8 +260,13 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             if len(handoffs) > 0:
                 if len(handoffs) > 1:
                     raise ValueError(f"Multiple handoffs detected: {[handoff.name for handoff in handoffs]}")
-                # Respond with a handoff message.
-                return HandoffMessage(content=handoffs[0].message, target=handoffs[0].target, source=self.name)
+                # Return the output messages to signal the handoff.
+                return Response(
+                    chat_message=HandoffMessage(
+                        content=handoffs[0].message, target=handoffs[0].target, source=self.name
+                    ),
+                    inner_messages=inner_messages,
+                )
 
             # Generate an inference result based on the current model context.
             result = await self._model_client.create(
@@ -262,9 +278,13 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         # Detect stop request.
         request_stop = "terminate" in result.content.strip().lower()
         if request_stop:
-            return StopMessage(content=result.content, source=self.name)
+            return Response(
+                chat_message=StopMessage(content=result.content, source=self.name), inner_messages=inner_messages
+            )
 
-        return TextMessage(content=result.content, source=self.name)
+        return Response(
+            chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
+        )
 
     async def _execute_tool_call(
         self, tool_call: FunctionCall, cancellation_token: CancellationToken
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index bc5352867800..ac74077e27c8 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -3,9 +3,8 @@
 
 from autogen_core.base import CancellationToken
 
-from ..base import ChatAgent, TaskResult, TerminationCondition
-from ..messages import ChatMessage
-from ..teams import RoundRobinGroupChat
+from ..base import ChatAgent, Response, TaskResult, TerminationCondition
+from ..messages import ChatMessage, InnerMessage, TextMessage
 
 
 class BaseChatAgent(ChatAgent, ABC):
@@ -37,8 +36,8 @@ def produced_message_types(self) -> List[type[ChatMessage]]:
         ...
 
     @abstractmethod
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        """Handle incoming messages and return a response message."""
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        """Handles incoming messages and returns a response."""
         ...
 
     async def run(
@@ -49,10 +48,12 @@ async def run(
         termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
         """Run the agent with the given task and return the result."""
-        group_chat = RoundRobinGroupChat(participants=[self])
-        result = await group_chat.run(
-            task=task,
-            cancellation_token=cancellation_token,
-            termination_condition=termination_condition,
-        )
-        return result
+        if cancellation_token is None:
+            cancellation_token = CancellationToken()
+        first_message = TextMessage(content=task, source="user")
+        response = await self.on_messages([first_message], cancellation_token)
+        messages: List[InnerMessage | ChatMessage] = [first_message]
+        if response.inner_messages is not None:
+            messages += response.inner_messages
+        messages.append(response.chat_message)
+        return TaskResult(messages=messages)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
index c5c216e52e08..8c21d53fb8b1 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
@@ -3,6 +3,7 @@
 from autogen_core.base import CancellationToken
 from autogen_core.components.code_executor import CodeBlock, CodeExecutor, extract_markdown_code_blocks
 
+from ..base import Response
 from ..messages import ChatMessage, TextMessage
 from ._base_chat_agent import BaseChatAgent
 
@@ -25,7 +26,7 @@ def produced_message_types(self) -> List[type[ChatMessage]]:
         """The types of messages that the code executor agent produces."""
         return [TextMessage]
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
         # Extract code blocks from the messages.
         code_blocks: List[CodeBlock] = []
         for msg in messages:
@@ -34,6 +35,6 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         if code_blocks:
             # Execute the code blocks.
             result = await self._code_executor.execute_code_blocks(code_blocks, cancellation_token=cancellation_token)
-            return TextMessage(content=result.output, source=self.name)
+            return Response(chat_message=TextMessage(content=result.output, source=self.name))
         else:
-            return TextMessage(content="No code blocks found in the thread.", source=self.name)
+            return Response(chat_message=TextMessage(content="No code blocks found in the thread.", source=self.name))
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
index 436d69fb0440..1b95d6e180fd 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/__init__.py
@@ -1,10 +1,11 @@
-from ._chat_agent import ChatAgent
+from ._chat_agent import ChatAgent, Response
 from ._task import TaskResult, TaskRunner
 from ._team import Team
 from ._termination import TerminatedException, TerminationCondition
 
 __all__ = [
     "ChatAgent",
+    "Response",
     "Team",
     "TerminatedException",
     "TerminationCondition",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index 689f6e6d5e7a..d60dba349cbb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -1,12 +1,24 @@
+from dataclasses import dataclass
 from typing import List, Protocol, Sequence, runtime_checkable
 
 from autogen_core.base import CancellationToken
 
-from ..messages import ChatMessage
+from ..messages import ChatMessage, InnerMessage
 from ._task import TaskResult, TaskRunner
 from ._termination import TerminationCondition
 
 
+@dataclass(kw_only=True)
+class Response:
+    """A response from calling :meth:`ChatAgent.on_messages`."""
+
+    chat_message: ChatMessage
+    """A chat message produced by the agent as the response."""
+
+    inner_messages: List[InnerMessage] | None = None
+    """Inner messages produced by the agent."""
+
+
 @runtime_checkable
 class ChatAgent(TaskRunner, Protocol):
     """Protocol for a chat agent."""
@@ -29,8 +41,8 @@ def produced_message_types(self) -> List[type[ChatMessage]]:
         """The types of messages that the agent produces."""
         ...
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        """Handle incoming messages and return a response message."""
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        """Handles incoming messages and returns a response."""
         ...
 
     async def run(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 1d9a768b90bb..326cceecb1fd 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -3,7 +3,7 @@
 
 from autogen_core.base import CancellationToken
 
-from ..messages import ChatMessage
+from ..messages import ChatMessage, InnerMessage
 from ._termination import TerminationCondition
 
 
@@ -11,7 +11,7 @@
 class TaskResult:
     """Result of running a task."""
 
-    messages: Sequence[ChatMessage]
+    messages: Sequence[InnerMessage | ChatMessage]
     """Messages produced by the task."""
 
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index feb8b867c745..f206250e101e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -1,6 +1,7 @@
 from typing import List
 
-from autogen_core.components import Image
+from autogen_core.components import FunctionCall, Image
+from autogen_core.components.models import FunctionExecutionResult
 from pydantic import BaseModel
 
 
@@ -49,8 +50,26 @@ class ResetMessage(BaseMessage):
     """The content for the reset message."""
 
 
+class ToolCallMessage(BaseMessage):
+    """A message signaling the use of tools."""
+
+    content: List[FunctionCall]
+    """The tool calls."""
+
+
+class ToolCallResultMessages(BaseMessage):
+    """A message signaling the results of tool calls."""
+
+    content: List[FunctionExecutionResult]
+    """The tool call results."""
+
+
+InnerMessage = ToolCallMessage | ToolCallResultMessages
+"""Messages for intra-agent monologues."""
+
+
 ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage | ResetMessage
-"""A message used by agents in a team."""
+"""Messages for agent-to-agent communication."""
 
 
 __all__ = [
@@ -60,5 +79,7 @@ class ResetMessage(BaseMessage):
     "StopMessage",
     "HandoffMessage",
     "ResetMessage",
+    "ToolCallMessage",
+    "ToolCallResultMessages",
     "ChatMessage",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index f5268a3a9afa..9f3132a74955 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -15,7 +15,7 @@
 from autogen_core.components import ClosureAgent, TypeSubscription
 
 from ...base import ChatAgent, TaskResult, Team, TerminationCondition
-from ...messages import ChatMessage, TextMessage
+from ...messages import ChatMessage, InnerMessage, TextMessage
 from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
 from ._base_group_chat_manager import BaseGroupChatManager
 from ._chat_agent_container import ChatAgentContainer
@@ -56,12 +56,13 @@ def _create_group_chat_manager_factory(
     def _create_participant_factory(
         self,
         parent_topic_type: str,
+        output_topic_type: str,
         agent: ChatAgent,
     ) -> Callable[[], ChatAgentContainer]:
         def _factory() -> ChatAgentContainer:
             id = AgentInstantiationContext.current_agent_id()
             assert id == AgentId(type=agent.name, key=self._team_id)
-            container = ChatAgentContainer(parent_topic_type, agent)
+            container = ChatAgentContainer(parent_topic_type, output_topic_type, agent)
             assert container.id == id
             return container
 
@@ -85,6 +86,7 @@ async def run(
         group_chat_manager_topic_type = group_chat_manager_agent_type.type
         group_topic_type = "round_robin_group_topic"
         team_topic_type = "team_topic"
+        output_topic_type = "output_topic"
 
         # Register participants.
         participant_topic_types: List[str] = []
@@ -97,7 +99,7 @@ async def run(
             await ChatAgentContainer.register(
                 runtime,
                 type=agent_type,
-                factory=self._create_participant_factory(group_topic_type, participant),
+                factory=self._create_participant_factory(group_topic_type, output_topic_type, participant),
             )
             # Add subscriptions for the participant.
             await runtime.add_subscription(TypeSubscription(topic_type=topic_type, agent_type=agent_type))
@@ -129,22 +131,22 @@ async def run(
             TypeSubscription(topic_type=team_topic_type, agent_type=group_chat_manager_agent_type.type)
         )
 
-        group_chat_messages: List[ChatMessage] = []
+        output_messages: List[InnerMessage | ChatMessage] = []
 
-        async def collect_group_chat_messages(
+        async def collect_output_messages(
             _runtime: AgentRuntime,
             id: AgentId,
-            message: GroupChatPublishEvent,
+            message: InnerMessage | ChatMessage,
             ctx: MessageContext,
         ) -> None:
-            group_chat_messages.append(message.agent_message)
+            output_messages.append(message)
 
         await ClosureAgent.register(
             runtime,
-            type="collect_group_chat_messages",
-            closure=collect_group_chat_messages,
+            type="collect_output_messages",
+            closure=collect_output_messages,
             subscriptions=lambda: [
-                TypeSubscription(topic_type=group_topic_type, agent_type="collect_group_chat_messages"),
+                TypeSubscription(topic_type=output_topic_type, agent_type="collect_output_messages"),
             ],
         )
 
@@ -154,8 +156,10 @@ async def collect_group_chat_messages(
         # Run the team by publishing the task to the team topic and then requesting the result.
         team_topic_id = TopicId(type=team_topic_type, source=self._team_id)
         group_chat_manager_topic_id = TopicId(type=group_chat_manager_topic_type, source=self._team_id)
+        first_chat_message = TextMessage(content=task, source="user")
+        output_messages.append(first_chat_message)
         await runtime.publish_message(
-            GroupChatPublishEvent(agent_message=TextMessage(content=task, source="user")),
+            GroupChatPublishEvent(agent_message=first_chat_message),
             topic_id=team_topic_id,
         )
         await runtime.publish_message(GroupChatRequestPublishEvent(), topic_id=group_chat_manager_topic_id)
@@ -164,4 +168,4 @@ async def collect_group_chat_messages(
         await runtime.stop_when_idle()
 
         # Return the result.
-        return TaskResult(messages=group_chat_messages)
+        return TaskResult(messages=output_messages)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index e2970ffe6376..1423735c2f7c 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -16,12 +16,14 @@ class ChatAgentContainer(SequentialRoutedAgent):
 
     Args:
         parent_topic_type (str): The topic type of the parent orchestrator.
+        output_topic_type (str): The topic type for the output.
         agent (ChatAgent): The agent to delegate message handling to.
     """
 
-    def __init__(self, parent_topic_type: str, agent: ChatAgent) -> None:
+    def __init__(self, parent_topic_type: str, output_topic_type: str, agent: ChatAgent) -> None:
         super().__init__(description=agent.description)
         self._parent_topic_type = parent_topic_type
+        self._output_topic_type = output_topic_type
         self._agent = agent
         self._message_buffer: List[ChatMessage] = []
 
@@ -36,18 +38,27 @@ async def handle_content_request(self, message: GroupChatRequestPublishEvent, ct
         to the delegate agent and publish the response."""
         # Pass the messages in the buffer to the delegate agent.
         response = await self._agent.on_messages(self._message_buffer, ctx.cancellation_token)
-        if not any(isinstance(response, msg_type) for msg_type in self._agent.produced_message_types):
+        if not any(isinstance(response.chat_message, msg_type) for msg_type in self._agent.produced_message_types):
             raise ValueError(
                 f"The agent {self._agent.name} produced an unexpected message type: {type(response)}. "
-                f"Expected one of: {self._agent.produced_message_types}"
+                f"Expected one of: {self._agent.produced_message_types}. "
+                f"Check the agent's produced_message_types property."
             )
 
+        # Publish inner messages to the output topic.
+        if response.inner_messages is not None:
+            for inner_message in response.inner_messages:
+                await self.publish_message(inner_message, topic_id=DefaultTopicId(type=self._output_topic_type))
+
         # Publish the response.
         self._message_buffer.clear()
         await self.publish_message(
-            GroupChatPublishEvent(agent_message=response, source=self.id),
+            GroupChatPublishEvent(agent_message=response.chat_message, source=self.id),
             topic_id=DefaultTopicId(type=self._parent_topic_type),
         )
 
+        # Publish the response to the output topic.
+        await self.publish_message(response.chat_message, topic_id=DefaultTopicId(type=self._output_topic_type))
+
     async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> None:
         raise ValueError(f"Unhandled message in agent container: {type(message)}")
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 332a7bab15a8..9dee76539be4 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -7,7 +7,7 @@
 from autogen_agentchat import EVENT_LOGGER_NAME
 from autogen_agentchat.agents import AssistantAgent, Handoff
 from autogen_agentchat.logging import FileLogHandler
-from autogen_agentchat.messages import HandoffMessage, StopMessage, TextMessage
+from autogen_agentchat.messages import HandoffMessage, TextMessage, ToolCallMessage, ToolCallResultMessages
 from autogen_core.base import CancellationToken
 from autogen_core.components.tools import FunctionTool
 from autogen_ext.models import OpenAIChatCompletionClient
@@ -111,10 +111,11 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
         tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
     )
     result = await tool_use_agent.run("task")
-    assert len(result.messages) == 3
+    assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
-    assert isinstance(result.messages[1], TextMessage)
-    assert isinstance(result.messages[2], StopMessage)
+    assert isinstance(result.messages[1], ToolCallMessage)
+    assert isinstance(result.messages[2], ToolCallResultMessages)
+    assert isinstance(result.messages[3], TextMessage)
 
 
 @pytest.mark.asyncio
@@ -162,5 +163,5 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
     response = await tool_use_agent.on_messages(
         [TextMessage(content="task", source="user")], cancellation_token=CancellationToken()
     )
-    assert isinstance(response, HandoffMessage)
-    assert response.target == "agent2"
+    assert isinstance(response.chat_message, HandoffMessage)
+    assert response.chat_message.target == "agent2"
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 1d04c78b605d..e6510c2fa17e 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -12,12 +12,15 @@
     CodeExecutorAgent,
     Handoff,
 )
+from autogen_agentchat.base import Response
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import (
     ChatMessage,
     HandoffMessage,
     StopMessage,
     TextMessage,
+    ToolCallMessage,
+    ToolCallResultMessages,
 )
 from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination
 from autogen_agentchat.teams import (
@@ -66,14 +69,14 @@ def __init__(self, name: str, description: str) -> None:
     def produced_message_types(self) -> List[type[ChatMessage]]:
         return [TextMessage]
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
         if len(messages) > 0:
             assert isinstance(messages[0], TextMessage)
             self._last_message = messages[0].content
-            return TextMessage(content=messages[0].content, source=self.name)
+            return Response(chat_message=TextMessage(content=messages[0].content, source=self.name))
         else:
             assert self._last_message is not None
-            return TextMessage(content=self._last_message, source=self.name)
+            return Response(chat_message=TextMessage(content=self._last_message, source=self.name))
 
 
 class _StopAgent(_EchoAgent):
@@ -86,11 +89,11 @@ def __init__(self, name: str, description: str, *, stop_at: int = 1) -> None:
     def produced_message_types(self) -> List[type[ChatMessage]]:
         return [TextMessage, StopMessage]
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
         self._count += 1
         if self._count < self._stop_at:
             return await super().on_messages(messages, cancellation_token)
-        return StopMessage(content="TERMINATE", source=self.name)
+        return Response(chat_message=StopMessage(content="TERMINATE", source=self.name))
 
 
 def _pass_function(input: str) -> str:
@@ -230,11 +233,13 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
         "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
     )
 
-    assert len(result.messages) == 4
+    assert len(result.messages) == 6
     assert isinstance(result.messages[0], TextMessage)  # task
-    assert isinstance(result.messages[1], TextMessage)  # tool use agent response
-    assert isinstance(result.messages[2], TextMessage)  # echo agent response
-    assert isinstance(result.messages[3], StopMessage)  # tool use agent response
+    assert isinstance(result.messages[1], ToolCallMessage)  # tool call
+    assert isinstance(result.messages[2], ToolCallResultMessages)  # tool call result
+    assert isinstance(result.messages[3], TextMessage)  # tool use agent response
+    assert isinstance(result.messages[4], TextMessage)  # echo agent response
+    assert isinstance(result.messages[5], StopMessage)  # tool use agent response
 
     context = tool_use_agent._model_context  # pyright: ignore
     assert context[0].content == "Write a program that prints 'Hello, world!'"
@@ -427,8 +432,12 @@ def __init__(self, name: str, description: str, next_agent: str) -> None:
     def produced_message_types(self) -> List[type[ChatMessage]]:
         return [HandoffMessage]
 
-    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:
-        return HandoffMessage(content=f"Transferred to {self._next_agent}.", target=self._next_agent, source=self.name)
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        return Response(
+            chat_message=HandoffMessage(
+                content=f"Transferred to {self._next_agent}.", target=self._next_agent, source=self.name
+            )
+        )
 
 
 @pytest.mark.asyncio
@@ -513,9 +522,11 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
     team = Swarm([agnet1, agent2])
     result = await team.run("task", termination_condition=StopMessageTermination())
-    assert len(result.messages) == 5
+    assert len(result.messages) == 7
     assert result.messages[0].content == "task"
-    assert result.messages[1].content == "handoff to agent2"
-    assert result.messages[2].content == "Transferred to agent1."
-    assert result.messages[3].content == "Hello"
-    assert result.messages[4].content == "TERMINATE"
+    assert isinstance(result.messages[1], ToolCallMessage)
+    assert isinstance(result.messages[2], ToolCallResultMessages)
+    assert result.messages[3].content == "handoff to agent2"
+    assert result.messages[4].content == "Transferred to agent1."
+    assert result.messages[5].content == "Hello"
+    assert result.messages[6].content == "TERMINATE"
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index 0e58c2522a5e..d367ba29b7e0 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -251,6 +251,7 @@
     "from typing import List, Sequence\n",
     "\n",
     "from autogen_agentchat.agents import BaseChatAgent\n",
+    "from autogen_agentchat.base import Response\n",
     "from autogen_agentchat.messages import (\n",
     "    ChatMessage,\n",
     "    StopMessage,\n",
@@ -266,11 +267,11 @@
     "    def produced_message_types(self) -> List[type[ChatMessage]]:\n",
     "        return [TextMessage, StopMessage]\n",
     "\n",
-    "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:\n",
+    "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:\n",
     "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
     "        if \"TERMINATE\" in user_input:\n",
-    "            return StopMessage(content=\"User has terminated the conversation.\", source=self.name)\n",
-    "        return TextMessage(content=user_input, source=self.name)\n",
+    "            return Response(chat_message=StopMessage(content=\"User has terminated the conversation.\", source=self.name))\n",
+    "        return Response(chat_message=TextMessage(content=user_input, source=self.name))\n",
     "\n",
     "\n",
     "user_proxy_agent = UserProxyAgent(name=\"user_proxy_agent\")\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index f5a5358aae51..633c81867bf5 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -45,6 +45,7 @@
     "    CodingAssistantAgent,\n",
     "    ToolUseAssistantAgent,\n",
     ")\n",
+    "from autogen_agentchat.base import Response\n",
     "from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage\n",
     "from autogen_agentchat.task import StopMessageTermination\n",
     "from autogen_agentchat.teams import SelectorGroupChat\n",
@@ -75,11 +76,11 @@
     "    def produced_message_types(self) -> List[type[ChatMessage]]:\n",
     "        return [TextMessage, StopMessage]\n",
     "\n",
-    "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> ChatMessage:\n",
+    "    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:\n",
     "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
     "        if \"TERMINATE\" in user_input:\n",
-    "            return StopMessage(content=\"User has terminated the conversation.\", source=self.name)\n",
-    "        return TextMessage(content=user_input, source=self.name)"
+    "            return Response(chat_message=StopMessage(content=\"User has terminated the conversation.\", source=self.name))\n",
+    "        return Response(chat_message=TextMessage(content=user_input, source=self.name))"
    ]
   },
   {

From 6bea055b26f2966cf6aba8b2a39b63fcd9ba367b Mon Sep 17 00:00:00 2001
From: Xiaoyun Zhang 
Date: Wed, 30 Oct 2024 11:53:37 -0700
Subject: [PATCH 054/173] [.Net] Add a generic `IHandle` interface so
 AgentRuntime doesn't need to deal with typed handler (#3985)

* add IHandle for object type

* rename handle -> handleObject

* remove duplicate file header setting

* update

* remove AgentId

* fix format
---
 dotnet/.editorconfig                          |  8 +--
 dotnet/AutoGen.sln                            |  7 +++
 .../AgentBaseTests.cs                         | 51 +++++++++++++++++++
 .../Microsoft.AutoGen.Agents.Tests.csproj     | 14 +++++
 .../CodeSnippet/AgentCodeSnippet.cs           |  1 +
 .../CodeSnippet/UserProxyAgentCodeSnippet.cs  |  1 +
 .../Example06_UserProxyAgent.cs               |  1 +
 .../samples/AutoGen.BasicSamples/Program.cs   |  3 +-
 .../Connect_To_Azure_OpenAI.cs                |  3 +-
 dotnet/samples/Hello/Backend/Program.cs       |  4 +-
 dotnet/samples/Hello/Hello.AppHost/Program.cs |  3 +-
 .../Hello/HelloAIAgents/HelloAIAgent.cs       |  3 ++
 dotnet/samples/Hello/HelloAIAgents/Program.cs |  3 ++
 dotnet/samples/Hello/HelloAgent/Program.cs    | 13 ++++-
 .../samples/Hello/HelloAgentState/Program.cs  |  3 +-
 .../dev-team/DevTeam.AgentHost/Program.cs     |  3 ++
 .../DevTeam.Agents/Developer/Developer.cs     |  3 ++
 .../Developer/DeveloperPrompts.cs             |  2 +
 .../DeveloperLead/DeveloperLead.cs            |  3 ++
 .../DeveloperLead/DeveloperLeadPrompts.cs     |  3 ++
 .../ProductManager/PMPrompts.cs               |  3 ++
 .../ProductManager/ProductManager.cs          |  3 ++
 .../dev-team/DevTeam.Agents/Program.cs        |  3 ++
 .../dev-team/DevTeam.AppHost/Program.cs       |  3 ++
 .../DevTeam.Backend/Agents/AzureGenie.cs      |  3 ++
 .../dev-team/DevTeam.Backend/Agents/Hubber.cs |  3 ++
 .../DevTeam.Backend/Agents/Sandbox.cs         |  6 +--
 .../dev-team/DevTeam.Backend/Program.cs       |  3 ++
 .../DevTeam.Backend/Services/AzureService.cs  |  2 +
 .../Services/GithubAuthService.cs             |  3 ++
 .../DevTeam.Backend/Services/GithubService.cs |  3 ++
 .../Services/GithubWebHookProcessor.cs        |  3 ++
 .../DevTeam.Shared/EventExtensions.cs         |  3 +-
 .../dev-team/DevTeam.Shared/Models/DevPlan.cs |  3 ++
 .../DevTeam.Shared/Options/AzureOptions.cs    |  3 ++
 .../DevTeam.Shared/Options/GithubOptions.cs   |  3 ++
 .../DevTeam.Shared/ParseExtensions.cs         |  3 +-
 .../DTO/ChatCompletionRequest.cs              |  1 +
 .../AutoGen.Core/Extension/AgentExtension.cs  |  3 +-
 .../src/AutoGen.Core/GroupChat/GroupChat.cs   |  3 +-
 dotnet/src/AutoGen/LMStudioConfig.cs          |  1 +
 .../Microsoft.AutoGen/Abstractions/AgentId.cs | 13 +++++
 .../Abstractions/ChatHistoryItem.cs           |  3 ++
 .../Abstractions/ChatState.cs                 |  3 ++
 .../Abstractions/ChatUserType.cs              |  3 ++
 .../{Agents => Abstractions}/IAgentBase.cs    |  6 ++-
 .../Abstractions/IAgentContext.cs             | 20 ++++++++
 .../IAgentWorkerRuntime.cs                    |  6 +--
 .../Microsoft.AutoGen/Abstractions/IHandle.cs | 10 +++-
 .../Abstractions/MessageExtensions.cs         |  3 ++
 .../TopicSubscriptionAttribute.cs             |  3 ++
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs | 25 ++++++++-
 .../Agents/AgentBaseExtensions.cs             |  3 ++
 .../Microsoft.AutoGen/Agents/AgentContext.cs  |  7 ++-
 .../src/Microsoft.AutoGen/Agents/AgentId.cs   | 15 ------
 .../Microsoft.AutoGen/Agents/AgentWorker.cs   |  3 ++
 .../Agents/Agents/AIAgent/InferenceAgent.cs   |  4 ++
 .../Agents/Agents/AIAgent/SKAiAgent.cs        |  4 +-
 .../IOAgent/ConsoleAgent/ConsoleAgent.cs      |  3 ++
 .../IOAgent/ConsoleAgent/IHandleConsole.cs    |  3 ++
 .../Agents/IOAgent/FileAgent/FileAgent.cs     |  3 ++
 .../Agents/Agents/IOAgent/IOAgent.cs          |  3 ++
 .../Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs |  3 ++
 dotnet/src/Microsoft.AutoGen/Agents/App.cs    |  3 ++
 .../Agents/GrpcAgentWorkerRuntime.cs          |  3 ++
 .../Agents/HostBuilderExtensions.cs           |  3 ++
 .../Microsoft.AutoGen/Agents/IAgentContext.cs | 18 -------
 .../Agents/Microsoft.AutoGen.Agents.csproj    |  2 +-
 .../AIModelClientHostingExtensions.cs         |  3 ++
 .../Options/AIClientOptions.cs                |  3 ++
 ...rviceCollectionChatCompletionExtensions.cs |  3 ++
 .../CloudEvents/CloudEventExtensions.cs       |  3 ++
 .../SemanticKernel/Options/QdrantOptions.cs   |  3 ++
 .../SemanticKernelHostingExtensions.cs        |  3 +-
 .../Runtime/AgentWorkerHostingExtensions.cs   |  3 ++
 .../Runtime/AgentWorkerRegistryGrain.cs       |  3 ++
 dotnet/src/Microsoft.AutoGen/Runtime/Host.cs  |  3 ++
 .../Runtime/IAgentWorkerRegistryGrain.cs      |  3 ++
 .../Runtime/IWorkerAgentGrain.cs              |  3 ++
 .../Runtime/IWorkerGateway.cs                 |  2 +
 .../Runtime/OrleansRuntimeHostingExtenions.cs |  3 ++
 .../Runtime/WorkerAgentGrain.cs               |  3 ++
 .../Runtime/WorkerGateway.cs                  |  3 ++
 .../Runtime/WorkerGatewayService.cs           |  3 ++
 .../Runtime/WorkerProcessConnection.cs        |  3 ++
 .../ServiceDefaults/Extensions.cs             |  3 ++
 .../ChatRequestMessageTests.cs                |  3 +-
 .../KernelFunctionMiddlewareTests.cs          |  3 +-
 .../FunctionCallTemplateEncodingTests.cs      |  3 +-
 dotnet/test/AutoGen.Tests/TwoAgentTest.cs     |  1 +
 90 files changed, 361 insertions(+), 70 deletions(-)
 create mode 100644 dotnet/Microsoft.AutoGen.Agents.Tests/AgentBaseTests.cs
 create mode 100644 dotnet/Microsoft.AutoGen.Agents.Tests/Microsoft.AutoGen.Agents.Tests.csproj
 create mode 100644 dotnet/src/Microsoft.AutoGen/Abstractions/AgentId.cs
 rename dotnet/src/Microsoft.AutoGen/{Agents => Abstractions}/IAgentBase.cs (78%)
 create mode 100644 dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
 rename dotnet/src/Microsoft.AutoGen/{Agents => Abstractions}/IAgentWorkerRuntime.cs (69%)
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Agents/AgentId.cs
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs

diff --git a/dotnet/.editorconfig b/dotnet/.editorconfig
index 6e2b709d881c..3821c59cc19f 100644
--- a/dotnet/.editorconfig
+++ b/dotnet/.editorconfig
@@ -193,10 +193,6 @@ csharp_using_directive_placement = outside_namespace:error
 csharp_prefer_static_local_function = true:warning
 csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
 
-# Header template
-file_header_template = Copyright (c) Microsoft Corporation. All rights reserved.\n{fileName}
-dotnet_diagnostic.IDE0073.severity = error
-
 # enable format error
 dotnet_diagnostic.IDE0055.severity = error
 
@@ -557,8 +553,8 @@ dotnet_diagnostic.IDE0060.severity = warning
 dotnet_diagnostic.IDE0062.severity = warning
 
 # IDE0073: File header
-dotnet_diagnostic.IDE0073.severity = suggestion
-file_header_template = Copyright (c) Microsoft. All rights reserved.
+dotnet_diagnostic.IDE0073.severity = warning
+file_header_template = Copyright (c) Microsoft Corporation. All rights reserved.\n{fileName}
 
 # IDE1006: Required naming style
 dotnet_diagnostic.IDE1006.severity = warning
diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 4b8ce8ff0142..291cb484649d 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -123,6 +123,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAgent", "samples\Hello
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AIModelClientHostingExtensions", "src\Microsoft.AutoGen\Extensions\AIModelClientHostingExtensions\AIModelClientHostingExtensions.csproj", "{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Agents.Tests", "Microsoft.AutoGen.Agents.Tests\Microsoft.AutoGen.Agents.Tests.csproj", "{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}"
+EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sample", "sample", "{686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAgentState", "samples\Hello\HelloAgentState\HelloAgentState.csproj", "{64EF61E7-00A6-4E5E-9808-62E10993A0E5}"
@@ -337,6 +339,10 @@ Global
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}.Release|Any CPU.Build.0 = Release|Any CPU
 		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{64EF61E7-00A6-4E5E-9808-62E10993A0E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -401,6 +407,7 @@ Global
 		{A20B9894-F352-4338-872A-F215A241D43D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{8F7560CF-EEBB-4333-A69F-838CA40FD85D} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 		{97550E87-48C6-4EBF-85E1-413ABAE9DBFD} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
+		{CF4C92BD-28AE-4B8F-B173-601004AEC9BF} = {F823671B-3ECA-4AE6-86DA-25E920D3FE64}
 		{64EF61E7-00A6-4E5E-9808-62E10993A0E5} = {7EB336C2-7C0A-4BC8-80C6-A3173AB8DC45}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
diff --git a/dotnet/Microsoft.AutoGen.Agents.Tests/AgentBaseTests.cs b/dotnet/Microsoft.AutoGen.Agents.Tests/AgentBaseTests.cs
new file mode 100644
index 000000000000..4e17dd56f5a2
--- /dev/null
+++ b/dotnet/Microsoft.AutoGen.Agents.Tests/AgentBaseTests.cs
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentBaseTests.cs
+
+using FluentAssertions;
+using Google.Protobuf.Reflection;
+using Microsoft.AutoGen.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Microsoft.AutoGen.Agents.Tests;
+
+public class AgentBaseTests
+{
+    [Fact]
+    public async Task ItInvokeRightHandlerTestAsync()
+    {
+        var mockContext = new Mock();
+        var agent = new TestAgent(mockContext.Object, new EventTypes(TypeRegistry.Empty, [], []));
+
+        await agent.HandleObject("hello world");
+        await agent.HandleObject(42);
+
+        agent.ReceivedItems.Should().HaveCount(2);
+        agent.ReceivedItems[0].Should().Be("hello world");
+        agent.ReceivedItems[1].Should().Be(42);
+    }
+
+    /// 
+    /// The test agent is a simple agent that is used for testing purposes.
+    /// 
+    public class TestAgent : AgentBase, IHandle, IHandle
+    {
+        public TestAgent(IAgentContext context, EventTypes eventTypes) : base(context, eventTypes)
+        {
+        }
+
+        public Task Handle(string item)
+        {
+            ReceivedItems.Add(item);
+            return Task.CompletedTask;
+        }
+
+        public Task Handle(int item)
+        {
+            ReceivedItems.Add(item);
+            return Task.CompletedTask;
+        }
+
+        public List ReceivedItems { get; private set; } = [];
+    }
+}
diff --git a/dotnet/Microsoft.AutoGen.Agents.Tests/Microsoft.AutoGen.Agents.Tests.csproj b/dotnet/Microsoft.AutoGen.Agents.Tests/Microsoft.AutoGen.Agents.Tests.csproj
new file mode 100644
index 000000000000..ca18cf97c547
--- /dev/null
+++ b/dotnet/Microsoft.AutoGen.Agents.Tests/Microsoft.AutoGen.Agents.Tests.csproj
@@ -0,0 +1,14 @@
+
+
+  
+    $(TestTargetFrameworks)
+    enable
+    enable
+    True
+  
+
+  
+    
+  
+
+
diff --git a/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/AgentCodeSnippet.cs b/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/AgentCodeSnippet.cs
index 8bb9871b192b..b97f302294e8 100644
--- a/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/AgentCodeSnippet.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/AgentCodeSnippet.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // AgentCodeSnippet.cs
+
 using AutoGen.Core;
 
 namespace AutoGen.BasicSample.CodeSnippet;
diff --git a/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/UserProxyAgentCodeSnippet.cs b/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/UserProxyAgentCodeSnippet.cs
index b34d201d2656..a04685be9283 100644
--- a/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/UserProxyAgentCodeSnippet.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/CodeSnippet/UserProxyAgentCodeSnippet.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // UserProxyAgentCodeSnippet.cs
+
 using AutoGen.Core;
 
 namespace AutoGen.BasicSample.CodeSnippet;
diff --git a/dotnet/samples/AutoGen.BasicSamples/Example06_UserProxyAgent.cs b/dotnet/samples/AutoGen.BasicSamples/Example06_UserProxyAgent.cs
index 314062dc2031..655121f961d8 100644
--- a/dotnet/samples/AutoGen.BasicSamples/Example06_UserProxyAgent.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/Example06_UserProxyAgent.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Example06_UserProxyAgent.cs
+
 using AutoGen.Core;
 using AutoGen.OpenAI;
 using AutoGen.OpenAI.Extension;
diff --git a/dotnet/samples/AutoGen.BasicSamples/Program.cs b/dotnet/samples/AutoGen.BasicSamples/Program.cs
index 5afbd8ec15e1..3a2edbb585f4 100644
--- a/dotnet/samples/AutoGen.BasicSamples/Program.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/Program.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
 
 //await Example07_Dynamic_GroupChat_Calculate_Fibonacci.RunAsync();
 
diff --git a/dotnet/samples/AutoGen.OpenAI.Sample/Connect_To_Azure_OpenAI.cs b/dotnet/samples/AutoGen.OpenAI.Sample/Connect_To_Azure_OpenAI.cs
index 0cc9fe988d14..f7ecbf3710e5 100644
--- a/dotnet/samples/AutoGen.OpenAI.Sample/Connect_To_Azure_OpenAI.cs
+++ b/dotnet/samples/AutoGen.OpenAI.Sample/Connect_To_Azure_OpenAI.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Connect_To_Azure_OpenAI.cs
 
 #region using_statement
 using System.ClientModel;
diff --git a/dotnet/samples/Hello/Backend/Program.cs b/dotnet/samples/Hello/Backend/Program.cs
index 747e0d860ab4..9f55daf69fc9 100644
--- a/dotnet/samples/Hello/Backend/Program.cs
+++ b/dotnet/samples/Hello/Backend/Program.cs
@@ -1,4 +1,6 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 using Microsoft.Extensions.Hosting;
 
 var app = await Microsoft.AutoGen.Runtime.Host.StartAsync(local: true);
diff --git a/dotnet/samples/Hello/Hello.AppHost/Program.cs b/dotnet/samples/Hello/Hello.AppHost/Program.cs
index d7c37df8ec13..d9acc3ea3f12 100644
--- a/dotnet/samples/Hello/Hello.AppHost/Program.cs
+++ b/dotnet/samples/Hello/Hello.AppHost/Program.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
 
 var builder = DistributedApplication.CreateBuilder(args);
 var backend = builder.AddProject("backend");
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
index 935d1d50b7a8..ebde6d6d2f51 100644
--- a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// HelloAIAgent.cs
+
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
 using Microsoft.Extensions.AI;
diff --git a/dotnet/samples/Hello/HelloAIAgents/Program.cs b/dotnet/samples/Hello/HelloAIAgents/Program.cs
index d2239f22b700..9d1964bfd1e1 100644
--- a/dotnet/samples/Hello/HelloAIAgents/Program.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 using Hello;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/samples/Hello/HelloAgent/Program.cs b/dotnet/samples/Hello/HelloAgent/Program.cs
index bccc66dfb9c9..fbe5d2f6dff9 100644
--- a/dotnet/samples/Hello/HelloAgent/Program.cs
+++ b/dotnet/samples/Hello/HelloAgent/Program.cs
@@ -1,11 +1,20 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
 
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 
-// send a message to the agent
+// step 1: create in-memory agent runtime
+
+// step 2: register HelloAgent to that agent runtime
+
+// step 3: start the agent runtime
+
+// step 4: send a message to the agent
+
+// step 5: wait for the agent runtime to shutdown
 var app = await AgentsApp.PublishMessageAsync("HelloAgents", new NewMessageReceived
 {
     Message = "World"
diff --git a/dotnet/samples/Hello/HelloAgentState/Program.cs b/dotnet/samples/Hello/HelloAgentState/Program.cs
index 6880bdd61679..66b888d6c46e 100644
--- a/dotnet/samples/Hello/HelloAgentState/Program.cs
+++ b/dotnet/samples/Hello/HelloAgentState/Program.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
 
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
diff --git a/dotnet/samples/dev-team/DevTeam.AgentHost/Program.cs b/dotnet/samples/dev-team/DevTeam.AgentHost/Program.cs
index d5c129c3bfae..4864f394217d 100644
--- a/dotnet/samples/dev-team/DevTeam.AgentHost/Program.cs
+++ b/dotnet/samples/dev-team/DevTeam.AgentHost/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 using Microsoft.AutoGen.Runtime;
 var builder = WebApplication.CreateBuilder(args);
 
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
index 70632518271d..42a1cc97dec9 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Developer.cs
+
 using DevTeam.Shared;
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Developer/DeveloperPrompts.cs b/dotnet/samples/dev-team/DevTeam.Agents/Developer/DeveloperPrompts.cs
index 5aa8c2756504..d4b5a4f942d3 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/Developer/DeveloperPrompts.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Developer/DeveloperPrompts.cs
@@ -1,3 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// DeveloperPrompts.cs
 
 namespace DevTeam.Agents;
 public static class DeveloperSkills
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
index a0bd80497c80..f66fed5078ea 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// DeveloperLead.cs
+
 using DevTeam.Shared;
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLeadPrompts.cs b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLeadPrompts.cs
index 3ab394cdbaeb..0aeb3b26dbb4 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLeadPrompts.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLeadPrompts.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// DeveloperLeadPrompts.cs
+
 namespace DevTeam.Agents;
 public static class DevLeadSkills
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/PMPrompts.cs b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/PMPrompts.cs
index ad1c431a4853..08d173b1166e 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/PMPrompts.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/PMPrompts.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// PMPrompts.cs
+
 namespace DevTeam.Agents;
 public static class PMSkills
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
index a5bdca19d1bb..140f573c7160 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ProductManager.cs
+
 using DevTeam.Shared;
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Program.cs b/dotnet/samples/dev-team/DevTeam.Agents/Program.cs
index 965c23cc948b..6d9937889491 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/Program.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 using DevTeam.Agents;
 using Microsoft.AutoGen.Agents;
 using Microsoft.AutoGen.Extensions.SemanticKernel;
diff --git a/dotnet/samples/dev-team/DevTeam.AppHost/Program.cs b/dotnet/samples/dev-team/DevTeam.AppHost/Program.cs
index 99a1978c5f1c..99dd61a790bc 100644
--- a/dotnet/samples/dev-team/DevTeam.AppHost/Program.cs
+++ b/dotnet/samples/dev-team/DevTeam.AppHost/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 var builder = DistributedApplication.CreateBuilder(args);
 
 builder.AddAzureProvisioning();
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
index 61c618acda72..258e0d1c2cf3 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AzureGenie.cs
+
 using DevTeam.Backend;
 using DevTeam.Shared;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
index f42eb4763b45..2f4c37338554 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Hubber.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Hubber.cs
+
 using System.Text.Json;
 using DevTeam;
 using DevTeam.Backend;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
index 1d13c7bd2aa4..2090ca39e731 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
@@ -1,7 +1,5 @@
-// TODO: Reimplement using ACA Sessions
-// using DevTeam.Events;
-// using Microsoft.AutoGen.Abstractions;
-// using Microsoft.AutoGen.Agents;
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Sandbox.cs
 
 // namespace DevTeam.Backend;
 
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Program.cs b/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
index 9de188bdfe8c..b24476692d08 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Program.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Program.cs
+
 using Azure.Identity;
 using DevTeam.Backend;
 using DevTeam.Options;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Services/AzureService.cs b/dotnet/samples/dev-team/DevTeam.Backend/Services/AzureService.cs
index 826751065d27..3c3bbf07a0b7 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Services/AzureService.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Services/AzureService.cs
@@ -1,3 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AzureService.cs
 
 using System.Text;
 using Azure;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubAuthService.cs b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubAuthService.cs
index 19d9e1214b62..d1a3bb7c08df 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubAuthService.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubAuthService.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GithubAuthService.cs
+
 using System.IdentityModel.Tokens.Jwt;
 using System.Security.Claims;
 using System.Security.Cryptography;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubService.cs b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubService.cs
index b1e0dcc77e5a..5c6dc2125fa9 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubService.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubService.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GithubService.cs
+
 using System.Text;
 using Azure.Storage.Files.Shares;
 using DevTeam.Options;
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
index e72b511e2381..54ef97e059b2 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Services/GithubWebHookProcessor.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GithubWebHookProcessor.cs
+
 using System.Globalization;
 using DevTeam.Shared;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/samples/dev-team/DevTeam.Shared/EventExtensions.cs b/dotnet/samples/dev-team/DevTeam.Shared/EventExtensions.cs
index f276d294fa11..60c044ea92eb 100644
--- a/dotnet/samples/dev-team/DevTeam.Shared/EventExtensions.cs
+++ b/dotnet/samples/dev-team/DevTeam.Shared/EventExtensions.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// EventExtensions.cs
 
 using System.Globalization;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/samples/dev-team/DevTeam.Shared/Models/DevPlan.cs b/dotnet/samples/dev-team/DevTeam.Shared/Models/DevPlan.cs
index 51c4ae49cdb2..5d9bdb59a50c 100644
--- a/dotnet/samples/dev-team/DevTeam.Shared/Models/DevPlan.cs
+++ b/dotnet/samples/dev-team/DevTeam.Shared/Models/DevPlan.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// DevPlan.cs
+
 namespace DevTeam;
 public class DevLeadPlan
 {
diff --git a/dotnet/samples/dev-team/DevTeam.Shared/Options/AzureOptions.cs b/dotnet/samples/dev-team/DevTeam.Shared/Options/AzureOptions.cs
index 3bdd1adf51db..56499982ae27 100644
--- a/dotnet/samples/dev-team/DevTeam.Shared/Options/AzureOptions.cs
+++ b/dotnet/samples/dev-team/DevTeam.Shared/Options/AzureOptions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AzureOptions.cs
+
 using System.ComponentModel.DataAnnotations;
 
 namespace DevTeam.Options;
diff --git a/dotnet/samples/dev-team/DevTeam.Shared/Options/GithubOptions.cs b/dotnet/samples/dev-team/DevTeam.Shared/Options/GithubOptions.cs
index b279d8df7c24..0ceb2e68a46a 100644
--- a/dotnet/samples/dev-team/DevTeam.Shared/Options/GithubOptions.cs
+++ b/dotnet/samples/dev-team/DevTeam.Shared/Options/GithubOptions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GithubOptions.cs
+
 using System.ComponentModel.DataAnnotations;
 
 namespace DevTeam.Options;
diff --git a/dotnet/samples/dev-team/DevTeam.Shared/ParseExtensions.cs b/dotnet/samples/dev-team/DevTeam.Shared/ParseExtensions.cs
index b6f5b5292c58..c4681513dd10 100644
--- a/dotnet/samples/dev-team/DevTeam.Shared/ParseExtensions.cs
+++ b/dotnet/samples/dev-team/DevTeam.Shared/ParseExtensions.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ParseExtensions.cs
 
 namespace DevTeam;
 
diff --git a/dotnet/src/AutoGen.Anthropic/DTO/ChatCompletionRequest.cs b/dotnet/src/AutoGen.Anthropic/DTO/ChatCompletionRequest.cs
index b9f5fb630cde..c3f378dffe3a 100644
--- a/dotnet/src/AutoGen.Anthropic/DTO/ChatCompletionRequest.cs
+++ b/dotnet/src/AutoGen.Anthropic/DTO/ChatCompletionRequest.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // ChatCompletionRequest.cs
+
 using System.Collections.Generic;
 using System.Text.Json.Serialization;
 
diff --git a/dotnet/src/AutoGen.Core/Extension/AgentExtension.cs b/dotnet/src/AutoGen.Core/Extension/AgentExtension.cs
index 01138250268c..3bc5787a8594 100644
--- a/dotnet/src/AutoGen.Core/Extension/AgentExtension.cs
+++ b/dotnet/src/AutoGen.Core/Extension/AgentExtension.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentExtension.cs
 
 using System;
 using System.Collections.Generic;
diff --git a/dotnet/src/AutoGen.Core/GroupChat/GroupChat.cs b/dotnet/src/AutoGen.Core/GroupChat/GroupChat.cs
index 7fca2e8f4065..198eb4d6fcfb 100644
--- a/dotnet/src/AutoGen.Core/GroupChat/GroupChat.cs
+++ b/dotnet/src/AutoGen.Core/GroupChat/GroupChat.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GroupChat.cs
 
 using System;
 using System.Collections.Generic;
diff --git a/dotnet/src/AutoGen/LMStudioConfig.cs b/dotnet/src/AutoGen/LMStudioConfig.cs
index a2c74c6d2b28..4605b051142f 100644
--- a/dotnet/src/AutoGen/LMStudioConfig.cs
+++ b/dotnet/src/AutoGen/LMStudioConfig.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // LMStudioConfig.cs
+
 using System;
 using System.ClientModel;
 using OpenAI;
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/AgentId.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/AgentId.cs
new file mode 100644
index 000000000000..7229b7365773
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/AgentId.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentId.cs
+
+namespace Microsoft.AutoGen.Abstractions;
+
+public partial class AgentId
+{
+    public AgentId(string type, string key)
+    {
+        Type = type;
+        Key = key;
+    }
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatHistoryItem.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatHistoryItem.cs
index 911c13f24315..0a779405e278 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatHistoryItem.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatHistoryItem.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ChatHistoryItem.cs
+
 namespace Microsoft.AutoGen.Abstractions;
 
 [Serializable]
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
index 8185c153d9d0..459a17045496 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatState.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ChatState.cs
+
 using Google.Protobuf;
 
 namespace Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatUserType.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatUserType.cs
index 74743fbffed9..4ee8dcd33890 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/ChatUserType.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/ChatUserType.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ChatUserType.cs
+
 namespace Microsoft.AutoGen.Abstractions;
 
 public enum ChatUserType
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
similarity index 78%
rename from dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
rename to dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
index cd0f63b4f25e..6b41594932a5 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
@@ -1,7 +1,9 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IAgentBase.cs
+
 using Google.Protobuf;
-using Microsoft.AutoGen.Abstractions;
 
-namespace Microsoft.AutoGen.Agents;
+namespace Microsoft.AutoGen.Abstractions;
 
 public interface IAgentBase
 {
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
new file mode 100644
index 000000000000..d93b6246765d
--- /dev/null
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IAgentContext.cs
+
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AutoGen.Abstractions;
+
+public interface IAgentContext
+{
+    AgentId AgentId { get; }
+    IAgentBase? AgentInstance { get; set; }
+    DistributedContextPropagator DistributedContextPropagator { get; } // TODO: Remove this. An abstraction should not have a dependency on DistributedContextPropagator.
+    ILogger Logger { get; } // TODO: Remove this. An abstraction should not have a dependency on ILogger.
+    ValueTask Store(AgentState value);
+    ValueTask Read(AgentId agentId);
+    ValueTask SendResponseAsync(RpcRequest request, RpcResponse response);
+    ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request);
+    ValueTask PublishEventAsync(CloudEvent @event);
+}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
similarity index 69%
rename from dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs
rename to dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
index 5c2c7f486402..1a255e132346 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
@@ -1,8 +1,8 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IAgentWorkerRuntime.cs
 
-using Microsoft.AutoGen.Abstractions;
+namespace Microsoft.AutoGen.Abstractions;
 
-namespace Microsoft.AutoGen.Agents;
 public interface IAgentWorkerRuntime
 {
     ValueTask PublishEvent(CloudEvent evt);
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IHandle.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IHandle.cs
index 4465d8889c47..ff43852b14e5 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IHandle.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IHandle.cs
@@ -1,6 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IHandle.cs
+
 namespace Microsoft.AutoGen.Abstractions;
 
-public interface IHandle
+public interface IHandle
+{
+    Task HandleObject(object item);
+}
+
+public interface IHandle : IHandle
 {
     Task Handle(T item);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
index 5fa09ae218b2..2c8f5d053063 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/MessageExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// MessageExtensions.cs
+
 using Google.Protobuf;
 using Google.Protobuf.WellKnownTypes;
 
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/TopicSubscriptionAttribute.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/TopicSubscriptionAttribute.cs
index 7651c78ca460..79d8393d2027 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/TopicSubscriptionAttribute.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/TopicSubscriptionAttribute.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// TopicSubscriptionAttribute.cs
+
 namespace Microsoft.AutoGen.Abstractions;
 
 [AttributeUsage(AttributeTargets.All)]
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index cfe2b409133c..af06c84e9ba1 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentBase.cs
+
 using System.Diagnostics;
 using System.Reflection;
 using System.Text;
@@ -9,7 +12,7 @@
 
 namespace Microsoft.AutoGen.Agents;
 
-public abstract class AgentBase : IAgentBase
+public abstract class AgentBase : IAgentBase, IHandle
 {
     public static readonly ActivitySource s_source = new("AutoGen.Agent");
     public AgentId AgentId => _context.AgentId;
@@ -251,5 +254,23 @@ public Task CallHandler(CloudEvent item)
         return Task.CompletedTask;
     }
 
-    public virtual Task HandleRequest(RpcRequest request) => Task.FromResult(new RpcResponse { Error = "Not implemented" });
+    public Task HandleRequest(RpcRequest request) => Task.FromResult(new RpcResponse { Error = "Not implemented" });
+
+    public virtual Task HandleObject(object item)
+    {
+        // get all Handle methods
+        var handleTMethods = this.GetType().GetMethods().Where(m => m.Name == "Handle" && m.GetParameters().Length == 1).ToList();
+
+        // get the one that matches the type of the item
+        var handleTMethod = handleTMethods.FirstOrDefault(m => m.GetParameters()[0].ParameterType == item.GetType());
+
+        // if we found one, invoke it
+        if (handleTMethod != null)
+        {
+            return (Task)handleTMethod.Invoke(this, [item])!;
+        }
+
+        // otherwise, complain
+        throw new InvalidOperationException($"No handler found for type {item.GetType().FullName}");
+    }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
index 0f815e3d2ecd..ef62a2b1d4d1 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBaseExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentBaseExtensions.cs
+
 using System.Diagnostics;
 
 namespace Microsoft.AutoGen.Agents;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
index 30be1406d3d3..325bc33a11d0 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentContext.cs
+
 using System.Diagnostics;
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.Extensions.Logging;
@@ -10,14 +13,14 @@ internal sealed class AgentContext(AgentId agentId, IAgentWorkerRuntime runtime,
 
     public AgentId AgentId { get; } = agentId;
     public ILogger Logger { get; } = logger;
-    public AgentBase? AgentInstance { get; set; }
+    public IAgentBase? AgentInstance { get; set; }
     public DistributedContextPropagator DistributedContextPropagator { get; } = distributedContextPropagator;
     public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse response)
     {
         response.RequestId = request.RequestId;
         await _runtime.SendResponse(response);
     }
-    public async ValueTask SendRequestAsync(AgentBase agent, RpcRequest request)
+    public async ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request)
     {
         await _runtime.SendRequest(agent, request).ConfigureAwait(false);
     }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentId.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentId.cs
deleted file mode 100644
index da771c47df40..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentId.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using RpcAgentId = Microsoft.AutoGen.Abstractions.AgentId;
-
-namespace Microsoft.AutoGen.Agents;
-
-public sealed record class AgentId(string Type, string Key)
-{
-    public static implicit operator RpcAgentId(AgentId agentId) => new()
-    {
-        Type = agentId.Type,
-        Key = agentId.Key
-    };
-
-    public static implicit operator AgentId(RpcAgentId agentId) => new(agentId.Type, agentId.Key);
-    public override string ToString() => $"{Type}/{Key}";
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
index 0ba909ac61d5..30ebda6e7196 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentWorker.cs
+
 using System.Diagnostics;
 using Google.Protobuf;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
index 15c4fc095fa6..1568d97696dc 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/InferenceAgent.cs
@@ -1,4 +1,8 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// InferenceAgent.cs
+
 using Google.Protobuf;
+using Microsoft.AutoGen.Abstractions;
 using Microsoft.Extensions.AI;
 namespace Microsoft.AutoGen.Agents.Client;
 public abstract class InferenceAgent : AgentBase where T : IMessage, new()
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
index becd2c208fa6..ceeeadacc5c7 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/AIAgent/SKAiAgent.cs
@@ -1,7 +1,9 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// SKAiAgent.cs
 
 using System.Globalization;
 using System.Text;
+using Microsoft.AutoGen.Abstractions;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.Connectors.OpenAI;
 using Microsoft.SemanticKernel.Memory;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
index 2df6c7965031..9470b0fb05d9 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ConsoleAgent.cs
+
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.Extensions.DependencyInjection;
 
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
index fc9ccae560d7..a103aa5e3fe7 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IHandleConsole.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Agents;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
index 2149a32d23cc..bcc52bba43d5 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// FileAgent.cs
+
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
index fc0f49733176..34c9ef3067c2 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IOAgent.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Agents;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
index 418ef8d5ab0e..76b57b598beb 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// WebAPIAgent.cs
+
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/App.cs b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
index be5da1ac5772..68c57e8d6dd1 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/App.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/App.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// App.cs
+
 using System.Diagnostics.CodeAnalysis;
 using Google.Protobuf;
 using Microsoft.AspNetCore.Builder;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
index 3a8355166d5b..c52509876ffd 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// GrpcAgentWorkerRuntime.cs
+
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Reflection;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
index 74d19042e980..ea8870a511f8 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/HostBuilderExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// HostBuilderExtensions.cs
+
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs
deleted file mode 100644
index 0dfa78b36e9f..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Agents/IAgentContext.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-using System.Diagnostics;
-using Microsoft.AutoGen.Abstractions;
-using Microsoft.Extensions.Logging;
-
-namespace Microsoft.AutoGen.Agents;
-
-public interface IAgentContext
-{
-    AgentId AgentId { get; }
-    AgentBase? AgentInstance { get; set; }
-    DistributedContextPropagator DistributedContextPropagator { get; }
-    ILogger Logger { get; }
-    ValueTask Store(AgentState value);
-    ValueTask Read(AgentId agentId);
-    ValueTask SendResponseAsync(RpcRequest request, RpcResponse response);
-    ValueTask SendRequestAsync(AgentBase agent, RpcRequest request);
-    ValueTask PublishEventAsync(CloudEvent @event);
-}
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj b/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
index 5c921fc2b0a8..8e2c4577661a 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Microsoft.AutoGen.Agents.csproj
@@ -12,7 +12,7 @@
   
 
 	
-		
+		
 		
 	
 
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
index 9d16db45cb9b..c3c9c197392d 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AIModelClientHostingExtensions.cs
+
 using Microsoft.Extensions.AI;
 
 namespace Microsoft.Extensions.Hosting;
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
index 57d6e1a611af..85e946edd15e 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/Options/AIClientOptions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AIClientOptions.cs
+
 using System.ComponentModel.DataAnnotations;
 
 namespace Microsoft.Extensions.Hosting;
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs
index 9511d7e737ec..114562993c29 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/ServiceCollectionChatCompletionExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ServiceCollectionChatCompletionExtensions.cs
+
 using System.ClientModel;
 using System.Data.Common;
 using Azure;
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
index 313a0f50fa2a..23c2edb26e15 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// CloudEventExtensions.cs
+
 using Google.Protobuf;
 using Google.Protobuf.WellKnownTypes;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/QdrantOptions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/QdrantOptions.cs
index b5f61657f0b1..1ee150f79937 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/QdrantOptions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Options/QdrantOptions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// QdrantOptions.cs
+
 using System.ComponentModel.DataAnnotations;
 
 namespace Microsoft.AutoGen.Extensions.SemanticKernel;
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
index 0c50b6e896ce..666bcc04a6d0 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/SemanticKernelHostingExtensions.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// SemanticKernelHostingExtensions.cs
 
 using System.Text.Json;
 using Azure.AI.OpenAI;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
index 447b527417a5..db582e051a10 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerHostingExtensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentWorkerHostingExtensions.cs
+
 using System.Diagnostics;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerRegistryGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerRegistryGrain.cs
index c9b51813b677..0e7ffa7f28cc 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerRegistryGrain.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/AgentWorkerRegistryGrain.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// AgentWorkerRegistryGrain.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Runtime;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs b/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
index f6e9326da734..73b53dd41444 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/Host.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Host.cs
+
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Hosting;
 
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IAgentWorkerRegistryGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IAgentWorkerRegistryGrain.cs
index 94d99dcaab55..bda83f16f7eb 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/IAgentWorkerRegistryGrain.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/IAgentWorkerRegistryGrain.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IAgentWorkerRegistryGrain.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Runtime;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
index ce93b9a41efd..d28e2a8c8d6b 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerAgentGrain.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IWorkerAgentGrain.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Runtime;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
index ec63cdcc8874..54ca077de126 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/IWorkerGateway.cs
@@ -1,3 +1,5 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// IWorkerGateway.cs
 
 using Microsoft.AutoGen.Abstractions;
 
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs b/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
index 3f980cf85d36..fae441e0ce8f 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/OrleansRuntimeHostingExtenions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// OrleansRuntimeHostingExtenions.cs
+
 using System.Configuration;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.Configuration;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs
index 3bbe7d78cd5b..7d752d156634 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerAgentGrain.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// WorkerAgentGrain.cs
+
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Runtime;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
index 424c5193a0a0..cca25d36a8d5 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGateway.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// WorkerGateway.cs
+
 using System.Collections.Concurrent;
 using Grpc.Core;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
index 8600aa5fd233..b5c452785483 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerGatewayService.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// WorkerGatewayService.cs
+
 using Grpc.Core;
 using Microsoft.AutoGen.Abstractions;
 
diff --git a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerProcessConnection.cs b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerProcessConnection.cs
index bd69c79055da..d998ce205158 100644
--- a/dotnet/src/Microsoft.AutoGen/Runtime/WorkerProcessConnection.cs
+++ b/dotnet/src/Microsoft.AutoGen/Runtime/WorkerProcessConnection.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// WorkerProcessConnection.cs
+
 using System.Threading.Channels;
 using Grpc.Core;
 using Microsoft.AutoGen.Abstractions;
diff --git a/dotnet/src/Microsoft.AutoGen/ServiceDefaults/Extensions.cs b/dotnet/src/Microsoft.AutoGen/ServiceDefaults/Extensions.cs
index d45caeae6cde..a4eccacb7fd8 100644
--- a/dotnet/src/Microsoft.AutoGen/ServiceDefaults/Extensions.cs
+++ b/dotnet/src/Microsoft.AutoGen/ServiceDefaults/Extensions.cs
@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Extensions.cs
+
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
 using Microsoft.Extensions.DependencyInjection;
diff --git a/dotnet/test/AutoGen.AzureAIInference.Tests/ChatRequestMessageTests.cs b/dotnet/test/AutoGen.AzureAIInference.Tests/ChatRequestMessageTests.cs
index 0e785b5e50aa..3eacada41c30 100644
--- a/dotnet/test/AutoGen.AzureAIInference.Tests/ChatRequestMessageTests.cs
+++ b/dotnet/test/AutoGen.AzureAIInference.Tests/ChatRequestMessageTests.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// ChatRequestMessageTests.cs
 
 using System;
 using System.Collections.Generic;
diff --git a/dotnet/test/AutoGen.SemanticKernel.Tests/KernelFunctionMiddlewareTests.cs b/dotnet/test/AutoGen.SemanticKernel.Tests/KernelFunctionMiddlewareTests.cs
index 80a60421d15b..bc00bb2287ed 100644
--- a/dotnet/test/AutoGen.SemanticKernel.Tests/KernelFunctionMiddlewareTests.cs
+++ b/dotnet/test/AutoGen.SemanticKernel.Tests/KernelFunctionMiddlewareTests.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// KernelFunctionMiddlewareTests.cs
 
 using System.ClientModel;
 using AutoGen.Core;
diff --git a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
index e82aec06d614..f54271844169 100644
--- a/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
+++ b/dotnet/test/AutoGen.SourceGenerator.Tests/FunctionCallTemplateEncodingTests.cs
@@ -1,4 +1,5 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// FunctionCallTemplateEncodingTests.cs
 
 using AutoGen.SourceGenerator.Template; // Needed for FunctionCallTemplate
 using Xunit; // Needed for Fact and Assert
diff --git a/dotnet/test/AutoGen.Tests/TwoAgentTest.cs b/dotnet/test/AutoGen.Tests/TwoAgentTest.cs
index a72e084510a7..5537506d344a 100644
--- a/dotnet/test/AutoGen.Tests/TwoAgentTest.cs
+++ b/dotnet/test/AutoGen.Tests/TwoAgentTest.cs
@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // TwoAgentTest.cs
+
 #pragma warning disable xUnit1013
 using System;
 using System.Collections.Generic;

From 3c63f6f3ef817ebc8f49cff7aeb722ec498b85de Mon Sep 17 00:00:00 2001
From: Rohan Thacker 
Date: Thu, 31 Oct 2024 02:09:45 +0530
Subject: [PATCH 055/173] Corrected typo in get_capabilities in _model_info.py
 (#4002)

---
 .../src/autogen_core/components/models/_model_info.py           | 2 +-
 .../src/autogen_core/components/models/_openai_client.py        | 2 +-
 .../autogen-ext/src/autogen_ext/models/_openai/_model_info.py   | 2 +-
 .../src/autogen_ext/models/_openai/_openai_client.py            | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py b/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
index f54df6fade5b..2440d5b18682 100644
--- a/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
+++ b/python/packages/autogen-core/src/autogen_core/components/models/_model_info.py
@@ -112,7 +112,7 @@ def resolve_model(model: str) -> str:
     return model
 
 
-def get_capabilties(model: str) -> ModelCapabilities:
+def get_capabilities(model: str) -> ModelCapabilities:
     resolved_model = resolve_model(model)
     return _MODEL_CAPABILITIES[resolved_model]
 
diff --git a/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py b/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
index 813bb59b520f..8ce8ddff2cbc 100644
--- a/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
+++ b/python/packages/autogen-core/src/autogen_core/components/models/_openai_client.py
@@ -333,7 +333,7 @@ def __init__(
         if model_capabilities is None and isinstance(client, AsyncAzureOpenAI):
             raise ValueError("AzureOpenAIChatCompletionClient requires explicit model capabilities")
         elif model_capabilities is None:
-            self._model_capabilities = _model_info.get_capabilties(create_args["model"])
+            self._model_capabilities = _model_info.get_capabilities(create_args["model"])
         else:
             self._model_capabilities = model_capabilities
 
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
index 79747ab679d3..aea2bfb5d1c4 100644
--- a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_model_info.py
@@ -112,7 +112,7 @@ def resolve_model(model: str) -> str:
     return model
 
 
-def get_capabilties(model: str) -> ModelCapabilities:
+def get_capabilities(model: str) -> ModelCapabilities:
     resolved_model = resolve_model(model)
     return _MODEL_CAPABILITIES[resolved_model]
 
diff --git a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
index ee2fc920541c..aa9f772d0b95 100644
--- a/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
+++ b/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py
@@ -334,7 +334,7 @@ def __init__(
         if model_capabilities is None and isinstance(client, AsyncAzureOpenAI):
             raise ValueError("AzureOpenAIChatCompletionClient requires explicit model capabilities")
         elif model_capabilities is None:
-            self._model_capabilities = _model_info.get_capabilties(create_args["model"])
+            self._model_capabilities = _model_info.get_capabilities(create_args["model"])
         else:
             self._model_capabilities = model_capabilities
 

From 4023454c584029ed9984c44fea4fbe5dc4d31e74 Mon Sep 17 00:00:00 2001
From: Mohammad Mazraeh 
Date: Thu, 31 Oct 2024 11:54:24 +0000
Subject: [PATCH 056/173] add simple chainlit integration (#3999)

---
 .../framework/distributed-agent-runtime.ipynb |  2 +-
 .../distributed-group-chat/.gitattributes     |  1 -
 .../samples/distributed-group-chat/.gitignore |  1 +
 .../samples/distributed-group-chat/README.md  | 38 +++++++++++--------
 .../samples/distributed-group-chat/_agents.py | 16 ++++----
 .../samples/distributed-group-chat/_utils.py  |  9 +++++
 .../public/avatars/editor.png                 |  3 ++
 .../public/avatars/group_chat_manager.png     |  3 ++
 .../public/avatars/user.png                   |  3 ++
 .../public/avatars/writer.png                 |  3 ++
 .../distributed-group-chat/public/favicon.png |  3 ++
 .../distributed-group-chat/public/logo.png    |  3 ++
 .../samples/distributed-group-chat/run.sh     |  2 +-
 .../run_editor_agent.py                       |  6 ++-
 .../run_group_chat_manager.py                 | 34 ++++++++++++++---
 .../distributed-group-chat/run_host.py        |  1 -
 .../run_writer_agent.py                       |  5 ++-
 17 files changed, 98 insertions(+), 35 deletions(-)
 delete mode 100644 python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/.gitignore
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/avatars/editor.png
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/avatars/group_chat_manager.png
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/avatars/user.png
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/avatars/writer.png
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/favicon.png
 create mode 100644 python/packages/autogen-core/samples/distributed-group-chat/public/logo.png

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
index 29034112376f..833799c2096a 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/distributed-agent-runtime.ipynb
@@ -188,7 +188,7 @@
     "\n",
     "- [Distributed Workers](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/worker)  \n",
     "- [Distributed Semantic Router](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/semantic_router)  \n",
-    "- [Distributed Group Chat](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/distributed_group_chat)  \n"
+    "- [Distributed Group Chat](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core/samples/distributed-group-chat)  \n"
    ]
   }
  ],
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes b/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
deleted file mode 100644
index 6884bd468147..000000000000
--- a/python/packages/autogen-core/samples/distributed-group-chat/.gitattributes
+++ /dev/null
@@ -1 +0,0 @@
-distributed_group_chat.gif filter=lfs diff=lfs merge=lfs -text
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/.gitignore b/python/packages/autogen-core/samples/distributed-group-chat/.gitignore
new file mode 100644
index 000000000000..2121b2589457
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/.gitignore
@@ -0,0 +1 @@
+.chainlit
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/README.md b/python/packages/autogen-core/samples/distributed-group-chat/README.md
index b62085ae9bdd..43d17ee0ebd9 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/README.md
+++ b/python/packages/autogen-core/samples/distributed-group-chat/README.md
@@ -8,7 +8,8 @@ This example runs a gRPC server using [WorkerAgentRuntimeHost](../../src/autogen
 
 ### Setup Python Environment
 
-You should run this project using the same virtual environment created for it. Instructions are provided in the [README](../../../../../../../../README.md).
+1. Create a virtual environment as instructed in [README](../../../../../../../../README.md).
+2. Run `uv pip install chainlit` in the same virtual environment
 
 ### General Configuration
 
@@ -30,7 +31,7 @@ The [run.sh](./run.sh) file provides commands to run the host and agents using [
 
 Here is a screen recording of the execution:
 
-![Distributed Group Chat Sample Run](./distributed_group_chat.gif)
+[![Distributed Group Chat Demo with Simple UI Integration](https://img.youtube.com/vi/kLTzI-3VgPQ/0.jpg)](https://youtu.be/kLTzI-3VgPQ)
 
 **Note**: Some `asyncio.sleep` commands have been added to the example code to make the `./run.sh` execution look sequential and visually easy to follow. In practice, these lines are not necessary.
 
@@ -39,21 +40,21 @@ Here is a screen recording of the execution:
 If you prefer to run Python files individually, follow these steps. Note that each step must be run in a different terminal process, and the virtual environment should be activated using `source .venv/bin/activate`.
 
 1. `python run_host.py`: Starts the host and listens for agent connections.
-2. `python run_editor.py`: Starts the editor agent and connects it to the host.
-3. `python run_writer.py`: Starts the writer agent and connects it to the host.
-4. `python run_group_chat_manager.py`: Starts the group chat manager and sends a message to initiate the writer agent.
+2. `python run_editor.py`: Starts the  editor agent and connects it to the host.
+3. `python run_writer.py`: Starts the  writer agent and connects it to the host.
+4. `chainlit run run_group_chat_manager.py --port 8001`: Run chainlit app which starts  group chat manager agent and sends the initial message to start the conversation. We're using port 8001 as the default port 8000 is used to run host (assuming using same machine to run all of the agents)
 
 ## What's Going On?
 
 The general flow of this example is as follows:
 
-1. The Group Chat Manager sends a `RequestToSpeak` request to the `writer_agent`.
-2. The `writer_agent` writes a short sentence into the group chat topic.
-3. The `editor_agent` receives the message in the group chat topic and updates its memory.
-4. The Group Chat Manager receives the message sent by the writer into the group chat simultaneously and sends the next participant, the `editor_agent`, a `RequestToSpeak` message.
-5. The `editor_agent` sends its feedback to the group chat topic.
-6. The `writer_agent` receives the feedback and updates its memory.
-7. The Group Chat Manager receives the message simultaneously and repeats the loop from step 1.
+1. The  Group Chat Manager, on behalf of  `User`, sends a `RequestToSpeak` request to the  `writer_agent`.
+2. The  `writer_agent` writes a short sentence into the group chat topic.
+3. The  `editor_agent` receives the message in the group chat topic and updates its memory.
+4. The  Group Chat Manager receives the message sent by the writer into the group chat simultaneously and sends the next participant, the  `editor_agent`, a `RequestToSpeak` message.
+5. The  `editor_agent` sends its feedback to the group chat topic.
+6. The  `writer_agent` receives the feedback and updates its memory.
+7. The  Group Chat Manager receives the message simultaneously and repeats the loop from step 1.
 
 Here is an illustration of the system developed in this example:
 
@@ -67,21 +68,21 @@ graph TD;
     end
 
     subgraph Distributed Writer Runtime
-        writer_agent[Writer Agent] --> A1
+        writer_agent[ Writer Agent] --> A1
         wt -.->|2 - Subscription| writer_agent
         gct -.->|4 - Subscription| writer_agent
         writer_agent -.->|3 - Publish: Group Chat Message| gct
     end
 
     subgraph Distributed Editor Runtime
-        editor_agent[Editor Agent] --> A1
+        editor_agent[ Editor Agent] --> A1
         et -.->|6 - Subscription| editor_agent
         gct -.->|4 - Subscription| editor_agent
         editor_agent -.->|7 - Publish: Group Chat Message| gct
     end
 
     subgraph Distributed Group Chat Manager Runtime
-        group_chat_manager[Group Chat Manager Agent] --> A1
+        group_chat_manager[ Group Chat Manager Agent] --> A1
         gct -.->|4 - Subscription| group_chat_manager
         group_chat_manager -.->|1 - Request To Speak| wt
         group_chat_manager -.->|5 - Request To Speak| et
@@ -93,4 +94,11 @@ graph TD;
     style writer_agent fill:#b7c4d7,color:#000
     style editor_agent fill:#b7c4d7,color:#000
     style group_chat_manager fill:#b7c4d7,color:#000
+
 ```
+
+## TODO:
+
+- [ ] Properly handle chat restarts. It complains about group chat manager being already registered
+- [ ] Send Chainlit messages within each agent (Currently the manager can just sends messages in the group chat topic)
+- [ ] Add streaming to the UI like [this example](https://docs.chainlit.io/advanced-features/streaming) but Autogen's Open AI Client [does not supporting streaming yet](https://github.com/microsoft/autogen/blob/0f4dd0cc6dd3eea303ad3d2063979b4b9a1aacfc/python/packages/autogen-ext/src/autogen_ext/models/_openai/_openai_client.py#L81)
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/_agents.py b/python/packages/autogen-core/samples/distributed-group-chat/_agents.py
index 968fd3b6667c..89ac74555967 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/_agents.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/_agents.py
@@ -1,4 +1,4 @@
-from typing import List
+from typing import Awaitable, Callable, List
 
 from _types import GroupChatMessage, RequestToSpeak
 from autogen_core.base import MessageContext
@@ -61,6 +61,7 @@ def __init__(
         model_client: ChatCompletionClient,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        on_message_func: Callable[[str, str], Awaitable[None]],
         max_rounds: int = 3,
     ) -> None:
         super().__init__("Group chat manager")
@@ -70,14 +71,15 @@ def __init__(
         self._chat_history: List[GroupChatMessage] = []
         self._max_rounds = max_rounds
         self.console = Console()
+        self._on_message_func = on_message_func
         self._participant_descriptions = participant_descriptions
         self._previous_participant_topic_type: str | None = None
 
     @message_handler
     async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:
         assert isinstance(message.body, UserMessage)
-
-        self._chat_history.append(message.body)  # type: ignore[reportargumenttype]
+        await self._on_message_func(message.body.content, message.body.source)  # type: ignore[arg-type]
+        self._chat_history.append(message.body)  # type: ignore[reportargumenttype,arg-type]
 
         # Format message history.
         messages: List[str] = []
@@ -118,11 +120,9 @@ async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -
         assert isinstance(completion.content, str)
 
         if completion.content.upper() == "FINISH":
-            self.console.print(
-                Markdown(
-                    f"\n{'-'*80}\n Manager ({id(self)}): I think it's enough iterations on the story! Thanks for collaborating!"
-                )
-            )
+            manager_message = f"\n{'-'*80}\n Manager ({id(self)}): I think it's enough iterations on the story! Thanks for collaborating!"
+            await self._on_message_func(manager_message, "group_chat_manager")
+            self.console.print(Markdown(manager_message))
             return
 
         selected_topic_type: str
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/_utils.py b/python/packages/autogen-core/samples/distributed-group-chat/_utils.py
index 737bb8bda517..2c4b768e49da 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/_utils.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/_utils.py
@@ -1,3 +1,4 @@
+import logging
 import os
 from typing import Any, Iterable, Type
 
@@ -32,3 +33,11 @@ def get_serializers(types: Iterable[Type[Any]]) -> list[MessageSerializer[Any]]:
     for type in types:
         serializers.extend(try_get_known_serializers_for_type(type))  # type: ignore
     return serializers  # type: ignore [reportUnknownVariableType]
+
+
+# TODO: This is a helper function to get rid of a lot of logs until we find exact loggers to properly set log levels ...
+def set_all_log_levels(log_leve: int):
+    # Iterate through all existing loggers and set their levels
+    for _, logger in logging.root.manager.loggerDict.items():
+        if isinstance(logger, logging.Logger):  # Ensure it's actually a Logger object
+            logger.setLevel(log_leve)  # Adjust to DEBUG or another level as needed
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/editor.png b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/editor.png
new file mode 100644
index 000000000000..1963104774a6
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/editor.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca081360cdb35adbc43e282675757a8f94a6b59cba38224c36a6ca2a80a4dce5
+size 5675
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/group_chat_manager.png b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/group_chat_manager.png
new file mode 100644
index 000000000000..08a537646f93
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/group_chat_manager.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e8370f35865293d3126f7f282e6ffef8052a266d205ce2acbee5d211c531a18
+size 6026
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/user.png b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/user.png
new file mode 100644
index 000000000000..8e67f65f3b65
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/user.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52e3e0154e49f6a09b2a16d6671acb98c32ab53490ff080f0674e83163c640e8
+size 5215
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/writer.png b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/writer.png
new file mode 100644
index 000000000000..eacb0bfa1634
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/avatars/writer.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd82203ec3fa337ea5b61de36c3e4223c175871e40e34ee6b36c3281130979b4
+size 5426
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/favicon.png b/python/packages/autogen-core/samples/distributed-group-chat/public/favicon.png
new file mode 100644
index 000000000000..27e52d184bfc
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/favicon.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a60b36ba9e366a244eb641ca59588b6734839c360a42405a369d7af77e7613fc
+size 3700
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/public/logo.png b/python/packages/autogen-core/samples/distributed-group-chat/public/logo.png
new file mode 100644
index 000000000000..27e52d184bfc
--- /dev/null
+++ b/python/packages/autogen-core/samples/distributed-group-chat/public/logo.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a60b36ba9e366a244eb641ca59588b6734839c360a42405a369d7af77e7613fc
+size 3700
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run.sh b/python/packages/autogen-core/samples/distributed-group-chat/run.sh
index 615ca0189669..859096e9402b 100755
--- a/python/packages/autogen-core/samples/distributed-group-chat/run.sh
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run.sh
@@ -20,7 +20,7 @@ tmux select-pane -t distributed_group_chat:0.0
 tmux send-keys -t distributed_group_chat:0.0 "python run_host.py" C-m
 tmux send-keys -t distributed_group_chat:0.2 "python run_writer_agent.py" C-m
 tmux send-keys -t distributed_group_chat:0.3 "python run_editor_agent.py" C-m
-tmux send-keys -t distributed_group_chat:0.1 "python run_group_chat_manager.py" C-m
+tmux send-keys -t distributed_group_chat:0.1 "chainlit run run_group_chat_manager.py --port 8001" C-m
 
 # # Attach to the session
 tmux attach-session -t distributed_group_chat
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py b/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
index 8d72b631d1f8..a452db6b9a3e 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_editor_agent.py
@@ -1,9 +1,10 @@
 import asyncio
+import logging
 import warnings
 
 from _agents import BaseGroupChatAgent
 from _types import AppConfig, GroupChatMessage, RequestToSpeak
-from _utils import get_serializers, load_config
+from _utils import get_serializers, load_config, set_all_log_levels
 from autogen_core.application import WorkerAgentRuntime
 from autogen_core.components import (
     TypeSubscription,
@@ -14,12 +15,12 @@
 
 
 async def main(config: AppConfig):
+    set_all_log_levels(logging.ERROR)
     editor_agent_runtime = WorkerAgentRuntime(host_address=config.host.address)
     editor_agent_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
     await asyncio.sleep(4)
     Console().print(Markdown("Starting **`Editor Agent`**"))
     editor_agent_runtime.start()
-
     editor_agent_type = await BaseGroupChatAgent.register(
         editor_agent_runtime,
         config.editor_agent.topic_type,
@@ -41,5 +42,6 @@ async def main(config: AppConfig):
 
 
 if __name__ == "__main__":
+    set_all_log_levels(logging.ERROR)
     warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
     asyncio.run(main(load_config()))
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py b/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
index 41f5a91a050b..5af446ab1a94 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_group_chat_manager.py
@@ -1,14 +1,16 @@
 import asyncio
+import logging
 import warnings
 
+import chainlit as cl  # type: ignore [reportUnknownMemberType] # This dependency is installed through instructions
 from _agents import GroupChatManager
 from _types import AppConfig, GroupChatMessage, RequestToSpeak
-from _utils import get_serializers, load_config
+from _utils import get_serializers, load_config, set_all_log_levels
 from autogen_core.application import WorkerAgentRuntime
 from autogen_core.components import (
+    DefaultTopicId,
     TypeSubscription,
 )
-from autogen_core.components._default_topic import DefaultTopicId
 from autogen_core.components.models import (
     UserMessage,
 )
@@ -16,16 +18,25 @@
 from rich.console import Console
 from rich.markdown import Markdown
 
+set_all_log_levels(logging.ERROR)
+
+
+# TODO: This is the simple hack to send messages to the UI, needs to be improved once we get some help in https://github.com/Chainlit/chainlit/issues/1491
+async def send_cl(msg: str, author: str) -> None:
+    await cl.Message(content=msg, author=author).send()  # type: ignore [reportAttributeAccessIssue,reportUnknownMemberType]
+
 
 async def main(config: AppConfig):
-    # Add group chat manager runtime
+    set_all_log_levels(logging.ERROR)
     group_chat_manager_runtime = WorkerAgentRuntime(host_address=config.host.address)
 
+    # Add group chat manager runtime
+
     group_chat_manager_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
     await asyncio.sleep(1)
     Console().print(Markdown("Starting **`Group Chat Manager`**"))
     group_chat_manager_runtime.start()
-
+    set_all_log_levels(logging.ERROR)
     group_chat_manager_type = await GroupChatManager.register(
         group_chat_manager_runtime,
         "group_chat_manager",
@@ -34,6 +45,7 @@ async def main(config: AppConfig):
             participant_topic_types=[config.writer_agent.topic_type, config.editor_agent.topic_type],
             participant_descriptions=[config.writer_agent.description, config.editor_agent.description],
             max_rounds=config.group_chat_manager.max_rounds,
+            on_message_func=send_cl,
         ),
     )
 
@@ -59,6 +71,18 @@ async def main(config: AppConfig):
     Console().print("Manager left the chat!")
 
 
-if __name__ == "__main__":
+@cl.on_chat_start  # type: ignore
+async def start_chat():
+    set_all_log_levels(logging.ERROR)
     warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
     asyncio.run(main(load_config()))
+
+
+# This can be used for debugging, you can run this file using python
+# if __name__ == "__main__":
+#     from chainlit.cli import run_chainlit
+
+#     set_all_log_levels(logging.ERROR)
+#     run_chainlit(
+#         __file__,
+#     )
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_host.py b/python/packages/autogen-core/samples/distributed-group-chat/run_host.py
index 726d7022e91d..6f1d1f646ace 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/run_host.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_host.py
@@ -7,7 +7,6 @@
 from rich.markdown import Markdown
 
 
-# TODO: Use config.yaml
 async def main(host_config: HostConfig):
     host = WorkerAgentRuntimeHost(address=host_config.address)
     host.start()
diff --git a/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py b/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py
index 041fe5728905..1c6935de383e 100644
--- a/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py
+++ b/python/packages/autogen-core/samples/distributed-group-chat/run_writer_agent.py
@@ -1,9 +1,10 @@
 import asyncio
+import logging
 import warnings
 
 from _agents import BaseGroupChatAgent
 from _types import AppConfig, GroupChatMessage, RequestToSpeak
-from _utils import get_serializers, load_config
+from _utils import get_serializers, load_config, set_all_log_levels
 from autogen_core.application import WorkerAgentRuntime
 from autogen_core.components import (
     TypeSubscription,
@@ -14,6 +15,7 @@
 
 
 async def main(config: AppConfig) -> None:
+    set_all_log_levels(logging.ERROR)
     writer_agent_runtime = WorkerAgentRuntime(host_address=config.host.address)
     writer_agent_runtime.add_message_serializer(get_serializers([RequestToSpeak, GroupChatMessage]))  # type: ignore[arg-type]
     await asyncio.sleep(3)
@@ -41,5 +43,6 @@ async def main(config: AppConfig) -> None:
 
 
 if __name__ == "__main__":
+    set_all_log_levels(logging.ERROR)
     warnings.filterwarnings("ignore", category=UserWarning, message="Resolved model mismatch.*")
     asyncio.run(main(load_config()))

From cff7d842a6d4acd2733c1f6207061cd60fa10821 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 04:12:43 -0700
Subject: [PATCH 057/173] AgentChat streaming API (#4015)

---
 .../agents/_assistant_agent.py                |  43 +++++--
 .../agents/_base_chat_agent.py                |  38 +++++-
 .../src/autogen_agentchat/base/_chat_agent.py |  18 ++-
 .../src/autogen_agentchat/base/_task.py       |  14 ++-
 .../src/autogen_agentchat/base/_team.py       |  15 +--
 .../src/autogen_agentchat/messages.py         |   6 +-
 .../teams/_group_chat/_base_group_chat.py     |  49 ++++++--
 .../_group_chat/_chat_agent_container.py      |  34 +++--
 .../_group_chat/_round_robin_group_chat.py    |  41 +++++--
 .../teams/_group_chat/_selector_group_chat.py |  50 ++++++--
 .../teams/_group_chat/_swarm_group_chat.py    |   5 +-
 .../tests/test_assistant_agent.py             |  37 ++++--
 .../tests/test_group_chat.py                  | 116 ++++++++++++++++--
 13 files changed, 356 insertions(+), 110 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 5414f782f022..86a4f39952b8 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -1,7 +1,7 @@
 import asyncio
 import json
 import logging
-from typing import Any, Awaitable, Callable, Dict, List, Sequence
+from typing import Any, AsyncGenerator, Awaitable, Callable, Dict, List, Sequence
 
 from autogen_core.base import CancellationToken
 from autogen_core.components import FunctionCall
@@ -27,7 +27,7 @@
     StopMessage,
     TextMessage,
     ToolCallMessage,
-    ToolCallResultMessages,
+    ToolCallResultMessage,
 )
 from ._base_chat_agent import BaseChatAgent
 
@@ -98,7 +98,11 @@ def set_defaults(cls, values: Dict[str, Any]) -> Dict[str, Any]:
     @property
     def handoff_tool(self) -> Tool:
         """Create a handoff tool from this handoff configuration."""
-        return FunctionTool(lambda: self.message, name=self.name, description=self.description)
+
+        def _handoff_tool() -> str:
+            return self.message
+
+        return FunctionTool(_handoff_tool, name=self.name, description=self.description)
 
 
 class AssistantAgent(BaseChatAgent):
@@ -138,7 +142,7 @@ class AssistantAgent(BaseChatAgent):
 
 
         The following example demonstrates how to create an assistant agent with
-        a model client and a tool, and generate a response to a simple task using the tool.
+        a model client and a tool, and generate a stream of messages for a task.
 
         .. code-block:: python
 
@@ -154,7 +158,11 @@ async def get_current_time() -> str:
             model_client = OpenAIChatCompletionClient(model="gpt-4o")
             agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
 
-            await agent.run("What is the current time?", termination_condition=MaxMessageTermination(3))
+            stream = agent.run_stream("What is the current time?", termination_condition=MaxMessageTermination(3))
+
+            async for message in stream:
+                print(message)
+
 
     """
 
@@ -219,6 +227,14 @@ def produced_message_types(self) -> List[type[ChatMessage]]:
         return [TextMessage, StopMessage]
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        async for message in self.on_messages_stream(messages, cancellation_token):
+            if isinstance(message, Response):
+                return message
+        raise AssertionError("The stream should have returned the final result.")
+
+    async def on_messages_stream(
+        self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
+    ) -> AsyncGenerator[InnerMessage | Response, None]:
         # Add messages to the model context.
         for msg in messages:
             if isinstance(msg, ResetMessage):
@@ -243,6 +259,7 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
             # Add the tool call message to the output.
             inner_messages.append(ToolCallMessage(content=result.content, source=self.name))
+            yield ToolCallMessage(content=result.content, source=self.name)
 
             # Execute the tool calls.
             results = await asyncio.gather(
@@ -250,7 +267,8 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             )
             event_logger.debug(ToolCallResultEvent(tool_call_results=results, source=self.name))
             self._model_context.append(FunctionExecutionResultMessage(content=results))
-            inner_messages.append(ToolCallResultMessages(content=results, source=self.name))
+            inner_messages.append(ToolCallResultMessage(content=results, source=self.name))
+            yield ToolCallResultMessage(content=results, source=self.name)
 
             # Detect handoff requests.
             handoffs: List[Handoff] = []
@@ -261,12 +279,13 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
                 if len(handoffs) > 1:
                     raise ValueError(f"Multiple handoffs detected: {[handoff.name for handoff in handoffs]}")
                 # Return the output messages to signal the handoff.
-                return Response(
+                yield Response(
                     chat_message=HandoffMessage(
                         content=handoffs[0].message, target=handoffs[0].target, source=self.name
                     ),
                     inner_messages=inner_messages,
                 )
+                return
 
             # Generate an inference result based on the current model context.
             result = await self._model_client.create(
@@ -278,13 +297,13 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         # Detect stop request.
         request_stop = "terminate" in result.content.strip().lower()
         if request_stop:
-            return Response(
+            yield Response(
                 chat_message=StopMessage(content=result.content, source=self.name), inner_messages=inner_messages
             )
-
-        return Response(
-            chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
-        )
+        else:
+            yield Response(
+                chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
+            )
 
     async def _execute_tool_call(
         self, tool_call: FunctionCall, cancellation_token: CancellationToken
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index ac74077e27c8..cf146b0c10fb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -1,9 +1,9 @@
 from abc import ABC, abstractmethod
-from typing import List, Sequence
+from typing import AsyncGenerator, List, Sequence
 
 from autogen_core.base import CancellationToken
 
-from ..base import ChatAgent, Response, TaskResult, TerminationCondition
+from ..base import ChatAgent, Response, TaskResult
 from ..messages import ChatMessage, InnerMessage, TextMessage
 
 
@@ -40,12 +40,22 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         """Handles incoming messages and returns a response."""
         ...
 
+    async def on_messages_stream(
+        self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
+    ) -> AsyncGenerator[InnerMessage | Response, None]:
+        """Handles incoming messages and returns a stream of messages and
+        and the final item is the response. The base implementation in :class:`BaseChatAgent`
+        simply calls :meth:`on_messages` and yields the messages in the response."""
+        response = await self.on_messages(messages, cancellation_token)
+        for inner_message in response.inner_messages or []:
+            yield inner_message
+        yield response
+
     async def run(
         self,
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
         """Run the agent with the given task and return the result."""
         if cancellation_token is None:
@@ -57,3 +67,25 @@ async def run(
             messages += response.inner_messages
         messages.append(response.chat_message)
         return TaskResult(messages=messages)
+
+    async def run_stream(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+        """Run the agent with the given task and return a stream of messages
+        and the final task result as the last item in the stream."""
+        if cancellation_token is None:
+            cancellation_token = CancellationToken()
+        first_message = TextMessage(content=task, source="user")
+        yield first_message
+        messages: List[InnerMessage | ChatMessage] = [first_message]
+        async for message in self.on_messages_stream([first_message], cancellation_token):
+            if isinstance(message, Response):
+                yield message.chat_message
+                messages.append(message.chat_message)
+                yield TaskResult(messages=messages)
+            else:
+                messages.append(message)
+                yield message
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index d60dba349cbb..ce73352daecc 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -1,11 +1,10 @@
 from dataclasses import dataclass
-from typing import List, Protocol, Sequence, runtime_checkable
+from typing import AsyncGenerator, List, Protocol, Sequence, runtime_checkable
 
 from autogen_core.base import CancellationToken
 
 from ..messages import ChatMessage, InnerMessage
-from ._task import TaskResult, TaskRunner
-from ._termination import TerminationCondition
+from ._task import TaskRunner
 
 
 @dataclass(kw_only=True)
@@ -45,12 +44,9 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
         """Handles incoming messages and returns a response."""
         ...
 
-    async def run(
-        self,
-        task: str,
-        *,
-        cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
-    ) -> TaskResult:
-        """Run the agent with the given task and return the result."""
+    def on_messages_stream(
+        self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
+    ) -> AsyncGenerator[InnerMessage | Response, None]:
+        """Handles incoming messages and returns a stream of inner messages and
+        and the final item is the response."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 326cceecb1fd..2e68c2b8118b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -1,10 +1,9 @@
 from dataclasses import dataclass
-from typing import Protocol, Sequence
+from typing import AsyncGenerator, Protocol, Sequence
 
 from autogen_core.base import CancellationToken
 
 from ..messages import ChatMessage, InnerMessage
-from ._termination import TerminationCondition
 
 
 @dataclass
@@ -23,7 +22,16 @@ async def run(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
         """Run the task."""
         ...
+
+    def run_stream(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+        """Run the task and produces a stream of messages and the final result
+        as the last item in the stream."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
index b0a1dc3d2a38..e112a3b512ed 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
@@ -1,18 +1,7 @@
 from typing import Protocol
 
-from autogen_core.base import CancellationToken
-
-from ._task import TaskResult, TaskRunner
-from ._termination import TerminationCondition
+from ._task import TaskRunner
 
 
 class Team(TaskRunner, Protocol):
-    async def run(
-        self,
-        task: str,
-        *,
-        cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
-    ) -> TaskResult:
-        """Run the team on a given task until the termination condition is met."""
-        ...
+    pass
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index f206250e101e..51dbcca333d7 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -57,14 +57,14 @@ class ToolCallMessage(BaseMessage):
     """The tool calls."""
 
 
-class ToolCallResultMessages(BaseMessage):
+class ToolCallResultMessage(BaseMessage):
     """A message signaling the results of tool calls."""
 
     content: List[FunctionExecutionResult]
     """The tool call results."""
 
 
-InnerMessage = ToolCallMessage | ToolCallResultMessages
+InnerMessage = ToolCallMessage | ToolCallResultMessage
 """Messages for intra-agent monologues."""
 
 
@@ -80,6 +80,6 @@ class ToolCallResultMessages(BaseMessage):
     "HandoffMessage",
     "ResetMessage",
     "ToolCallMessage",
-    "ToolCallResultMessages",
+    "ToolCallResultMessage",
     "ChatMessage",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 9f3132a74955..78ec5159e369 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -1,6 +1,7 @@
+import asyncio
 import uuid
 from abc import ABC, abstractmethod
-from typing import Callable, List
+from typing import AsyncGenerator, Callable, List
 
 from autogen_core.application import SingleThreadedAgentRuntime
 from autogen_core.base import (
@@ -75,9 +76,24 @@ async def run(
         cancellation_token: CancellationToken | None = None,
         termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
-        """Run the team and return the result."""
-        # Create intervention handler for termination.
-
+        """Run the team and return the result. The base implementation uses
+        :meth:`run_stream` to run the team and then returns the final result."""
+        async for message in self.run_stream(
+            task, cancellation_token=cancellation_token, termination_condition=termination_condition
+        ):
+            if isinstance(message, TaskResult):
+                return message
+        raise AssertionError("The stream should have returned the final result.")
+
+    async def run_stream(
+        self,
+        task: str,
+        *,
+        cancellation_token: CancellationToken | None = None,
+        termination_condition: TerminationCondition | None = None,
+    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+        """Run the team and produces a stream of messages and the final result
+        as the last item in the stream."""
         # Create the runtime.
         runtime = SingleThreadedAgentRuntime()
 
@@ -132,6 +148,7 @@ async def run(
         )
 
         output_messages: List[InnerMessage | ChatMessage] = []
+        output_message_queue: asyncio.Queue[InnerMessage | ChatMessage | None] = asyncio.Queue()
 
         async def collect_output_messages(
             _runtime: AgentRuntime,
@@ -140,6 +157,7 @@ async def collect_output_messages(
             ctx: MessageContext,
         ) -> None:
             output_messages.append(message)
+            await output_message_queue.put(message)
 
         await ClosureAgent.register(
             runtime,
@@ -158,14 +176,29 @@ async def collect_output_messages(
         group_chat_manager_topic_id = TopicId(type=group_chat_manager_topic_type, source=self._team_id)
         first_chat_message = TextMessage(content=task, source="user")
         output_messages.append(first_chat_message)
+        await output_message_queue.put(first_chat_message)
         await runtime.publish_message(
             GroupChatPublishEvent(agent_message=first_chat_message),
             topic_id=team_topic_id,
         )
         await runtime.publish_message(GroupChatRequestPublishEvent(), topic_id=group_chat_manager_topic_id)
 
-        # Wait for the runtime to stop.
-        await runtime.stop_when_idle()
+        # Start a coroutine to stop the runtime and signal the output message queue is complete.
+        async def stop_runtime() -> None:
+            await runtime.stop_when_idle()
+            await output_message_queue.put(None)
+
+        shutdown_task = asyncio.create_task(stop_runtime())
+
+        # Yield the messsages until the queue is empty.
+        while True:
+            message = await output_message_queue.get()
+            if message is None:
+                break
+            yield message
+
+        # Wait for the shutdown task to finish.
+        await shutdown_task
 
-        # Return the result.
-        return TaskResult(messages=output_messages)
+        # Yield the final result.
+        yield TaskResult(messages=output_messages)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index 1423735c2f7c..3fde3f6864b9 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -3,7 +3,7 @@
 from autogen_core.base import MessageContext
 from autogen_core.components import DefaultTopicId, event
 
-from ...base import ChatAgent
+from ...base import ChatAgent, Response
 from ...messages import ChatMessage
 from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
 from ._sequential_routed_agent import SequentialRoutedAgent
@@ -37,28 +37,26 @@ async def handle_content_request(self, message: GroupChatRequestPublishEvent, ct
         """Handle a content request event by passing the messages in the buffer
         to the delegate agent and publish the response."""
         # Pass the messages in the buffer to the delegate agent.
-        response = await self._agent.on_messages(self._message_buffer, ctx.cancellation_token)
-        if not any(isinstance(response.chat_message, msg_type) for msg_type in self._agent.produced_message_types):
-            raise ValueError(
-                f"The agent {self._agent.name} produced an unexpected message type: {type(response)}. "
-                f"Expected one of: {self._agent.produced_message_types}. "
-                f"Check the agent's produced_message_types property."
-            )
-
-        # Publish inner messages to the output topic.
-        if response.inner_messages is not None:
-            for inner_message in response.inner_messages:
-                await self.publish_message(inner_message, topic_id=DefaultTopicId(type=self._output_topic_type))
-
-        # Publish the response.
+        response: Response | None = None
+        async for msg in self._agent.on_messages_stream(self._message_buffer, ctx.cancellation_token):
+            if isinstance(msg, Response):
+                await self.publish_message(
+                    msg.chat_message,
+                    topic_id=DefaultTopicId(type=self._output_topic_type),
+                )
+                response = msg
+            else:
+                # Publish the message to the output topic.
+                await self.publish_message(msg, topic_id=DefaultTopicId(type=self._output_topic_type))
+        if response is None:
+            raise ValueError("The agent did not produce a final response. Check the agent's on_messages_stream method.")
+
+        # Publish the response to the group chat.
         self._message_buffer.clear()
         await self.publish_message(
             GroupChatPublishEvent(agent_message=response.chat_message, source=self.id),
             topic_id=DefaultTopicId(type=self._parent_topic_type),
         )
 
-        # Publish the response to the output topic.
-        await self.publish_message(response.chat_message, topic_id=DefaultTopicId(type=self._output_topic_type))
-
     async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> None:
         raise ValueError(f"Unhandled message in agent container: {type(message)}")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index e8f5f66533f2..cec47f6e1b1b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -61,24 +61,45 @@ class RoundRobinGroupChat(BaseGroupChat):
 
         .. code-block:: python
 
-            from autogen_agentchat.agents import ToolUseAssistantAgent
-            from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.teams import RoundRobinGroupChat
+            from autogen_agentchat.task import StopMessageTermination
 
-            assistant = ToolUseAssistantAgent("Assistant", model_client=..., registered_tools=...)
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+
+            async def get_weather(location: str) -> str:
+                return f"The weather in {location} is sunny."
+
+
+            assistant = AssistantAgent(
+                "Assistant",
+                model_client=model_client,
+                tools=[get_weather],
+            )
             team = RoundRobinGroupChat([assistant])
-            await team.run("What's the weather in New York?", termination_condition=StopMessageTermination())
+            stream = team.run_stream("What's the weather in New York?", termination_condition=StopMessageTermination())
+            async for message in stream:
+                print(message)
 
     A team with multiple participants:
 
         .. code-block:: python
 
-            from autogen_agentchat.agents import CodingAssistantAgent, CodeExecutorAgent
-            from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.teams import RoundRobinGroupChat
+            from autogen_agentchat.task import StopMessageTermination
+
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
-            coding_assistant = CodingAssistantAgent("Coding_Assistant", model_client=...)
-            executor_agent = CodeExecutorAgent("Code_Executor", code_executor=...)
-            team = RoundRobinGroupChat([coding_assistant, executor_agent])
-            await team.run("Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination())
+            agent1 = AssistantAgent("Assistant1", model_client=model_client)
+            agent2 = AssistantAgent("Assistant2", model_client=model_client)
+            team = RoundRobinGroupChat([agent1, agent2])
+            stream = team.run_stream("Tell me some jokes.", termination_condition=StopMessageTermination())
+            async for message in stream:
+                print(message)
 
     """
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 3cc489daa6b7..ed7694d38584 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -170,14 +170,48 @@ class SelectorGroupChat(BaseGroupChat):
 
         .. code-block:: python
 
-            from autogen_agentchat.agents import ToolUseAssistantAgent
-            from autogen_agentchat.teams import SelectorGroupChat, StopMessageTermination
-
-            travel_advisor = ToolUseAssistantAgent("Travel_Advisor", model_client=..., registered_tools=...)
-            hotel_agent = ToolUseAssistantAgent("Hotel_Agent", model_client=..., registered_tools=...)
-            flight_agent = ToolUseAssistantAgent("Flight_Agent", model_client=..., registered_tools=...)
-            team = SelectorGroupChat([travel_advisor, hotel_agent, flight_agent], model_client=...)
-            await team.run("Book a 3-day trip to new york.", termination_condition=StopMessageTermination())
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.teams import SelectorGroupChat
+            from autogen_agentchat.task import StopMessageTermination
+
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+
+            async def lookup_hotel(location: str) -> str:
+                return f"Here are some hotels in {location}: hotel1, hotel2, hotel3."
+
+
+            async def lookup_flight(origin: str, destination: str) -> str:
+                return f"Here are some flights from {origin} to {destination}: flight1, flight2, flight3."
+
+
+            async def book_trip() -> str:
+                return "Your trip is booked!"
+
+
+            travel_advisor = AssistantAgent(
+                "Travel_Advisor",
+                model_client,
+                tools=[book_trip],
+                description="Helps with travel planning.",
+            )
+            hotel_agent = AssistantAgent(
+                "Hotel_Agent",
+                model_client,
+                tools=[lookup_hotel],
+                description="Helps with hotel booking.",
+            )
+            flight_agent = AssistantAgent(
+                "Flight_Agent",
+                model_client,
+                tools=[lookup_flight],
+                description="Helps with flight booking.",
+            )
+            team = SelectorGroupChat([travel_advisor, hotel_agent, flight_agent], model_client=model_client)
+            stream = team.run_stream("Book a 3-day trip to new york.", termination_condition=StopMessageTermination())
+            async for message in stream:
+                print(message)
     """
 
     def __init__(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 872f12e2ba31..0f4ec0e63a48 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -79,7 +79,10 @@ class Swarm(BaseGroupChat):
             )
 
             team = Swarm([agent1, agent2])
-            await team.run("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
+
+            stream = team.run_stream("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
+            async for message in stream:
+                print(message)
     """
 
     def __init__(self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None):
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 9dee76539be4..4589f86860d3 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -6,9 +6,9 @@
 import pytest
 from autogen_agentchat import EVENT_LOGGER_NAME
 from autogen_agentchat.agents import AssistantAgent, Handoff
+from autogen_agentchat.base import TaskResult
 from autogen_agentchat.logging import FileLogHandler
-from autogen_agentchat.messages import HandoffMessage, TextMessage, ToolCallMessage, ToolCallResultMessages
-from autogen_core.base import CancellationToken
+from autogen_agentchat.messages import HandoffMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
 from autogen_core.components.tools import FunctionTool
 from autogen_ext.models import OpenAIChatCompletionClient
 from openai.resources.chat.completions import AsyncCompletions
@@ -114,9 +114,19 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
     assert isinstance(result.messages[1], ToolCallMessage)
-    assert isinstance(result.messages[2], ToolCallResultMessages)
+    assert isinstance(result.messages[2], ToolCallResultMessage)
     assert isinstance(result.messages[3], TextMessage)
 
+    # Test streaming.
+    mock._curr_index = 0  # pyright: ignore
+    index = 0
+    async for message in tool_use_agent.run_stream("task"):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 @pytest.mark.asyncio
 async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -160,8 +170,19 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
         handoffs=[handoff],
     )
     assert HandoffMessage in tool_use_agent.produced_message_types
-    response = await tool_use_agent.on_messages(
-        [TextMessage(content="task", source="user")], cancellation_token=CancellationToken()
-    )
-    assert isinstance(response.chat_message, HandoffMessage)
-    assert response.chat_message.target == "agent2"
+    result = await tool_use_agent.run("task")
+    assert len(result.messages) == 4
+    assert isinstance(result.messages[0], TextMessage)
+    assert isinstance(result.messages[1], ToolCallMessage)
+    assert isinstance(result.messages[2], ToolCallResultMessage)
+    assert isinstance(result.messages[3], HandoffMessage)
+
+    # Test streaming.
+    mock._curr_index = 0  # pyright: ignore
+    index = 0
+    async for message in tool_use_agent.run_stream("task"):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index e6510c2fa17e..4e1485ce3094 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -12,7 +12,7 @@
     CodeExecutorAgent,
     Handoff,
 )
-from autogen_agentchat.base import Response
+from autogen_agentchat.base import Response, TaskResult
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import (
     ChatMessage,
@@ -20,7 +20,7 @@
     StopMessage,
     TextMessage,
     ToolCallMessage,
-    ToolCallResultMessages,
+    ToolCallResultMessage,
 )
 from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination
 from autogen_agentchat.teams import (
@@ -59,6 +59,9 @@ async def mock_create(
         self._curr_index += 1
         return completion
 
+    def reset(self) -> None:
+        self._curr_index = 0
+
 
 class _EchoAgent(BaseChatAgent):
     def __init__(self, name: str, description: str) -> None:
@@ -147,7 +150,8 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         )
         team = RoundRobinGroupChat(participants=[coding_assistant_agent, code_executor_agent])
         result = await team.run(
-            "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+            "Write a program that prints 'Hello, world!'",
+            termination_condition=StopMessageTermination(),
         )
         expected_messages = [
             "Write a program that prints 'Hello, world!'",
@@ -164,6 +168,18 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         # Assert that all expected messages are in the collected messages
         assert normalized_messages == expected_messages
 
+        # Test streaming.
+        mock.reset()
+        index = 0
+        async for message in team.run_stream(
+            "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        ):
+            if isinstance(message, TaskResult):
+                assert message == result
+            else:
+                assert message == result.messages[index]
+            index += 1
+
 
 @pytest.mark.asyncio
 async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -230,13 +246,14 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     echo_agent = _EchoAgent("echo_agent", description="echo agent")
     team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent])
     result = await team.run(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'",
+        termination_condition=StopMessageTermination(),
     )
 
     assert len(result.messages) == 6
     assert isinstance(result.messages[0], TextMessage)  # task
     assert isinstance(result.messages[1], ToolCallMessage)  # tool call
-    assert isinstance(result.messages[2], ToolCallResultMessages)  # tool call result
+    assert isinstance(result.messages[2], ToolCallResultMessage)  # tool call result
     assert isinstance(result.messages[3], TextMessage)  # tool use agent response
     assert isinstance(result.messages[4], TextMessage)  # echo agent response
     assert isinstance(result.messages[5], StopMessage)  # tool use agent response
@@ -253,6 +270,19 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     assert context[2].content[0].call_id == "1"
     assert context[3].content == "Hello"
 
+    # Test streaming.
+    tool_use_agent._model_context.clear()  # pyright: ignore
+    mock.reset()
+    index = 0
+    async for message in team.run_stream(
+        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+    ):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 @pytest.mark.asyncio
 async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -320,7 +350,8 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
     )
     result = await team.run(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'",
+        termination_condition=StopMessageTermination(),
     )
     assert len(result.messages) == 6
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -330,6 +361,19 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     assert result.messages[4].source == "agent2"
     assert result.messages[5].source == "agent1"
 
+    # Test streaming.
+    mock.reset()
+    agent1._count = 0  # pyright: ignore
+    index = 0
+    async for message in team.run_stream(
+        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+    ):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 @pytest.mark.asyncio
 async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -356,7 +400,8 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
     )
     result = await team.run(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'",
+        termination_condition=StopMessageTermination(),
     )
     assert len(result.messages) == 5
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -367,6 +412,19 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     # only one chat completion was called
     assert mock._curr_index == 1  # pyright: ignore
 
+    # Test streaming.
+    mock.reset()
+    agent1._count = 0  # pyright: ignore
+    index = 0
+    async for message in team.run_stream(
+        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+    ):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 @pytest.mark.asyncio
 async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -422,6 +480,18 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     assert result.messages[2].source == "agent2"
     assert result.messages[3].source == "agent1"
 
+    # Test streaming.
+    mock.reset()
+    index = 0
+    async for message in team.run_stream(
+        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+    ):
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 class _HandOffAgent(BaseChatAgent):
     def __init__(self, name: str, description: str, next_agent: str) -> None:
@@ -446,8 +516,8 @@ async def test_swarm_handoff() -> None:
     second_agent = _HandOffAgent("second_agent", description="second agent", next_agent="third_agent")
     third_agent = _HandOffAgent("third_agent", description="third agent", next_agent="first_agent")
 
-    team = Swarm([second_agent, first_agent, third_agent])
-    result = await team.run("task", termination_condition=MaxMessageTermination(6))
+    team = Swarm([second_agent, first_agent, third_agent], termination_condition=MaxMessageTermination(6))
+    result = await team.run("task")
     assert len(result.messages) == 6
     assert result.messages[0].content == "task"
     assert result.messages[1].content == "Transferred to third_agent."
@@ -456,6 +526,16 @@ async def test_swarm_handoff() -> None:
     assert result.messages[4].content == "Transferred to third_agent."
     assert result.messages[5].content == "Transferred to first_agent."
 
+    # Test streaming.
+    index = 0
+    stream = team.run_stream("task", termination_condition=MaxMessageTermination(6))
+    async for message in stream:
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1
+
 
 @pytest.mark.asyncio
 async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -514,19 +594,31 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     mock = _MockChatCompletion(chat_completions)
     monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
 
-    agnet1 = AssistantAgent(
+    agent1 = AssistantAgent(
         "agent1",
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
         handoffs=[Handoff(target="agent2", name="handoff_to_agent2", message="handoff to agent2")],
     )
     agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
-    team = Swarm([agnet1, agent2])
+    team = Swarm([agent1, agent2])
     result = await team.run("task", termination_condition=StopMessageTermination())
     assert len(result.messages) == 7
     assert result.messages[0].content == "task"
     assert isinstance(result.messages[1], ToolCallMessage)
-    assert isinstance(result.messages[2], ToolCallResultMessages)
+    assert isinstance(result.messages[2], ToolCallResultMessage)
     assert result.messages[3].content == "handoff to agent2"
     assert result.messages[4].content == "Transferred to agent1."
     assert result.messages[5].content == "Hello"
     assert result.messages[6].content == "TERMINATE"
+
+    # Test streaming.
+    agent1._model_context.clear()  # pyright: ignore
+    mock.reset()
+    index = 0
+    stream = team.run_stream("task", termination_condition=StopMessageTermination())
+    async for message in stream:
+        if isinstance(message, TaskResult):
+            assert message == result
+        else:
+            assert message == result.messages[index]
+        index += 1

From 369ffb511bb8497a871690e7c88e9cee5c0cb91e Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 05:50:20 -0700
Subject: [PATCH 058/173] Remove termination condition from team constructor
 (#4025)

* Remove termination condition from team constructor

* fix usage
---
 .../autogen_agentchat/teams/_group_chat/_base_group_chat.py | 4 +---
 .../teams/_group_chat/_round_robin_group_chat.py            | 3 +--
 .../teams/_group_chat/_selector_group_chat.py               | 4 +---
 .../teams/_group_chat/_swarm_group_chat.py                  | 6 ++----
 python/packages/autogen-agentchat/tests/test_group_chat.py  | 4 ++--
 .../src/user-guide/agentchat-user-guide/quickstart.ipynb    | 3 ++-
 6 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 78ec5159e369..e035a9874361 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -33,7 +33,6 @@ def __init__(
         self,
         participants: List[ChatAgent],
         group_chat_manager_class: type[BaseGroupChatManager],
-        termination_condition: TerminationCondition | None = None,
     ):
         if len(participants) == 0:
             raise ValueError("At least one participant is required.")
@@ -42,7 +41,6 @@ def __init__(
         self._participants = participants
         self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
-        self._termination_condition = termination_condition
 
     @abstractmethod
     def _create_group_chat_manager_factory(
@@ -133,7 +131,7 @@ async def run_stream(
                 group_topic_type=group_topic_type,
                 participant_topic_types=participant_topic_types,
                 participant_descriptions=participant_descriptions,
-                termination_condition=termination_condition or self._termination_condition,
+                termination_condition=termination_condition,
             ),
         )
         # Add subscriptions for the group chat manager.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index cec47f6e1b1b..b2dcdb640297 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -103,10 +103,9 @@ async def get_weather(location: str) -> str:
 
     """
 
-    def __init__(self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None):
+    def __init__(self, participants: List[ChatAgent]):
         super().__init__(
             participants,
-            termination_condition=termination_condition,
             group_chat_manager_class=RoundRobinGroupChatManager,
         )
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index ed7694d38584..d91d89e26a5a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -230,9 +230,7 @@ def __init__(
 """,
         allow_repeated_speaker: bool = False,
     ):
-        super().__init__(
-            participants, termination_condition=termination_condition, group_chat_manager_class=SelectorGroupChatManager
-        )
+        super().__init__(participants, group_chat_manager_class=SelectorGroupChatManager)
         # Validate the participants.
         if len(participants) < 2:
             raise ValueError("At least two participants are required for SelectorGroupChat.")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 0f4ec0e63a48..0afc41afe98b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -85,10 +85,8 @@ class Swarm(BaseGroupChat):
                 print(message)
     """
 
-    def __init__(self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None):
-        super().__init__(
-            participants, termination_condition=termination_condition, group_chat_manager_class=SwarmGroupChatManager
-        )
+    def __init__(self, participants: List[ChatAgent]):
+        super().__init__(participants, group_chat_manager_class=SwarmGroupChatManager)
         # The first participant must be able to produce handoff messages.
         first_participant = self._participants[0]
         if HandoffMessage not in first_participant.produced_message_types:
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 4e1485ce3094..72fdc6bcd68a 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -516,8 +516,8 @@ async def test_swarm_handoff() -> None:
     second_agent = _HandOffAgent("second_agent", description="second agent", next_agent="third_agent")
     third_agent = _HandOffAgent("third_agent", description="third agent", next_agent="first_agent")
 
-    team = Swarm([second_agent, first_agent, third_agent], termination_condition=MaxMessageTermination(6))
-    result = await team.run("task")
+    team = Swarm([second_agent, first_agent, third_agent])
+    result = await team.run("task", termination_condition=MaxMessageTermination(6))
     assert len(result.messages) == 6
     assert result.messages[0].content == "task"
     assert result.messages[1].content == "Transferred to third_agent."
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 52f4b1baa914..3c37aee209ef 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -81,10 +81,11 @@
     ")\n",
     "\n",
     "# add the agent to a team\n",
-    "agent_team = RoundRobinGroupChat([weather_agent], termination_condition=MaxMessageTermination(max_messages=2))\n",
+    "agent_team = RoundRobinGroupChat([weather_agent])\n",
     "# Note: if running in a Python file directly you'll need to use asyncio.run(agent_team.run(...)) instead of await agent_team.run(...)\n",
     "result = await agent_team.run(\n",
     "    task=\"What is the weather in New York?\",\n",
+    "    termination_condition=MaxMessageTermination(max_messages=2),\n",
     ")\n",
     "print(\"\\n\", result)"
    ]

From 173acc6638c70de031ad833ed5a1850831bcd739 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 09:08:29 -0700
Subject: [PATCH 059/173] Custom selector function for SelectorGroupChat
 (#4026)

* Custom selector function for SelectorGroupChat

* Update documentation
---
 .../agents/_assistant_agent.py                |  25 +++-
 .../autogen_agentchat/base/_termination.py    |  22 ++-
 .../_group_chat/_round_robin_group_chat.py    |  47 +++---
 .../teams/_group_chat/_selector_group_chat.py | 141 +++++++++++++-----
 .../teams/_group_chat/_swarm_group_chat.py    |  34 +++--
 .../tests/test_group_chat.py                  |  48 ++++++
 6 files changed, 234 insertions(+), 83 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 86a4f39952b8..28c4ccc16f88 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -131,14 +131,19 @@ class AssistantAgent(BaseChatAgent):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.task import MaxMessageTermination
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
-            agent = AssistantAgent(name="assistant", model_client=model_client)
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+                agent = AssistantAgent(name="assistant", model_client=model_client)
 
-            await agent.run("What is the capital of France?", termination_condition=MaxMessageTermination(2))
+                result await agent.run("What is the capital of France?", termination_condition=MaxMessageTermination(2))
+                print(result)
+
+            asyncio.run(main())
 
 
         The following example demonstrates how to create an assistant agent with
@@ -146,6 +151,7 @@ class AssistantAgent(BaseChatAgent):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.task import MaxMessageTermination
@@ -155,14 +161,17 @@ async def get_current_time() -> str:
                 return "The current time is 12:00 PM."
 
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
-            agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+                agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
+
+                stream = agent.run_stream("What is the current time?", termination_condition=MaxMessageTermination(3))
 
-            stream = agent.run_stream("What is the current time?", termination_condition=MaxMessageTermination(3))
+                async for message in stream:
+                    print(message)
 
-            async for message in stream:
-                print(message)
 
+            asyncio.run(main())
 
     """
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
index 0d0a056eab4c..1442dd51358a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
@@ -22,19 +22,25 @@ class TerminationCondition(ABC):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_agentchat.teams import MaxTurnsTermination, TextMentionTermination
 
-            # Terminate the conversation after 10 turns or if the text "TERMINATE" is mentioned.
-            cond1 = MaxTurnsTermination(10) | TextMentionTermination("TERMINATE")
 
-            # Terminate the conversation after 10 turns and if the text "TERMINATE" is mentioned.
-            cond2 = MaxTurnsTermination(10) & TextMentionTermination("TERMINATE")
+            async def main() -> None:
+                # Terminate the conversation after 10 turns or if the text "TERMINATE" is mentioned.
+                cond1 = MaxTurnsTermination(10) | TextMentionTermination("TERMINATE")
 
-            ...
+                # Terminate the conversation after 10 turns and if the text "TERMINATE" is mentioned.
+                cond2 = MaxTurnsTermination(10) & TextMentionTermination("TERMINATE")
 
-            # Reset the termination condition.
-            await cond1.reset()
-            await cond2.reset()
+                # ...
+
+                # Reset the termination condition.
+                await cond1.reset()
+                await cond2.reset()
+
+
+            asyncio.run(main())
     """
 
     @property
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index b2dcdb640297..6fe0be858c39 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -61,46 +61,55 @@ class RoundRobinGroupChat(BaseGroupChat):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import RoundRobinGroupChat
             from autogen_agentchat.task import StopMessageTermination
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
-            async def get_weather(location: str) -> str:
-                return f"The weather in {location} is sunny."
+                async def get_weather(location: str) -> str:
+                    return f"The weather in {location} is sunny."
 
+                assistant = AssistantAgent(
+                    "Assistant",
+                    model_client=model_client,
+                    tools=[get_weather],
+                )
+                team = RoundRobinGroupChat([assistant])
+                stream = team.run_stream("What's the weather in New York?", termination_condition=StopMessageTermination())
+                async for message in stream:
+                    print(message)
 
-            assistant = AssistantAgent(
-                "Assistant",
-                model_client=model_client,
-                tools=[get_weather],
-            )
-            team = RoundRobinGroupChat([assistant])
-            stream = team.run_stream("What's the weather in New York?", termination_condition=StopMessageTermination())
-            async for message in stream:
-                print(message)
+
+            asyncio.run(main())
 
     A team with multiple participants:
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import RoundRobinGroupChat
             from autogen_agentchat.task import StopMessageTermination
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
-            agent1 = AssistantAgent("Assistant1", model_client=model_client)
-            agent2 = AssistantAgent("Assistant2", model_client=model_client)
-            team = RoundRobinGroupChat([agent1, agent2])
-            stream = team.run_stream("Tell me some jokes.", termination_condition=StopMessageTermination())
-            async for message in stream:
-                print(message)
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                agent1 = AssistantAgent("Assistant1", model_client=model_client)
+                agent2 = AssistantAgent("Assistant2", model_client=model_client)
+                team = RoundRobinGroupChat([agent1, agent2])
+                stream = team.run_stream("Tell me some jokes.", termination_condition=StopMessageTermination())
+                async for message in stream:
+                    print(message)
+
 
+            asyncio.run(main())
     """
 
     def __init__(self, participants: List[ChatAgent]):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index d91d89e26a5a..ee9c006c3fbb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -1,12 +1,12 @@
 import logging
 import re
-from typing import Callable, Dict, List
+from typing import Callable, Dict, List, Sequence
 
 from autogen_core.components.models import ChatCompletionClient, SystemMessage
 
 from ... import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
-from ...messages import MultiModalMessage, StopMessage, TextMessage
+from ...messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
 from .._events import (
     GroupChatPublishEvent,
     GroupChatSelectSpeakerEvent,
@@ -20,7 +20,7 @@
 
 class SelectorGroupChatManager(BaseGroupChatManager):
     """A group chat manager that selects the next speaker using a ChatCompletion
-    model."""
+    model and a custom selector function."""
 
     def __init__(
         self,
@@ -32,6 +32,7 @@ def __init__(
         model_client: ChatCompletionClient,
         selector_prompt: str,
         allow_repeated_speaker: bool,
+        selector_func: Callable[[Sequence[ChatMessage]], str | None] | None,
     ) -> None:
         super().__init__(
             parent_topic_type,
@@ -44,12 +45,24 @@ def __init__(
         self._selector_prompt = selector_prompt
         self._previous_speaker: str | None = None
         self._allow_repeated_speaker = allow_repeated_speaker
+        self._selector_func = selector_func
 
     async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
-        """Selects the next speaker in a group chat using a ChatCompletion client.
+        """Selects the next speaker in a group chat using a ChatCompletion client,
+        with the selector function as override if it returns a speaker name.
 
         A key assumption is that the agent type is the same as the topic type, which we use as the agent name.
         """
+
+        # Use the selector function if provided.
+        if self._selector_func is not None:
+            speaker = self._selector_func([msg.agent_message for msg in thread])
+            if speaker is not None:
+                # Skip the model based selection.
+                event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=speaker, source=self.id))
+                return speaker
+
+        # Construct the history of the conversation.
         history_messages: List[str] = []
         for event in thread:
             msg = event.agent_message
@@ -160,6 +173,10 @@ class SelectorGroupChat(BaseGroupChat):
             Must contain '{roles}', '{participants}', and '{history}' to be filled in.
         allow_repeated_speaker (bool, optional): Whether to allow the same speaker to be selected
             consecutively. Defaults to False.
+        selector_func (Callable[[Sequence[ChatMessage]], str | None], optional): A custom selector
+            function that takes the conversation history and returns the name of the next speaker.
+            If provided, this function will be used to override the model to select the next speaker.
+            If the function returns None, the model will be used to select the next speaker.
 
     Raises:
         ValueError: If the number of participants is less than two or if the selector prompt is invalid.
@@ -175,43 +192,97 @@ class SelectorGroupChat(BaseGroupChat):
             from autogen_agentchat.teams import SelectorGroupChat
             from autogen_agentchat.task import StopMessageTermination
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
-            async def lookup_hotel(location: str) -> str:
-                return f"Here are some hotels in {location}: hotel1, hotel2, hotel3."
+                async def lookup_hotel(location: str) -> str:
+                    return f"Here are some hotels in {location}: hotel1, hotel2, hotel3."
 
+                async def lookup_flight(origin: str, destination: str) -> str:
+                    return f"Here are some flights from {origin} to {destination}: flight1, flight2, flight3."
 
-            async def lookup_flight(origin: str, destination: str) -> str:
-                return f"Here are some flights from {origin} to {destination}: flight1, flight2, flight3."
+                async def book_trip() -> str:
+                    return "Your trip is booked!"
 
+                travel_advisor = AssistantAgent(
+                    "Travel_Advisor",
+                    model_client,
+                    tools=[book_trip],
+                    description="Helps with travel planning.",
+                )
+                hotel_agent = AssistantAgent(
+                    "Hotel_Agent",
+                    model_client,
+                    tools=[lookup_hotel],
+                    description="Helps with hotel booking.",
+                )
+                flight_agent = AssistantAgent(
+                    "Flight_Agent",
+                    model_client,
+                    tools=[lookup_flight],
+                    description="Helps with flight booking.",
+                )
+                team = SelectorGroupChat([travel_advisor, hotel_agent, flight_agent], model_client=model_client)
+                stream = team.run_stream("Book a 3-day trip to new york.", termination_condition=StopMessageTermination())
+                async for message in stream:
+                    print(message)
 
-            async def book_trip() -> str:
-                return "Your trip is booked!"
 
+            import asyncio
 
-            travel_advisor = AssistantAgent(
-                "Travel_Advisor",
-                model_client,
-                tools=[book_trip],
-                description="Helps with travel planning.",
-            )
-            hotel_agent = AssistantAgent(
-                "Hotel_Agent",
-                model_client,
-                tools=[lookup_hotel],
-                description="Helps with hotel booking.",
-            )
-            flight_agent = AssistantAgent(
-                "Flight_Agent",
-                model_client,
-                tools=[lookup_flight],
-                description="Helps with flight booking.",
-            )
-            team = SelectorGroupChat([travel_advisor, hotel_agent, flight_agent], model_client=model_client)
-            stream = team.run_stream("Book a 3-day trip to new york.", termination_condition=StopMessageTermination())
-            async for message in stream:
-                print(message)
+            asyncio.run(main())
+
+    A team with a custom selector function:
+
+        .. code-block:: python
+
+            from autogen_ext.models import OpenAIChatCompletionClient
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.teams import SelectorGroupChat
+            from autogen_agentchat.task import TextMentionTermination
+
+
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                def check_caculation(x: int, y: int, answer: int) -> str:
+                    if x + y == answer:
+                        return "Correct!"
+                    else:
+                        return "Incorrect!"
+
+                agent1 = AssistantAgent(
+                    "Agent1",
+                    model_client,
+                    description="For calculation",
+                    system_message="Calculate the sum of two numbers",
+                )
+                agent2 = AssistantAgent(
+                    "Agent2",
+                    model_client,
+                    tools=[check_caculation],
+                    description="For checking calculation",
+                    system_message="Check the answer and respond with 'Correct!' or 'Incorrect!'",
+                )
+
+                def selector_func(messages):
+                    if len(messages) == 1 or messages[-1].content == "Incorrect!":
+                        return "Agent1"
+                    if messages[-1].source == "Agent1":
+                        return "Agent2"
+                    return None
+
+                team = SelectorGroupChat([agent1, agent2], model_client=model_client, selector_func=selector_func)
+
+                stream = team.run_stream("What is 1 + 1?", termination_condition=TextMentionTermination("Correct!"))
+                async for message in stream:
+                    print(message)
+
+
+            import asyncio
+
+            asyncio.run(main())
     """
 
     def __init__(
@@ -219,7 +290,6 @@ def __init__(
         participants: List[ChatAgent],
         model_client: ChatCompletionClient,
         *,
-        termination_condition: TerminationCondition | None = None,
         selector_prompt: str = """You are in a role play game. The following roles are available:
 {roles}.
 Read the following conversation. Then select the next role from {participants} to play. Only return the role.
@@ -229,6 +299,7 @@ def __init__(
 Read the above conversation. Then select the next role from {participants} to play. Only return the role.
 """,
         allow_repeated_speaker: bool = False,
+        selector_func: Callable[[Sequence[ChatMessage]], str | None] | None = None,
     ):
         super().__init__(participants, group_chat_manager_class=SelectorGroupChatManager)
         # Validate the participants.
@@ -244,6 +315,7 @@ def __init__(
         self._selector_prompt = selector_prompt
         self._model_client = model_client
         self._allow_repeated_speaker = allow_repeated_speaker
+        self._selector_func = selector_func
 
     def _create_group_chat_manager_factory(
         self,
@@ -262,4 +334,5 @@ def _create_group_chat_manager_factory(
             self._model_client,
             self._selector_prompt,
             self._allow_repeated_speaker,
+            self._selector_func,
         )
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 0afc41afe98b..fcaee4d80c7e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -61,28 +61,34 @@ class Swarm(BaseGroupChat):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import Swarm
             from autogen_agentchat.task import MaxMessageTermination
 
-            model_client = OpenAIChatCompletionClient(model="gpt-4o")
 
-            agent1 = AssistantAgent(
-                "Alice",
-                model_client=model_client,
-                handoffs=["Bob"],
-                system_message="You are Alice and you only answer questions about yourself.",
-            )
-            agent2 = AssistantAgent(
-                "Bob", model_client=model_client, system_message="You are Bob and your birthday is on 1st January."
-            )
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                agent1 = AssistantAgent(
+                    "Alice",
+                    model_client=model_client,
+                    handoffs=["Bob"],
+                    system_message="You are Alice and you only answer questions about yourself.",
+                )
+                agent2 = AssistantAgent(
+                    "Bob", model_client=model_client, system_message="You are Bob and your birthday is on 1st January."
+                )
+
+                team = Swarm([agent1, agent2])
+
+                stream = team.run_stream("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
+                async for message in stream:
+                    print(message)
 
-            team = Swarm([agent1, agent2])
 
-            stream = team.run_stream("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
-            async for message in stream:
-                print(message)
+            asyncio.run(main())
     """
 
     def __init__(self, participants: List[ChatAgent]):
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 72fdc6bcd68a..1ff4b124994b 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -493,6 +493,54 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
         index += 1
 
 
+@pytest.mark.asyncio
+async def test_selector_group_chat_custom_selector(monkeypatch: pytest.MonkeyPatch) -> None:
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="agent3", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+    agent1 = _EchoAgent("agent1", description="echo agent 1")
+    agent2 = _EchoAgent("agent2", description="echo agent 2")
+    agent3 = _EchoAgent("agent3", description="echo agent 3")
+    agent4 = _EchoAgent("agent4", description="echo agent 4")
+
+    def _select_agent(messages: Sequence[ChatMessage]) -> str | None:
+        if len(messages) == 0:
+            return "agent1"
+        elif messages[-1].source == "agent1":
+            return "agent2"
+        elif messages[-1].source == "agent2":
+            return None
+        elif messages[-1].source == "agent3":
+            return "agent4"
+        else:
+            return "agent1"
+
+    team = SelectorGroupChat(
+        participants=[agent1, agent2, agent3, agent4],
+        model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        selector_func=_select_agent,
+    )
+    result = await team.run("task", termination_condition=MaxMessageTermination(6))
+    assert len(result.messages) == 6
+    assert result.messages[1].source == "agent1"
+    assert result.messages[2].source == "agent2"
+    assert result.messages[3].source == "agent3"
+    assert result.messages[4].source == "agent4"
+    assert result.messages[5].source == "agent1"
+
+
 class _HandOffAgent(BaseChatAgent):
     def __init__(self, name: str, description: str, next_agent: str) -> None:
         super().__init__(name, description)

From c3b2597e1237a5be45494d1c14b41c53e695f7c8 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 12:35:26 -0700
Subject: [PATCH 060/173] AssistantAgent no longer sends out StopMessage. We
 use TextMentionTermination("TERMINATE") on the team instead for default
 setting. (#4030)

* AssistantAgent no longer sends out StopMessage. We use TextMentionTermination("TERMINATE") on the team instead for default setting.

* Fix test
---
 .../agents/_assistant_agent.py                | 18 ++++--------
 .../tests/test_group_chat.py                  | 28 +++++++++----------
 .../examples/company-research.ipynb           | 10 ++++---
 .../examples/literature-review.ipynb          |  8 +++---
 .../examples/travel-planning.ipynb            | 10 ++++---
 .../tutorial/selector-group-chat.ipynb        | 10 +++----
 .../tutorial/termination.ipynb                |  8 +++---
 7 files changed, 44 insertions(+), 48 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 28c4ccc16f88..37d4646c685b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -24,7 +24,6 @@
     HandoffMessage,
     InnerMessage,
     ResetMessage,
-    StopMessage,
     TextMessage,
     ToolCallMessage,
     ToolCallResultMessage,
@@ -232,8 +231,8 @@ def __init__(
     def produced_message_types(self) -> List[type[ChatMessage]]:
         """The types of messages that the assistant agent produces."""
         if self._handoffs:
-            return [TextMessage, HandoffMessage, StopMessage]
-        return [TextMessage, StopMessage]
+            return [TextMessage, HandoffMessage]
+        return [TextMessage]
 
     async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
         async for message in self.on_messages_stream(messages, cancellation_token):
@@ -303,16 +302,9 @@ async def on_messages_stream(
             self._model_context.append(AssistantMessage(content=result.content, source=self.name))
 
         assert isinstance(result.content, str)
-        # Detect stop request.
-        request_stop = "terminate" in result.content.strip().lower()
-        if request_stop:
-            yield Response(
-                chat_message=StopMessage(content=result.content, source=self.name), inner_messages=inner_messages
-            )
-        else:
-            yield Response(
-                chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
-            )
+        yield Response(
+            chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
+        )
 
     async def _execute_tool_call(
         self, tool_call: FunctionCall, cancellation_token: CancellationToken
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 1ff4b124994b..0fc39453d7ea 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -22,7 +22,7 @@
     ToolCallMessage,
     ToolCallResultMessage,
 )
-from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination
+from autogen_agentchat.task import MaxMessageTermination, TextMentionTermination
 from autogen_agentchat.teams import (
     RoundRobinGroupChat,
     SelectorGroupChat,
@@ -151,7 +151,7 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         team = RoundRobinGroupChat(participants=[coding_assistant_agent, code_executor_agent])
         result = await team.run(
             "Write a program that prints 'Hello, world!'",
-            termination_condition=StopMessageTermination(),
+            termination_condition=TextMentionTermination("TERMINATE"),
         )
         expected_messages = [
             "Write a program that prints 'Hello, world!'",
@@ -172,7 +172,7 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         mock.reset()
         index = 0
         async for message in team.run_stream(
-            "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+            "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
         ):
             if isinstance(message, TaskResult):
                 assert message == result
@@ -247,7 +247,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent])
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=StopMessageTermination(),
+        termination_condition=TextMentionTermination("TERMINATE"),
     )
 
     assert len(result.messages) == 6
@@ -256,7 +256,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     assert isinstance(result.messages[2], ToolCallResultMessage)  # tool call result
     assert isinstance(result.messages[3], TextMessage)  # tool use agent response
     assert isinstance(result.messages[4], TextMessage)  # echo agent response
-    assert isinstance(result.messages[5], StopMessage)  # tool use agent response
+    assert isinstance(result.messages[5], TextMessage)  # tool use agent response
 
     context = tool_use_agent._model_context  # pyright: ignore
     assert context[0].content == "Write a program that prints 'Hello, world!'"
@@ -275,7 +275,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     mock.reset()
     index = 0
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -351,7 +351,7 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     )
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=StopMessageTermination(),
+        termination_condition=TextMentionTermination("TERMINATE"),
     )
     assert len(result.messages) == 6
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -366,7 +366,7 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     agent1._count = 0  # pyright: ignore
     index = 0
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -401,7 +401,7 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     )
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=StopMessageTermination(),
+        termination_condition=TextMentionTermination("TERMINATE"),
     )
     assert len(result.messages) == 5
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -417,7 +417,7 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     agent1._count = 0  # pyright: ignore
     index = 0
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -472,7 +472,7 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
         allow_repeated_speaker=True,
     )
     result = await team.run(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
     )
     assert len(result.messages) == 4
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -484,7 +484,7 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     mock.reset()
     index = 0
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=StopMessageTermination()
+        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -649,7 +649,7 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     )
     agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
     team = Swarm([agent1, agent2])
-    result = await team.run("task", termination_condition=StopMessageTermination())
+    result = await team.run("task", termination_condition=TextMentionTermination("TERMINATE"))
     assert len(result.messages) == 7
     assert result.messages[0].content == "task"
     assert isinstance(result.messages[1], ToolCallMessage)
@@ -663,7 +663,7 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     agent1._model_context.clear()  # pyright: ignore
     mock.reset()
     index = 0
-    stream = team.run_stream("task", termination_condition=StopMessageTermination())
+    stream = team.run_stream("task", termination_condition=TextMentionTermination("TERMINATE"))
     async for message in stream:
         if isinstance(message, TaskResult):
             assert message == result
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
index 15a641b7e973..2e87fe4c402b 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
@@ -18,12 +18,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
-    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.task import TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
@@ -265,7 +265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -400,7 +400,9 @@
     }
    ],
    "source": [
-    "result = await team.run(\"Write a financial report on American airlines\", termination_condition=StopMessageTermination())\n",
+    "result = await team.run(\n",
+    "    \"Write a financial report on American airlines\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
+    ")\n",
     "print(result)"
    ]
   }
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
index a8b933585995..84f14c74476f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
@@ -18,12 +18,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n",
-    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.task import TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.tools import FunctionTool\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
@@ -161,7 +161,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -332,7 +332,7 @@
     "\n",
     "result = await team.run(\n",
     "    task=\"Write a literature review on no code tools for building multi agent ai systems\",\n",
-    "    termination_condition=StopMessageTermination(),\n",
+    "    termination_condition=TextMentionTermination(\"TERMINATE\"),\n",
     ")"
    ]
   }
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
index e42c569b4081..d78f433fae3e 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
@@ -13,12 +13,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "from autogen_agentchat.agents import CodingAssistantAgent\n",
-    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.task import TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_ext.models import OpenAIChatCompletionClient"
    ]
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -195,7 +195,9 @@
    ],
    "source": [
     "group_chat = RoundRobinGroupChat([planner_agent, local_agent, language_agent, travel_summary_agent])\n",
-    "result = await group_chat.run(task=\"Plan a 3 day trip to Nepal.\", termination_condition=StopMessageTermination())\n",
+    "result = await group_chat.run(\n",
+    "    task=\"Plan a 3 day trip to Nepal.\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
+    ")\n",
     "print(result)"
    ]
   }
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index 633c81867bf5..e15e4ce81e90 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -47,7 +47,7 @@
     ")\n",
     "from autogen_agentchat.base import Response\n",
     "from autogen_agentchat.messages import ChatMessage, StopMessage, TextMessage\n",
-    "from autogen_agentchat.task import StopMessageTermination\n",
+    "from autogen_agentchat.task import TextMentionTermination\n",
     "from autogen_agentchat.teams import SelectorGroupChat\n",
     "from autogen_core.base import CancellationToken\n",
     "from autogen_core.components.tools import FunctionTool\n",
@@ -114,7 +114,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -254,7 +254,7 @@
     "team = SelectorGroupChat(\n",
     "    [user_proxy, flight_broker, travel_assistant], model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\")\n",
     ")\n",
-    "await team.run(\"Help user plan a trip and book a flight.\", termination_condition=StopMessageTermination())"
+    "await team.run(\"Help user plan a trip and book a flight.\", termination_condition=TextMentionTermination(\"TERMINATE\"))"
    ]
   }
  ],
@@ -274,7 +274,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
index ef09378635f9..f3a1ad1ea050 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -37,7 +37,7 @@
     "from autogen_agentchat import EVENT_LOGGER_NAME\n",
     "from autogen_agentchat.agents import CodingAssistantAgent\n",
     "from autogen_agentchat.logging import ConsoleLogHandler\n",
-    "from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination\n",
+    "from autogen_agentchat.task import MaxMessageTermination, TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_core.components.models import OpenAIChatCompletionClient\n",
     "\n",
@@ -140,7 +140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -178,7 +178,7 @@
     "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])\n",
     "\n",
     "round_robin_team_result = await round_robin_team.run(\n",
-    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=StopMessageTermination()\n",
+    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
     ")"
    ]
   }

From a4901f3ba886034f535048989c3a52fb076f60b4 Mon Sep 17 00:00:00 2001
From: Reuben Bond <203839+ReubenBond@users.noreply.github.com>
Date: Fri, 1 Nov 2024 12:59:50 -0700
Subject: [PATCH 061/173] Wait for acknowledgment when sending message to gRPC
 channel (#4034)

---
 .../Agents/GrpcAgentWorkerRuntime.cs          | 48 +++++++++++++++----
 1 file changed, 39 insertions(+), 9 deletions(-)

diff --git a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
index c52509876ffd..193f9dd2b633 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
@@ -19,7 +19,7 @@ public sealed class GrpcAgentWorkerRuntime : IHostedService, IDisposable, IAgent
     private readonly ConcurrentDictionary _agentTypes = new();
     private readonly ConcurrentDictionary<(string Type, string Key), IAgentBase> _agents = new();
     private readonly ConcurrentDictionary _pendingRequests = new();
-    private readonly Channel _outboundMessagesChannel = Channel.CreateBounded(new BoundedChannelOptions(1024)
+    private readonly Channel<(Message Message, TaskCompletionSource WriteCompletionSource)> _outboundMessagesChannel = Channel.CreateBounded<(Message, TaskCompletionSource)>(new BoundedChannelOptions(1024)
     {
         AllowSynchronousContinuations = true,
         SingleReader = true,
@@ -138,30 +138,34 @@ private async Task RunWritePump()
         var outboundMessages = _outboundMessagesChannel.Reader;
         while (!_shutdownCts.IsCancellationRequested)
         {
+            (Message Message, TaskCompletionSource WriteCompletionSource) item = default;
             try
             {
                 await outboundMessages.WaitToReadAsync().ConfigureAwait(false);
 
                 // Read the next message if we don't already have an unsent message
                 // waiting to be sent.
-                if (!outboundMessages.TryRead(out var message))
+                if (!outboundMessages.TryRead(out item))
                 {
                     break;
                 }
 
                 while (!_shutdownCts.IsCancellationRequested)
                 {
-                    await channel.RequestStream.WriteAsync(message, _shutdownCts.Token).ConfigureAwait(false);
+                    await channel.RequestStream.WriteAsync(item.Message, _shutdownCts.Token).ConfigureAwait(false);
+                    item.WriteCompletionSource.TrySetResult();
                     break;
                 }
             }
             catch (OperationCanceledException)
             {
                 // Time to shut down.
+                item.WriteCompletionSource?.TrySetCanceled();
                 break;
             }
             catch (Exception ex) when (!_shutdownCts.IsCancellationRequested)
             {
+                item.WriteCompletionSource?.TrySetException(ex);
                 _logger.LogError(ex, "Error writing to channel.");
                 channel = RecreateChannel(channel);
                 continue;
@@ -169,9 +173,15 @@ private async Task RunWritePump()
             catch
             {
                 // Shutdown requested.
+                item.WriteCompletionSource?.TrySetCanceled();
                 break;
             }
         }
+
+        while (outboundMessages.TryRead(out var item))
+        {
+            item.WriteCompletionSource.TrySetCanceled();
+        }
     }
 
     private IAgentBase GetOrActivateAgent(AgentId agentId)
@@ -213,7 +223,8 @@ await WriteChannelAsync(new Message
                     //StateType = state?.Name,
                     //Events = { events }
                 }
-            }).ConfigureAwait(false);
+            },
+            _shutdownCts.Token).ConfigureAwait(false);
         }
     }
 
@@ -229,17 +240,36 @@ public async ValueTask SendRequest(IAgentBase agent, RpcRequest request)
         var requestId = Guid.NewGuid().ToString();
         _pendingRequests[requestId] = (agent, request.RequestId);
         request.RequestId = requestId;
-        await WriteChannelAsync(new Message { Request = request }).ConfigureAwait(false);
+        try
+        {
+            await WriteChannelAsync(new Message { Request = request }).ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            if (_pendingRequests.TryRemove(requestId, out _))
+            {
+                agent.ReceiveMessage(new Message { Response = new RpcResponse { RequestId = request.RequestId, Error = exception.Message } });
+            }
+        }
     }
 
     public async ValueTask PublishEvent(CloudEvent @event)
     {
-        await WriteChannelAsync(new Message { CloudEvent = @event }).ConfigureAwait(false);
+        try
+        {
+            await WriteChannelAsync(new Message { CloudEvent = @event }).ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            _logger.LogWarning(exception, "Failed to publish event '{Event}'.", @event);
+        }
     }
 
-    private async Task WriteChannelAsync(Message message)
+    private async Task WriteChannelAsync(Message message, CancellationToken cancellationToken = default)
     {
-        await _outboundMessagesChannel.Writer.WriteAsync(message).ConfigureAwait(false);
+        var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        await _outboundMessagesChannel.Writer.WriteAsync((message, tcs), cancellationToken).ConfigureAwait(false);
+        await tcs.Task.WaitAsync(cancellationToken);
     }
 
     private AsyncDuplexStreamingCall GetChannel()
@@ -269,7 +299,7 @@ private AsyncDuplexStreamingCall RecreateChannel(AsyncDuplexSt
                 if (_channel is null || _channel == channel)
                 {
                     _channel?.Dispose();
-                    _channel = _client.OpenChannel();
+                    _channel = _client.OpenChannel(cancellationToken: _shutdownCts.Token);
                 }
             }
         }

From e9c16fe22ef82ec5fe7d548a3907f02299f93335 Mon Sep 17 00:00:00 2001
From: Reuben Bond <203839+ReubenBond@users.noreply.github.com>
Date: Fri, 1 Nov 2024 13:17:17 -0700
Subject: [PATCH 062/173] Add CancellationToken parameters to API surface
 (#4036)

---
 .../Abstractions/IAgentContext.cs             | 10 ++++-----
 .../Abstractions/IAgentWorkerRuntime.cs       | 10 ++++-----
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs |  5 ++---
 .../Microsoft.AutoGen/Agents/AgentContext.cs  | 20 ++++++++---------
 .../Agents/GrpcAgentWorkerRuntime.cs          | 22 +++++++++----------
 5 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
index d93b6246765d..ab5972730fb7 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentContext.cs
@@ -12,9 +12,9 @@ public interface IAgentContext
     IAgentBase? AgentInstance { get; set; }
     DistributedContextPropagator DistributedContextPropagator { get; } // TODO: Remove this. An abstraction should not have a dependency on DistributedContextPropagator.
     ILogger Logger { get; } // TODO: Remove this. An abstraction should not have a dependency on ILogger.
-    ValueTask Store(AgentState value);
-    ValueTask Read(AgentId agentId);
-    ValueTask SendResponseAsync(RpcRequest request, RpcResponse response);
-    ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request);
-    ValueTask PublishEventAsync(CloudEvent @event);
+    ValueTask Store(AgentState value, CancellationToken cancellationToken = default);
+    ValueTask Read(AgentId agentId, CancellationToken cancellationToken = default);
+    ValueTask SendResponseAsync(RpcRequest request, RpcResponse response, CancellationToken cancellationToken = default);
+    ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request, CancellationToken cancellationToken = default);
+    ValueTask PublishEventAsync(CloudEvent @event, CancellationToken cancellationToken = default);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
index 1a255e132346..c03259f722f3 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentWorkerRuntime.cs
@@ -5,9 +5,9 @@ namespace Microsoft.AutoGen.Abstractions;
 
 public interface IAgentWorkerRuntime
 {
-    ValueTask PublishEvent(CloudEvent evt);
-    ValueTask SendRequest(IAgentBase agent, RpcRequest request);
-    ValueTask SendResponse(RpcResponse response);
-    ValueTask Store(AgentState value);
-    ValueTask Read(AgentId agentId);
+    ValueTask PublishEvent(CloudEvent evt, CancellationToken cancellationToken);
+    ValueTask SendRequest(IAgentBase agent, RpcRequest request, CancellationToken cancellationToken);
+    ValueTask SendResponse(RpcResponse response, CancellationToken cancellationToken);
+    ValueTask Store(AgentState value, CancellationToken cancellationToken);
+    ValueTask Read(AgentId agentId, CancellationToken cancellationToken);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index af06c84e9ba1..baa7ee201edd 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -202,15 +202,14 @@ public async ValueTask PublishEvent(CloudEvent item)
         var activity = s_source.StartActivity($"PublishEvent '{item.Type}'", ActivityKind.Client, Activity.Current?.Context ?? default);
         activity?.SetTag("peer.service", $"{item.Type}/{item.Source}");
 
-        var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         // TODO: fix activity
         Context.DistributedContextPropagator.Inject(activity, item.Metadata, static (carrier, key, value) => ((IDictionary)carrier!)[key] = value);
         await this.InvokeWithActivityAsync(
-            static async ((AgentBase Agent, CloudEvent Event, TaskCompletionSource) state) =>
+            static async ((AgentBase Agent, CloudEvent Event) state) =>
             {
                 await state.Agent._context.PublishEventAsync(state.Event).ConfigureAwait(false);
             },
-            (this, item, completion),
+            (this, item),
             activity,
             item.Type).ConfigureAwait(false);
     }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
index 325bc33a11d0..7de1e6565d33 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentContext.cs
@@ -15,25 +15,25 @@ internal sealed class AgentContext(AgentId agentId, IAgentWorkerRuntime runtime,
     public ILogger Logger { get; } = logger;
     public IAgentBase? AgentInstance { get; set; }
     public DistributedContextPropagator DistributedContextPropagator { get; } = distributedContextPropagator;
-    public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse response)
+    public async ValueTask SendResponseAsync(RpcRequest request, RpcResponse response, CancellationToken cancellationToken)
     {
         response.RequestId = request.RequestId;
-        await _runtime.SendResponse(response);
+        await _runtime.SendResponse(response, cancellationToken).ConfigureAwait(false);
     }
-    public async ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request)
+    public async ValueTask SendRequestAsync(IAgentBase agent, RpcRequest request, CancellationToken cancellationToken)
     {
-        await _runtime.SendRequest(agent, request).ConfigureAwait(false);
+        await _runtime.SendRequest(agent, request, cancellationToken).ConfigureAwait(false);
     }
-    public async ValueTask PublishEventAsync(CloudEvent @event)
+    public async ValueTask PublishEventAsync(CloudEvent @event, CancellationToken cancellationToken)
     {
-        await _runtime.PublishEvent(@event).ConfigureAwait(false);
+        await _runtime.PublishEvent(@event, cancellationToken).ConfigureAwait(false);
     }
-    public async ValueTask Store(AgentState value)
+    public async ValueTask Store(AgentState value, CancellationToken cancellationToken)
     {
-        await _runtime.Store(value).ConfigureAwait(false);
+        await _runtime.Store(value, cancellationToken).ConfigureAwait(false);
     }
-    public ValueTask Read(AgentId agentId)
+    public ValueTask Read(AgentId agentId, CancellationToken cancellationToken)
     {
-        return _runtime.Read(agentId);
+        return _runtime.Read(agentId, cancellationToken);
     }
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
index 193f9dd2b633..b0550c1fb715 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/GrpcAgentWorkerRuntime.cs
@@ -228,13 +228,13 @@ await WriteChannelAsync(new Message
         }
     }
 
-    public async ValueTask SendResponse(RpcResponse response)
+    public async ValueTask SendResponse(RpcResponse response, CancellationToken cancellationToken)
     {
         _logger.LogInformation("Sending response '{Response}'.", response);
-        await WriteChannelAsync(new Message { Response = response }).ConfigureAwait(false);
+        await WriteChannelAsync(new Message { Response = response }, cancellationToken).ConfigureAwait(false);
     }
 
-    public async ValueTask SendRequest(IAgentBase agent, RpcRequest request)
+    public async ValueTask SendRequest(IAgentBase agent, RpcRequest request, CancellationToken cancellationToken)
     {
         _logger.LogInformation("[{AgentId}] Sending request '{Request}'.", agent.AgentId, request);
         var requestId = Guid.NewGuid().ToString();
@@ -242,7 +242,7 @@ public async ValueTask SendRequest(IAgentBase agent, RpcRequest request)
         request.RequestId = requestId;
         try
         {
-            await WriteChannelAsync(new Message { Request = request }).ConfigureAwait(false);
+            await WriteChannelAsync(new Message { Request = request }, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception exception)
         {
@@ -253,11 +253,11 @@ public async ValueTask SendRequest(IAgentBase agent, RpcRequest request)
         }
     }
 
-    public async ValueTask PublishEvent(CloudEvent @event)
+    public async ValueTask PublishEvent(CloudEvent @event, CancellationToken cancellationToken)
     {
         try
         {
-            await WriteChannelAsync(new Message { CloudEvent = @event }).ConfigureAwait(false);
+            await WriteChannelAsync(new Message { CloudEvent = @event }, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception exception)
         {
@@ -265,7 +265,7 @@ public async ValueTask PublishEvent(CloudEvent @event)
         }
     }
 
-    private async Task WriteChannelAsync(Message message, CancellationToken cancellationToken = default)
+    private async Task WriteChannelAsync(Message message, CancellationToken cancellationToken)
     {
         var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         await _outboundMessagesChannel.Writer.WriteAsync((message, tcs), cancellationToken).ConfigureAwait(false);
@@ -364,19 +364,19 @@ public async Task StopAsync(CancellationToken cancellationToken)
             _channel?.Dispose();
         }
     }
-    public ValueTask Store(AgentState value)
+    public ValueTask Store(AgentState value, CancellationToken cancellationToken)
     {
         var agentId = value.AgentId ?? throw new InvalidOperationException("AgentId is required when saving AgentState.");
-        var response = _client.SaveState(value);
+        var response = _client.SaveState(value, cancellationToken: cancellationToken);
         if (!response.Success)
         {
             throw new InvalidOperationException($"Error saving AgentState for AgentId {agentId}.");
         }
         return ValueTask.CompletedTask;
     }
-    public async ValueTask Read(AgentId agentId)
+    public async ValueTask Read(AgentId agentId, CancellationToken cancellationToken)
     {
-        var response = await _client.GetStateAsync(agentId);
+        var response = await _client.GetStateAsync(agentId, cancellationToken: cancellationToken);
         //        if (response.Success && response.AgentState.AgentId is not null) - why is success always false?
         if (response.AgentState.AgentId is not null)
         {

From ca7caa779d72279547f8e88d40a2354635eef41e Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 13:20:25 -0700
Subject: [PATCH 063/173] Add token usage to messages (#4028)

* Add token usage to messages

* small test edit
---
 .../agents/_assistant_agent.py                |  7 +++---
 .../src/autogen_agentchat/messages.py         |  5 +++-
 .../tests/test_assistant_agent.py             | 24 +++++++++++++++----
 3 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 37d4646c685b..8ef47806ac4d 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -266,8 +266,8 @@ async def on_messages_stream(
         while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
             event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
             # Add the tool call message to the output.
-            inner_messages.append(ToolCallMessage(content=result.content, source=self.name))
-            yield ToolCallMessage(content=result.content, source=self.name)
+            inner_messages.append(ToolCallMessage(content=result.content, source=self.name, model_usage=result.usage))
+            yield ToolCallMessage(content=result.content, source=self.name, model_usage=result.usage)
 
             # Execute the tool calls.
             results = await asyncio.gather(
@@ -303,7 +303,8 @@ async def on_messages_stream(
 
         assert isinstance(result.content, str)
         yield Response(
-            chat_message=TextMessage(content=result.content, source=self.name), inner_messages=inner_messages
+            chat_message=TextMessage(content=result.content, source=self.name, model_usage=result.usage),
+            inner_messages=inner_messages,
         )
 
     async def _execute_tool_call(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 51dbcca333d7..c8037671e131 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -1,7 +1,7 @@
 from typing import List
 
 from autogen_core.components import FunctionCall, Image
-from autogen_core.components.models import FunctionExecutionResult
+from autogen_core.components.models import FunctionExecutionResult, RequestUsage
 from pydantic import BaseModel
 
 
@@ -11,6 +11,9 @@ class BaseMessage(BaseModel):
     source: str
     """The name of the agent that sent this message."""
 
+    model_usage: RequestUsage | None = None
+    """The model client usage incurred when producing this message."""
+
 
 class TextMessage(BaseMessage):
     """A text message."""
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 4589f86860d3..20556ad783cb 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -78,7 +78,7 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
             created=0,
             model=model,
             object="chat.completion",
-            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
         ),
         ChatCompletion(
             id="id2",
@@ -88,7 +88,7 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
             created=0,
             model=model,
             object="chat.completion",
-            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
         ),
         ChatCompletion(
             id="id2",
@@ -100,7 +100,7 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
             created=0,
             model=model,
             object="chat.completion",
-            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
         ),
     ]
     mock = _MockChatCompletion(chat_completions)
@@ -113,9 +113,17 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
+    assert result.messages[0].model_usage is None
     assert isinstance(result.messages[1], ToolCallMessage)
+    assert result.messages[1].model_usage is not None
+    assert result.messages[1].model_usage.completion_tokens == 5
+    assert result.messages[1].model_usage.prompt_tokens == 10
     assert isinstance(result.messages[2], ToolCallResultMessage)
+    assert result.messages[2].model_usage is None
     assert isinstance(result.messages[3], TextMessage)
+    assert result.messages[3].model_usage is not None
+    assert result.messages[3].model_usage.completion_tokens == 5
+    assert result.messages[3].model_usage.prompt_tokens == 10
 
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore
@@ -158,7 +166,7 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
             created=0,
             model=model,
             object="chat.completion",
-            usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+            usage=CompletionUsage(prompt_tokens=42, completion_tokens=43, total_tokens=85),
         ),
     ]
     mock = _MockChatCompletion(chat_completions)
@@ -173,9 +181,17 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
+    assert result.messages[0].model_usage is None
     assert isinstance(result.messages[1], ToolCallMessage)
+    assert result.messages[1].model_usage is not None
+    assert result.messages[1].model_usage.completion_tokens == 43
+    assert result.messages[1].model_usage.prompt_tokens == 42
     assert isinstance(result.messages[2], ToolCallResultMessage)
+    assert result.messages[2].model_usage is None
     assert isinstance(result.messages[3], HandoffMessage)
+    assert result.messages[3].content == handoff.message
+    assert result.messages[3].target == handoff.target
+    assert result.messages[3].model_usage is None
 
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore

From 27ea99a4855b4d1dc8a117806ab9ba5628047ec2 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 15:01:43 -0700
Subject: [PATCH 064/173] Add token usage termination (#4035)

* Add token usage termination

* fix test
---
 .../src/autogen_agentchat/task/__init__.py    |  3 +-
 .../autogen_agentchat/task/_terminations.py   | 56 +++++++++++++++++++
 .../tests/test_termination_condition.py       | 53 +++++++++++++++++-
 3 files changed, 110 insertions(+), 2 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
index 757edc043f38..0c1415d3bd1e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
@@ -1,7 +1,8 @@
-from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination
+from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination, TokenUsageTermination
 
 __all__ = [
     "MaxMessageTermination",
     "TextMentionTermination",
     "StopMessageTermination",
+    "TokenUsageTermination",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
index ade11d759b36..24cefc1af284 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
@@ -88,3 +88,59 @@ async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
 
     async def reset(self) -> None:
         self._terminated = False
+
+
+class TokenUsageTermination(TerminationCondition):
+    """Terminate the conversation if a token usage limit is reached.
+
+    Args:
+        max_total_token: The maximum total number of tokens allowed in the conversation.
+        max_prompt_token: The maximum number of prompt tokens allowed in the conversation.
+        max_completion_token: The maximum number of completion tokens allowed in the conversation.
+
+    Raises:
+        ValueError: If none of max_total_token, max_prompt_token, or max_completion_token is provided.
+    """
+
+    def __init__(
+        self,
+        max_total_token: int | None = None,
+        max_prompt_token: int | None = None,
+        max_completion_token: int | None = None,
+    ) -> None:
+        if max_total_token is None and max_prompt_token is None and max_completion_token is None:
+            raise ValueError(
+                "At least one of max_total_token, max_prompt_token, or max_completion_token must be provided"
+            )
+        self._max_total_token = max_total_token
+        self._max_prompt_token = max_prompt_token
+        self._max_completion_token = max_completion_token
+        self._total_token_count = 0
+        self._prompt_token_count = 0
+        self._completion_token_count = 0
+
+    @property
+    def terminated(self) -> bool:
+        return (
+            (self._max_total_token is not None and self._total_token_count >= self._max_total_token)
+            or (self._max_prompt_token is not None and self._prompt_token_count >= self._max_prompt_token)
+            or (self._max_completion_token is not None and self._completion_token_count >= self._max_completion_token)
+        )
+
+    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+        if self.terminated:
+            raise TerminatedException("Termination condition has already been reached")
+        for message in messages:
+            if message.model_usage is not None:
+                self._prompt_token_count += message.model_usage.prompt_tokens
+                self._completion_token_count += message.model_usage.completion_tokens
+                self._total_token_count += message.model_usage.prompt_tokens + message.model_usage.completion_tokens
+        if self.terminated:
+            content = f"Token usage limit reached, total token count: {self._total_token_count}, prompt token count: {self._prompt_token_count}, completion token count: {self._completion_token_count}."
+            return StopMessage(content=content, source="TokenUsageTermination")
+        return None
+
+    async def reset(self) -> None:
+        self._total_token_count = 0
+        self._prompt_token_count = 0
+        self._completion_token_count = 0
diff --git a/python/packages/autogen-agentchat/tests/test_termination_condition.py b/python/packages/autogen-agentchat/tests/test_termination_condition.py
index 7d504dce3a03..c13544515c14 100644
--- a/python/packages/autogen-agentchat/tests/test_termination_condition.py
+++ b/python/packages/autogen-agentchat/tests/test_termination_condition.py
@@ -1,6 +1,12 @@
 import pytest
 from autogen_agentchat.messages import StopMessage, TextMessage
-from autogen_agentchat.task import MaxMessageTermination, StopMessageTermination, TextMentionTermination
+from autogen_agentchat.task import (
+    MaxMessageTermination,
+    StopMessageTermination,
+    TextMentionTermination,
+    TokenUsageTermination,
+)
+from autogen_core.components.models import RequestUsage
 
 
 @pytest.mark.asyncio
@@ -51,6 +57,51 @@ async def test_mention_termination() -> None:
     )
 
 
+@pytest.mark.asyncio
+async def test_token_usage_termination() -> None:
+    termination = TokenUsageTermination(max_total_token=10)
+    assert await termination([]) is None
+    await termination.reset()
+    assert (
+        await termination(
+            [
+                TextMessage(
+                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=10, completion_tokens=10)
+                )
+            ]
+        )
+        is not None
+    )
+    await termination.reset()
+    assert (
+        await termination(
+            [
+                TextMessage(
+                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
+                ),
+                TextMessage(
+                    content="World", source="agent", model_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
+                ),
+            ]
+        )
+        is None
+    )
+    await termination.reset()
+    assert (
+        await termination(
+            [
+                TextMessage(
+                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=5, completion_tokens=0)
+                ),
+                TextMessage(
+                    content="stop", source="user", model_usage=RequestUsage(prompt_tokens=0, completion_tokens=5)
+                ),
+            ]
+        )
+        is not None
+    )
+
+
 @pytest.mark.asyncio
 async def test_and_termination() -> None:
     termination = MaxMessageTermination(2) & TextMentionTermination("stop")

From 7d1857dae621243bab67fb9c92235f75aa0afd24 Mon Sep 17 00:00:00 2001
From: Reuben Bond <203839+ReubenBond@users.noreply.github.com>
Date: Fri, 1 Nov 2024 15:43:20 -0700
Subject: [PATCH 065/173] Clean up the Hello sample, support Aspire 9.0, & fix
 shutdown in the sample (#4037)

* Wait for acknowledgment when sending message to gRPC channel

* Add CancellationToken parameters to API surface

* Clean up the Hello sample, support Aspire 9.0, & fix shutdown
---
 dotnet/samples/Hello/Backend/Backend.csproj   | 16 +++++++------
 dotnet/samples/Hello/Backend/Program.cs       |  2 --
 .../Hello/Hello.AppHost/Hello.AppHost.csproj  |  7 +++---
 .../Hello/HelloAIAgents/HelloAIAgent.cs       |  1 -
 .../Hello/HelloAIAgents/HelloAIAgents.csproj  | 24 +++++++++----------
 dotnet/samples/Hello/HelloAIAgents/Program.cs |  3 ---
 .../Hello/HelloAgent/HelloAgent.csproj        | 24 +++++++++----------
 dotnet/samples/Hello/HelloAgent/Program.cs    | 11 ++++-----
 .../HelloAgentState/HelloAgentState.csproj    | 24 +++++++++----------
 .../samples/Hello/HelloAgentState/Program.cs  |  2 --
 10 files changed, 50 insertions(+), 64 deletions(-)

diff --git a/dotnet/samples/Hello/Backend/Backend.csproj b/dotnet/samples/Hello/Backend/Backend.csproj
index 60097b5d379d..2f5a02ee5117 100644
--- a/dotnet/samples/Hello/Backend/Backend.csproj
+++ b/dotnet/samples/Hello/Backend/Backend.csproj
@@ -1,14 +1,16 @@
-
-  
-    
-  
-  
-    
-  
+
   
     Exe
     net8.0
     enable
     enable
   
+
+  
+    
+  
+
+  
+    
+  
 
diff --git a/dotnet/samples/Hello/Backend/Program.cs b/dotnet/samples/Hello/Backend/Program.cs
index 9f55daf69fc9..7abdb205a85c 100644
--- a/dotnet/samples/Hello/Backend/Program.cs
+++ b/dotnet/samples/Hello/Backend/Program.cs
@@ -1,7 +1,5 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Program.cs
 
-using Microsoft.Extensions.Hosting;
-
 var app = await Microsoft.AutoGen.Runtime.Host.StartAsync(local: true);
 await app.WaitForShutdownAsync();
diff --git a/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj b/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
index 3ecd30dee13a..88d23268c44d 100644
--- a/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
+++ b/dotnet/samples/Hello/Hello.AppHost/Hello.AppHost.csproj
@@ -1,5 +1,4 @@
 
-
   
     Exe
     net8.0
@@ -10,12 +9,12 @@
   
 
   
-    
-    
+    
+    
   
+
   
     
     
   
-
 
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
index ebde6d6d2f51..f7939da7d68e 100644
--- a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
@@ -4,7 +4,6 @@
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
 using Microsoft.Extensions.AI;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Hello;
 [TopicSubscription("HelloAgents")]
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
index 73f1891b3f22..86bccb13b371 100644
--- a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgents.csproj
@@ -1,16 +1,4 @@
-
-
-  
-    
-    
-    
-    
-  
-
-  
-    
-  
-
+
   
     Exe
     net8.0
@@ -18,4 +6,14 @@
     enable
   
 
+  
+    
+  
+
+  
+    
+    
+    
+    
+  
 
diff --git a/dotnet/samples/Hello/HelloAIAgents/Program.cs b/dotnet/samples/Hello/HelloAIAgents/Program.cs
index 9d1964bfd1e1..ebede82bb4fb 100644
--- a/dotnet/samples/Hello/HelloAIAgents/Program.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/Program.cs
@@ -2,11 +2,8 @@
 // Program.cs
 
 using Hello;
-using Microsoft.AspNetCore.Builder;
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 
 // send a message to the agent
 var builder = WebApplication.CreateBuilder();
diff --git a/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj b/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
index eb2ba96d6644..8799eb7275d1 100644
--- a/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
+++ b/dotnet/samples/Hello/HelloAgent/HelloAgent.csproj
@@ -1,16 +1,4 @@
-
-
-  
-    
-    
-    
-  
-
-  
-    
-    
-  
-
+
   
     Exe
     net8.0
@@ -18,4 +6,14 @@
     enable
   
 
+  
+    
+    
+  
+
+  
+    
+    
+    
+  
 
diff --git a/dotnet/samples/Hello/HelloAgent/Program.cs b/dotnet/samples/Hello/HelloAgent/Program.cs
index fbe5d2f6dff9..02ad838dea0d 100644
--- a/dotnet/samples/Hello/HelloAgent/Program.cs
+++ b/dotnet/samples/Hello/HelloAgent/Program.cs
@@ -3,8 +3,6 @@
 
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 
 // step 1: create in-memory agent runtime
 
@@ -27,7 +25,8 @@ namespace Hello
     [TopicSubscription("HelloAgents")]
     public class HelloAgent(
         IAgentContext context,
-        [FromKeyedServices("EventTypes")] EventTypes typeRegistry) : AgentBase(
+        [FromKeyedServices("EventTypes")] EventTypes typeRegistry,
+        IHostApplicationLifetime hostApplicationLifetime) : AgentBase(
             context,
             typeRegistry),
             ISayHello,
@@ -58,11 +57,11 @@ public async Task Handle(ConversationClosed item)
                 Message = goodbye
             }.ToCloudEvent(this.AgentId.Key);
             await PublishEvent(evt).ConfigureAwait(false);
-            //sleep
-            await Task.Delay(10000).ConfigureAwait(false);
-            await AgentsApp.ShutdownAsync().ConfigureAwait(false);
 
+            // Signal shutdown.
+            hostApplicationLifetime.StopApplication();
         }
+
         public async Task SayHello(string ask)
         {
             var response = $"\n\n\n\n***************Hello {ask}**********************\n\n\n\n";
diff --git a/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj b/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
index eb2ba96d6644..8799eb7275d1 100644
--- a/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
+++ b/dotnet/samples/Hello/HelloAgentState/HelloAgentState.csproj
@@ -1,16 +1,4 @@
-
-
-  
-    
-    
-    
-  
-
-  
-    
-    
-  
-
+
   
     Exe
     net8.0
@@ -18,4 +6,14 @@
     enable
   
 
+  
+    
+    
+  
+
+  
+    
+    
+    
+  
 
diff --git a/dotnet/samples/Hello/HelloAgentState/Program.cs b/dotnet/samples/Hello/HelloAgentState/Program.cs
index 66b888d6c46e..c1e00e4d6322 100644
--- a/dotnet/samples/Hello/HelloAgentState/Program.cs
+++ b/dotnet/samples/Hello/HelloAgentState/Program.cs
@@ -3,8 +3,6 @@
 
 using Microsoft.AutoGen.Abstractions;
 using Microsoft.AutoGen.Agents;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 
 // send a message to the agent
 var app = await AgentsApp.PublishMessageAsync("HelloAgents", new NewMessageReceived

From 4fec22ddc59645f5993916c072b419edad58ebea Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 15:49:37 -0700
Subject: [PATCH 066/173] Team termination condition sets in the constructor
 (#4042)

* Termination condition as part of constructor

* Update doc

* Update notebooks
---
 .../src/autogen_agentchat/base/_task.py       |  2 +-
 .../teams/_group_chat/_base_group_chat.py     | 11 ++--
 .../_group_chat/_round_robin_group_chat.py    | 22 ++++---
 .../teams/_group_chat/_selector_group_chat.py | 34 ++++++++---
 .../teams/_group_chat/_swarm_group_chat.py    | 15 +++--
 .../tests/test_group_chat.py                  | 61 +++++++++++--------
 .../examples/company-research.ipynb           |  9 ++-
 .../examples/literature-review.ipynb          |  8 ++-
 .../examples/travel-planning.ipynb            |  7 ++-
 .../agentchat-user-guide/quickstart.ipynb     | 12 ++--
 .../tutorial/selector-group-chat.ipynb        | 10 ++-
 .../agentchat-user-guide/tutorial/teams.ipynb | 19 +++---
 .../tutorial/termination.ipynb                | 21 +++----
 13 files changed, 134 insertions(+), 97 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 2e68c2b8118b..a642120799f2 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -33,5 +33,5 @@ def run_stream(
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
         """Run the task and produces a stream of messages and the final result
-        as the last item in the stream."""
+        :class:`TaskResult` as the last item in the stream."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index e035a9874361..cd4efe8f350e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -33,6 +33,7 @@ def __init__(
         self,
         participants: List[ChatAgent],
         group_chat_manager_class: type[BaseGroupChatManager],
+        termination_condition: TerminationCondition | None = None,
     ):
         if len(participants) == 0:
             raise ValueError("At least one participant is required.")
@@ -41,6 +42,7 @@ def __init__(
         self._participants = participants
         self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
+        self._termination_condition = termination_condition
 
     @abstractmethod
     def _create_group_chat_manager_factory(
@@ -72,12 +74,12 @@ async def run(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
     ) -> TaskResult:
         """Run the team and return the result. The base implementation uses
         :meth:`run_stream` to run the team and then returns the final result."""
         async for message in self.run_stream(
-            task, cancellation_token=cancellation_token, termination_condition=termination_condition
+            task,
+            cancellation_token=cancellation_token,
         ):
             if isinstance(message, TaskResult):
                 return message
@@ -88,10 +90,9 @@ async def run_stream(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-        termination_condition: TerminationCondition | None = None,
     ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
         """Run the team and produces a stream of messages and the final result
-        as the last item in the stream."""
+        of the type :class:`TaskResult` as the last item in the stream."""
         # Create the runtime.
         runtime = SingleThreadedAgentRuntime()
 
@@ -131,7 +132,7 @@ async def run_stream(
                 group_topic_type=group_topic_type,
                 participant_topic_types=participant_topic_types,
                 participant_descriptions=participant_descriptions,
-                termination_condition=termination_condition,
+                termination_condition=self._termination_condition,
             ),
         )
         # Add subscriptions for the group chat manager.
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index 6fe0be858c39..3ef4a2e07ad0 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -50,7 +50,8 @@ class RoundRobinGroupChat(BaseGroupChat):
 
     Args:
         participants (List[BaseChatAgent]): The participants in the group chat.
-        tools (List[Tool], optional): The tools to use in the group chat. Defaults to None.
+        termination_condition (TerminationCondition, optional): The termination condition for the group chat. Defaults to None.
+            Without a termination condition, the group chat will run indefinitely.
 
     Raises:
         ValueError: If no participants are provided or if participant names are not unique.
@@ -65,7 +66,7 @@ class RoundRobinGroupChat(BaseGroupChat):
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import RoundRobinGroupChat
-            from autogen_agentchat.task import StopMessageTermination
+            from autogen_agentchat.task import TextMentionTermination
 
 
             async def main() -> None:
@@ -79,8 +80,9 @@ async def get_weather(location: str) -> str:
                     model_client=model_client,
                     tools=[get_weather],
                 )
-                team = RoundRobinGroupChat([assistant])
-                stream = team.run_stream("What's the weather in New York?", termination_condition=StopMessageTermination())
+                termination = TextMentionTermination("TERMINATE")
+                team = RoundRobinGroupChat([assistant], termination_condition=termination)
+                stream = team.run_stream("What's the weather in New York?")
                 async for message in stream:
                     print(message)
 
@@ -95,7 +97,7 @@ async def get_weather(location: str) -> str:
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import RoundRobinGroupChat
-            from autogen_agentchat.task import StopMessageTermination
+            from autogen_agentchat.task import TextMentionTermination
 
 
             async def main() -> None:
@@ -103,8 +105,9 @@ async def main() -> None:
 
                 agent1 = AssistantAgent("Assistant1", model_client=model_client)
                 agent2 = AssistantAgent("Assistant2", model_client=model_client)
-                team = RoundRobinGroupChat([agent1, agent2])
-                stream = team.run_stream("Tell me some jokes.", termination_condition=StopMessageTermination())
+                termination = TextMentionTermination("TERMINATE")
+                team = RoundRobinGroupChat([agent1, agent2], termination_condition=termination)
+                stream = team.run_stream("Tell me some jokes.")
                 async for message in stream:
                     print(message)
 
@@ -112,10 +115,13 @@ async def main() -> None:
             asyncio.run(main())
     """
 
-    def __init__(self, participants: List[ChatAgent]):
+    def __init__(
+        self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None
+    ) -> None:
         super().__init__(
             participants,
             group_chat_manager_class=RoundRobinGroupChatManager,
+            termination_condition=termination_condition,
         )
 
     def _create_group_chat_manager_factory(
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index ee9c006c3fbb..63b73cb88c2b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -169,6 +169,8 @@ class SelectorGroupChat(BaseGroupChat):
             must have unique names and at least two participants.
         model_client (ChatCompletionClient): The ChatCompletion model client used
             to select the next speaker.
+        termination_condition (TerminationCondition, optional): The termination condition for the group chat. Defaults to None.
+            Without a termination condition, the group chat will run indefinitely.
         selector_prompt (str, optional): The prompt template to use for selecting the next speaker.
             Must contain '{roles}', '{participants}', and '{history}' to be filled in.
         allow_repeated_speaker (bool, optional): Whether to allow the same speaker to be selected
@@ -187,10 +189,11 @@ class SelectorGroupChat(BaseGroupChat):
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import SelectorGroupChat
-            from autogen_agentchat.task import StopMessageTermination
+            from autogen_agentchat.task import TextMentionTermination
 
 
             async def main() -> None:
@@ -223,20 +226,24 @@ async def book_trip() -> str:
                     tools=[lookup_flight],
                     description="Helps with flight booking.",
                 )
-                team = SelectorGroupChat([travel_advisor, hotel_agent, flight_agent], model_client=model_client)
-                stream = team.run_stream("Book a 3-day trip to new york.", termination_condition=StopMessageTermination())
+                termination = TextMentionTermination("TERMINATE")
+                team = SelectorGroupChat(
+                    [travel_advisor, hotel_agent, flight_agent],
+                    model_client=model_client,
+                    termination_condition=termination,
+                )
+                stream = team.run_stream("Book a 3-day trip to new york.")
                 async for message in stream:
                     print(message)
 
 
-            import asyncio
-
             asyncio.run(main())
 
     A team with a custom selector function:
 
         .. code-block:: python
 
+            import asyncio
             from autogen_ext.models import OpenAIChatCompletionClient
             from autogen_agentchat.agents import AssistantAgent
             from autogen_agentchat.teams import SelectorGroupChat
@@ -273,15 +280,19 @@ def selector_func(messages):
                         return "Agent2"
                     return None
 
-                team = SelectorGroupChat([agent1, agent2], model_client=model_client, selector_func=selector_func)
+                termination = TextMentionTermination("Correct!")
+                team = SelectorGroupChat(
+                    [agent1, agent2],
+                    model_client=model_client,
+                    selector_func=selector_func,
+                    termination_condition=termination,
+                )
 
-                stream = team.run_stream("What is 1 + 1?", termination_condition=TextMentionTermination("Correct!"))
+                stream = team.run_stream("What is 1 + 1?")
                 async for message in stream:
                     print(message)
 
 
-            import asyncio
-
             asyncio.run(main())
     """
 
@@ -290,6 +301,7 @@ def __init__(
         participants: List[ChatAgent],
         model_client: ChatCompletionClient,
         *,
+        termination_condition: TerminationCondition | None = None,
         selector_prompt: str = """You are in a role play game. The following roles are available:
 {roles}.
 Read the following conversation. Then select the next role from {participants} to play. Only return the role.
@@ -301,7 +313,9 @@ def __init__(
         allow_repeated_speaker: bool = False,
         selector_func: Callable[[Sequence[ChatMessage]], str | None] | None = None,
     ):
-        super().__init__(participants, group_chat_manager_class=SelectorGroupChatManager)
+        super().__init__(
+            participants, group_chat_manager_class=SelectorGroupChatManager, termination_condition=termination_condition
+        )
         # Validate the participants.
         if len(participants) < 2:
             raise ValueError("At least two participants are required for SelectorGroupChat.")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index fcaee4d80c7e..0a6bf9ee73fa 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -56,6 +56,8 @@ class Swarm(BaseGroupChat):
 
     Args:
         participants (List[ChatAgent]): The agents participating in the group chat. The first agent in the list is the initial speaker.
+        termination_condition (TerminationCondition, optional): The termination condition for the group chat. Defaults to None.
+            Without a termination condition, the group chat will run indefinitely.
 
     Examples:
 
@@ -81,9 +83,10 @@ async def main() -> None:
                     "Bob", model_client=model_client, system_message="You are Bob and your birthday is on 1st January."
                 )
 
-                team = Swarm([agent1, agent2])
+                termination = MaxMessageTermination(3)
+                team = Swarm([agent1, agent2], termination_condition=termination)
 
-                stream = team.run_stream("What is bob's birthday?", termination_condition=MaxMessageTermination(3))
+                stream = team.run_stream("What is bob's birthday?")
                 async for message in stream:
                     print(message)
 
@@ -91,8 +94,12 @@ async def main() -> None:
             asyncio.run(main())
     """
 
-    def __init__(self, participants: List[ChatAgent]):
-        super().__init__(participants, group_chat_manager_class=SwarmGroupChatManager)
+    def __init__(
+        self, participants: List[ChatAgent], termination_condition: TerminationCondition | None = None
+    ) -> None:
+        super().__init__(
+            participants, group_chat_manager_class=SwarmGroupChatManager, termination_condition=termination_condition
+        )
         # The first participant must be able to produce handoff messages.
         first_participant = self._participants[0]
         if HandoffMessage not in first_participant.produced_message_types:
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 0fc39453d7ea..4922ceed9143 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -148,10 +148,12 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         coding_assistant_agent = AssistantAgent(
             "coding_assistant", model_client=OpenAIChatCompletionClient(model=model, api_key="")
         )
-        team = RoundRobinGroupChat(participants=[coding_assistant_agent, code_executor_agent])
+        termination = TextMentionTermination("TERMINATE")
+        team = RoundRobinGroupChat(
+            participants=[coding_assistant_agent, code_executor_agent], termination_condition=termination
+        )
         result = await team.run(
             "Write a program that prints 'Hello, world!'",
-            termination_condition=TextMentionTermination("TERMINATE"),
         )
         expected_messages = [
             "Write a program that prints 'Hello, world!'",
@@ -171,8 +173,9 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         # Test streaming.
         mock.reset()
         index = 0
+        await termination.reset()
         async for message in team.run_stream(
-            "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
+            "Write a program that prints 'Hello, world!'",
         ):
             if isinstance(message, TaskResult):
                 assert message == result
@@ -244,10 +247,10 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
         tools=[tool],
     )
     echo_agent = _EchoAgent("echo_agent", description="echo agent")
-    team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent])
+    termination = TextMentionTermination("TERMINATE")
+    team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent], termination_condition=termination)
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=TextMentionTermination("TERMINATE"),
     )
 
     assert len(result.messages) == 6
@@ -274,8 +277,9 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     tool_use_agent._model_context.clear()  # pyright: ignore
     mock.reset()
     index = 0
+    await termination.reset()
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
+        "Write a program that prints 'Hello, world!'",
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -345,13 +349,14 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     agent1 = _StopAgent("agent1", description="echo agent 1", stop_at=2)
     agent2 = _EchoAgent("agent2", description="echo agent 2")
     agent3 = _EchoAgent("agent3", description="echo agent 3")
+    termination = TextMentionTermination("TERMINATE")
     team = SelectorGroupChat(
         participants=[agent1, agent2, agent3],
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        termination_condition=termination,
     )
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=TextMentionTermination("TERMINATE"),
     )
     assert len(result.messages) == 6
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -365,8 +370,9 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     mock.reset()
     agent1._count = 0  # pyright: ignore
     index = 0
+    await termination.reset()
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
+        "Write a program that prints 'Hello, world!'",
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -395,13 +401,14 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
 
     agent1 = _StopAgent("agent1", description="echo agent 1", stop_at=2)
     agent2 = _EchoAgent("agent2", description="echo agent 2")
+    termination = TextMentionTermination("TERMINATE")
     team = SelectorGroupChat(
         participants=[agent1, agent2],
+        termination_condition=termination,
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
     )
     result = await team.run(
         "Write a program that prints 'Hello, world!'",
-        termination_condition=TextMentionTermination("TERMINATE"),
     )
     assert len(result.messages) == 5
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -416,9 +423,8 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     mock.reset()
     agent1._count = 0  # pyright: ignore
     index = 0
-    async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
-    ):
+    await termination.reset()
+    async for message in team.run_stream("Write a program that prints 'Hello, world!'"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
@@ -466,14 +472,14 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
 
     agent1 = _StopAgent("agent1", description="echo agent 1", stop_at=1)
     agent2 = _EchoAgent("agent2", description="echo agent 2")
+    termination = TextMentionTermination("TERMINATE")
     team = SelectorGroupChat(
         participants=[agent1, agent2],
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
+        termination_condition=termination,
         allow_repeated_speaker=True,
     )
-    result = await team.run(
-        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
-    )
+    result = await team.run("Write a program that prints 'Hello, world!'")
     assert len(result.messages) == 4
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
     assert result.messages[1].source == "agent2"
@@ -483,9 +489,8 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     # Test streaming.
     mock.reset()
     index = 0
-    async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'", termination_condition=TextMentionTermination("TERMINATE")
-    ):
+    await termination.reset()
+    async for message in team.run_stream("Write a program that prints 'Hello, world!'"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
@@ -527,12 +532,14 @@ def _select_agent(messages: Sequence[ChatMessage]) -> str | None:
         else:
             return "agent1"
 
+    termination = MaxMessageTermination(6)
     team = SelectorGroupChat(
         participants=[agent1, agent2, agent3, agent4],
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
         selector_func=_select_agent,
+        termination_condition=termination,
     )
-    result = await team.run("task", termination_condition=MaxMessageTermination(6))
+    result = await team.run("task")
     assert len(result.messages) == 6
     assert result.messages[1].source == "agent1"
     assert result.messages[2].source == "agent2"
@@ -564,8 +571,9 @@ async def test_swarm_handoff() -> None:
     second_agent = _HandOffAgent("second_agent", description="second agent", next_agent="third_agent")
     third_agent = _HandOffAgent("third_agent", description="third agent", next_agent="first_agent")
 
-    team = Swarm([second_agent, first_agent, third_agent])
-    result = await team.run("task", termination_condition=MaxMessageTermination(6))
+    termination = MaxMessageTermination(6)
+    team = Swarm([second_agent, first_agent, third_agent], termination_condition=termination)
+    result = await team.run("task")
     assert len(result.messages) == 6
     assert result.messages[0].content == "task"
     assert result.messages[1].content == "Transferred to third_agent."
@@ -576,7 +584,8 @@ async def test_swarm_handoff() -> None:
 
     # Test streaming.
     index = 0
-    stream = team.run_stream("task", termination_condition=MaxMessageTermination(6))
+    await termination.reset()
+    stream = team.run_stream("task")
     async for message in stream:
         if isinstance(message, TaskResult):
             assert message == result
@@ -648,8 +657,9 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
         handoffs=[Handoff(target="agent2", name="handoff_to_agent2", message="handoff to agent2")],
     )
     agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
-    team = Swarm([agent1, agent2])
-    result = await team.run("task", termination_condition=TextMentionTermination("TERMINATE"))
+    termination = TextMentionTermination("TERMINATE")
+    team = Swarm([agent1, agent2], termination_condition=termination)
+    result = await team.run("task")
     assert len(result.messages) == 7
     assert result.messages[0].content == "task"
     assert isinstance(result.messages[1], ToolCallMessage)
@@ -663,7 +673,8 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     agent1._model_context.clear()  # pyright: ignore
     mock.reset()
     index = 0
-    stream = team.run_stream("task", termination_condition=TextMentionTermination("TERMINATE"))
+    await termination.reset()
+    stream = team.run_stream("task")
     async for message in stream:
         if isinstance(message, TaskResult):
             assert message == result
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
index 2e87fe4c402b..ce5844f4dec1 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
@@ -260,7 +260,8 @@
     "    system_message=\"You are a helpful assistant that can generate a comprehensive report on a given topic based on search and stock analysis. When you done with generating the report, reply with TERMINATE.\",\n",
     ")\n",
     "\n",
-    "team = RoundRobinGroupChat([search_agent, stock_analysis_agent, report_agent])"
+    "termination = TextMentionTermination(\"TERMINATE\")\n",
+    "team = RoundRobinGroupChat([search_agent, stock_analysis_agent, report_agent], termination_condition=termination)"
    ]
   },
   {
@@ -400,9 +401,7 @@
     }
    ],
    "source": [
-    "result = await team.run(\n",
-    "    \"Write a financial report on American airlines\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
-    ")\n",
+    "result = await team.run(\"Write a financial report on American airlines\")\n",
     "print(result)"
    ]
   }
@@ -423,7 +422,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
index 84f14c74476f..cefb6e6f49ce 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
@@ -328,11 +328,13 @@
     "    system_message=\"You are a helpful assistant. Your task is to synthesize data extracted into a high quality literature review including CORRECT references. You MUST write a final report that is formatted as a literature review with CORRECT references.  Your response should end with the word 'TERMINATE'\",\n",
     ")\n",
     "\n",
-    "team = RoundRobinGroupChat(participants=[google_search_agent, arxiv_search_agent, report_agent])\n",
+    "termination = TextMentionTermination(\"TERMINATE\")\n",
+    "team = RoundRobinGroupChat(\n",
+    "    participants=[google_search_agent, arxiv_search_agent, report_agent], termination_condition=termination\n",
+    ")\n",
     "\n",
     "result = await team.run(\n",
     "    task=\"Write a literature review on no code tools for building multi agent ai systems\",\n",
-    "    termination_condition=TextMentionTermination(\"TERMINATE\"),\n",
     ")"
    ]
   }
@@ -353,7 +355,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
index d78f433fae3e..fbcce8f53ad4 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/travel-planning.ipynb
@@ -194,10 +194,11 @@
     }
    ],
    "source": [
-    "group_chat = RoundRobinGroupChat([planner_agent, local_agent, language_agent, travel_summary_agent])\n",
-    "result = await group_chat.run(\n",
-    "    task=\"Plan a 3 day trip to Nepal.\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
+    "termination = TextMentionTermination(\"TERMINATE\")\n",
+    "group_chat = RoundRobinGroupChat(\n",
+    "    [planner_agent, local_agent, language_agent, travel_summary_agent], termination_condition=termination\n",
     ")\n",
+    "result = await group_chat.run(task=\"Plan a 3 day trip to Nepal.\")\n",
     "print(result)"
    ]
   }
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 3c37aee209ef..684dcb838a7c 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -81,12 +81,10 @@
     ")\n",
     "\n",
     "# add the agent to a team\n",
-    "agent_team = RoundRobinGroupChat([weather_agent])\n",
+    "termination = MaxMessageTermination(max_messages=2)\n",
+    "agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)\n",
     "# Note: if running in a Python file directly you'll need to use asyncio.run(agent_team.run(...)) instead of await agent_team.run(...)\n",
-    "result = await agent_team.run(\n",
-    "    task=\"What is the weather in New York?\",\n",
-    "    termination_condition=MaxMessageTermination(max_messages=2),\n",
-    ")\n",
+    "result = await agent_team.run(task=\"What is the weather in New York?\")\n",
     "print(\"\\n\", result)"
    ]
   },
@@ -110,7 +108,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "agnext",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -124,7 +122,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index e15e4ce81e90..bcf8c6afc5ee 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -251,10 +251,14 @@
     "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
     "    system_message=\"You are a travel assistant.\",\n",
     ")\n",
+    "\n",
+    "termination = TextMentionTermination(\"TERMINATE\")\n",
     "team = SelectorGroupChat(\n",
-    "    [user_proxy, flight_broker, travel_assistant], model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\")\n",
+    "    [user_proxy, flight_broker, travel_assistant],\n",
+    "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
+    "    termination_condition=termination,\n",
     ")\n",
-    "await team.run(\"Help user plan a trip and book a flight.\", termination_condition=TextMentionTermination(\"TERMINATE\"))"
+    "await team.run(\"Help user plan a trip and book a flight.\")"
    ]
   }
  ],
@@ -274,7 +278,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
index acc3d239b390..b85f1223cb04 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -103,10 +103,9 @@
     }
    ],
    "source": [
-    "round_robin_team = RoundRobinGroupChat([tool_use_agent, writing_assistant_agent])\n",
-    "round_robin_team_result = await round_robin_team.run(\n",
-    "    \"Write a Haiku about the weather in Paris\", termination_condition=MaxMessageTermination(max_messages=1)\n",
-    ")"
+    "termination = MaxMessageTermination(max_messages=1)\n",
+    "round_robin_team = RoundRobinGroupChat([tool_use_agent, writing_assistant_agent], termination_condition=termination)\n",
+    "round_robin_team_result = await round_robin_team.run(\"Write a Haiku about the weather in Paris\")"
    ]
   },
   {
@@ -173,12 +172,12 @@
     }
    ],
    "source": [
-    "llm_team = SelectorGroupChat([tool_use_agent, writing_assistant_agent], model_client=model_client)\n",
+    "termination = MaxMessageTermination(max_messages=2)\n",
+    "llm_team = SelectorGroupChat(\n",
+    "    [tool_use_agent, writing_assistant_agent], model_client=model_client, termination_condition=termination\n",
+    ")\n",
     "\n",
-    "llm_team_result = await llm_team.run(\n",
-    "    \"What is the weather in paris right now? Also write a haiku about it.\",\n",
-    "    termination_condition=MaxMessageTermination(max_messages=2),\n",
-    ")"
+    "llm_team_result = await llm_team.run(\"What is the weather in paris right now? Also write a haiku about it.\")"
    ]
   },
   {
@@ -209,7 +208,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
index f3a1ad1ea050..301ce6663426 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -56,9 +56,7 @@
     "    name=\"writing_assistant_agent\",\n",
     "    system_message=\"You are a helpful assistant that solve tasks by generating text responses and code.\",\n",
     "    model_client=model_client,\n",
-    ")\n",
-    "\n",
-    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])"
+    ")"
    ]
   },
   {
@@ -110,10 +108,9 @@
     }
    ],
    "source": [
-    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])\n",
-    "round_robin_team_result = await round_robin_team.run(\n",
-    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=MaxMessageTermination(max_messages=3)\n",
-    ")"
+    "max_msg_termination = MaxMessageTermination(max_messages=3)\n",
+    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent], termination_condition=max_msg_termination)\n",
+    "round_robin_team_result = await round_robin_team.run(\"Write a unique, Haiku about the weather in Paris\")"
    ]
   },
   {
@@ -174,12 +171,10 @@
     "    model_client=model_client,\n",
     ")\n",
     "\n",
+    "text_termination = TextMentionTermination(\"TERMINATE\")\n",
+    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent], termination_condition=text_termination)\n",
     "\n",
-    "round_robin_team = RoundRobinGroupChat([writing_assistant_agent])\n",
-    "\n",
-    "round_robin_team_result = await round_robin_team.run(\n",
-    "    \"Write a unique, Haiku about the weather in Paris\", termination_condition=TextMentionTermination(\"TERMINATE\")\n",
-    ")"
+    "round_robin_team_result = await round_robin_team.run(\"Write a unique, Haiku about the weather in Paris\")"
    ]
   }
  ],
@@ -199,7 +194,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

From 4e5f3ababea1997ea6a94021ce3bfd8aa7d60938 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 1 Nov 2024 16:08:09 -0700
Subject: [PATCH 067/173] Update version to 0.4.0.dev3 (#4043)

---
 .github/workflows/docs.yml                    |  1 +
 README.md                                     | 24 ++++++++-----------
 docs/switcher.json                            |  7 +++++-
 .../packages/autogen-agentchat/pyproject.toml |  4 ++--
 .../packages/autogen-core/docs/src/index.md   |  4 ++--
 .../autogen-core/docs/src/packages/index.md   | 12 +++++-----
 .../agentchat-user-guide/installation.md      |  2 +-
 python/packages/autogen-core/pyproject.toml   |  2 +-
 python/packages/autogen-ext/pyproject.toml    |  4 ++--
 python/uv.lock                                |  6 ++---
 10 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index d2219e6c7ed2..4e469df1730d 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -35,6 +35,7 @@ jobs:
             { ref: "v0.4.0.dev0", dest-dir: "0.4.0.dev0" },
             { ref: "v0.4.0.dev1", dest-dir: "0.4.0.dev1" },
             { ref: "v0.4.0.dev2", dest-dir: "0.4.0.dev2" },
+            { ref: "v0.4.0.dev3", dest-dir: "0.4.0.dev3" },
           ]
     steps:
       - name: Checkout
diff --git a/README.md b/README.md
index 43bdd263d310..049612da46be 100644
--- a/README.md
+++ b/README.md
@@ -101,7 +101,7 @@ We look forward to your contributions!
 First install the packages:
 
 ```bash
-pip install autogen-agentchat==0.4.0.dev2 autogen-ext==0.4.0.dev2
+pip install 'autogen-agentchat==0.4.0.dev3' 'autogen-ext[docker]==0.4.0.dev3'
 ```
 
 The following code uses code execution, you need to have [Docker installed](https://docs.docker.com/engine/install/)
@@ -109,17 +109,11 @@ and running on your machine.
 
 ```python
 import asyncio
-import logging
-from autogen_agentchat import EVENT_LOGGER_NAME
-from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
-from autogen_agentchat.logging import ConsoleLogHandler
-from autogen_agentchat.teams import RoundRobinGroupChat, StopMessageTermination
 from autogen_ext.code_executor.docker_executor import DockerCommandLineCodeExecutor
 from autogen_ext.models import OpenAIChatCompletionClient
-
-logger = logging.getLogger(EVENT_LOGGER_NAME)
-logger.addHandler(ConsoleLogHandler())
-logger.setLevel(logging.INFO)
+from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
+from autogen_agentchat.teams import RoundRobinGroupChat
+from autogen_agentchat.task import TextMentionTermination
 
 async def main() -> None:
     async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor:
@@ -127,11 +121,13 @@ async def main() -> None:
         coding_assistant_agent = CodingAssistantAgent(
             "coding_assistant", model_client=OpenAIChatCompletionClient(model="gpt-4o", api_key="YOUR_API_KEY")
         )
-        group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent])
-        result = await group_chat.run(
-            task="Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'.",
-            termination_condition=StopMessageTermination(),
+        termination = TextMentionTermination("TERMINATE")
+        group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent], termination_condition=termination)
+        stream = group_chat.run_stream(
+            "Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
         )
+        async for message in stream:
+            print(message)
 
 asyncio.run(main())
 ```
diff --git a/docs/switcher.json b/docs/switcher.json
index 364394a4f3f7..8bde73629168 100644
--- a/docs/switcher.json
+++ b/docs/switcher.json
@@ -21,7 +21,12 @@
     {
         "name": "0.4.0.dev2",
         "version": "0.4.0.dev2",
-        "url": "/autogen/0.4.0.dev2/",
+        "url": "/autogen/0.4.0.dev2/"
+    },
+    {
+        "name": "0.4.0.dev3",
+        "version": "0.4.0.dev3",
+        "url": "/autogen/0.4.0.dev3/",
         "preferred": true
     }
 ]
diff --git a/python/packages/autogen-agentchat/pyproject.toml b/python/packages/autogen-agentchat/pyproject.toml
index 48874b9de662..755959b5abf8 100644
--- a/python/packages/autogen-agentchat/pyproject.toml
+++ b/python/packages/autogen-agentchat/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-agentchat"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen agents and teams library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0.dev2",
+    "autogen-core==0.4.0.dev3",
 ]
 
 [tool.uv]
diff --git a/python/packages/autogen-core/docs/src/index.md b/python/packages/autogen-core/docs/src/index.md
index 4910721f53ab..21a6fa35a922 100644
--- a/python/packages/autogen-core/docs/src/index.md
+++ b/python/packages/autogen-core/docs/src/index.md
@@ -61,7 +61,7 @@ AgentChat 
 High-level API that includes preset agents and teams for building multi-agent systems.
 
 ```sh
-pip install autogen-agentchat==0.4.0.dev2
+pip install autogen-agentchat==0.4.0.dev3
 ```
 
 💡 *Start here if you are looking for an API similar to AutoGen 0.2*
@@ -82,7 +82,7 @@ Get Started
 Provides building blocks for creating asynchronous, event driven multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0.dev2
+pip install autogen-core==0.4.0.dev3
 ```
 
 +++
diff --git a/python/packages/autogen-core/docs/src/packages/index.md b/python/packages/autogen-core/docs/src/packages/index.md
index f471d4e48a3a..7dd616108414 100644
--- a/python/packages/autogen-core/docs/src/packages/index.md
+++ b/python/packages/autogen-core/docs/src/packages/index.md
@@ -29,10 +29,10 @@ myst:
 Library that is at a similar level of abstraction as AutoGen 0.2, including default agents and group chat.
 
 ```sh
-pip install autogen-agentchat==0.4.0.dev2
+pip install autogen-agentchat==0.4.0.dev3
 ```
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
 :::
 
 (pkg-info-autogen-core)=
@@ -44,10 +44,10 @@ pip install autogen-agentchat==0.4.0.dev2
 Implements the core functionality of the AutoGen framework, providing basic building blocks for creating multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0.dev2
+pip install autogen-core==0.4.0.dev3
 ```
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
 :::
 
 (pkg-info-autogen-ext)=
@@ -59,7 +59,7 @@ pip install autogen-core==0.4.0.dev2
 Implementations of core components that interface with external services, or use extra dependencies. For example, Docker based code execution.
 
 ```sh
-pip install autogen-ext==0.4.0.dev2
+pip install autogen-ext==0.4.0.dev3
 ```
 
 Extras:
@@ -69,7 +69,7 @@ Extras:
 - `docker` needed for {py:class}`~autogen_ext.code_executors.DockerCommandLineCodeExecutor`
 - `openai` needed for {py:class}`~autogen_ext.models.OpenAIChatCompletionClient`
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev2/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
 :::
 
 (pkg-info-autogen-magentic-one)=
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
index 528710a54e4f..0b005a2b3a38 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
@@ -61,7 +61,7 @@ Install the `autogen-agentchat` package using pip:
 
 ```bash
 
-pip install autogen-agentchat==0.4.0.dev2
+pip install autogen-agentchat==0.4.0.dev3
 ```
 
 ## Install Docker for Code Execution
diff --git a/python/packages/autogen-core/pyproject.toml b/python/packages/autogen-core/pyproject.toml
index ea2a1b545e08..bc0b614cff06 100644
--- a/python/packages/autogen-core/pyproject.toml
+++ b/python/packages/autogen-core/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-core"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 license = {file = "LICENSE-CODE"}
 description = "Foundational interfaces and agent runtime implementation for AutoGen"
 readme = "README.md"
diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index f13843aabcf7..9740f3d20889 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-ext"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen extensions library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0.dev2",
+    "autogen-core==0.4.0.dev3",
 ]
 
 
diff --git a/python/uv.lock b/python/uv.lock
index d1c9d588c3eb..facd0b402efe 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -360,7 +360,7 @@ wheels = [
 
 [[package]]
 name = "autogen-agentchat"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 source = { editable = "packages/autogen-agentchat" }
 dependencies = [
     { name = "autogen-core" },
@@ -371,7 +371,7 @@ requires-dist = [{ name = "autogen-core", editable = "packages/autogen-core" }]
 
 [[package]]
 name = "autogen-core"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 source = { editable = "packages/autogen-core" }
 dependencies = [
     { name = "aiohttp" },
@@ -484,7 +484,7 @@ dev = [
 
 [[package]]
 name = "autogen-ext"
-version = "0.4.0.dev2"
+version = "0.4.0.dev3"
 source = { editable = "packages/autogen-ext" }
 dependencies = [
     { name = "autogen-core" },

From 5e0b677acc10bbbf4fab889bbcc0c70f3f13abb8 Mon Sep 17 00:00:00 2001
From: Xiaoyun Zhang 
Date: Sun, 3 Nov 2024 09:18:32 -0800
Subject: [PATCH 068/173] [.NET] Create tools from M.E.A.I AIFunctionFactory
 (#4041)

* add MEAI tool support

* fix format

* update

---------

Co-authored-by: Ryan Sweet 
---
 dotnet/AutoGen.sln                            |  9 +-
 dotnet/Directory.Build.props                  |  4 -
 .../AutoGen.BasicSample.csproj                |  1 +
 .../Example03_Agent_FunctionCall.cs           | 68 ++++++++++++++-
 .../samples/AutoGen.BasicSamples/Program.cs   |  3 +-
 dotnet/src/AutoGen.Core/AutoGen.Core.csproj   |  1 +
 .../Function/FunctionAttribute.cs             | 67 +++++++++++++++
 .../Middleware/FunctionCallMiddleware.cs      | 31 +++++++
 .../test/AutoGen.Tests/AutoGen.Tests.csproj   |  2 +
 dotnet/test/AutoGen.Tests/BasicSampleTest.cs  |  3 +-
 ...ionFromAIFunctionFactoryAsync.approved.txt | 76 +++++++++++++++++
 .../AutoGen.Tests/Function/FunctionTests.cs   | 82 +++++++++++++++++++
 dotnet/test/AutoGen.Tests/MiddlewareTest.cs   | 25 ++++--
 .../Create-type-safe-function-call.md         |  2 +-
 14 files changed, 356 insertions(+), 18 deletions(-)
 create mode 100644 dotnet/test/AutoGen.Tests/Function/ApprovalTests/FunctionTests.CreateGetWeatherFunctionFromAIFunctionFactoryAsync.approved.txt
 create mode 100644 dotnet/test/AutoGen.Tests/Function/FunctionTests.cs

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 291cb484649d..4f82713b5adb 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -68,6 +68,13 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{243E768F-EA7D-4AF1-B625-0398440BB1AB}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
+		.gitattributes = .gitattributes
+		.gitignore = .gitignore
+		Directory.Build.props = Directory.Build.props
+		Directory.Build.targets = Directory.Build.targets
+		Directory.Packages.props = Directory.Packages.props
+		global.json = global.json
+		NuGet.config = NuGet.config
 		spelling.dic = spelling.dic
 	EndProjectSection
 EndProject
@@ -123,7 +130,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HelloAgent", "samples\Hello
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AIModelClientHostingExtensions", "src\Microsoft.AutoGen\Extensions\AIModelClientHostingExtensions\AIModelClientHostingExtensions.csproj", "{97550E87-48C6-4EBF-85E1-413ABAE9DBFD}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AutoGen.Agents.Tests", "Microsoft.AutoGen.Agents.Tests\Microsoft.AutoGen.Agents.Tests.csproj", "{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Agents.Tests", "Microsoft.AutoGen.Agents.Tests\Microsoft.AutoGen.Agents.Tests.csproj", "{CF4C92BD-28AE-4B8F-B173-601004AEC9BF}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sample", "sample", "{686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}"
 EndProject
diff --git a/dotnet/Directory.Build.props b/dotnet/Directory.Build.props
index bb78c84d14f4..ae30d2c48a5e 100644
--- a/dotnet/Directory.Build.props
+++ b/dotnet/Directory.Build.props
@@ -32,10 +32,6 @@
     $(NoWarn);CA1829
   
 
-  
-    
-  
-
   
     
     
diff --git a/dotnet/samples/AutoGen.BasicSamples/AutoGen.BasicSample.csproj b/dotnet/samples/AutoGen.BasicSamples/AutoGen.BasicSample.csproj
index 460c95f3743a..9e510ffa2f1a 100644
--- a/dotnet/samples/AutoGen.BasicSamples/AutoGen.BasicSample.csproj
+++ b/dotnet/samples/AutoGen.BasicSamples/AutoGen.BasicSample.csproj
@@ -15,5 +15,6 @@
     
     
     
+    
   
 
diff --git a/dotnet/samples/AutoGen.BasicSamples/Example03_Agent_FunctionCall.cs b/dotnet/samples/AutoGen.BasicSamples/Example03_Agent_FunctionCall.cs
index ca05a42ca367..c1087080350d 100644
--- a/dotnet/samples/AutoGen.BasicSamples/Example03_Agent_FunctionCall.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/Example03_Agent_FunctionCall.cs
@@ -6,6 +6,7 @@
 using AutoGen.OpenAI;
 using AutoGen.OpenAI.Extension;
 using FluentAssertions;
+using Microsoft.Extensions.AI;
 
 /// 
 /// This example shows how to add type-safe function call to an agent.
@@ -37,13 +38,20 @@ public async Task ConcatString(string[] strings)
     /// 
     /// price, should be an integer
     /// tax rate, should be in range (0, 1)
-    [FunctionAttribute]
+    [Function]
     public async Task CalculateTax(int price, float taxRate)
     {
         return $"tax is {price * taxRate}";
     }
 
-    public static async Task RunAsync()
+    /// 
+    /// This example shows how to add type-safe function call using AutoGen.SourceGenerator.
+    /// The SourceGenerator will automatically generate FunctionDefinition and FunctionCallWrapper during compiling time.
+    ///
+    /// For adding type-safe function call from M.E.A.I tools, please refer to .
+    /// 
+    /// 
+    public static async Task ToolCallWithSourceGenerator()
     {
         var instance = new Example03_Agent_FunctionCall();
         var gpt4o = LLMConfiguration.GetOpenAIGPT4o_mini();
@@ -101,4 +109,60 @@ public static async Task RunAsync()
         // send aggregate message back to llm to get the final result
         var finalResult = await agent.SendAsync(calculateTaxes);
     }
+
+    /// 
+    /// This example shows how to add type-safe function call from M.E.A.I tools.
+    ///
+    /// For adding type-safe function call from source generator, please refer to .
+    /// 
+    public static async Task ToolCallWithMEAITools()
+    {
+        var gpt4o = LLMConfiguration.GetOpenAIGPT4o_mini();
+        var instance = new Example03_Agent_FunctionCall();
+
+        AIFunction[] tools = [
+            AIFunctionFactory.Create(instance.UpperCase),
+            AIFunctionFactory.Create(instance.ConcatString),
+            AIFunctionFactory.Create(instance.CalculateTax),
+        ];
+
+        var toolCallMiddleware = new FunctionCallMiddleware(tools);
+
+        var agent = new OpenAIChatAgent(
+            chatClient: gpt4o,
+            name: "agent",
+            systemMessage: "You are a helpful AI assistant")
+            .RegisterMessageConnector()
+            .RegisterStreamingMiddleware(toolCallMiddleware)
+            .RegisterPrintMessage();
+
+        // talk to the assistant agent
+        var upperCase = await agent.SendAsync("convert to upper case: hello world");
+        upperCase.GetContent()?.Should().Be("HELLO WORLD");
+        upperCase.Should().BeOfType();
+        upperCase.GetToolCalls().Should().HaveCount(1);
+        upperCase.GetToolCalls().First().FunctionName.Should().Be(nameof(UpperCase));
+
+        var concatString = await agent.SendAsync("concatenate strings: a, b, c, d, e");
+        concatString.GetContent()?.Should().Be("a b c d e");
+        concatString.Should().BeOfType();
+        concatString.GetToolCalls().Should().HaveCount(1);
+        concatString.GetToolCalls().First().FunctionName.Should().Be(nameof(ConcatString));
+
+        var calculateTax = await agent.SendAsync("calculate tax: 100, 0.1");
+        calculateTax.GetContent().Should().Be("tax is 10");
+        calculateTax.Should().BeOfType();
+        calculateTax.GetToolCalls().Should().HaveCount(1);
+        calculateTax.GetToolCalls().First().FunctionName.Should().Be(nameof(CalculateTax));
+
+        // parallel function calls
+        var calculateTaxes = await agent.SendAsync("calculate tax: 100, 0.1; calculate tax: 200, 0.2");
+        calculateTaxes.GetContent().Should().Be("tax is 10\ntax is 40"); // "tax is 10\n tax is 40
+        calculateTaxes.Should().BeOfType();
+        calculateTaxes.GetToolCalls().Should().HaveCount(2);
+        calculateTaxes.GetToolCalls().First().FunctionName.Should().Be(nameof(CalculateTax));
+
+        // send aggregate message back to llm to get the final result
+        var finalResult = await agent.SendAsync(calculateTaxes);
+    }
 }
diff --git a/dotnet/samples/AutoGen.BasicSamples/Program.cs b/dotnet/samples/AutoGen.BasicSamples/Program.cs
index 3a2edbb585f4..16a79e75cffe 100644
--- a/dotnet/samples/AutoGen.BasicSamples/Program.cs
+++ b/dotnet/samples/AutoGen.BasicSamples/Program.cs
@@ -11,7 +11,8 @@
     // When a new sample is created please add them to the allSamples collection
     ("Assistant Agent", Example01_AssistantAgent.RunAsync),
     ("Two-agent Math Chat", Example02_TwoAgent_MathChat.RunAsync),
-    ("Agent Function Call", Example03_Agent_FunctionCall.RunAsync),
+    ("Agent Function Call With Source Generator", Example03_Agent_FunctionCall.ToolCallWithSourceGenerator),
+    ("Agent Function Call With M.E.A.I AI Functions", Example03_Agent_FunctionCall.ToolCallWithMEAITools),
     ("Dynamic Group Chat Coding Task", Example04_Dynamic_GroupChat_Coding_Task.RunAsync),
     ("DALL-E and GPT4v", Example05_Dalle_And_GPT4V.RunAsync),
     ("User Proxy Agent", Example06_UserProxyAgent.RunAsync),
diff --git a/dotnet/src/AutoGen.Core/AutoGen.Core.csproj b/dotnet/src/AutoGen.Core/AutoGen.Core.csproj
index c34c03af2b51..f46d48dc844f 100644
--- a/dotnet/src/AutoGen.Core/AutoGen.Core.csproj
+++ b/dotnet/src/AutoGen.Core/AutoGen.Core.csproj
@@ -17,6 +17,7 @@
   
     
     
+    
   
   
   
diff --git a/dotnet/src/AutoGen.Core/Function/FunctionAttribute.cs b/dotnet/src/AutoGen.Core/Function/FunctionAttribute.cs
index bb37f1cb25de..9418dc7fd6ae 100644
--- a/dotnet/src/AutoGen.Core/Function/FunctionAttribute.cs
+++ b/dotnet/src/AutoGen.Core/Function/FunctionAttribute.cs
@@ -3,6 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.AI;
 
 namespace AutoGen.Core;
 
@@ -22,6 +25,10 @@ public FunctionAttribute(string? functionName = null, string? description = null
 
 public class FunctionContract
 {
+    private const string NamespaceKey = nameof(Namespace);
+
+    private const string ClassNameKey = nameof(ClassName);
+
     /// 
     /// The namespace of the function.
     /// 
@@ -52,6 +59,7 @@ public class FunctionContract
     /// 
     /// The return type of the function.
     /// 
+    [JsonIgnore]
     public Type? ReturnType { get; set; }
 
     /// 
@@ -60,6 +68,39 @@ public class FunctionContract
     /// Otherwise, the description will be null.
     /// 
     public string? ReturnDescription { get; set; }
+
+    public static implicit operator FunctionContract(AIFunctionMetadata metadata)
+    {
+        return new FunctionContract
+        {
+            Namespace = metadata.AdditionalProperties.ContainsKey(NamespaceKey) ? metadata.AdditionalProperties[NamespaceKey] as string : null,
+            ClassName = metadata.AdditionalProperties.ContainsKey(ClassNameKey) ? metadata.AdditionalProperties[ClassNameKey] as string : null,
+            Name = metadata.Name,
+            Description = metadata.Description,
+            Parameters = metadata.Parameters?.Select(p => (FunctionParameterContract)p).ToList(),
+            ReturnType = metadata.ReturnParameter.ParameterType,
+            ReturnDescription = metadata.ReturnParameter.Description,
+        };
+    }
+
+    public static implicit operator AIFunctionMetadata(FunctionContract contract)
+    {
+        return new AIFunctionMetadata(contract.Name)
+        {
+            Description = contract.Description,
+            ReturnParameter = new AIFunctionReturnParameterMetadata()
+            {
+                Description = contract.ReturnDescription,
+                ParameterType = contract.ReturnType,
+            },
+            AdditionalProperties = new Dictionary
+            {
+                [NamespaceKey] = contract.Namespace,
+                [ClassNameKey] = contract.ClassName,
+            },
+            Parameters = [.. contract.Parameters?.Select(p => (AIFunctionParameterMetadata)p)],
+        };
+    }
 }
 
 public class FunctionParameterContract
@@ -79,6 +120,7 @@ public class FunctionParameterContract
     /// 
     /// The type of the parameter.
     /// 
+    [JsonIgnore]
     public Type? ParameterType { get; set; }
 
     /// 
@@ -90,4 +132,29 @@ public class FunctionParameterContract
     /// The default value of the parameter.
     /// 
     public object? DefaultValue { get; set; }
+
+    // convert to/from FunctionParameterMetadata
+    public static implicit operator FunctionParameterContract(AIFunctionParameterMetadata metadata)
+    {
+        return new FunctionParameterContract
+        {
+            Name = metadata.Name,
+            Description = metadata.Description,
+            ParameterType = metadata.ParameterType,
+            IsRequired = metadata.IsRequired,
+            DefaultValue = metadata.DefaultValue,
+        };
+    }
+
+    public static implicit operator AIFunctionParameterMetadata(FunctionParameterContract contract)
+    {
+        return new AIFunctionParameterMetadata(contract.Name!)
+        {
+            DefaultValue = contract.DefaultValue,
+            Description = contract.Description,
+            IsRequired = contract.IsRequired,
+            ParameterType = contract.ParameterType,
+            HasDefaultValue = contract.DefaultValue != null,
+        };
+    }
 }
diff --git a/dotnet/src/AutoGen.Core/Middleware/FunctionCallMiddleware.cs b/dotnet/src/AutoGen.Core/Middleware/FunctionCallMiddleware.cs
index 21461834dc83..266155316c81 100644
--- a/dotnet/src/AutoGen.Core/Middleware/FunctionCallMiddleware.cs
+++ b/dotnet/src/AutoGen.Core/Middleware/FunctionCallMiddleware.cs
@@ -5,8 +5,10 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
 
 namespace AutoGen.Core;
 
@@ -43,6 +45,19 @@ public FunctionCallMiddleware(
         this.functionMap = functionMap;
     }
 
+    /// 
+    /// Create a new instance of  with a list of .
+    /// 
+    /// function list
+    /// optional middleware name. If not provided, the class name  will be used.
+    public FunctionCallMiddleware(IEnumerable functions, string? name = null)
+    {
+        this.Name = name ?? nameof(FunctionCallMiddleware);
+        this.functions = functions.Select(f => (FunctionContract)f.Metadata).ToArray();
+
+        this.functionMap = functions.Select(f => (f.Metadata.Name, this.AIToolInvokeWrapper(f.InvokeAsync))).ToDictionary(f => f.Name, f => f.Item2);
+    }
+
     public string? Name { get; }
 
     public async Task InvokeAsync(MiddlewareContext context, IAgent agent, CancellationToken cancellationToken = default)
@@ -173,4 +188,20 @@ private async Task InvokeToolCallMessagesAfterInvokingAgentAsync(ToolC
             return toolCallMsg;
         }
     }
+
+    private Func> AIToolInvokeWrapper(Func>?, CancellationToken, Task> lambda)
+    {
+        return async (string args) =>
+        {
+            var arguments = JsonSerializer.Deserialize>(args);
+            var result = await lambda(arguments, CancellationToken.None);
+
+            return result switch
+            {
+                string s => s,
+                JsonElement e => e.ToString(),
+                _ => JsonSerializer.Serialize(result),
+            };
+        };
+    }
 }
diff --git a/dotnet/test/AutoGen.Tests/AutoGen.Tests.csproj b/dotnet/test/AutoGen.Tests/AutoGen.Tests.csproj
index 12c31e1a473c..248a9e29b00d 100644
--- a/dotnet/test/AutoGen.Tests/AutoGen.Tests.csproj
+++ b/dotnet/test/AutoGen.Tests/AutoGen.Tests.csproj
@@ -13,6 +13,8 @@
     
     
     
+    
+    
   
 
   
diff --git a/dotnet/test/AutoGen.Tests/BasicSampleTest.cs b/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
index df02bb3dcd0f..5cf4704037fc 100644
--- a/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
+++ b/dotnet/test/AutoGen.Tests/BasicSampleTest.cs
@@ -34,7 +34,8 @@ public async Task TwoAgentMathClassTestAsync()
     [ApiKeyFact("OPENAI_API_KEY")]
     public async Task AgentFunctionCallTestAsync()
     {
-        await Example03_Agent_FunctionCall.RunAsync();
+        await Example03_Agent_FunctionCall.ToolCallWithSourceGenerator();
+        await Example03_Agent_FunctionCall.ToolCallWithMEAITools();
     }
 
     [ApiKeyFact("MISTRAL_API_KEY")]
diff --git a/dotnet/test/AutoGen.Tests/Function/ApprovalTests/FunctionTests.CreateGetWeatherFunctionFromAIFunctionFactoryAsync.approved.txt b/dotnet/test/AutoGen.Tests/Function/ApprovalTests/FunctionTests.CreateGetWeatherFunctionFromAIFunctionFactoryAsync.approved.txt
new file mode 100644
index 000000000000..f57e0203e353
--- /dev/null
+++ b/dotnet/test/AutoGen.Tests/Function/ApprovalTests/FunctionTests.CreateGetWeatherFunctionFromAIFunctionFactoryAsync.approved.txt
@@ -0,0 +1,76 @@
+[
+  {
+    "Kind": 0,
+    "FunctionName": "GetWeather",
+    "FunctionDescription": "get weather",
+    "FunctionParameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string"
+        },
+        "date": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "city"
+      ]
+    }
+  },
+  {
+    "Kind": 0,
+    "FunctionName": "GetWeatherStatic",
+    "FunctionDescription": "get weather from static method",
+    "FunctionParameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string"
+        },
+        "date": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "required": [
+        "city",
+        "date"
+      ]
+    }
+  },
+  {
+    "Kind": 0,
+    "FunctionName": "GetWeather",
+    "FunctionDescription": "get weather from async method",
+    "FunctionParameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "city"
+      ]
+    }
+  },
+  {
+    "Kind": 0,
+    "FunctionName": "GetWeatherAsyncStatic",
+    "FunctionDescription": "get weather from async static method",
+    "FunctionParameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "city"
+      ]
+    }
+  }
+]
\ No newline at end of file
diff --git a/dotnet/test/AutoGen.Tests/Function/FunctionTests.cs b/dotnet/test/AutoGen.Tests/Function/FunctionTests.cs
new file mode 100644
index 000000000000..64abb293bb16
--- /dev/null
+++ b/dotnet/test/AutoGen.Tests/Function/FunctionTests.cs
@@ -0,0 +1,82 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// FunctionTests.cs
+
+using System;
+using System.ComponentModel;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using ApprovalTests;
+using ApprovalTests.Namers;
+using ApprovalTests.Reporters;
+using AutoGen.OpenAI.Extension;
+using FluentAssertions;
+using Microsoft.Extensions.AI;
+using Xunit;
+
+namespace AutoGen.Tests.Function;
+public class FunctionTests
+{
+    private readonly JsonSerializerOptions _jsonSerializerOptions = new() { WriteIndented = true, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull };
+    [Description("get weather")]
+    public string GetWeather(string city, string date = "today")
+    {
+        return $"The weather in {city} is sunny.";
+    }
+
+    [Description("get weather from static method")]
+    [return: Description("weather information")]
+    public static string GetWeatherStatic(string city, string[] date)
+    {
+        return $"The weather in {city} is sunny.";
+    }
+
+    [Description("get weather from async method")]
+    public async Task GetWeatherAsync(string city)
+    {
+        await Task.Delay(100);
+        return $"The weather in {city} is sunny.";
+    }
+
+    [Description("get weather from async static method")]
+    public static async Task GetWeatherAsyncStatic(string city)
+    {
+        await Task.Delay(100);
+        return $"The weather in {city} is sunny.";
+    }
+
+    [Fact]
+    [UseReporter(typeof(DiffReporter))]
+    [UseApprovalSubdirectory("ApprovalTests")]
+    public async Task CreateGetWeatherFunctionFromAIFunctionFactoryAsync()
+    {
+        Delegate[] availableDelegates = [
+            GetWeather,
+            GetWeatherStatic,
+            GetWeatherAsync,
+            GetWeatherAsyncStatic,
+        ];
+
+        var functionContracts = availableDelegates.Select(function => (FunctionContract)AIFunctionFactory.Create(function).Metadata).ToList();
+
+        // Verify the function contracts
+        functionContracts.Should().HaveCount(4);
+
+        var openAIToolContracts = functionContracts.Select(f =>
+        {
+            var tool = f.ToChatTool();
+
+            return new
+            {
+                tool.Kind,
+                tool.FunctionName,
+                tool.FunctionDescription,
+                FunctionParameters = tool.FunctionParameters.ToObjectFromJson(),
+            };
+        });
+
+        var json = JsonSerializer.Serialize(openAIToolContracts, _jsonSerializerOptions);
+        Approvals.Verify(json);
+    }
+}
diff --git a/dotnet/test/AutoGen.Tests/MiddlewareTest.cs b/dotnet/test/AutoGen.Tests/MiddlewareTest.cs
index d98fa14ec19d..61691b225437 100644
--- a/dotnet/test/AutoGen.Tests/MiddlewareTest.cs
+++ b/dotnet/test/AutoGen.Tests/MiddlewareTest.cs
@@ -7,6 +7,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using FluentAssertions;
+using Microsoft.Extensions.AI;
 using Xunit;
 
 namespace AutoGen.Tests;
@@ -72,7 +73,7 @@ public async Task FunctionCallMiddlewareTestAsync()
         var agent = new EchoAgent("echo");
         var args = new EchoSchema { message = "hello" };
         var argsJson = JsonSerializer.Serialize(args) ?? throw new InvalidOperationException("Failed to serialize args");
-        var functionCall = new ToolCall("echo", argsJson);
+        var functionCall = new ToolCall("Echo", argsJson);
         var functionCallAgent = agent.RegisterMiddleware(async (messages, options, agent, ct) =>
         {
             if (options?.Functions is null)
@@ -86,7 +87,7 @@ public async Task FunctionCallMiddlewareTestAsync()
         // test 1
         // middleware should invoke function call if the message is a function call message
         var mw = new FunctionCallMiddleware(
-            functionMap: new Dictionary>> { { "echo", EchoWrapper } });
+            functionMap: new Dictionary>> { { "Echo", EchoWrapper } });
 
         var testAgent = agent.RegisterMiddleware(mw);
         var functionCallMessage = new ToolCallMessage(functionCall.FunctionName, functionCall.FunctionArguments, from: "user");
@@ -96,30 +97,38 @@ public async Task FunctionCallMiddlewareTestAsync()
         reply.From.Should().Be("echo");
 
         // test 2
+        // middleware should work with AIFunction from M.E.A.I
+        var getWeatherTool = AIFunctionFactory.Create(this.Echo);
+        mw = new FunctionCallMiddleware([getWeatherTool]);
+        testAgent = agent.RegisterMiddleware(mw);
+        reply = await testAgent.SendAsync(functionCallMessage);
+        reply.GetContent()!.Should().Be("[FUNC] hello");
+
+        // test 3
         // middleware should invoke function call if agent reply is a function call message
         mw = new FunctionCallMiddleware(
             functions: [this.EchoFunctionContract],
-            functionMap: new Dictionary>> { { "echo", EchoWrapper } });
+            functionMap: new Dictionary>> { { "Echo", EchoWrapper } });
         testAgent = functionCallAgent.RegisterMiddleware(mw);
         reply = await testAgent.SendAsync("hello");
         reply.GetContent()!.Should().Be("[FUNC] hello");
         reply.From.Should().Be("echo");
 
-        // test 3
+        // test 4
         // middleware should return original reply if the reply from agent is not a function call message
         mw = new FunctionCallMiddleware(
-            functionMap: new Dictionary>> { { "echo", EchoWrapper } });
+            functionMap: new Dictionary>> { { "Echo", EchoWrapper } });
         testAgent = agent.RegisterMiddleware(mw);
         reply = await testAgent.SendAsync("hello");
         reply.GetContent()!.Should().Be("hello");
         reply.From.Should().Be("echo");
 
-        // test 4
+        // test 5
         // middleware should return an error message if the function name is not available when invoking the function from previous agent reply
         mw = new FunctionCallMiddleware(
-            functionMap: new Dictionary>> { { "echo2", EchoWrapper } });
+            functionMap: new Dictionary>> { { "Echo2", EchoWrapper } });
         testAgent = agent.RegisterMiddleware(mw);
         reply = await testAgent.SendAsync(functionCallMessage);
-        reply.GetContent()!.Should().Be("Function echo is not available. Available functions are: echo2");
+        reply.GetContent()!.Should().Be("Function Echo is not available. Available functions are: Echo2");
     }
 }
diff --git a/dotnet/website/articles/Create-type-safe-function-call.md b/dotnet/website/articles/Create-type-safe-function-call.md
index a12869661817..059a912d0717 100644
--- a/dotnet/website/articles/Create-type-safe-function-call.md
+++ b/dotnet/website/articles/Create-type-safe-function-call.md
@@ -1,4 +1,4 @@
-## Type-safe function call
+## Create type-safe function call using AutoGen.SourceGenerator
 
 `AutoGen` provides a source generator to easness the trouble of manually craft function definition and function call wrapper from a function. To use this feature, simply add the `AutoGen.SourceGenerator` package to your project and decorate your function with @AutoGen.Core.FunctionAttribute.
 

From f46e52e6ffec1bee89d462aac3fbd52f8a600c56 Mon Sep 17 00:00:00 2001
From: David Luong 
Date: Mon, 4 Nov 2024 08:40:53 -0500
Subject: [PATCH 069/173] [.NET] Update version of Microsoft.Extension.Ai &
 System.Text.Json (#4044)

* Upgrade version of M.E.A.I & STJ

* remove copilot generated comment

* Revert NoWarnDuplicatePackages and remove S.T.J from Directory.Packages.props

---------

Co-authored-by: Xiaoyun Zhang 
---
 dotnet/Directory.Build.props                                 | 1 +
 dotnet/Directory.Packages.props                              | 5 ++---
 dotnet/samples/dev-team/DevTeam.Agents/DevTeam.Agents.csproj | 4 ++--
 .../AIModelClientHostingExtensions.csproj                    | 1 +
 .../Microsoft.AutoGen.Extensions.SemanticKernel.csproj       | 2 +-
 5 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/dotnet/Directory.Build.props b/dotnet/Directory.Build.props
index ae30d2c48a5e..1e84f78232ad 100644
--- a/dotnet/Directory.Build.props
+++ b/dotnet/Directory.Build.props
@@ -13,6 +13,7 @@
     CS1998;CS1591;CS8002;
     SKEXP0001;SKEXP0010;SKEXP0020
     $(NoWarn);$(CSNoWarn);$(SKEXPNoWarn);NU5104
+
     true
     true
     false
diff --git a/dotnet/Directory.Packages.props b/dotnet/Directory.Packages.props
index dd9df7161047..75580bba007a 100644
--- a/dotnet/Directory.Packages.props
+++ b/dotnet/Directory.Packages.props
@@ -3,7 +3,7 @@
     true
     1.22.0
     1.22.0-alpha
-    9.0.0-preview.9.24507.7
+    9.0.0-preview.9.24525.1
   
   
     
@@ -111,6 +111,5 @@
     
     
     
-    
   
-
\ No newline at end of file
+
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/DevTeam.Agents.csproj b/dotnet/samples/dev-team/DevTeam.Agents/DevTeam.Agents.csproj
index d7dbd1688599..03176d2cfd25 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/DevTeam.Agents.csproj
+++ b/dotnet/samples/dev-team/DevTeam.Agents/DevTeam.Agents.csproj
@@ -7,9 +7,9 @@
   
 
   
-   
+
     
-   
+
     
     
     
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
index a94921946c09..2358351deb6c 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/AIModelClientHostingExtensions/AIModelClientHostingExtensions.csproj
@@ -14,5 +14,6 @@
     
     
     
+    
   
 
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
index a976c007715c..fb47750fd44d 100644
--- a/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
+++ b/dotnet/src/Microsoft.AutoGen/Extensions/SemanticKernel/Microsoft.AutoGen.Extensions.SemanticKernel.csproj
@@ -14,7 +14,7 @@
   
 	
 	
-	  
+
     
     
   

From 16e64c4c10b13294a9c5cb5d12e47eba42173728 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Mon, 4 Nov 2024 09:25:53 -0800
Subject: [PATCH 070/173] Rename `model_usage` to `models_usage`. (#4053)

---
 .../agents/_assistant_agent.py                |  6 ++--
 .../src/autogen_agentchat/messages.py         |  2 +-
 .../autogen_agentchat/task/_terminations.py   |  8 +++---
 .../tests/test_assistant_agent.py             | 28 +++++++++----------
 .../tests/test_termination_condition.py       | 10 +++----
 5 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 8ef47806ac4d..daaacda15870 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -266,8 +266,8 @@ async def on_messages_stream(
         while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
             event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
             # Add the tool call message to the output.
-            inner_messages.append(ToolCallMessage(content=result.content, source=self.name, model_usage=result.usage))
-            yield ToolCallMessage(content=result.content, source=self.name, model_usage=result.usage)
+            inner_messages.append(ToolCallMessage(content=result.content, source=self.name, models_usage=result.usage))
+            yield ToolCallMessage(content=result.content, source=self.name, models_usage=result.usage)
 
             # Execute the tool calls.
             results = await asyncio.gather(
@@ -303,7 +303,7 @@ async def on_messages_stream(
 
         assert isinstance(result.content, str)
         yield Response(
-            chat_message=TextMessage(content=result.content, source=self.name, model_usage=result.usage),
+            chat_message=TextMessage(content=result.content, source=self.name, models_usage=result.usage),
             inner_messages=inner_messages,
         )
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index c8037671e131..1ac85edf1bd1 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -11,7 +11,7 @@ class BaseMessage(BaseModel):
     source: str
     """The name of the agent that sent this message."""
 
-    model_usage: RequestUsage | None = None
+    models_usage: RequestUsage | None = None
     """The model client usage incurred when producing this message."""
 
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
index 24cefc1af284..825d5bea28e6 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
@@ -131,10 +131,10 @@ async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
         if self.terminated:
             raise TerminatedException("Termination condition has already been reached")
         for message in messages:
-            if message.model_usage is not None:
-                self._prompt_token_count += message.model_usage.prompt_tokens
-                self._completion_token_count += message.model_usage.completion_tokens
-                self._total_token_count += message.model_usage.prompt_tokens + message.model_usage.completion_tokens
+            if message.models_usage is not None:
+                self._prompt_token_count += message.models_usage.prompt_tokens
+                self._completion_token_count += message.models_usage.completion_tokens
+                self._total_token_count += message.models_usage.prompt_tokens + message.models_usage.completion_tokens
         if self.terminated:
             content = f"Token usage limit reached, total token count: {self._total_token_count}, prompt token count: {self._prompt_token_count}, completion token count: {self._completion_token_count}."
             return StopMessage(content=content, source="TokenUsageTermination")
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 20556ad783cb..5e133b91a23d 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -113,17 +113,17 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
-    assert result.messages[0].model_usage is None
+    assert result.messages[0].models_usage is None
     assert isinstance(result.messages[1], ToolCallMessage)
-    assert result.messages[1].model_usage is not None
-    assert result.messages[1].model_usage.completion_tokens == 5
-    assert result.messages[1].model_usage.prompt_tokens == 10
+    assert result.messages[1].models_usage is not None
+    assert result.messages[1].models_usage.completion_tokens == 5
+    assert result.messages[1].models_usage.prompt_tokens == 10
     assert isinstance(result.messages[2], ToolCallResultMessage)
-    assert result.messages[2].model_usage is None
+    assert result.messages[2].models_usage is None
     assert isinstance(result.messages[3], TextMessage)
-    assert result.messages[3].model_usage is not None
-    assert result.messages[3].model_usage.completion_tokens == 5
-    assert result.messages[3].model_usage.prompt_tokens == 10
+    assert result.messages[3].models_usage is not None
+    assert result.messages[3].models_usage.completion_tokens == 5
+    assert result.messages[3].models_usage.prompt_tokens == 10
 
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore
@@ -181,17 +181,17 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
     result = await tool_use_agent.run("task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
-    assert result.messages[0].model_usage is None
+    assert result.messages[0].models_usage is None
     assert isinstance(result.messages[1], ToolCallMessage)
-    assert result.messages[1].model_usage is not None
-    assert result.messages[1].model_usage.completion_tokens == 43
-    assert result.messages[1].model_usage.prompt_tokens == 42
+    assert result.messages[1].models_usage is not None
+    assert result.messages[1].models_usage.completion_tokens == 43
+    assert result.messages[1].models_usage.prompt_tokens == 42
     assert isinstance(result.messages[2], ToolCallResultMessage)
-    assert result.messages[2].model_usage is None
+    assert result.messages[2].models_usage is None
     assert isinstance(result.messages[3], HandoffMessage)
     assert result.messages[3].content == handoff.message
     assert result.messages[3].target == handoff.target
-    assert result.messages[3].model_usage is None
+    assert result.messages[3].models_usage is None
 
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore
diff --git a/python/packages/autogen-agentchat/tests/test_termination_condition.py b/python/packages/autogen-agentchat/tests/test_termination_condition.py
index c13544515c14..06362e156e01 100644
--- a/python/packages/autogen-agentchat/tests/test_termination_condition.py
+++ b/python/packages/autogen-agentchat/tests/test_termination_condition.py
@@ -66,7 +66,7 @@ async def test_token_usage_termination() -> None:
         await termination(
             [
                 TextMessage(
-                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=10, completion_tokens=10)
+                    content="Hello", source="user", models_usage=RequestUsage(prompt_tokens=10, completion_tokens=10)
                 )
             ]
         )
@@ -77,10 +77,10 @@ async def test_token_usage_termination() -> None:
         await termination(
             [
                 TextMessage(
-                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
+                    content="Hello", source="user", models_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
                 ),
                 TextMessage(
-                    content="World", source="agent", model_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
+                    content="World", source="agent", models_usage=RequestUsage(prompt_tokens=1, completion_tokens=1)
                 ),
             ]
         )
@@ -91,10 +91,10 @@ async def test_token_usage_termination() -> None:
         await termination(
             [
                 TextMessage(
-                    content="Hello", source="user", model_usage=RequestUsage(prompt_tokens=5, completion_tokens=0)
+                    content="Hello", source="user", models_usage=RequestUsage(prompt_tokens=5, completion_tokens=0)
                 ),
                 TextMessage(
-                    content="stop", source="user", model_usage=RequestUsage(prompt_tokens=0, completion_tokens=5)
+                    content="stop", source="user", models_usage=RequestUsage(prompt_tokens=0, completion_tokens=5)
                 ),
             ]
         )

From f40336fda1f0a8a6bb5d9fece689eedb9948f689 Mon Sep 17 00:00:00 2001
From: Reuben Bond <203839+ReubenBond@users.noreply.github.com>
Date: Mon, 4 Nov 2024 11:48:46 -0800
Subject: [PATCH 071/173] Do not exclude Properties or appsettings.json via
 .gitignore, commit missing files (#4057)

---
 dotnet/.gitignore                             |  5 ---
 .../Properties/launchSettings.json            | 12 ++++++
 .../Backend/Properties/launchSettings.json    | 12 ++++++
 .../Properties/launchSettings.json            | 43 +++++++++++++++++++
 .../Properties/launchSettings.json            | 12 ++++++
 .../HelloAgent/Properties/launchSettings.json | 12 ++++++
 .../Properties/launchSettings.json            | 12 ++++++
 .../Properties/launchSettings.json            | 12 ++++++
 .../Properties/launchSettings.json            | 12 ++++++
 .../Properties/launchSettings.json            | 12 ++++++
 10 files changed, 139 insertions(+), 5 deletions(-)
 create mode 100644 dotnet/samples/AutoGen.WebAPI.Sample/Properties/launchSettings.json
 create mode 100644 dotnet/samples/Hello/Backend/Properties/launchSettings.json
 create mode 100644 dotnet/samples/Hello/Hello.AppHost/Properties/launchSettings.json
 create mode 100644 dotnet/samples/Hello/HelloAIAgents/Properties/launchSettings.json
 create mode 100644 dotnet/samples/Hello/HelloAgent/Properties/launchSettings.json
 create mode 100644 dotnet/samples/Hello/HelloAgentState/Properties/launchSettings.json
 create mode 100644 dotnet/samples/dev-team/DevTeam.AgentHost/Properties/launchSettings.json
 create mode 100644 dotnet/samples/dev-team/DevTeam.Agents/Properties/launchSettings.json
 create mode 100644 dotnet/samples/dev-team/DevTeam.Backend/Properties/launchSettings.json

diff --git a/dotnet/.gitignore b/dotnet/.gitignore
index 25f613c7945f..2fc32d9ac7e4 100644
--- a/dotnet/.gitignore
+++ b/dotnet/.gitignore
@@ -37,9 +37,6 @@ bld/
 # vs code cache
 .vscode/
 
-# Properties
-Properties/
-
 artifacts/
 output/
 
@@ -56,8 +53,6 @@ bld/
 [Ll]og/
 [Ll]ogs/
 
-appsettings.json
-
 # Visual Studio 2015/2017 cache/options directory
 .vs/
 # Uncomment if you have tasks that create the project's static files in wwwroot
diff --git a/dotnet/samples/AutoGen.WebAPI.Sample/Properties/launchSettings.json b/dotnet/samples/AutoGen.WebAPI.Sample/Properties/launchSettings.json
new file mode 100644
index 000000000000..b9cc7582305f
--- /dev/null
+++ b/dotnet/samples/AutoGen.WebAPI.Sample/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "AutoGen.WebAPI.Sample": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:50675;http://localhost:50676"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/Hello/Backend/Properties/launchSettings.json b/dotnet/samples/Hello/Backend/Properties/launchSettings.json
new file mode 100644
index 000000000000..db9c6bf2c316
--- /dev/null
+++ b/dotnet/samples/Hello/Backend/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "Backend": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:53071;http://localhost:53072"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/Hello/Hello.AppHost/Properties/launchSettings.json b/dotnet/samples/Hello/Hello.AppHost/Properties/launchSettings.json
new file mode 100644
index 000000000000..ea78f2933fdb
--- /dev/null
+++ b/dotnet/samples/Hello/Hello.AppHost/Properties/launchSettings.json
@@ -0,0 +1,43 @@
+{
+  "profiles": {
+    "https": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "dotnetRunMessages": true,
+      "applicationUrl": "https://localhost:15887;http://localhost:15888",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        //"DOTNET_DASHBOARD_OTLP_ENDPOINT_URL": "https://localhost:16037",
+        "DOTNET_DASHBOARD_OTLP_HTTP_ENDPOINT_URL": "https://localhost:16038",
+        "DOTNET_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:17037",
+        "DOTNET_ASPIRE_SHOW_DASHBOARD_RESOURCES": "true"
+      }
+    },
+    "http": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://localhost:15888",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        //"DOTNET_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:16031",
+        "DOTNET_DASHBOARD_OTLP_HTTP_ENDPOINT_URL": "http://localhost:16032",
+        "DOTNET_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:17031",
+        "DOTNET_ASPIRE_SHOW_DASHBOARD_RESOURCES": "true",
+        "ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"
+      }
+    },
+    "generate-manifest": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "commandLineArgs": "--publisher manifest --output-path aspire-manifest.json",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  },
+  "$schema": "https://json.schemastore.org/launchsettings.json"
+}
diff --git a/dotnet/samples/Hello/HelloAIAgents/Properties/launchSettings.json b/dotnet/samples/Hello/HelloAIAgents/Properties/launchSettings.json
new file mode 100644
index 000000000000..a5d241b0b325
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAIAgents/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "HelloAIAgents": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:53139;http://localhost:53140"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/Hello/HelloAgent/Properties/launchSettings.json b/dotnet/samples/Hello/HelloAgent/Properties/launchSettings.json
new file mode 100644
index 000000000000..04cd1b228704
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgent/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "HelloAgent": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:53113;http://localhost:53114"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/Hello/HelloAgentState/Properties/launchSettings.json b/dotnet/samples/Hello/HelloAgentState/Properties/launchSettings.json
new file mode 100644
index 000000000000..067d2fb83551
--- /dev/null
+++ b/dotnet/samples/Hello/HelloAgentState/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "HelloAgentState": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:53136;http://localhost:53137"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/dev-team/DevTeam.AgentHost/Properties/launchSettings.json b/dotnet/samples/dev-team/DevTeam.AgentHost/Properties/launchSettings.json
new file mode 100644
index 000000000000..c43e7586ac17
--- /dev/null
+++ b/dotnet/samples/dev-team/DevTeam.AgentHost/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "DevTeam.AgentHost": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:50670;http://localhost:50673"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Properties/launchSettings.json b/dotnet/samples/dev-team/DevTeam.Agents/Properties/launchSettings.json
new file mode 100644
index 000000000000..8edfece6ad8d
--- /dev/null
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "DevTeam.Agents": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:50669;http://localhost:50671"
+    }
+  }
+}
\ No newline at end of file
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Properties/launchSettings.json b/dotnet/samples/dev-team/DevTeam.Backend/Properties/launchSettings.json
new file mode 100644
index 000000000000..f63e521d5545
--- /dev/null
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Properties/launchSettings.json
@@ -0,0 +1,12 @@
+{
+  "profiles": {
+    "DevTeam.Backend": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:50672;http://localhost:50674"
+    }
+  }
+}
\ No newline at end of file

From eca8a95c61879eae76dcdff0d68c56f94f687e00 Mon Sep 17 00:00:00 2001
From: Gerardo Moreno 
Date: Mon, 4 Nov 2024 16:48:57 -0800
Subject: [PATCH 072/173] Remove isinstance check from FunctionTool (#3987)
 (#4056)

* Remove isinstance check from FunctionTool (#3987)

* Move __init__ Args to class docstring

---------

Co-authored-by: Eric Zhu 
---
 .../core-user-guide/framework/tools.ipynb     | 14 +++++-
 .../components/tools/_function_tool.py        | 48 ++++++++++++++++++-
 .../packages/autogen-core/tests/test_tools.py | 14 +++++-
 3 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
index 0214b0286896..183d878e4c8f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/framework/tools.ipynb
@@ -59,6 +59,13 @@
     "print(code_execution_tool.return_value_as_string(result))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -82,6 +89,11 @@
     "To create a custom function tool, you just need to create a Python function\n",
     "and use the {py:class}`~autogen_core.components.tools.FunctionTool` class to wrap it.\n",
     "\n",
+    "The {py:class}`~autogen_core.components.tools.FunctionTool` class uses descriptions and type annotations\n",
+    "to inform the LLM when and how to use a given function. The description provides context\n",
+    "about the function’s purpose and intended use cases, while type annotations inform the LLM about\n",
+    "the expected parameters and return type.\n",
+    "\n",
     "For example, a simple tool to obtain the stock price of a company might look like this:"
    ]
   },
@@ -296,7 +308,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.7"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py b/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
index e537deeba9c6..462374116d04 100644
--- a/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
+++ b/python/packages/autogen-core/src/autogen_core/components/tools/_function_tool.py
@@ -13,6 +13,52 @@
 
 
 class FunctionTool(BaseTool[BaseModel, BaseModel]):
+    """
+    Create custom tools by wrapping standard Python functions.
+
+    `FunctionTool` offers an interface for executing Python functions either asynchronously or synchronously.
+    Each function must include type annotations for all parameters and its return type. These annotations
+    enable `FunctionTool` to generate a schema necessary for input validation, serialization, and for informing
+    the LLM about expected parameters. When the LLM prepares a function call, it leverages this schema to
+    generate arguments that align with the function's specifications.
+
+    .. note::
+
+        It is the user's responsibility to verify that the tool's output type matches the expected type.
+
+    Args:
+        func (Callable[..., ReturnT | Awaitable[ReturnT]]): The function to wrap and expose as a tool.
+        description (str): A description to inform the model of the function's purpose, specifying what
+            it does and the context in which it should be called.
+        name (str, optional): An optional custom name for the tool. Defaults to
+            the function's original name if not provided.
+
+    Example:
+
+        .. code-block:: python
+
+            import random
+            from autogen_core.base import CancellationToken
+            from autogen_core.components.tools import FunctionTool
+            from typing_extensions import Annotated
+
+
+            async def get_stock_price(ticker: str, date: Annotated[str, "Date in YYYY/MM/DD"]) -> float:
+                # Simulates a stock price retrieval by returning a random float within a specified range.
+                return random.uniform(10, 200)
+
+
+            # Initialize a FunctionTool instance for retrieving stock prices.
+            stock_price_tool = FunctionTool(get_stock_price, description="Fetch the stock price for a given ticker.")
+
+            # Execute the tool with cancellation support.
+            cancellation_token = CancellationToken()
+            result = await stock_price_tool.run_json({"ticker": "AAPL", "date": "2021/01/01"}, cancellation_token)
+
+            # Output the result as a formatted string.
+            print(stock_price_tool.return_value_as_string(result))
+    """
+
     def __init__(self, func: Callable[..., Any], description: str, name: str | None = None) -> None:
         self._func = func
         signature = get_typed_signature(func)
@@ -46,6 +92,4 @@ async def run(self, args: BaseModel, cancellation_token: CancellationToken) -> A
                 cancellation_token.link_future(future)
                 result = await future
 
-        if not isinstance(result, self.return_type()):
-            raise ValueError(f"Expected return type {self.return_type()}, got {type(result)}")
         return result
diff --git a/python/packages/autogen-core/tests/test_tools.py b/python/packages/autogen-core/tests/test_tools.py
index 2a0c82b8f67b..f41b5edd46f8 100644
--- a/python/packages/autogen-core/tests/test_tools.py
+++ b/python/packages/autogen-core/tests/test_tools.py
@@ -1,5 +1,5 @@
 import inspect
-from typing import Annotated
+from typing import Annotated, List
 
 import pytest
 from autogen_core.base import CancellationToken
@@ -324,3 +324,15 @@ def test_convert_tools_accepts_both_tool_and_schema() -> None:
 
     assert len(converted_tool_schema) == 2
     assert converted_tool_schema[0] == converted_tool_schema[1]
+
+
+@pytest.mark.asyncio
+async def test_func_tool_return_list() -> None:
+    def my_function() -> List[int]:
+        return [1, 2]
+
+    tool = FunctionTool(my_function, description="Function tool.")
+    result = await tool.run_json({}, CancellationToken())
+    assert isinstance(result, list)
+    assert result == [1, 2]
+    assert tool.return_value_as_string(result) == "[1, 2]"

From 86033175375d7a46de8d2c68132802b82fc28749 Mon Sep 17 00:00:00 2001
From: Hussein Mozannar 
Date: Mon, 4 Nov 2024 17:18:46 -0800
Subject: [PATCH 073/173] Magentic-One Log Viewer + preview API (#4032)

* update example script with logs dir, add screenshot timestamp

* readme examples update

* add flask app to view magentic_one

* remove copy example

* rename

* changes to magentic one helper

* update test web surfer to delete logs

* magentic_one icons

* fix colors - final log viewer

* fix termination condition

* update coder and log viewer

* timeout time

* make tests pass

* logs dir

* repeated thing

* remove log_viewer, mm web surfer comments

* coder change prompt, edit readmes

* type ignore

* remove logviewer

* add flag for coder agent

* readme

* changes readme

* uv lock

* update readme figures

* not yet

* pointer images
---
 .gitattributes                                |   6 +-
 .../packages/autogen-magentic-one/README.md   | 153 ++++++++++++
 .../autogen-magentic-one/examples/README.md   |  28 ++-
 .../autogen-magentic-one/examples/example.py  |  34 ++-
 .../imgs/autogen-magentic-one-agents.png      |   4 +-
 .../imgs/autogen-magentic-one-arch.png        |   3 -
 .../imgs/autogen-magentic-one-example.png     |   4 +-
 .../autogen-magentic-one/interface/README.md  |  50 ++++
 .../interface/example_magentic_one_helper.py  |  40 +++
 .../interface/magentic_one_helper.py          | 217 +++++++++++++++++
 .../autogen-magentic-one/pyproject.toml       |   4 +-
 .../packages/autogen-magentic-one/readme.md   | 230 ------------------
 .../src/autogen_magentic_one/agents/coder.py  |   7 +-
 .../multimodal_web_surfer.py                  | 120 ++++++---
 .../src/autogen_magentic_one/utils.py         |   5 +
 .../headless_web_surfer/test_web_surfer.py    |  35 ++-
 python/uv.lock                                |  18 +-
 17 files changed, 660 insertions(+), 298 deletions(-)
 create mode 100644 python/packages/autogen-magentic-one/README.md
 delete mode 100644 python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
 create mode 100644 python/packages/autogen-magentic-one/interface/README.md
 create mode 100644 python/packages/autogen-magentic-one/interface/example_magentic_one_helper.py
 create mode 100644 python/packages/autogen-magentic-one/interface/magentic_one_helper.py
 delete mode 100644 python/packages/autogen-magentic-one/readme.md

diff --git a/.gitattributes b/.gitattributes
index 513c7ecbf037..877d0a1fb12e 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,10 +33,8 @@
 *.tsx             text
 *.xml             text
 *.xhtml           text diff=html
-
 # Docker
 Dockerfile        text eol=lf
-
 # Documentation
 *.ipynb           text
 *.markdown        text diff=markdown eol=lf
@@ -62,7 +60,6 @@ NEWS              text eol=lf
 readme            text eol=lf
 *README*          text eol=lf
 TODO              text
-
 # Configs
 *.cnf             text eol=lf
 *.conf            text eol=lf
@@ -84,8 +81,9 @@ yarn.lock         text -diff
 browserslist      text
 Makefile          text eol=lf
 makefile          text eol=lf
-
 # Images
 *.png filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
+python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png filter=lfs diff=lfs merge=lfs -text
+python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png filter=lfs diff=lfs merge=lfs -text
diff --git a/python/packages/autogen-magentic-one/README.md b/python/packages/autogen-magentic-one/README.md
new file mode 100644
index 000000000000..e764ece8985d
--- /dev/null
+++ b/python/packages/autogen-magentic-one/README.md
@@ -0,0 +1,153 @@
+# Magentic-One
+
+> [!CAUTION]
+> Using Magentic-One involves interacting with a digital world designed for humans, which carries inherent risks. To minimize these risks, consider the following precautions:
+>
+> 1. **Use Containers**: Run all tasks in docker containers to isolate the agents and prevent direct system attacks.
+> 2. **Virtual Environment**: Use a virtual environment to run the agents and prevent them from accessing sensitive data.
+> 3. **Monitor Logs**: Closely monitor logs during and after execution to detect and mitigate risky behavior.
+> 4. **Human Oversight**: Run the examples with a human in the loop to supervise the agents and prevent unintended consequences.
+> 5. **Limit Access**: Restrict the agents' access to the internet and other resources to prevent unauthorized actions.
+> 6. **Safeguard Data**: Ensure that the agents do not have access to sensitive data or resources that could be compromised. Do not share sensitive information with the agents.
+> Be aware that agents may occasionally attempt risky actions, such as recruiting humans for help or accepting cookie agreements without human involvement. Always ensure agents are monitored and operate within a controlled environment to prevent unintended consequences. Moreover, be cautious that Magentic-One may be susceptible to prompt injection attacks from webpages.
+
+> [!NOTE]
+> This code is currently being ported to AutoGen AgentChat. If you want to build on top of Magentic-One, we recommend waiting for the port to be completed. In the meantime, you can use this codebase to experiment with Magentic-One.
+
+
+We are introducing Magentic-One, our new generalist multi-agent system for solving open-ended web and file-based tasks across a variety of domains. Magentic-One represents a significant step towards developing agents that can complete tasks that people encounter in their work and personal lives.
+
+![](./imgs/autogen-magentic-one-example.png)
+
+> _Example_: The figure above illustrates Magentic-One mutli-agent team completing a complex task from the GAIA benchmark. Magentic-One's Orchestrator agent creates a plan, delegates tasks to other agents, and tracks progress towards the goal, dynamically revising the plan as needed. The Orchestrator can delegate tasks to a FileSurfer agent to read and handle files, a WebSurfer agent to operate a web browser, or a Coder or Computer Terminal agent to write or execute code, respectively.
+
+## Architecture
+
+
+
+![](./imgs/autogen-magentic-one-agents.png)
+
+Magentic-One work is based on a multi-agent architecture where a lead Orchestrator agent is responsible for high-level planning, directing other agents and tracking task progress. The Orchestrator begins by creating a plan to tackle the task, gathering needed facts and educated guesses in a Task Ledger that is maintained. At each step of its plan, the Orchestrator creates a Progress Ledger where it self-reflects on task progress and checks whether the task is completed. If the task is not yet completed, it assigns one of Magentic-One other agents a subtask to complete. After the assigned agent completes its subtask, the Orchestrator updates the Progress Ledger and continues in this way until the task is complete. If the Orchestrator finds that progress is not being made for enough steps, it can update the Task Ledger and create a new plan. This is illustrated in the figure above; the Orchestrator work is thus divided into an outer loop where it updates the Task Ledger and an inner loop to update the Progress Ledger.
+
+Overall, Magentic-One consists of the following agents:
+- Orchestrator: the lead agent responsible for task decomposition and planning, directing other agents in executing subtasks, tracking overall progress, and taking corrective actions as needed 
+- WebSurfer: This is an LLM-based agent that is proficient in commanding and managing the state of a Chromium-based web browser. With each incoming request, the WebSurfer performs an action on the browser then reports on the new state of the web page   The action space of the WebSurfer includes navigation (e.g. visiting a URL, performing a web search);  web page actions (e.g., clicking and typing); and reading actions (e.g., summarizing or answering questions). The WebSurfer relies on the accessibility tree of the browser and on set-of-marks prompting to perform its actions.
+- FileSurfer: This is an LLM-based agent that commands a markdown-based file preview application to read local files of most types. The FileSurfer can also perform common navigation tasks such as listing the contents of directories and navigating a folder structure.
+- Coder: This is an LLM-based agent specialized through its system prompt for writing code, analyzing information collected from the other agents, or creating new artifacts.
+- ComputerTerminal: Finally, ComputerTerminal provides the team with access to a console shell where the Coder’s programs can be executed, and where new programming libraries can be installed.
+
+Together, Magentic-One’s agents provide the Orchestrator with the tools and capabilities that it needs to solve a broad variety of open-ended problems, as well as the ability to autonomously adapt to, and act in, dynamic and ever-changing web and file-system environments. 
+
+While the default multimodal LLM we use for all agents is GPT-4o, Magentic-One is model agnostic and can incorporate heterogonous models to support different capabilities or meet different cost requirements when getting tasks done. For example, it can use different LLMs and SLMs and their specialized versions to power different agents. We recommend a strong reasoning model for the Orchestrator agent such as GPT-4o. In a different configuration of Magentic-One, we also experiment with using OpenAI o1-preview for the outer loop of the Orchestrator and for the Coder, while other agents continue to use GPT-4o. 
+
+
+### Logging in Team One Agents
+
+Team One agents can emit several log events that can be consumed by a log handler (see the example log handler in [utils.py](src/autogen_magentic_one/utils.py)). A list of currently emitted events are:
+
+- OrchestrationEvent : emitted by a an [Orchestrator](src/autogen_magentic_one/agents/base_orchestrator.py) agent.
+- WebSurferEvent : emitted by a [WebSurfer](src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py) agent.
+
+In addition, developers can also handle and process logs generated from the AutoGen core library (e.g., LLMCallEvent etc). See the example log handler in [utils.py](src/autogen_magentic_one/utils.py) on how this can be implemented. By default, the logs are written to a file named `log.jsonl` which can be configured as a parameter to the defined log handler. These logs can be parsed to retrieved data agent actions.
+
+# Setup and Usage
+
+You can install the Magentic-One package and then run the example code to see how the agents work together to accomplish a task.
+
+1. Clone the code and install the package:
+
+```bash
+git clone -b staging https://github.com/microsoft/autogen.git
+cd autogen/python/packages/autogen-magentic-one
+pip install -e .
+```
+
+The following instructions are for running the example code:
+
+2. Configure the environment variables for the chat completion client. See instructions below [Environment Configuration for Chat Completion Client](#environment-configuration-for-chat-completion-client).
+3. Magentic-One code uses code execution, you need to have [Docker installed](https://docs.docker.com/engine/install/) to run any examples.
+4. Magentic-One uses playwright to interact with web pages. You need to install the playwright dependencies. Run the following command to install the playwright dependencies:
+
+```bash
+playwright install-deps
+```
+5. Now you can run the example code to see how the agents work together to accomplish a task.
+
+> [!CAUTION]  
+> The example code may download files from the internet, execute code, and interact with web pages. Ensure you are in a safe environment before running the example code. 
+
+> [!NOTE]
+> You will need to ensure Docker is running prior to running the example. 
+
+  ```bash
+
+  # Specify logs directory
+  python examples/example.py --logs_dir ./my_logs
+
+  # Enable human-in-the-loop mode
+  python examples/example.py -logs_dir ./my_logs --hil_mode
+
+  # Save screenshots of browser
+  python examples/example.py -logs_dir ./my_logs --save_screenshots
+  ```
+
+  Arguments:
+
+  - logs_dir: (Required) Directory for logs, downloads and screenshots of browser (default: current directory)
+  - hil_mode: (Optional) Enable human-in-the-loop mode (default: disabled)
+  - save_screenshots: (Optional) Save screenshots of browser (default: disabled)
+
+6. [Preview] We have a preview API for Magentic-One. 
+ You can use the `MagenticOneHelper` class to interact with the system. See the [interface README](interface/README.md) for more details.
+
+
+## Environment Configuration for Chat Completion Client
+
+This guide outlines how to configure your environment to use the `create_completion_client_from_env` function, which reads environment variables to return an appropriate `ChatCompletionClient`.
+
+Currently, Magentic-One only supports OpenAI's GPT-4o as the underlying LLM.
+
+### Azure with Active Directory
+
+To configure for Azure with Active Directory, set the following environment variables:
+
+- `CHAT_COMPLETION_PROVIDER='azure'`
+- `CHAT_COMPLETION_KWARGS_JSON` with the following JSON structure:
+
+```json
+{
+  "api_version": "2024-02-15-preview",
+  "azure_endpoint": "REPLACE_WITH_YOUR_ENDPOINT",
+  "model_capabilities": {
+    "function_calling": true,
+    "json_output": true,
+    "vision": true
+  },
+  "azure_ad_token_provider": "DEFAULT",
+  "model": "gpt-4o-2024-05-13"
+}
+```
+
+### With OpenAI
+
+To configure for OpenAI, set the following environment variables:
+
+- `CHAT_COMPLETION_PROVIDER='openai'`
+- `CHAT_COMPLETION_KWARGS_JSON` with the following JSON structure:
+
+```json
+{
+  "api_key": "REPLACE_WITH_YOUR_API",
+  "model": "gpt-4o-2024-05-13"
+}
+```
+Feel free to replace the model with newer versions of gpt-4o if needed.
+
+### Other Keys (Optional)
+
+Some functionalities, such as using web-search requires an API key for Bing.
+You can set it using:
+
+```bash
+export BING_API_KEY=xxxxxxx
+```
diff --git a/python/packages/autogen-magentic-one/examples/README.md b/python/packages/autogen-magentic-one/examples/README.md
index 21ffcd768548..90030228354f 100644
--- a/python/packages/autogen-magentic-one/examples/README.md
+++ b/python/packages/autogen-magentic-one/examples/README.md
@@ -1,11 +1,34 @@
 # Examples of Magentic-One
 
-**Note**: The examples in this folder are ran at your own risk. They involve agents navigating the web, executing code and browsing local files. Please supervise the execution of the agents to reduce any risks. We also recommend running the examples in a docker environment.
+**Note**: The examples in this folder are ran at your own risk. They involve agents navigating the web, executing code and browsing local files. Please supervise the execution of the agents to reduce any risks. We also recommend running the examples in a virtual machine or a sandboxed environment.
 
 
 We include various examples for using Magentic-One and is agents:
 
-- [example.py](example.py): Is a human-in-the-loop of Magentic-One trying to solve a task specified by user input. If you wish for the team to execute the task without involving the user, remove user_proxy from the Orchestrator agents list.
+- [example.py](example.py): Is [human-in-the-loop] Magentic-One trying to solve a task specified by user input. 
+
+
+
+    ```bash
+
+    # Specify logs directory
+    python examples/example.py --logs_dir ./my_logs
+
+    # Enable human-in-the-loop mode
+    python examples/example.py -logs_dir ./my_logs --hil_mode
+
+    # Save screenshots of browser
+    python examples/example.py -logs_dir ./my_logs --save_screenshots
+    ```
+
+    Arguments:
+
+    - logs_dir: (Required) Directory for logs, downloads and screenshots of browser (default: current directory)
+    - hil_mode: (Optional) Enable human-in-the-loop mode (default: disabled)
+    - save_screenshots: (Optional) Save screenshots of browser (default: disabled)
+
+
+The following examples are for individual agents in Magentic-One:
 
 - [example_coder.py](example_coder.py): Is an example of the Coder + Execution agents in Magentic-One -- without the Magentic-One orchestrator. In a loop, specified by using the RoundRobinOrchestrator, the coder will write code based on user input, executor will run the code and then the user is asked for input again.
 
@@ -16,4 +39,3 @@ We include various examples for using Magentic-One and is agents:
 - [example_websurfer.py](example_websurfer.py): Is an example of the MultimodalWebSurfer agent in Magentic-one -- without the orchestrator. To view the browser the agent uses, pass the argument 'headless = False' to 'actual_surfer.init'. In a loop, specified by using the RoundRobinOrchestrator, the web surfer will perform a single action on the browser in response to user input and then the user is asked for input again.
 
 
-Running these examples is simple. First make sure you have installed 'autogen-magentic-one' either from source or from pip, then run 'python example.py'
diff --git a/python/packages/autogen-magentic-one/examples/example.py b/python/packages/autogen-magentic-one/examples/example.py
index f6fd5a284d06..3274ca458dea 100644
--- a/python/packages/autogen-magentic-one/examples/example.py
+++ b/python/packages/autogen-magentic-one/examples/example.py
@@ -1,5 +1,6 @@
 """This example demonstrates MagenticOne performing a task given by the user and returning a final answer."""
 
+import argparse
 import asyncio
 import logging
 import os
@@ -8,7 +9,7 @@
 from autogen_core.application.logging import EVENT_LOGGER_NAME
 from autogen_core.base import AgentId, AgentProxy
 from autogen_core.components.code_executor import CodeBlock
-from autogen_ext.code_executor.docker_executor import DockerCommandLineCodeExecutor
+from autogen_ext.code_executors import DockerCommandLineCodeExecutor
 from autogen_magentic_one.agents.coder import Coder, Executor
 from autogen_magentic_one.agents.file_surfer import FileSurfer
 from autogen_magentic_one.agents.multimodal_web_surfer import MultimodalWebSurfer
@@ -28,14 +29,14 @@ async def confirm_code(code: CodeBlock) -> bool:
     return response.lower() == "yes"
 
 
-async def main() -> None:
+async def main(logs_dir: str, hil_mode: bool, save_screenshots: bool) -> None:
     # Create the runtime.
     runtime = SingleThreadedAgentRuntime()
 
     # Create an appropriate client
     client = create_completion_client_from_env(model="gpt-4o")
 
-    async with DockerCommandLineCodeExecutor() as code_executor:
+    async with DockerCommandLineCodeExecutor(work_dir=logs_dir) as code_executor:
         # Register agents.
         await Coder.register(runtime, "Coder", lambda: Coder(model_client=client))
         coder = AgentProxy(AgentId("Coder", "default"), runtime)
@@ -61,11 +62,15 @@ async def main() -> None:
         )
         user_proxy = AgentProxy(AgentId("UserProxy", "default"), runtime)
 
+        agent_list = [web_surfer, coder, executor, file_surfer]
+        if hil_mode:
+            agent_list.append(user_proxy)
+
         await LedgerOrchestrator.register(
             runtime,
             "Orchestrator",
             lambda: LedgerOrchestrator(
-                agents=[web_surfer, user_proxy, coder, executor, file_surfer],
+                agents=agent_list,
                 model_client=client,
                 max_rounds=30,
                 max_time=25 * 60,
@@ -79,10 +84,12 @@ async def main() -> None:
         actual_surfer = await runtime.try_get_underlying_agent_instance(web_surfer.id, type=MultimodalWebSurfer)
         await actual_surfer.init(
             model_client=client,
-            downloads_folder=os.getcwd(),
+            downloads_folder=logs_dir,
             start_page="https://www.bing.com",
             browser_channel="chromium",
             headless=True,
+            debug_dir=logs_dir,
+            to_save_screenshots=save_screenshots,
         )
 
         await runtime.send_message(RequestReplyMessage(), user_proxy.id)
@@ -90,8 +97,21 @@ async def main() -> None:
 
 
 if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run MagenticOne example with log directory.")
+    parser.add_argument("--logs_dir", type=str, required=True, help="Directory to store log files and downloads")
+    parser.add_argument("--hil_mode", action="store_true", default=False, help="Run in human-in-the-loop mode")
+    parser.add_argument(
+        "--save_screenshots", action="store_true", default=False, help="Save additional browser screenshots to file"
+    )
+
+    args = parser.parse_args()
+
+    # Ensure the log directory exists
+    if not os.path.exists(args.logs_dir):
+        os.makedirs(args.logs_dir)
+
     logger = logging.getLogger(EVENT_LOGGER_NAME)
     logger.setLevel(logging.INFO)
-    log_handler = LogHandler()
+    log_handler = LogHandler(filename=os.path.join(args.logs_dir, "log.jsonl"))
     logger.handlers = [log_handler]
-    asyncio.run(main())
+    asyncio.run(main(args.logs_dir, args.hil_mode, args.save_screenshots))
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
index b8d44327ee80..cfed3e9729e5 100644
--- a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
+++ b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-agents.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e89c451d86c7e693127707e696443b77ddad2d9c596936f5fc2f6225cf4b431d
-size 97407
+oid sha256:25a3a1f79319b89d80b8459af8b522eb9a884dea842b11e3d7dae2bca30add5e
+size 90181
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
deleted file mode 100644
index 4d061bdfde41..000000000000
--- a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-arch.png
+++ /dev/null
@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a3aa615fa321b54e09efcd9dbb2e4d25a392232fd4e065f85b5a58ed58a7768c
-size 298340
diff --git a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
index 633729e794c1..afa76da21d8b 100644
--- a/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
+++ b/python/packages/autogen-magentic-one/imgs/autogen-magentic-one-example.png
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e6d0c57dc734747319fd4f847748fd2400cfb73ea01e87ac85dc8c28c738d21f
-size 206468
+oid sha256:fc910bda7e5f3b54d6502f26384f7b10b67f0597d7ac4631dfb45801882768fa
+size 201460
diff --git a/python/packages/autogen-magentic-one/interface/README.md b/python/packages/autogen-magentic-one/interface/README.md
new file mode 100644
index 000000000000..14ed3adb63eb
--- /dev/null
+++ b/python/packages/autogen-magentic-one/interface/README.md
@@ -0,0 +1,50 @@
+# MagenticOne Interface
+
+This repository contains a preview interface for interacting with the MagenticOne system. It includes helper classes, and example usage.
+
+
+## Usage
+
+### MagenticOneHelper
+
+The MagenticOneHelper class provides an interface to interact with the MagenticOne system. It saves logs to a user-specified directory and provides methods to run tasks, stream logs, and retrieve the final answer.
+
+The class provides the following methods:
+- async initialize(self) -> None: Initializes the MagenticOne system, setting up agents and runtime.
+- async run_task(self, task: str) -> None: Runs a specific task through the MagenticOne system.
+- get_final_answer(self) -> Optional[str]: Retrieves the final answer from the Orchestrator.
+- async stream_logs(self) -> AsyncGenerator[Dict[str, Any], None]: Streams logs from the system as they are generated.
+- get_all_logs(self) -> List[Dict[str, Any]]: Retrieves all logs that have been collected so far.
+
+We show an example of how to use the MagenticOneHelper class to in [example_magentic_one_helper.py](example_magentic_one_helper.py).
+
+```python
+from magentic_one_helper import MagenticOneHelper
+import asyncio
+import json
+
+async def magentic_one_example():
+    # Create and initialize MagenticOne
+    magnetic_one = MagenticOneHelper(logs_dir="./logs")
+    await magnetic_one.initialize()
+    print("MagenticOne initialized.")
+    
+    # Start a task and stream logs
+    task = "How many members are in the MSR HAX Team"
+    task_future = asyncio.create_task(magnetic_one.run_task(task))
+
+    # Stream and process logs
+    async for log_entry in magnetic_one.stream_logs():
+        print(json.dumps(log_entry, indent=2))
+
+    # Wait for task to complete
+    await task_future
+
+    # Get the final answer
+    final_answer = magnetic_one.get_final_answer()
+
+    if final_answer is not None:
+        print(f"Final answer: {final_answer}")
+    else:
+        print("No final answer found in logs.")
+```
diff --git a/python/packages/autogen-magentic-one/interface/example_magentic_one_helper.py b/python/packages/autogen-magentic-one/interface/example_magentic_one_helper.py
new file mode 100644
index 000000000000..de247f7ccc76
--- /dev/null
+++ b/python/packages/autogen-magentic-one/interface/example_magentic_one_helper.py
@@ -0,0 +1,40 @@
+from magentic_one_helper import MagenticOneHelper
+import asyncio
+import json
+import argparse
+import os
+
+
+async def main(task, logs_dir):
+    magnetic_one = MagenticOneHelper(logs_dir=logs_dir)
+    await magnetic_one.initialize()
+    print("MagenticOne initialized.")
+
+    # Create task and log streaming tasks
+    task_future = asyncio.create_task(magnetic_one.run_task(task))
+    final_answer = None
+
+    # Stream and process logs
+    async for log_entry in magnetic_one.stream_logs():
+        print(json.dumps(log_entry, indent=2))
+
+    # Wait for task to complete
+    await task_future
+
+    # Get the final answer
+    final_answer = magnetic_one.get_final_answer()
+
+    if final_answer is not None:
+        print(f"Final answer: {final_answer}")
+    else:
+        print("No final answer found in logs.")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run a task with MagenticOneHelper.")
+    parser.add_argument("task", type=str, help="The task to run")
+    parser.add_argument("--logs_dir", type=str, default="./logs", help="Directory to store logs")
+    args = parser.parse_args()
+    if not os.path.exists(args.logs_dir):
+        os.makedirs(args.logs_dir)
+    asyncio.run(main(args.task, args.logs_dir))
diff --git a/python/packages/autogen-magentic-one/interface/magentic_one_helper.py b/python/packages/autogen-magentic-one/interface/magentic_one_helper.py
new file mode 100644
index 000000000000..bf0dd05f637b
--- /dev/null
+++ b/python/packages/autogen-magentic-one/interface/magentic_one_helper.py
@@ -0,0 +1,217 @@
+import asyncio
+import logging
+import os
+from typing import Optional, AsyncGenerator, Dict, Any, List
+from datetime import datetime
+import json
+from dataclasses import asdict
+
+from autogen_core.application import SingleThreadedAgentRuntime
+from autogen_core.application.logging import EVENT_LOGGER_NAME
+from autogen_core.base import AgentId, AgentProxy
+from autogen_core.components import DefaultTopicId
+from autogen_core.components.code_executor import LocalCommandLineCodeExecutor
+from autogen_ext.code_executor.docker_executor import DockerCommandLineCodeExecutor
+from autogen_core.components.code_executor import CodeBlock
+from autogen_magentic_one.agents.coder import Coder, Executor
+from autogen_magentic_one.agents.file_surfer import FileSurfer
+from autogen_magentic_one.agents.multimodal_web_surfer import MultimodalWebSurfer
+from autogen_magentic_one.agents.orchestrator import LedgerOrchestrator
+from autogen_magentic_one.agents.user_proxy import UserProxy
+from autogen_magentic_one.messages import BroadcastMessage
+from autogen_magentic_one.utils import LogHandler, create_completion_client_from_env
+from autogen_core.components.models import UserMessage
+from threading import Lock
+
+
+async def confirm_code(code: CodeBlock) -> bool:
+    return True
+
+
+class MagenticOneHelper:
+    def __init__(self, logs_dir: str = None, save_screenshots: bool = False) -> None:
+        """
+        A helper class to interact with the MagenticOne system.
+        Initialize MagenticOne instance.
+
+        Args:
+            logs_dir: Directory to store logs and downloads
+            save_screenshots: Whether to save screenshots of web pages
+        """
+        self.logs_dir = logs_dir or os.getcwd()
+        self.runtime: Optional[SingleThreadedAgentRuntime] = None
+        self.log_handler: Optional[LogHandler] = None
+        self.save_screenshots = save_screenshots
+
+        if not os.path.exists(self.logs_dir):
+            os.makedirs(self.logs_dir)
+
+    async def initialize(self) -> None:
+        """
+        Initialize the MagenticOne system, setting up agents and runtime.
+        """
+        # Create the runtime
+        self.runtime = SingleThreadedAgentRuntime()
+
+        # Set up logging
+        logger = logging.getLogger(EVENT_LOGGER_NAME)
+        logger.setLevel(logging.INFO)
+        self.log_handler = LogHandler(filename=os.path.join(self.logs_dir, "log.jsonl"))
+        logger.handlers = [self.log_handler]
+
+        # Create client
+        client = create_completion_client_from_env(model="gpt-4o")
+
+        # Set up code executor
+        self.code_executor = DockerCommandLineCodeExecutor(work_dir=self.logs_dir)
+        await self.code_executor.__aenter__()
+
+        await Coder.register(self.runtime, "Coder", lambda: Coder(model_client=client))
+
+        coder = AgentProxy(AgentId("Coder", "default"), self.runtime)
+
+        await Executor.register(
+            self.runtime,
+            "Executor",
+            lambda: Executor("A agent for executing code", executor=self.code_executor, confirm_execution=confirm_code),
+        )
+        executor = AgentProxy(AgentId("Executor", "default"), self.runtime)
+
+        # Register agents.
+        await MultimodalWebSurfer.register(self.runtime, "WebSurfer", MultimodalWebSurfer)
+        web_surfer = AgentProxy(AgentId("WebSurfer", "default"), self.runtime)
+
+        await FileSurfer.register(self.runtime, "file_surfer", lambda: FileSurfer(model_client=client))
+        file_surfer = AgentProxy(AgentId("file_surfer", "default"), self.runtime)
+
+        agent_list = [web_surfer, coder, executor, file_surfer]
+        await LedgerOrchestrator.register(
+            self.runtime,
+            "Orchestrator",
+            lambda: LedgerOrchestrator(
+                agents=agent_list,
+                model_client=client,
+                max_rounds=30,
+                max_time=25 * 60,
+                max_stalls_before_replan=10,
+                return_final_answer=True,
+            ),
+        )
+
+        self.runtime.start()
+
+        actual_surfer = await self.runtime.try_get_underlying_agent_instance(web_surfer.id, type=MultimodalWebSurfer)
+        await actual_surfer.init(
+            model_client=client,
+            downloads_folder=os.getcwd(),
+            start_page="https://www.bing.com",
+            browser_channel="chromium",
+            headless=True,
+            debug_dir=self.logs_dir,
+            to_save_screenshots=self.save_screenshots,
+        )
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+        """
+        Clean up resources.
+        """
+        if self.code_executor:
+            await self.code_executor.__aexit__(exc_type, exc_value, traceback)
+
+    async def run_task(self, task: str) -> None:
+        """
+        Run a specific task through the MagenticOne system.
+
+        Args:
+            task: The task description to be executed
+        """
+        if not self.runtime:
+            raise RuntimeError("MagenticOne not initialized. Call initialize() first.")
+
+        task_message = BroadcastMessage(content=UserMessage(content=task, source="UserProxy"))
+
+        await self.runtime.publish_message(task_message, topic_id=DefaultTopicId())
+        await self.runtime.stop_when_idle()
+
+    def get_final_answer(self) -> Optional[str]:
+        """
+        Get the final answer from the Orchestrator.
+
+        Returns:
+            The final answer as a string
+        """
+        if not self.log_handler:
+            raise RuntimeError("Log handler not initialized")
+
+        for log_entry in self.log_handler.logs_list:
+            if (
+                log_entry.get("type") == "OrchestrationEvent"
+                and log_entry.get("source") == "Orchestrator (final answer)"
+            ):
+                return log_entry.get("message")
+        return None
+
+    async def stream_logs(self) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        Stream logs from the system as they are generated. Stops when it detects both
+        the final answer and termination condition from the Orchestrator.
+
+        Yields:
+            Dictionary containing log entry information
+        """
+        if not self.log_handler:
+            raise RuntimeError("Log handler not initialized")
+
+        last_index = 0
+        found_final_answer = False
+        found_termination = False
+        found_termination_no_agent = False
+
+        while True:
+            current_logs = self.log_handler.logs_list
+            while last_index < len(current_logs):
+                log_entry = current_logs[last_index]
+                yield log_entry
+                # Check for termination condition
+
+                if (
+                    log_entry.get("type") == "OrchestrationEvent"
+                    and log_entry.get("source") == "Orchestrator (final answer)"
+                ):
+                    found_final_answer = True
+
+                if (
+                    log_entry.get("type") == "OrchestrationEvent"
+                    and log_entry.get("source") == "Orchestrator (termination condition)"
+                ):
+                    found_termination = True
+
+                if (
+                    log_entry.get("type") == "OrchestrationEvent"
+                    and log_entry.get("source") == "Orchestrator (termination condition)"
+                    and log_entry.get("message") == "No agent selected."
+                ):
+                    found_termination_no_agent = True
+
+                if self.runtime._run_context is None:
+                    return
+
+                if found_termination_no_agent and found_final_answer:
+                    return
+                elif found_termination and not found_termination_no_agent:
+                    return
+
+                last_index += 1
+
+            await asyncio.sleep(0.1)  # Small delay to prevent busy waiting
+
+    def get_all_logs(self) -> List[Dict[str, Any]]:
+        """
+        Get all logs that have been collected so far.
+
+        Returns:
+            List of all log entries
+        """
+        if not self.log_handler:
+            raise RuntimeError("Log handler not initialized")
+        return self.log_handler.logs_list
diff --git a/python/packages/autogen-magentic-one/pyproject.toml b/python/packages/autogen-magentic-one/pyproject.toml
index a82de9bd6141..65e71dd8496f 100644
--- a/python/packages/autogen-magentic-one/pyproject.toml
+++ b/python/packages/autogen-magentic-one/pyproject.toml
@@ -7,7 +7,7 @@ name = "autogen-magentic-one"
 version = "0.0.1"
 license = {file = "LICENSE-CODE"}
 description = ''
-readme = "readme.md"
+readme = "README.md"
 requires-python = ">=3.10"
 keywords = []
 classifiers = [
@@ -18,7 +18,7 @@ classifiers = [
 
 dependencies = [
     "autogen-core",
-    "autogen-ext",
+    "autogen-ext[docker]",
     "beautifulsoup4",
     "aiofiles",
     "requests",
diff --git a/python/packages/autogen-magentic-one/readme.md b/python/packages/autogen-magentic-one/readme.md
deleted file mode 100644
index 1f14ffec15a7..000000000000
--- a/python/packages/autogen-magentic-one/readme.md
+++ /dev/null
@@ -1,230 +0,0 @@
-# Magentic-One
-
-Magentic-One is a generalist multi-agent softbot that utilizes a combination of five agents, including LLM and tool-based agents, to tackle intricate tasks. For example, it can be used to solve general tasks that involve multi-step planning and action in the real-world.
-
-![](./imgs/autogen-magentic-one-example.png)
-
-> _Example_: Suppose a user requests the following: _Can you rewrite the readme of the autogen GitHub repository to be more clear_. Magentic-One will use the following process to handle this task. The Orchestrator agent will break down the task into subtasks and assign them to the appropriate agents. In this case, the WebSurfer will navigate to GiHub, search for the autogen repository, and extract the readme file. Next the Coder agent will rewrite the readme file for clarity and return the updated content to the Orchestrator. At each point, the Orchestrator will monitor progress via a ledger, and terminate when the task is completed successfully.
-
-## Architecture
-
-
-
-![](./imgs/autogen-magentic-one-agents.png)
-
-Magentic-One uses agents with the following personas and capabilities:
-
-- Orchestrator: The orchestrator agent is responsible for planning, managing subgoals, and coordinating the other agents. It can break down complex tasks into smaller subtasks and assign them to the appropriate agents. It also keeps track of the overall progress and takes corrective actions if needed (such as reassigning tasks or replanning when stuck).
-
-- Coder: The coder agent is skilled in programming languages and is responsible for writing code.
-
-- Computer Terminal: The computer terminal agent acts as the interface that can execute code written by the coder agent.
-
-- Web Surfer: The web surfer agent is proficient is responsible for web-related tasks. It can browse the internet, retrieve information from websites, and interact with web-based applications. It can handle interactive web pages, forms, and other web elements.
-
-- File Surfer: The file surfer agent specializes in navigating files such as pdfs, powerpoints, WAV files, and other file types. It can search, read, and extract information from files.
-
-We created Magentic-One with one agent of each type because their combined abilities help tackle tough benchmarks. By splitting tasks among different agents, we keep the code simple and modular, like in object-oriented programming. This also makes each agent's job easier since they only need to focus on specific tasks. For example, the websurfer agent only needs to navigate webpages and doesn't worry about writing code, making the team more efficient and effective.
-
-### Planning and Tracking Task Progress
-
-

-drawing
-

-
-The figure illustrates the workflow of an orchestrator managing a multi-agent setup, starting with an initial prompt or task. The orchestrator creates or updates a ledger with gathered information, including verified facts, facts to look up, derived facts, and educated guesses. Using this ledger, a plan is derived, which consists of a sequence of steps and task assignments for the agents. Before execution, the orchestrator clears the agents' contexts to ensure they start fresh. The orchestrator then evaluates if the request is fully satisfied. If so, it reports the final answer or an educated guess.
-
-If the request is not fully satisfied, the orchestrator assesses whether the work is progressing or if there are significant barriers. If progress is being made, the orchestrator orchestrates the next step by selecting an agent and providing instructions. If the process stalls for more than two iterations, the ledger is updated with new information, and the plan is adjusted. This cycle continues, iterating through steps and evaluations, until the task is completed. The orchestrator ensures organized, effective tracking and iterative problem-solving to achieve the prompt's goal.
-
-Note that many parameters such as terminal logic and maximum number of stalled iterations are configurable. Also note that the orchestrator cannot instantiate new agents. This is possible but not implemented in Magentic-One.
-
-## Table of Definitions:
-
-| Term            | Definition                                                                                                                |
-| --------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| Agent           | A component that can (autonomously) act based on observations. Different agents may have different functions and actions. |
-| Planning        | The process of determining actions to achieve goals, performed by the Orchestrator agent in Magentic-One.                 |
-| Ledger          | A record-keeping component used by the Orchestrator agent to track the progress and manage subgoals in Magentic-One.      |
-| Stateful Tools  | Tools that maintain state or data, such as the web browser and markdown-based file browser used by Magentic-One.          |
-| Tools           | Resources used by Magentic-One for various purposes, including stateful and stateless tools.                              |
-| Stateless Tools | Tools that do not maintain state or data, like the commandline executor used by Magentic-One.                             |
-
-## Capabilities and Performance
-
-### Capabilities
-
-- Planning: The Orchestrator agent in Magentic-One excels at performing planning tasks. Planning involves determining actions to achieve goals. The Orchestrator agent breaks down complex tasks into smaller subtasks and assigns them to the appropriate agents.
-
-- Ledger: The Orchestrator agent in Magentic-One utilizes a ledger, which is a record-keeping component. The ledger tracks the progress of tasks and manages subgoals. It allows the Orchestrator agent to monitor the overall progress of the system and take corrective actions if needed.
-
-- Acting in the Real World: Magentic-One is designed to take action in the real world based on observations. The agents in Magentic-One can autonomously perform actions based on the information they observe from their environment.
-
-- Adaptation to Observation: The agents in Magentic-One can adapt to new observations. They can update their knowledge and behavior based on the information they receive from their environment. This allows Magentic-One to effectively handle dynamic and changing situations.
-
-- Stateful Tools: Magentic-One utilizes stateful tools such as a web browser and a markdown-based file browser. These tools maintain state or data, which is essential for performing complex tasks that involve actions that might change the state of the environment.
-
-- Stateless Tools: Magentic-One also utilizes stateless tools such as a command-line executor. These tools do not maintain state or data.
-
-- Coding: The Coder agent in Magentic-One is highly skilled in programming languages and is responsible for writing code. This capability enables Magentic-One to create and execute code to accomplish various tasks.
-
-- Execution of Code: The Computer Terminal agent in Magentic-One acts as an interface that can execute code written by the Coder agent. This capability allows Magentic-One to execute the code and perform actions in the system.
-
-- File Navigation and Extraction: The File Surfer agent in Magentic-One specializes in navigating and extracting information from various file types such as PDFs, PowerPoints, and WAV files. This capability enables Magentic-One to search, read, and extract relevant information from files.
-
-- Web Interaction: The Web Surfer agent in Magentic-One is proficient in web-related tasks. It can browse the internet, retrieve information from websites, and interact with web-based applications. This capability allows Magentic-One to handle interactive web pages, forms, and other web elements.
-
-### What Magentic-One Cannot Do
-
-- **Video Scrubbing:** The agents are unable to navigate and process video content.
-- **User in the Loop Optimization:** The system does not currently incorporate ongoing user interaction beyond the initial task submission.
-- **Code Execution Beyond Python or Shell:** The agents are limited to executing code written in Python or shell scripts.
-- **Agent Instantiation:** The orchestrator agent cannot create new agents dynamically.
-- **Session-Based Learning:** The agents do not learn from previous sessions or retain information beyond the current session.
-- **Limited LLM Capacity:** The agents' abilities are constrained by the limitations of the underlying language model.
-- **Web Surfer Limitations:** The web surfer agent may struggle with certain types of web pages, such as those requiring complex interactions or extensive JavaScript handling.
-
-### Safety and Risks
-
-**Code Execution:**
-
-- **Risks:** Code execution carries inherent risks as it happens in the environment where the agents run using the command line executor. This means that the agents can execute arbitrary Python code.
-- **Mitigation:** Users are advised to run the system in isolated environments, such as Docker containers, to mitigate the risks associated with executing arbitrary code.
-
-**Web Browsing:**
-
-- **Capabilities:** The web surfer agent can operate on most websites, including performing tasks like booking flights.
-- **Risks:** Since the requests are sent online using GPT-4-based models, there are potential privacy and security concerns. It is crucial not to provide sensitive information such as keys or credit card data to the agents.
-
-**Safeguards:**
-
-- **Guardrails from LLM:** The agents inherit the guardrails from the underlying language model (e.g., GPT-4). This means they will refuse to generate toxic or stereotyping content, providing a layer of protection against generating harmful outputs.
-- **Limitations:** The agents' behavior is directly influenced by the capabilities and limitations of the underlying LLM. Consequently, any lack of guardrails in the language model will also affect the behavior of the agents.
-
-**General Recommendations:**
-
-- Always use isolated or controlled environments for running the agents to prevent unauthorized or harmful code execution.
-- Avoid sharing sensitive information with the agents to protect your privacy and security.
-- Regularly update and review the underlying LLM and system configurations to ensure they adhere to the latest safety and security standards.
-
-### Performance
-
-Magentic-One currently achieves the following performance on complex agent benchmarks.
-
-#### GAIA
-
-GAIA is a benchmark from Meta that contains complex tasks that require multi-step reasoning and tool use. For example,
-
-> _Example_: If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.
-
-In order to solve this task, the orchestrator begins by outlining the steps needed to solve the task of calculating how many thousand hours it would take Eliud Kipchoge to run the distance between the Earth and the Moon at its closest approach. The orchestrator instructs the web surfer agent to gather Eliud Kipchoge's marathon world record time (2:01:39) and the minimum perigee distance of the Moon from Wikipedia (356,400 kilometers).
-
-Next, the orchestrator assigns the assistant agent to use this data to perform the necessary calculations. The assistant converts Kipchoge's marathon time to hours (2.0275 hours) and calculates his speed (approximately 20.81 km/h). It then calculates the total time to run the distance to the Moon (17,130.13 hours), rounding it to the nearest thousand hours, resulting in approximately 17,000 thousand hours. The orchestrator then confirms and reports this final result.
-
-Here is the performance of Magentic-One on a GAIA development set.
-
-| Level   | Task Completion Rate\* |
-| ------- | ---------------------- |
-| Level 1 | 55% (29/53)            |
-| Level 2 | 34% (29/86)            |
-| Level 3 | 12% (3/26)             |
-| Total   | 37% (61/165)           |
-
-*Indicates the percentage of tasks completed successfully on the *validation\* set.
-
-#### WebArena
-
-> Example: Tell me the count of comments that have received more downvotes than upvotes for the user who made the latest post on the Showerthoughts forum.
-
-To solve this task, the agents began by logging into the Postmill platform using provided credentials and navigating to the Showerthoughts forum. They identified the latest post in this forum, which was made by a user named Waoonet. To proceed with the task, they then accessed Waoonet's profile to examine the comments section, where they could find all comments made by this user.
-
-Once on Waoonet's profile, the agents focused on counting the comments that had received more downvotes than upvotes. The web_surfer agent analyzed the available comments and found that Waoonet had made two comments, both of which had more upvotes than downvotes. Consequently, they concluded that none of Waoonet's comments had received more downvotes than upvotes. This information was summarized and reported back, completing the task successfully.
-
-| Site           | Task Completion Rate |
-| -------------- | -------------------- |
-| Reddit         | 54%  (57/106)        |
-| Shopping       | 33%  (62/187)        |
-| CMS            | 29%  (53/182)        |
-| Gitlab         | 28%  (50/180)        |
-| Maps           | 35%  (38/109)        |
-| Multiple Sites | 15%  (7/48)          |
-| Total          | 33%  (267/812)       |
-
-### Logging in Team One Agents
-
-Team One agents can emit several log events that can be consumed by a log handler (see the example log handler in [utils.py](src/autogen_magentic_one/utils.py)). A list of currently emitted events are:
-
-- OrchestrationEvent : emitted by a an [Orchestrator](src/autogen_magentic_one/agents/base_orchestrator.py) agent.
-- WebSurferEvent : emitted by a [WebSurfer](src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py) agent.
-
-In addition, developers can also handle and process logs generated from the AutoGen core library (e.g., LLMCallEvent etc). See the example log handler in [utils.py](src/autogen_magentic_one/utils.py) on how this can be implemented. By default, the logs are written to a file named `log.jsonl` which can be configured as a parameter to the defined log handler. These logs can be parsed to retrieved data agent actions.
-
-# Setup
-
-You can install the Magentic-One package using pip and then run the example code to see how the agents work together to accomplish a task.
-
-1. Clone the code.
-
-```bash
-git clone -b staging https://github.com/microsoft/autogen.git
-cd autogen/python/packages/autogen-magentic-one
-pip install -e .
-```
-
-2. Configure the environment variables for the chat completion client. See instructions below.
-3. Now you can run the example code to see how the agents work together to accomplish a task.
-
-**NOTE:** The example code may download files from the internet, execute code, and interact with web pages. Ensure you are in a safe environment before running the example code.
-
-```bash
-python examples/example.py
-```
-
-## Environment Configuration for Chat Completion Client
-
-This guide outlines how to configure your environment to use the `create_completion_client_from_env` function, which reads environment variables to return an appropriate `ChatCompletionClient`.
-
-### Azure with Active Directory
-
-To configure for Azure with Active Directory, set the following environment variables:
-
-- `CHAT_COMPLETION_PROVIDER='azure'`
-- `CHAT_COMPLETION_KWARGS_JSON` with the following JSON structure:
-
-```json
-{
-  "api_version": "2024-02-15-preview",
-  "azure_endpoint": "REPLACE_WITH_YOUR_ENDPOINT",
-  "model_capabilities": {
-    "function_calling": true,
-    "json_output": true,
-    "vision": true
-  },
-  "azure_ad_token_provider": "DEFAULT",
-  "model": "gpt-4o-2024-05-13"
-}
-```
-
-### With OpenAI
-
-To configure for OpenAI, set the following environment variables:
-
-- `CHAT_COMPLETION_PROVIDER='openai'`
-- `CHAT_COMPLETION_KWARGS_JSON` with the following JSON structure:
-
-```json
-{
-  "api_key": "REPLACE_WITH_YOUR_API",
-  "model": "gpt-4o-2024-05-13"
-}
-```
-
-### Other Keys
-
-Some functionalities, such as using web-search requires an API key for Bing.
-You can set it using:
-
-```bash
-export BING_API_KEY=xxxxxxx
-```
diff --git a/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/coder.py b/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/coder.py
index 7106932514f8..e8b3e84421df 100644
--- a/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/coder.py
+++ b/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/coder.py
@@ -40,10 +40,12 @@ def __init__(
         model_client: ChatCompletionClient,
         description: str = DEFAULT_DESCRIPTION,
         system_messages: List[SystemMessage] = DEFAULT_SYSTEM_MESSAGES,
+        request_terminate: bool = False,
     ) -> None:
         super().__init__(description)
         self._model_client = model_client
         self._system_messages = system_messages
+        self._request_terminate = request_terminate
 
     async def _generate_reply(self, cancellation_token: CancellationToken) -> Tuple[bool, UserContent]:
         """Respond to a reply request."""
@@ -53,7 +55,10 @@ async def _generate_reply(self, cancellation_token: CancellationToken) -> Tuple[
             self._system_messages + self._chat_history, cancellation_token=cancellation_token
         )
         assert isinstance(response.content, str)
-        return "TERMINATE" in response.content, response.content
+        if self._request_terminate:
+            return "TERMINATE" in response.content, response.content
+        else:
+            return False, response.content
 
 
 # True if the user confirms the code, False otherwise
diff --git a/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py b/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py
index fee6b968d9c5..e90c50ff911e 100644
--- a/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py
+++ b/python/packages/autogen-magentic-one/src/autogen_magentic_one/agents/multimodal_web_surfer/multimodal_web_surfer.py
@@ -6,6 +6,7 @@
 import os
 import pathlib
 import re
+import time
 import traceback
 from typing import Any, BinaryIO, Dict, List, Optional, Tuple, Union, cast  # Any, Callable, Dict, List, Literal, Tuple
 from urllib.parse import quote_plus  # parse_qs, quote, unquote, urlparse, urlunparse
@@ -85,7 +86,7 @@ def __init__(
         self,
         description: str = DEFAULT_DESCRIPTION,
     ):
-        """Do not instantiate directly. Call MultimodalWebSurfer.create instead."""
+        """To instantiate properly please make sure to call MultimodalWebSurfer.init"""
         super().__init__(description)
 
         # Call init to set these
@@ -116,12 +117,28 @@ async def init(
         start_page: str | None = None,
         downloads_folder: str | None = None,
         debug_dir: str | None = os.getcwd(),
+        to_save_screenshots: bool = False,
         # navigation_allow_list=lambda url: True,
         markdown_converter: Any | None = None,  # TODO: Fixme
     ) -> None:
+        """
+        Initialize the MultimodalWebSurfer.
+
+        Args:
+            model_client (ChatCompletionClient): The client to use for chat completions.
+            headless (bool): Whether to run the browser in headless mode. Defaults to True.
+            browser_channel (str | type[DEFAULT_CHANNEL]): The browser channel to use. Defaults to DEFAULT_CHANNEL.
+            browser_data_dir (str | None): The directory to store browser data. Defaults to None.
+            start_page (str | None): The initial page to visit. Defaults to DEFAULT_START_PAGE.
+            downloads_folder (str | None): The folder to save downloads. Defaults to None.
+            debug_dir (str | None): The directory to save debug information. Defaults to the current working directory.
+            to_save_screenshots (bool): Whether to save screenshots. Defaults to False.
+            markdown_converter (Any | None): The markdown converter to use. Defaults to None.
+        """
         self._model_client = model_client
         self.start_page = start_page or self.DEFAULT_START_PAGE
         self.downloads_folder = downloads_folder
+        self.to_save_screenshots = to_save_screenshots
         self._chat_history: List[LLMMessage] = []
         self._last_download = None
         self._prior_metadata_hash = None
@@ -175,35 +192,57 @@ async def _set_debug_dir(self, debug_dir: str | None) -> None:
 
         if not os.path.isdir(self.debug_dir):
             os.mkdir(self.debug_dir)
-
-        debug_html = os.path.join(self.debug_dir, "screenshot.html")
-        async with aiofiles.open(debug_html, "wt") as file:
-            await file.write(
-                f"""
-
-
-    
-    
-
-
-""".strip(),
+        current_timestamp = "_" + int(time.time()).__str__()
+        screenshot_png_name = "screenshot" + current_timestamp + ".png"
+        debug_html = os.path.join(self.debug_dir, "screenshot" + current_timestamp + ".html")
+        if self.to_save_screenshots:
+            async with aiofiles.open(debug_html, "wt") as file:
+                await file.write(
+                    f"""
+    
+    
+        
+        
+    
+    
+    """.strip(),
+                )
+        if self.to_save_screenshots:
+            await self._page.screenshot(path=os.path.join(self.debug_dir, screenshot_png_name))
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.metadata["type"],
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+            self.logger.info(
+                f"Multimodal Web Surfer debug screens: {pathlib.Path(os.path.abspath(debug_html)).as_uri()}\n"
             )
-        await self._page.screenshot(path=os.path.join(self.debug_dir, "screenshot.png"))
-        self.logger.info(f"Multimodal Web Surfer debug screens: {pathlib.Path(os.path.abspath(debug_html)).as_uri()}\n")
 
     async def _reset(self, cancellation_token: CancellationToken) -> None:
         assert self._page is not None
         future = super()._reset(cancellation_token)
         await future
         await self._visit_page(self.start_page)
-        if self.debug_dir:
-            await self._page.screenshot(path=os.path.join(self.debug_dir, "screenshot.png"))
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot" + current_timestamp + ".png"
+            await self._page.screenshot(path=os.path.join(self.debug_dir, screenshot_png_name))  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.metadata["type"],
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+
         self.logger.info(
             WebSurferEvent(
                 source=self.metadata["type"],
@@ -373,7 +412,7 @@ async def _execute_tool(
 
         # Handle metadata
         page_metadata = json.dumps(await self._get_page_metadata(), indent=4)
-        metadata_hash = hashlib.sha256(page_metadata.encode("utf-8")).hexdigest()
+        metadata_hash = hashlib.md5(page_metadata.encode("utf-8")).hexdigest()
         if metadata_hash != self._prior_metadata_hash:
             page_metadata = (
                 "\nThe following metadata was extracted from the webpage:\n\n" + page_metadata.strip() + "\n"
@@ -394,9 +433,18 @@ async def _execute_tool(
             position_text = str(percent_scrolled) + "% down from the top of the page"
 
         new_screenshot = await self._page.screenshot()
-        if self.debug_dir:
-            async with aiofiles.open(os.path.join(self.debug_dir, "screenshot.png"), "wb") as file:
-                await file.write(new_screenshot)
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot" + current_timestamp + ".png"
+            async with aiofiles.open(os.path.join(self.debug_dir, screenshot_png_name), "wb") as file:  # type: ignore
+                await file.write(new_screenshot)  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.metadata["type"],
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
 
         ocr_text = (
             await self._get_ocr_text(new_screenshot, cancellation_token=cancellation_token) if use_ocr is True else ""
@@ -435,9 +483,17 @@ async def __generate_reply(self, cancellation_token: CancellationToken) -> Tuple
         screenshot = await self._page.screenshot()
         som_screenshot, visible_rects, rects_above, rects_below = add_set_of_mark(screenshot, rects)
 
-        if self.debug_dir:
-            som_screenshot.save(os.path.join(self.debug_dir, "screenshot.png"))
-
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot_som" + current_timestamp + ".png"
+            som_screenshot.save(os.path.join(self.debug_dir, screenshot_png_name))  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.metadata["type"],
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
         # What tools are available?
         tools = [
             TOOL_VISIT_URL,
@@ -516,8 +572,8 @@ async def __generate_reply(self, cancellation_token: CancellationToken) -> Tuple
         # Scale the screenshot for the MLM, and close the original
         scaled_screenshot = som_screenshot.resize((MLM_WIDTH, MLM_HEIGHT))
         som_screenshot.close()
-        if self.debug_dir:
-            scaled_screenshot.save(os.path.join(self.debug_dir, "screenshot_scaled.png"))
+        if self.to_save_screenshots:
+            scaled_screenshot.save(os.path.join(self.debug_dir, "screenshot_scaled.png"))  # type: ignore
 
         # Add the multimodal message and make the request
         history.append(
diff --git a/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py b/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
index 64c07313c557..9b4d62a29544 100644
--- a/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
+++ b/python/packages/autogen-magentic-one/src/autogen_magentic_one/utils.py
@@ -104,6 +104,7 @@ def message_content_to_str(
 class LogHandler(logging.FileHandler):
     def __init__(self, filename: str = "log.jsonl") -> None:
         super().__init__(filename)
+        self.logs_list: List[Dict[str, Any]] = []
 
     def emit(self, record: logging.LogRecord) -> None:
         try:
@@ -121,6 +122,7 @@ def emit(self, record: logging.LogRecord) -> None:
                         "type": "OrchestrationEvent",
                     }
                 )
+                self.logs_list.append(json.loads(record.msg))
                 super().emit(record)
             elif isinstance(record.msg, AgentEvent):
                 console_message = (
@@ -135,6 +137,7 @@ def emit(self, record: logging.LogRecord) -> None:
                         "type": "AgentEvent",
                     }
                 )
+                self.logs_list.append(json.loads(record.msg))
                 super().emit(record)
             elif isinstance(record.msg, WebSurferEvent):
                 console_message = f"\033[96m[{ts}], {record.msg.source}: {record.msg.message}\033[0m"
@@ -145,6 +148,7 @@ def emit(self, record: logging.LogRecord) -> None:
                 }
                 payload.update(asdict(record.msg))
                 record.msg = json.dumps(payload)
+                self.logs_list.append(json.loads(record.msg))
                 super().emit(record)
             elif isinstance(record.msg, LLMCallEvent):
                 record.msg = json.dumps(
@@ -155,6 +159,7 @@ def emit(self, record: logging.LogRecord) -> None:
                         "type": "LLMCallEvent",
                     }
                 )
+                self.logs_list.append(json.loads(record.msg))
                 super().emit(record)
         except Exception:
             self.handleError(record)
diff --git a/python/packages/autogen-magentic-one/tests/headless_web_surfer/test_web_surfer.py b/python/packages/autogen-magentic-one/tests/headless_web_surfer/test_web_surfer.py
index 05a66b6adbd8..769ac5080e88 100644
--- a/python/packages/autogen-magentic-one/tests/headless_web_surfer/test_web_surfer.py
+++ b/python/packages/autogen-magentic-one/tests/headless_web_surfer/test_web_surfer.py
@@ -41,7 +41,7 @@
 BLOG_POST_URL = "https://microsoft.github.io/autogen/blog/2023/04/21/LLM-tuning-math"
 BLOG_POST_TITLE = "Does Model and Inference Parameter Matter in LLM Applications? - A Case Study for MATH | AutoGen"
 BING_QUERY = "Microsoft"
-
+DEBUG_DIR = "test_logs_web_surfer_autogen"
 
 skip_all = False
 
@@ -65,6 +65,22 @@
     skip_openai = True
 
 
+def _rm_folder(path: str) -> None:
+    """Remove all the regular files in a folder, then deletes the folder. Assumes a flat file structure, with no subdirectories."""
+    for fname in os.listdir(path):
+        fpath = os.path.join(path, fname)
+        if os.path.isfile(fpath):
+            os.unlink(fpath)
+    os.rmdir(path)
+
+
+def _create_logs_dir() -> None:
+    logs_dir = os.path.join(os.getcwd(), DEBUG_DIR)
+    if os.path.isdir(logs_dir):
+        _rm_folder(logs_dir)
+    os.mkdir(logs_dir)
+
+
 def generate_tool_request(tool: ToolSchema, args: Mapping[str, str]) -> list[FunctionCall]:
     ret = [FunctionCall(id="", arguments="", name=tool["name"])]
     ret[0].arguments = dumps(args)
@@ -106,7 +122,9 @@ async def test_web_surfer() -> None:
     runtime.start()
 
     actual_surfer = await runtime.try_get_underlying_agent_instance(web_surfer, MultimodalWebSurfer)
-    await actual_surfer.init(model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium")
+    await actual_surfer.init(
+        model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium", debug_dir=DEBUG_DIR
+    )
 
     # Test some basic navigations
     tool_resp = await make_browser_request(actual_surfer, TOOL_VISIT_URL, {"url": BLOG_POST_URL})
@@ -189,7 +207,9 @@ async def test_web_surfer_oai() -> None:
     runtime.start()
 
     actual_surfer = await runtime.try_get_underlying_agent_instance(web_surfer.id, MultimodalWebSurfer)
-    await actual_surfer.init(model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium")
+    await actual_surfer.init(
+        model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium", debug_dir=DEBUG_DIR
+    )
 
     await runtime.send_message(
         BroadcastMessage(
@@ -248,7 +268,9 @@ async def test_web_surfer_bing() -> None:
 
     runtime.start()
     actual_surfer = await runtime.try_get_underlying_agent_instance(web_surfer.id, MultimodalWebSurfer)
-    await actual_surfer.init(model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium")
+    await actual_surfer.init(
+        model_client=client, downloads_folder=os.getcwd(), browser_channel="chromium", debug_dir=DEBUG_DIR
+    )
 
     # Test some basic navigations
     tool_resp = await make_browser_request(actual_surfer, TOOL_WEB_SEARCH, {"query": BING_QUERY})
@@ -262,10 +284,15 @@ async def test_web_surfer_bing() -> None:
     markdown = await actual_surfer._get_page_markdown()  # type: ignore
     assert "https://en.wikipedia.org/wiki/" in markdown
     await runtime.stop_when_idle()
+    # remove the logs directory
+    _rm_folder(DEBUG_DIR)
 
 
 if __name__ == "__main__":
     """Runs this file's tests from the command line."""
+
+    _create_logs_dir()
     asyncio.run(test_web_surfer())
     asyncio.run(test_web_surfer_oai())
+    # IMPORTANT: last test should remove the logs directory
     asyncio.run(test_web_surfer_bing())
diff --git a/python/uv.lock b/python/uv.lock
index facd0b402efe..bb7c34ec7c0d 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -4,8 +4,10 @@ resolution-markers = [
     "python_full_version < '3.11'",
     "python_full_version == '3.11.*'",
     "python_full_version >= '3.12' and python_full_version < '3.12.4'",
-    "python_full_version < '3.13'",
-    "python_full_version >= '3.13'",
+    "python_full_version < '3.11'",
+    "python_full_version == '3.11.*'",
+    "python_full_version >= '3.12' and python_full_version < '3.12.4'",
+    "python_full_version >= '3.12.4'",
 ]
 
 [manifest]
@@ -436,7 +438,7 @@ requires-dist = [
     { name = "opentelemetry-api", specifier = "~=1.27.0" },
     { name = "pillow" },
     { name = "protobuf", specifier = "~=4.25.1" },
-    { name = "pydantic", specifier = "<3.0.0,>=2.0.0" },
+    { name = "pydantic", specifier = ">=2.0.0,<3.0.0" },
     { name = "tiktoken" },
     { name = "typing-extensions" },
 ]
@@ -534,7 +536,7 @@ source = { editable = "packages/autogen-magentic-one" }
 dependencies = [
     { name = "aiofiles" },
     { name = "autogen-core" },
-    { name = "autogen-ext" },
+    { name = "autogen-ext", extra = ["docker"] },
     { name = "beautifulsoup4" },
     { name = "mammoth" },
     { name = "markdownify" },
@@ -567,7 +569,7 @@ dev = [
 requires-dist = [
     { name = "aiofiles" },
     { name = "autogen-core", editable = "packages/autogen-core" },
-    { name = "autogen-ext", editable = "packages/autogen-ext" },
+    { name = "autogen-ext", extras = ["docker"], editable = "packages/autogen-ext" },
     { name = "beautifulsoup4" },
     { name = "mammoth" },
     { name = "markdownify" },
@@ -578,7 +580,7 @@ requires-dist = [
     { name = "pdfminer-six" },
     { name = "playwright" },
     { name = "puremagic" },
-    { name = "pydantic", specifier = "<3.0.0,>=2.0.0" },
+    { name = "pydantic", specifier = ">=2.0.0,<3.0.0" },
     { name = "pydub" },
     { name = "python-pptx" },
     { name = "requests" },
@@ -3672,7 +3674,7 @@ name = "psycopg"
 version = "3.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+    { name = "typing-extensions" },
     { name = "tzdata", marker = "sys_platform == 'win32'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/d1/ad/7ce016ae63e231575df0498d2395d15f005f05e32d3a2d439038e1bd0851/psycopg-3.2.3.tar.gz", hash = "sha256:a5764f67c27bec8bfac85764d23c534af2c27b893550377e37ce59c12aac47a2", size = 155550 }
@@ -4798,7 +4800,7 @@ name = "sqlalchemy"
 version = "2.0.36"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "greenlet", marker = "(python_full_version < '3.13' and platform_machine == 'AMD64') or (python_full_version < '3.13' and platform_machine == 'WIN32') or (python_full_version < '3.13' and platform_machine == 'aarch64') or (python_full_version < '3.13' and platform_machine == 'amd64') or (python_full_version < '3.13' and platform_machine == 'ppc64le') or (python_full_version < '3.13' and platform_machine == 'win32') or (python_full_version < '3.13' and platform_machine == 'x86_64')" },
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
     { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/65/9cbc9c4c3287bed2499e05033e207473504dc4df999ce49385fb1f8b058a/sqlalchemy-2.0.36.tar.gz", hash = "sha256:7f2767680b6d2398aea7082e45a774b2b0767b5c8d8ffb9c8b683088ea9b29c5", size = 9574485 }

From 10987685b9f69463a19f2c4681de95f562167647 Mon Sep 17 00:00:00 2001
From: Hussein Mozannar 
Date: Mon, 4 Nov 2024 17:45:59 -0800
Subject: [PATCH 074/173] Update README.md for magentic-one (#4061)

---
 python/packages/autogen-magentic-one/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/packages/autogen-magentic-one/README.md b/python/packages/autogen-magentic-one/README.md
index e764ece8985d..c5216af7a41e 100644
--- a/python/packages/autogen-magentic-one/README.md
+++ b/python/packages/autogen-magentic-one/README.md
@@ -69,7 +69,7 @@ The following instructions are for running the example code:
 4. Magentic-One uses playwright to interact with web pages. You need to install the playwright dependencies. Run the following command to install the playwright dependencies:
 
 ```bash
-playwright install-deps
+playwright install --with-deps chromium
 ```
 5. Now you can run the example code to see how the agents work together to accomplish a task.
 

From c3283c64a3d3eb0bc81d66847d2d37a2f1a1b585 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 5 Nov 2024 08:07:49 -0800
Subject: [PATCH 075/173] Agentchat refactor (#4062)

* Agentchat refactor

* Move termination stop message to a separate field in task result

* Update quick start example

* Use string stop reason instead of stop message in task result for simpler API

* Use main function
---
 .../agents/_assistant_agent.py                |  40 ++----
 .../agents/_base_chat_agent.py                |   8 +-
 .../src/autogen_agentchat/base/_task.py       |   9 +-
 .../autogen_agentchat/base/_termination.py    |   8 +-
 .../logging/_console_log_handler.py           |  62 ++-------
 .../logging/_file_log_handler.py              |  70 +----------
 .../src/autogen_agentchat/messages.py         |  10 +-
 .../autogen_agentchat/task/_terminations.py   |  10 +-
 .../src/autogen_agentchat/teams/_events.py    |  51 --------
 .../teams/_group_chat/_base_group_chat.py     |  57 +++++----
 .../_group_chat/_base_group_chat_manager.py   | 118 +++++++-----------
 .../_group_chat/_chat_agent_container.py      |  26 ++--
 .../teams/_group_chat/_events.py              |  38 ++++++
 .../_group_chat/_round_robin_group_chat.py    |  24 ++--
 .../teams/_group_chat/_selector_group_chat.py |  54 ++++----
 .../teams/_group_chat/_swarm_group_chat.py    |  25 ++--
 .../tests/test_group_chat.py                  |  18 ++-
 .../agentchat-user-guide/quickstart.ipynb     |  68 +++++-----
 18 files changed, 284 insertions(+), 412 deletions(-)
 delete mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index daaacda15870..862b15e07f12 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -15,7 +15,7 @@
     UserMessage,
 )
 from autogen_core.components.tools import FunctionTool, Tool
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, Field, model_validator
 
 from .. import EVENT_LOGGER_NAME
 from ..base import Response
@@ -33,30 +33,6 @@
 event_logger = logging.getLogger(EVENT_LOGGER_NAME)
 
 
-class ToolCallEvent(BaseModel):
-    """A tool call event."""
-
-    source: str
-    """The source of the event."""
-
-    tool_calls: List[FunctionCall]
-    """The tool call message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class ToolCallResultEvent(BaseModel):
-    """A tool call result event."""
-
-    source: str
-    """The source of the event."""
-
-    tool_call_results: List[FunctionExecutionResult]
-    """The tool call result message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
 class Handoff(BaseModel):
     """Handoff configuration for :class:`AssistantAgent`."""
 
@@ -264,19 +240,21 @@ async def on_messages_stream(
 
         # Run tool calls until the model produces a string response.
         while isinstance(result.content, list) and all(isinstance(item, FunctionCall) for item in result.content):
-            event_logger.debug(ToolCallEvent(tool_calls=result.content, source=self.name))
+            tool_call_msg = ToolCallMessage(content=result.content, source=self.name, models_usage=result.usage)
+            event_logger.debug(tool_call_msg)
             # Add the tool call message to the output.
-            inner_messages.append(ToolCallMessage(content=result.content, source=self.name, models_usage=result.usage))
-            yield ToolCallMessage(content=result.content, source=self.name, models_usage=result.usage)
+            inner_messages.append(tool_call_msg)
+            yield tool_call_msg
 
             # Execute the tool calls.
             results = await asyncio.gather(
                 *[self._execute_tool_call(call, cancellation_token) for call in result.content]
             )
-            event_logger.debug(ToolCallResultEvent(tool_call_results=results, source=self.name))
+            tool_call_result_msg = ToolCallResultMessage(content=results, source=self.name)
+            event_logger.debug(tool_call_result_msg)
             self._model_context.append(FunctionExecutionResultMessage(content=results))
-            inner_messages.append(ToolCallResultMessage(content=results, source=self.name))
-            yield ToolCallResultMessage(content=results, source=self.name)
+            inner_messages.append(tool_call_result_msg)
+            yield tool_call_result_msg
 
             # Detect handoff requests.
             handoffs: List[Handoff] = []
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index cf146b0c10fb..bbfc1ce1e0ab 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -4,7 +4,7 @@
 from autogen_core.base import CancellationToken
 
 from ..base import ChatAgent, Response, TaskResult
-from ..messages import ChatMessage, InnerMessage, TextMessage
+from ..messages import AgentMessage, ChatMessage, InnerMessage, TextMessage
 
 
 class BaseChatAgent(ChatAgent, ABC):
@@ -62,7 +62,7 @@ async def run(
             cancellation_token = CancellationToken()
         first_message = TextMessage(content=task, source="user")
         response = await self.on_messages([first_message], cancellation_token)
-        messages: List[InnerMessage | ChatMessage] = [first_message]
+        messages: List[AgentMessage] = [first_message]
         if response.inner_messages is not None:
             messages += response.inner_messages
         messages.append(response.chat_message)
@@ -73,14 +73,14 @@ async def run_stream(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+    ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the agent with the given task and return a stream of messages
         and the final task result as the last item in the stream."""
         if cancellation_token is None:
             cancellation_token = CancellationToken()
         first_message = TextMessage(content=task, source="user")
         yield first_message
-        messages: List[InnerMessage | ChatMessage] = [first_message]
+        messages: List[AgentMessage] = [first_message]
         async for message in self.on_messages_stream([first_message], cancellation_token):
             if isinstance(message, Response):
                 yield message.chat_message
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index a642120799f2..1c33f7ecc185 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -3,16 +3,19 @@
 
 from autogen_core.base import CancellationToken
 
-from ..messages import ChatMessage, InnerMessage
+from ..messages import AgentMessage
 
 
 @dataclass
 class TaskResult:
     """Result of running a task."""
 
-    messages: Sequence[InnerMessage | ChatMessage]
+    messages: Sequence[AgentMessage]
     """Messages produced by the task."""
 
+    stop_reason: str | None = None
+    """The reason the task stopped."""
+
 
 class TaskRunner(Protocol):
     """A task runner."""
@@ -31,7 +34,7 @@ def run_stream(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+    ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the task and produces a stream of messages and the final result
         :class:`TaskResult` as the last item in the stream."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
index 1442dd51358a..859740fa093e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_termination.py
@@ -2,7 +2,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Sequence
 
-from ..messages import ChatMessage, StopMessage
+from ..messages import AgentMessage, StopMessage
 
 
 class TerminatedException(BaseException): ...
@@ -50,7 +50,7 @@ def terminated(self) -> bool:
         ...
 
     @abstractmethod
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         """Check if the conversation should be terminated based on the messages received
         since the last time the condition was called.
         Return a StopMessage if the conversation should be terminated, or None otherwise.
@@ -88,7 +88,7 @@ def __init__(self, *conditions: TerminationCondition) -> None:
     def terminated(self) -> bool:
         return all(condition.terminated for condition in self._conditions)
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self.terminated:
             raise TerminatedException("Termination condition has already been reached.")
         # Check all remaining conditions.
@@ -120,7 +120,7 @@ def __init__(self, *conditions: TerminationCondition) -> None:
     def terminated(self) -> bool:
         return any(condition.terminated for condition in self._conditions)
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self.terminated:
             raise RuntimeError("Termination condition has already been reached")
         stop_messages = await asyncio.gather(*[condition(messages) for condition in self._conditions])
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
index 571cc875cec3..cc292e76c7c4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_console_log_handler.py
@@ -3,62 +3,18 @@
 import sys
 from datetime import datetime
 
-from ..agents._assistant_agent import ToolCallEvent, ToolCallResultEvent
-from ..messages import ChatMessage, StopMessage, TextMessage
-from ..teams._events import (
-    GroupChatPublishEvent,
-    GroupChatSelectSpeakerEvent,
-    TerminationEvent,
-)
+from pydantic import BaseModel
 
 
 class ConsoleLogHandler(logging.Handler):
-    @staticmethod
-    def serialize_chat_message(message: ChatMessage) -> str:
-        if isinstance(message, TextMessage | StopMessage):
-            return message.content
-        else:
-            d = message.model_dump()
-            assert "content" in d
-            return json.dumps(d["content"], indent=2)
-
     def emit(self, record: logging.LogRecord) -> None:
         ts = datetime.fromtimestamp(record.created).isoformat()
-        if isinstance(record.msg, GroupChatPublishEvent):
-            if record.msg.source is None:
-                sys.stdout.write(
-                    f"\n{'-'*75} \n"
-                    f"\033[91m[{ts}]:\033[0m\n"
-                    f"\n{self.serialize_chat_message(record.msg.agent_message)}"
-                )
-            else:
-                sys.stdout.write(
-                    f"\n{'-'*75} \n"
-                    f"\033[91m[{ts}], {record.msg.source.type}:\033[0m\n"
-                    f"\n{self.serialize_chat_message(record.msg.agent_message)}"
-                )
-            sys.stdout.flush()
-        elif isinstance(record.msg, ToolCallEvent):
-            sys.stdout.write(
-                f"\n{'-'*75} \n" f"\033[91m[{ts}], Tool Call:\033[0m\n" f"\n{str(record.msg.model_dump())}"
-            )
-            sys.stdout.flush()
-        elif isinstance(record.msg, ToolCallResultEvent):
-            sys.stdout.write(
-                f"\n{'-'*75} \n" f"\033[91m[{ts}], Tool Call Result:\033[0m\n" f"\n{str(record.msg.model_dump())}"
-            )
-            sys.stdout.flush()
-        elif isinstance(record.msg, GroupChatSelectSpeakerEvent):
-            sys.stdout.write(
-                f"\n{'-'*75} \n" f"\033[91m[{ts}], Selected Next Speaker:\033[0m\n" f"\n{record.msg.selected_speaker}"
-            )
-            sys.stdout.flush()
-        elif isinstance(record.msg, TerminationEvent):
-            sys.stdout.write(
-                f"\n{'-'*75} \n"
-                f"\033[91m[{ts}], Termination:\033[0m\n"
-                f"\n{self.serialize_chat_message(record.msg.agent_message)}"
+        if isinstance(record.msg, BaseModel):
+            record.msg = json.dumps(
+                {
+                    "timestamp": ts,
+                    "message": record.msg.model_dump_json(indent=2),
+                    "type": record.msg.__class__.__name__,
+                },
             )
-            sys.stdout.flush()
-        else:
-            raise ValueError(f"Unexpected log record: {record.msg}")
+        sys.stdout.write(f"{record.msg}\n")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
index 9923f313d9e5..1e4b402da35a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/logging/_file_log_handler.py
@@ -1,15 +1,8 @@
 import json
 import logging
-from dataclasses import asdict, is_dataclass
 from datetime import datetime
-from typing import Any
 
-from ..agents._assistant_agent import ToolCallEvent, ToolCallResultEvent
-from ..teams._events import (
-    GroupChatPublishEvent,
-    GroupChatSelectSpeakerEvent,
-    TerminationEvent,
-)
+from pydantic import BaseModel
 
 
 class FileLogHandler(logging.Handler):
@@ -20,65 +13,12 @@ def __init__(self, filename: str) -> None:
 
     def emit(self, record: logging.LogRecord) -> None:
         ts = datetime.fromtimestamp(record.created).isoformat()
-        if isinstance(record.msg, GroupChatPublishEvent | TerminationEvent):
-            log_entry = json.dumps(
+        if isinstance(record.msg, BaseModel):
+            record.msg = json.dumps(
                 {
                     "timestamp": ts,
-                    "source": record.msg.source,
-                    "agent_message": record.msg.agent_message.model_dump(),
+                    "message": record.msg.model_dump(),
                     "type": record.msg.__class__.__name__,
                 },
-                default=self.json_serializer,
             )
-        elif isinstance(record.msg, GroupChatSelectSpeakerEvent):
-            log_entry = json.dumps(
-                {
-                    "timestamp": ts,
-                    "source": record.msg.source,
-                    "selected_speaker": record.msg.selected_speaker,
-                    "type": "SelectSpeakerEvent",
-                },
-                default=self.json_serializer,
-            )
-        elif isinstance(record.msg, ToolCallEvent):
-            log_entry = json.dumps(
-                {
-                    "timestamp": ts,
-                    "tool_calls": record.msg.model_dump(),
-                    "type": "ToolCallEvent",
-                },
-                default=self.json_serializer,
-            )
-        elif isinstance(record.msg, ToolCallResultEvent):
-            log_entry = json.dumps(
-                {
-                    "timestamp": ts,
-                    "tool_call_results": record.msg.model_dump(),
-                    "type": "ToolCallResultEvent",
-                },
-                default=self.json_serializer,
-            )
-        else:
-            raise ValueError(f"Unexpected log record: {record.msg}")
-        file_record = logging.LogRecord(
-            name=record.name,
-            level=record.levelno,
-            pathname=record.pathname,
-            lineno=record.lineno,
-            msg=log_entry,
-            args=(),
-            exc_info=record.exc_info,
-        )
-        self.file_handler.emit(file_record)
-
-    def close(self) -> None:
-        self.file_handler.close()
-        super().close()
-
-    @staticmethod
-    def json_serializer(obj: Any) -> Any:
-        if is_dataclass(obj) and not isinstance(obj, type):
-            return asdict(obj)
-        elif isinstance(obj, type):
-            return str(obj)
-        return str(obj)
+        self.file_handler.emit(record)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 1ac85edf1bd1..c2d2b7abf5cc 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -2,7 +2,7 @@
 
 from autogen_core.components import FunctionCall, Image
 from autogen_core.components.models import FunctionExecutionResult, RequestUsage
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 
 class BaseMessage(BaseModel):
@@ -14,6 +14,8 @@ class BaseMessage(BaseModel):
     models_usage: RequestUsage | None = None
     """The model client usage incurred when producing this message."""
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
 
 class TextMessage(BaseMessage):
     """A text message."""
@@ -75,6 +77,10 @@ class ToolCallResultMessage(BaseMessage):
 """Messages for agent-to-agent communication."""
 
 
+AgentMessage = InnerMessage | ChatMessage
+"""All message types."""
+
+
 __all__ = [
     "BaseMessage",
     "TextMessage",
@@ -85,4 +91,6 @@ class ToolCallResultMessage(BaseMessage):
     "ToolCallMessage",
     "ToolCallResultMessage",
     "ChatMessage",
+    "InnerMessage",
+    "AgentMessage",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
index 825d5bea28e6..68662326c9dd 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_terminations.py
@@ -1,7 +1,7 @@
 from typing import Sequence
 
 from ..base import TerminatedException, TerminationCondition
-from ..messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
+from ..messages import AgentMessage, MultiModalMessage, StopMessage, TextMessage
 
 
 class StopMessageTermination(TerminationCondition):
@@ -14,7 +14,7 @@ def __init__(self) -> None:
     def terminated(self) -> bool:
         return self._terminated
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self._terminated:
             raise TerminatedException("Termination condition has already been reached")
         for message in messages:
@@ -42,7 +42,7 @@ def __init__(self, max_messages: int) -> None:
     def terminated(self) -> bool:
         return self._message_count >= self._max_messages
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self.terminated:
             raise TerminatedException("Termination condition has already been reached")
         self._message_count += len(messages)
@@ -72,7 +72,7 @@ def __init__(self, text: str) -> None:
     def terminated(self) -> bool:
         return self._terminated
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self._terminated:
             raise TerminatedException("Termination condition has already been reached")
         for message in messages:
@@ -127,7 +127,7 @@ def terminated(self) -> bool:
             or (self._max_completion_token is not None and self._completion_token_count >= self._max_completion_token)
         )
 
-    async def __call__(self, messages: Sequence[ChatMessage]) -> StopMessage | None:
+    async def __call__(self, messages: Sequence[AgentMessage]) -> StopMessage | None:
         if self.terminated:
             raise TerminatedException("Termination condition has already been reached")
         for message in messages:
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
deleted file mode 100644
index 3442b35ce87a..000000000000
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_events.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from autogen_core.base import AgentId
-from pydantic import BaseModel, ConfigDict
-
-from ..messages import ChatMessage, StopMessage
-
-
-class GroupChatPublishEvent(BaseModel):
-    """An group chat event for sharing some data. Agents receive this event should
-    update their internal state (e.g., append to message history) with the
-    content of the event.
-    """
-
-    agent_message: ChatMessage
-    """The message published by the agent."""
-
-    source: AgentId | None = None
-    """The agent ID that published the message."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class GroupChatRequestPublishEvent(BaseModel):
-    """An event for requesting to publish a group chat publish event.
-    Upon receiving this event, the agent should publish a group chat publish event.
-    """
-
-    ...
-
-
-class GroupChatSelectSpeakerEvent(BaseModel):
-    """An event for selecting the next speaker in a group chat."""
-
-    selected_speaker: str
-    """The name of the selected speaker."""
-
-    source: AgentId
-    """The agent ID that selected the speaker."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-
-class TerminationEvent(BaseModel):
-    """An event for terminating a conversation."""
-
-    agent_message: StopMessage
-    """The stop message that terminates the conversation."""
-
-    source: AgentId
-    """The agent ID that triggered the termination."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index cd4efe8f350e..cc5c0e58138a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -1,4 +1,5 @@
 import asyncio
+import logging
 import uuid
 from abc import ABC, abstractmethod
 from typing import AsyncGenerator, Callable, List
@@ -15,11 +16,14 @@
 )
 from autogen_core.components import ClosureAgent, TypeSubscription
 
+from ... import EVENT_LOGGER_NAME
 from ...base import ChatAgent, TaskResult, Team, TerminationCondition
-from ...messages import ChatMessage, InnerMessage, TextMessage
-from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
+from ...messages import AgentMessage, TextMessage
 from ._base_group_chat_manager import BaseGroupChatManager
 from ._chat_agent_container import ChatAgentContainer
+from ._events import GroupChatMessage, GroupChatStart, GroupChatTermination
+
+event_logger = logging.getLogger(EVENT_LOGGER_NAME)
 
 
 class BaseGroupChat(Team, ABC):
@@ -43,14 +47,16 @@ def __init__(
         self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
         self._termination_condition = termination_condition
+        self._message_thread: List[AgentMessage] = []
 
     @abstractmethod
     def _create_group_chat_manager_factory(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], BaseGroupChatManager]: ...
 
@@ -90,9 +96,14 @@ async def run_stream(
         task: str,
         *,
         cancellation_token: CancellationToken | None = None,
-    ) -> AsyncGenerator[InnerMessage | ChatMessage | TaskResult, None]:
+    ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the team and produces a stream of messages and the final result
         of the type :class:`TaskResult` as the last item in the stream."""
+
+        # TODO: runtime is currently a local variable, but it should be stored in
+        # a managed context so it can be accessed by all nested teams. Also, the runtime
+        # should be not be started or stopped by the team, but by the context.
+
         # Create the runtime.
         runtime = SingleThreadedAgentRuntime()
 
@@ -100,7 +111,6 @@ async def run_stream(
         group_chat_manager_agent_type = AgentType("group_chat_manager")
         group_chat_manager_topic_type = group_chat_manager_agent_type.type
         group_topic_type = "round_robin_group_topic"
-        team_topic_type = "team_topic"
         output_topic_type = "output_topic"
 
         # Register participants.
@@ -128,10 +138,11 @@ async def run_stream(
             runtime,
             type=group_chat_manager_agent_type.type,
             factory=self._create_group_chat_manager_factory(
-                parent_topic_type=team_topic_type,
                 group_topic_type=group_topic_type,
+                output_topic_type=output_topic_type,
                 participant_topic_types=participant_topic_types,
                 participant_descriptions=participant_descriptions,
+                message_thread=self._message_thread,
                 termination_condition=self._termination_condition,
             ),
         )
@@ -142,21 +153,23 @@ async def run_stream(
         await runtime.add_subscription(
             TypeSubscription(topic_type=group_topic_type, agent_type=group_chat_manager_agent_type.type)
         )
-        await runtime.add_subscription(
-            TypeSubscription(topic_type=team_topic_type, agent_type=group_chat_manager_agent_type.type)
-        )
 
-        output_messages: List[InnerMessage | ChatMessage] = []
-        output_message_queue: asyncio.Queue[InnerMessage | ChatMessage | None] = asyncio.Queue()
+        # Create a closure agent to collect the output messages.
+        stop_reason: str | None = None
+        output_message_queue: asyncio.Queue[AgentMessage | None] = asyncio.Queue()
 
         async def collect_output_messages(
             _runtime: AgentRuntime,
             id: AgentId,
-            message: InnerMessage | ChatMessage,
+            message: GroupChatStart | GroupChatMessage | GroupChatTermination,
             ctx: MessageContext,
         ) -> None:
-            output_messages.append(message)
-            await output_message_queue.put(message)
+            event_logger.info(message.message)
+            if isinstance(message, GroupChatTermination):
+                nonlocal stop_reason
+                stop_reason = message.message.content
+                return
+            await output_message_queue.put(message.message)
 
         await ClosureAgent.register(
             runtime,
@@ -170,17 +183,12 @@ async def collect_output_messages(
         # Start the runtime.
         runtime.start()
 
-        # Run the team by publishing the task to the team topic and then requesting the result.
-        team_topic_id = TopicId(type=team_topic_type, source=self._team_id)
-        group_chat_manager_topic_id = TopicId(type=group_chat_manager_topic_type, source=self._team_id)
+        # Run the team by publishing the task to the group chat manager.
         first_chat_message = TextMessage(content=task, source="user")
-        output_messages.append(first_chat_message)
-        await output_message_queue.put(first_chat_message)
         await runtime.publish_message(
-            GroupChatPublishEvent(agent_message=first_chat_message),
-            topic_id=team_topic_id,
+            GroupChatStart(message=first_chat_message),
+            topic_id=TopicId(type=group_topic_type, source=self._team_id),
         )
-        await runtime.publish_message(GroupChatRequestPublishEvent(), topic_id=group_chat_manager_topic_id)
 
         # Start a coroutine to stop the runtime and signal the output message queue is complete.
         async def stop_runtime() -> None:
@@ -189,15 +197,18 @@ async def stop_runtime() -> None:
 
         shutdown_task = asyncio.create_task(stop_runtime())
 
+        # Collect the output messages in order.
+        output_messages: List[AgentMessage] = []
         # Yield the messsages until the queue is empty.
         while True:
             message = await output_message_queue.get()
             if message is None:
                 break
             yield message
+            output_messages.append(message)
 
         # Wait for the shutdown task to finish.
         await shutdown_task
 
         # Yield the final result.
-        yield TaskResult(messages=output_messages)
+        yield TaskResult(messages=output_messages, stop_reason=stop_reason)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
index 68eb76c06e81..ab10c2b864c5 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
@@ -1,139 +1,111 @@
-import logging
 from abc import ABC, abstractmethod
 from typing import Any, List
 
 from autogen_core.base import MessageContext
 from autogen_core.components import DefaultTopicId, event
 
-from ... import EVENT_LOGGER_NAME
 from ...base import TerminationCondition
-from .._events import (
-    GroupChatPublishEvent,
-    GroupChatRequestPublishEvent,
-    TerminationEvent,
-)
+from ...messages import AgentMessage, StopMessage
+from ._events import GroupChatAgentResponse, GroupChatRequestPublish, GroupChatStart, GroupChatTermination
 from ._sequential_routed_agent import SequentialRoutedAgent
 
-event_logger = logging.getLogger(EVENT_LOGGER_NAME)
-
 
 class BaseGroupChatManager(SequentialRoutedAgent, ABC):
     """Base class for a group chat manager that manages a group chat with multiple participants.
 
     It is the responsibility of the caller to ensure:
     - All participants must subscribe to the group chat topic and each of their own topics.
-    - The group chat manager must subscribe to the parent topic and the group chat topic.
+    - The group chat manager must subscribe to the group chat topic.
     - The agent types of the participants must be unique.
     - For each participant, the agent type must be the same as the topic type.
 
     Without the above conditions, the group chat will not function correctly.
-
-    Args:
-        parent_topic_type (str): The topic type of the parent orchestrator.
-        group_topic_type (str): The topic type of the group chat.
-        participant_topic_types (List[str]): The topic types of the participants.
-        participant_descriptions (List[str]): The descriptions of the participants
-        termination_condition (TerminationCondition, optional): The termination condition for the group chat. Defaults to None.
-
-    Raises:
-        ValueError: If the number of participant topic types, agent types, and descriptions are not the same.
-        ValueError: If the participant topic types are not unique.
-        ValueError: If the group topic type is in the participant topic types.
-        ValueError: If the parent topic type is in the participant topic types.
-        ValueError: If the group topic type is the same as the parent topic type.
     """
 
     def __init__(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None = None,
     ):
         super().__init__(description="Group chat manager")
-        self._parent_topic_type = parent_topic_type
         self._group_topic_type = group_topic_type
+        self._output_topic_type = output_topic_type
         if len(participant_topic_types) != len(participant_descriptions):
             raise ValueError("The number of participant topic types, agent types, and descriptions must be the same.")
         if len(set(participant_topic_types)) != len(participant_topic_types):
             raise ValueError("The participant topic types must be unique.")
         if group_topic_type in participant_topic_types:
             raise ValueError("The group topic type must not be in the participant topic types.")
-        if parent_topic_type in participant_topic_types:
-            raise ValueError("The parent topic type must not be in the participant topic types.")
-        if group_topic_type == parent_topic_type:
-            raise ValueError("The group topic type must not be the same as the parent topic type.")
         self._participant_topic_types = participant_topic_types
         self._participant_descriptions = participant_descriptions
-        self._message_thread: List[GroupChatPublishEvent] = []
+        self._message_thread = message_thread
         self._termination_condition = termination_condition
 
     @event
-    async def handle_content_publish(self, message: GroupChatPublishEvent, ctx: MessageContext) -> None:
-        """Handle a content publish event.
-
-        If the event is from the parent topic, add the message to the thread.
+    async def handle_start(self, message: GroupChatStart, ctx: MessageContext) -> None:
+        """Handle the start of a group chat by selecting a speaker to start the conversation."""
 
-        If the event is from the group chat topic, add the message to the thread and select a speaker to continue the conversation.
-        If the event from the group chat session requests a pause, publish the last message to the parent topic."""
-        assert ctx.topic_id is not None
-
-        event_logger.info(message)
+        # Log the start message.
+        await self.publish_message(message, topic_id=DefaultTopicId(type=self._output_topic_type))
 
+        # Check if the conversation has already terminated.
         if self._termination_condition is not None and self._termination_condition.terminated:
-            # The group chat has been terminated.
-            return
-
-        # Process event from parent.
-        if ctx.topic_id.type == self._parent_topic_type:
-            self._message_thread.append(message)
+            early_stop_message = StopMessage(
+                content="The group chat has already terminated.", source="Group chat manager"
+            )
             await self.publish_message(
-                GroupChatPublishEvent(agent_message=message.agent_message, source=self.id),
-                topic_id=DefaultTopicId(type=self._group_topic_type),
+                GroupChatTermination(message=early_stop_message), topic_id=DefaultTopicId(type=self._output_topic_type)
             )
-            if self._termination_condition is not None:
-                stop_message = await self._termination_condition([message.agent_message])
-                if stop_message is not None:
-                    event_logger.info(TerminationEvent(agent_message=stop_message, source=self.id))
-                    # Stop the group chat.
+            # Stop the group chat.
             return
 
-        # Process event from the group chat this agent manages.
-        assert ctx.topic_id.type == self._group_topic_type
-        self._message_thread.append(message)
+        # Append the user message to the message thread.
+        self._message_thread.append(message.message)
 
         # Check if the conversation should be terminated.
         if self._termination_condition is not None:
-            stop_message = await self._termination_condition([message.agent_message])
+            stop_message = await self._termination_condition([message.message])
             if stop_message is not None:
-                event_logger.info(TerminationEvent(agent_message=stop_message, source=self.id))
+                await self.publish_message(
+                    GroupChatTermination(message=stop_message), topic_id=DefaultTopicId(type=self._output_topic_type)
+                )
                 # Stop the group chat.
-                # TODO: this should be different if the group chat is nested.
                 return
 
-        # Select a speaker to continue the conversation.
         speaker_topic_type = await self.select_speaker(self._message_thread)
-
-        await self.publish_message(GroupChatRequestPublishEvent(), topic_id=DefaultTopicId(type=speaker_topic_type))
+        await self.publish_message(GroupChatRequestPublish(), topic_id=DefaultTopicId(type=speaker_topic_type))
 
     @event
-    async def handle_content_request(self, message: GroupChatRequestPublishEvent, ctx: MessageContext) -> None:
-        """Handle a content request by selecting a speaker to start the conversation."""
-        assert ctx.topic_id is not None
-        if ctx.topic_id.type == self._group_topic_type:
-            raise RuntimeError("Content request event from the group chat topic is not allowed.")
+    async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: MessageContext) -> None:
+        # Append the message to the message thread and construct the delta.
+        delta: List[AgentMessage] = []
+        if message.agent_response.inner_messages is not None:
+            for inner_message in message.agent_response.inner_messages:
+                self._message_thread.append(inner_message)
+                delta.append(inner_message)
+        self._message_thread.append(message.agent_response.chat_message)
+        delta.append(message.agent_response.chat_message)
 
-        if self._termination_condition is not None and self._termination_condition.terminated:
-            # The group chat has been terminated.
-            return
+        # Check if the conversation should be terminated.
+        if self._termination_condition is not None:
+            stop_message = await self._termination_condition(delta)
+            if stop_message is not None:
+                await self.publish_message(
+                    GroupChatTermination(message=stop_message), topic_id=DefaultTopicId(type=self._output_topic_type)
+                )
+                # Stop the group chat.
+                return
 
+        # Select a speaker to continue the conversation.
         speaker_topic_type = await self.select_speaker(self._message_thread)
-
-        await self.publish_message(GroupChatRequestPublishEvent(), topic_id=DefaultTopicId(type=speaker_topic_type))
+        await self.publish_message(GroupChatRequestPublish(), topic_id=DefaultTopicId(type=speaker_topic_type))
 
     @abstractmethod
-    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants and return the
         topic type of the selected speaker."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index 3fde3f6864b9..49325c39f044 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -5,7 +5,7 @@
 
 from ...base import ChatAgent, Response
 from ...messages import ChatMessage
-from .._events import GroupChatPublishEvent, GroupChatRequestPublishEvent
+from ._events import GroupChatAgentResponse, GroupChatMessage, GroupChatRequestPublish, GroupChatStart
 from ._sequential_routed_agent import SequentialRoutedAgent
 
 
@@ -28,33 +28,41 @@ def __init__(self, parent_topic_type: str, output_topic_type: str, agent: ChatAg
         self._message_buffer: List[ChatMessage] = []
 
     @event
-    async def handle_message(self, message: GroupChatPublishEvent, ctx: MessageContext) -> None:
-        """Handle an event by appending the content to the buffer."""
-        self._message_buffer.append(message.agent_message)
+    async def handle_start(self, message: GroupChatStart, ctx: MessageContext) -> None:
+        """Handle a start event by appending the content to the buffer."""
+        self._message_buffer.append(message.message)
 
     @event
-    async def handle_content_request(self, message: GroupChatRequestPublishEvent, ctx: MessageContext) -> None:
+    async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: MessageContext) -> None:
+        """Handle an agent response event by appending the content to the buffer."""
+        self._message_buffer.append(message.agent_response.chat_message)
+
+    @event
+    async def handle_request(self, message: GroupChatRequestPublish, ctx: MessageContext) -> None:
         """Handle a content request event by passing the messages in the buffer
         to the delegate agent and publish the response."""
         # Pass the messages in the buffer to the delegate agent.
         response: Response | None = None
         async for msg in self._agent.on_messages_stream(self._message_buffer, ctx.cancellation_token):
             if isinstance(msg, Response):
+                # Log the response.
                 await self.publish_message(
-                    msg.chat_message,
+                    GroupChatMessage(message=msg.chat_message),
                     topic_id=DefaultTopicId(type=self._output_topic_type),
                 )
                 response = msg
             else:
-                # Publish the message to the output topic.
-                await self.publish_message(msg, topic_id=DefaultTopicId(type=self._output_topic_type))
+                # Log the message.
+                await self.publish_message(
+                    GroupChatMessage(message=msg), topic_id=DefaultTopicId(type=self._output_topic_type)
+                )
         if response is None:
             raise ValueError("The agent did not produce a final response. Check the agent's on_messages_stream method.")
 
         # Publish the response to the group chat.
         self._message_buffer.clear()
         await self.publish_message(
-            GroupChatPublishEvent(agent_message=response.chat_message, source=self.id),
+            GroupChatAgentResponse(agent_response=response),
             topic_id=DefaultTopicId(type=self._parent_topic_type),
         )
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
new file mode 100644
index 000000000000..0b146c88667e
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
@@ -0,0 +1,38 @@
+from pydantic import BaseModel
+
+from ...base import Response
+from ...messages import AgentMessage, ChatMessage, StopMessage
+
+
+class GroupChatStart(BaseModel):
+    """A request to start a group chat."""
+
+    message: ChatMessage
+    """The user message that started the group chat."""
+
+
+class GroupChatAgentResponse(BaseModel):
+    """A response published to a group chat."""
+
+    agent_response: Response
+    """The response from an agent."""
+
+
+class GroupChatRequestPublish(BaseModel):
+    """A request to publish a message to a group chat."""
+
+    ...
+
+
+class GroupChatMessage(BaseModel):
+    """A message from a group chat."""
+
+    message: AgentMessage
+    """The message that was published."""
+
+
+class GroupChatTermination(BaseModel):
+    """A message indicating that a group chat has terminated."""
+
+    message: StopMessage
+    """The stop message that indicates the reason of termination."""
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index 3ef4a2e07ad0..4f355b58e66c 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -1,44 +1,38 @@
-import logging
 from typing import Callable, List
 
-from ... import EVENT_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
-from .._events import (
-    GroupChatPublishEvent,
-    GroupChatSelectSpeakerEvent,
-)
+from ...messages import AgentMessage
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
-event_logger = logging.getLogger(EVENT_LOGGER_NAME)
-
 
 class RoundRobinGroupChatManager(BaseGroupChatManager):
     """A group chat manager that selects the next speaker in a round-robin fashion."""
 
     def __init__(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> None:
         super().__init__(
-            parent_topic_type,
             group_topic_type,
+            output_topic_type,
             participant_topic_types,
             participant_descriptions,
+            message_thread,
             termination_condition,
         )
         self._next_speaker_index = 0
 
-    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants in a round-robin fashion."""
         current_speaker_index = self._next_speaker_index
         self._next_speaker_index = (current_speaker_index + 1) % len(self._participant_topic_types)
         current_speaker = self._participant_topic_types[current_speaker_index]
-        event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=current_speaker, source=self.id))
         return current_speaker
 
 
@@ -126,18 +120,20 @@ def __init__(
 
     def _create_group_chat_manager_factory(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], RoundRobinGroupChatManager]:
         def _factory() -> RoundRobinGroupChatManager:
             return RoundRobinGroupChatManager(
-                parent_topic_type,
                 group_topic_type,
+                output_topic_type,
                 participant_topic_types,
                 participant_descriptions,
+                message_thread,
                 termination_condition,
             )
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 63b73cb88c2b..a70f8494624f 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -6,10 +6,15 @@
 
 from ... import EVENT_LOGGER_NAME, TRACE_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
-from ...messages import ChatMessage, MultiModalMessage, StopMessage, TextMessage
-from .._events import (
-    GroupChatPublishEvent,
-    GroupChatSelectSpeakerEvent,
+from ...messages import (
+    AgentMessage,
+    HandoffMessage,
+    MultiModalMessage,
+    ResetMessage,
+    StopMessage,
+    TextMessage,
+    ToolCallMessage,
+    ToolCallResultMessage,
 )
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
@@ -24,21 +29,23 @@ class SelectorGroupChatManager(BaseGroupChatManager):
 
     def __init__(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
         model_client: ChatCompletionClient,
         selector_prompt: str,
         allow_repeated_speaker: bool,
-        selector_func: Callable[[Sequence[ChatMessage]], str | None] | None,
+        selector_func: Callable[[Sequence[AgentMessage]], str | None] | None,
     ) -> None:
         super().__init__(
-            parent_topic_type,
             group_topic_type,
+            output_topic_type,
             participant_topic_types,
             participant_descriptions,
+            message_thread,
             termination_condition,
         )
         self._model_client = model_client
@@ -47,7 +54,7 @@ def __init__(
         self._allow_repeated_speaker = allow_repeated_speaker
         self._selector_func = selector_func
 
-    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Selects the next speaker in a group chat using a ChatCompletion client,
         with the selector function as override if it returns a speaker name.
 
@@ -56,23 +63,20 @@ async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
 
         # Use the selector function if provided.
         if self._selector_func is not None:
-            speaker = self._selector_func([msg.agent_message for msg in thread])
+            speaker = self._selector_func(thread)
             if speaker is not None:
                 # Skip the model based selection.
-                event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=speaker, source=self.id))
                 return speaker
 
         # Construct the history of the conversation.
         history_messages: List[str] = []
-        for event in thread:
-            msg = event.agent_message
-            source = event.source
-            if source is None:
-                message = ""
-            else:
-                # The agent type must be the same as the topic type, which we use as the agent name.
-                message = f"{source.type}:"
-            if isinstance(msg, TextMessage | StopMessage):
+        for msg in thread:
+            if isinstance(msg, ToolCallMessage | ToolCallResultMessage | ResetMessage):
+                # Ignore tool call messages and reset messages.
+                continue
+            # The agent type must be the same as the topic type, which we use as the agent name.
+            message = f"{msg.source}:"
+            if isinstance(msg, TextMessage | StopMessage | HandoffMessage):
                 message += f" {msg.content}"
             elif isinstance(msg, MultiModalMessage):
                 for item in msg.content:
@@ -123,7 +127,7 @@ async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
         else:
             agent_name = participants[0]
         self._previous_speaker = agent_name
-        event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=agent_name, source=self.id))
+        trace_logger.debug(f"Selected speaker: {agent_name}")
         return agent_name
 
     def _mentioned_agents(self, message_content: str, agent_names: List[str]) -> Dict[str, int]:
@@ -175,7 +179,7 @@ class SelectorGroupChat(BaseGroupChat):
             Must contain '{roles}', '{participants}', and '{history}' to be filled in.
         allow_repeated_speaker (bool, optional): Whether to allow the same speaker to be selected
             consecutively. Defaults to False.
-        selector_func (Callable[[Sequence[ChatMessage]], str | None], optional): A custom selector
+        selector_func (Callable[[Sequence[AgentMessage]], str | None], optional): A custom selector
             function that takes the conversation history and returns the name of the next speaker.
             If provided, this function will be used to override the model to select the next speaker.
             If the function returns None, the model will be used to select the next speaker.
@@ -311,7 +315,7 @@ def __init__(
 Read the above conversation. Then select the next role from {participants} to play. Only return the role.
 """,
         allow_repeated_speaker: bool = False,
-        selector_func: Callable[[Sequence[ChatMessage]], str | None] | None = None,
+        selector_func: Callable[[Sequence[AgentMessage]], str | None] | None = None,
     ):
         super().__init__(
             participants, group_chat_manager_class=SelectorGroupChatManager, termination_condition=termination_condition
@@ -333,17 +337,19 @@ def __init__(
 
     def _create_group_chat_manager_factory(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], BaseGroupChatManager]:
         return lambda: SelectorGroupChatManager(
-            parent_topic_type,
             group_topic_type,
+            output_topic_type,
             participant_topic_types,
             participant_descriptions,
+            message_thread,
             termination_condition,
             self._model_client,
             self._selector_prompt,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index 0a6bf9ee73fa..bf464b526a7d 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -3,11 +3,7 @@
 
 from ... import EVENT_LOGGER_NAME
 from ...base import ChatAgent, TerminationCondition
-from ...messages import HandoffMessage
-from .._events import (
-    GroupChatPublishEvent,
-    GroupChatSelectSpeakerEvent,
-)
+from ...messages import AgentMessage, HandoffMessage
 from ._base_group_chat import BaseGroupChat
 from ._base_group_chat_manager import BaseGroupChatManager
 
@@ -19,28 +15,29 @@ class SwarmGroupChatManager(BaseGroupChatManager):
 
     def __init__(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> None:
         super().__init__(
-            parent_topic_type,
             group_topic_type,
+            output_topic_type,
             participant_topic_types,
             participant_descriptions,
+            message_thread,
             termination_condition,
         )
         self._current_speaker = participant_topic_types[0]
 
-    async def select_speaker(self, thread: List[GroupChatPublishEvent]) -> str:
+    async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants based on handoff message."""
-        if len(thread) > 0 and isinstance(thread[-1].agent_message, HandoffMessage):
-            self._current_speaker = thread[-1].agent_message.target
+        if len(thread) > 0 and isinstance(thread[-1], HandoffMessage):
+            self._current_speaker = thread[-1].target
             if self._current_speaker not in self._participant_topic_types:
                 raise ValueError("The selected speaker in the handoff message is not a participant.")
-            event_logger.debug(GroupChatSelectSpeakerEvent(selected_speaker=self._current_speaker, source=self.id))
             return self._current_speaker
         else:
             return self._current_speaker
@@ -107,18 +104,20 @@ def __init__(
 
     def _create_group_chat_manager_factory(
         self,
-        parent_topic_type: str,
         group_topic_type: str,
+        output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
+        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], SwarmGroupChatManager]:
         def _factory() -> SwarmGroupChatManager:
             return SwarmGroupChatManager(
-                parent_topic_type,
                 group_topic_type,
+                output_topic_type,
                 participant_topic_types,
                 participant_descriptions,
+                message_thread,
                 termination_condition,
             )
 
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 4922ceed9143..8f05c3f4977e 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -15,6 +15,7 @@
 from autogen_agentchat.base import Response, TaskResult
 from autogen_agentchat.logging import FileLogHandler
 from autogen_agentchat.messages import (
+    AgentMessage,
     ChatMessage,
     HandoffMessage,
     StopMessage,
@@ -170,6 +171,8 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         # Assert that all expected messages are in the collected messages
         assert normalized_messages == expected_messages
 
+        assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
+
         # Test streaming.
         mock.reset()
         index = 0
@@ -260,6 +263,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     assert isinstance(result.messages[3], TextMessage)  # tool use agent response
     assert isinstance(result.messages[4], TextMessage)  # echo agent response
     assert isinstance(result.messages[5], TextMessage)  # tool use agent response
+    assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
 
     context = tool_use_agent._model_context  # pyright: ignore
     assert context[0].content == "Write a program that prints 'Hello, world!'"
@@ -365,6 +369,7 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     assert result.messages[3].source == "agent1"
     assert result.messages[4].source == "agent2"
     assert result.messages[5].source == "agent1"
+    assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
 
     # Test streaming.
     mock.reset()
@@ -418,6 +423,7 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     assert result.messages[4].source == "agent1"
     # only one chat completion was called
     assert mock._curr_index == 1  # pyright: ignore
+    assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
 
     # Test streaming.
     mock.reset()
@@ -485,6 +491,7 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     assert result.messages[1].source == "agent2"
     assert result.messages[2].source == "agent2"
     assert result.messages[3].source == "agent1"
+    assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
 
     # Test streaming.
     mock.reset()
@@ -520,7 +527,7 @@ async def test_selector_group_chat_custom_selector(monkeypatch: pytest.MonkeyPat
     agent3 = _EchoAgent("agent3", description="echo agent 3")
     agent4 = _EchoAgent("agent4", description="echo agent 4")
 
-    def _select_agent(messages: Sequence[ChatMessage]) -> str | None:
+    def _select_agent(messages: Sequence[AgentMessage]) -> str | None:
         if len(messages) == 0:
             return "agent1"
         elif messages[-1].source == "agent1":
@@ -546,6 +553,10 @@ def _select_agent(messages: Sequence[ChatMessage]) -> str | None:
     assert result.messages[3].source == "agent3"
     assert result.messages[4].source == "agent4"
     assert result.messages[5].source == "agent1"
+    assert (
+        result.stop_reason is not None
+        and result.stop_reason == "Maximum number of messages 6 reached, current message count: 6"
+    )
 
 
 class _HandOffAgent(BaseChatAgent):
@@ -581,6 +592,10 @@ async def test_swarm_handoff() -> None:
     assert result.messages[3].content == "Transferred to second_agent."
     assert result.messages[4].content == "Transferred to third_agent."
     assert result.messages[5].content == "Transferred to first_agent."
+    assert (
+        result.stop_reason is not None
+        and result.stop_reason == "Maximum number of messages 6 reached, current message count: 6"
+    )
 
     # Test streaming.
     index = 0
@@ -668,6 +683,7 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     assert result.messages[4].content == "Transferred to agent1."
     assert result.messages[5].content == "Hello"
     assert result.messages[6].content == "TERMINATE"
+    assert result.stop_reason is not None and result.stop_reason == "Text 'TERMINATE' mentioned"
 
     # Test streaming.
     agent1._model_context.clear()  # pyright: ignore
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 684dcb838a7c..1a5875325de3 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -28,64 +28,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-29T15:48:06.329810]:\u001b[0m\n",
-      "\n",
-      "What is the weather in New York?\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-29T15:48:08.085839], weather_agent:\u001b[0m\n",
-      "\n",
-      "The weather in New York is 73 degrees and sunny.\n",
-      "--------------------------------------------------------------------------- \n",
-      "\u001b[91m[2024-10-29T15:48:08.086180], Termination:\u001b[0m\n",
-      "\n",
-      "Maximum number of messages 2 reached, current message count: 2\n",
-      " TaskResult(messages=[TextMessage(source='user', content='What is the weather in New York?'), TextMessage(source='weather_agent', content='The weather in New York is 73 degrees and sunny.')])\n"
+      "source='user' models_usage=None content='What is the weather in New York?'\n",
+      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=79, completion_tokens=15) content=[FunctionCall(id='call_CntvzLVL7iYJwPP2WWeBKNHc', arguments='{\"city\":\"New York\"}', name='get_weather')]\n",
+      "source='weather_agent' models_usage=None content=[FunctionExecutionResult(content='The weather in New York is 73 degrees and Sunny.', call_id='call_CntvzLVL7iYJwPP2WWeBKNHc')]\n",
+      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=90, completion_tokens=14) content='The weather in New York is currently 73 degrees and sunny.'\n",
+      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=137, completion_tokens=4) content='TERMINATE'\n",
+      "TaskResult(messages=[TextMessage(source='user', models_usage=None, content='What is the weather in New York?'), ToolCallMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=79, completion_tokens=15), content=[FunctionCall(id='call_CntvzLVL7iYJwPP2WWeBKNHc', arguments='{\"city\":\"New York\"}', name='get_weather')]), ToolCallResultMessage(source='weather_agent', models_usage=None, content=[FunctionExecutionResult(content='The weather in New York is 73 degrees and Sunny.', call_id='call_CntvzLVL7iYJwPP2WWeBKNHc')]), TextMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=90, completion_tokens=14), content='The weather in New York is currently 73 degrees and sunny.'), TextMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=137, completion_tokens=4), content='TERMINATE')], stop_reason=\"Text 'TERMINATE' mentioned\")\n"
      ]
     }
    ],
    "source": [
-    "import logging\n",
-    "\n",
-    "from autogen_agentchat import EVENT_LOGGER_NAME\n",
     "from autogen_agentchat.agents import AssistantAgent\n",
-    "from autogen_agentchat.logging import ConsoleLogHandler\n",
-    "from autogen_agentchat.task import MaxMessageTermination\n",
+    "from autogen_agentchat.task import TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
-    "# set up logging. You can define your own logger\n",
-    "logger = logging.getLogger(EVENT_LOGGER_NAME)\n",
-    "logger.addHandler(ConsoleLogHandler())\n",
-    "logger.setLevel(logging.INFO)\n",
-    "\n",
     "\n",
-    "# define a tool\n",
+    "# Define a tool\n",
     "async def get_weather(city: str) -> str:\n",
     "    return f\"The weather in {city} is 73 degrees and Sunny.\"\n",
     "\n",
     "\n",
-    "# define an agent\n",
-    "weather_agent = AssistantAgent(\n",
-    "    name=\"weather_agent\",\n",
-    "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-2024-08-06\"),\n",
-    "    tools=[get_weather],\n",
-    ")\n",
+    "async def main() -> None:\n",
+    "    # Define an agent\n",
+    "    weather_agent = AssistantAgent(\n",
+    "        name=\"weather_agent\",\n",
+    "        model_client=OpenAIChatCompletionClient(model=\"gpt-4o-2024-08-06\"),\n",
+    "        tools=[get_weather],\n",
+    "    )\n",
+    "\n",
+    "    # Define termination condition\n",
+    "    termination = TextMentionTermination(\"TERMINATE\")\n",
+    "\n",
+    "    # Define a team\n",
+    "    agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)\n",
+    "\n",
+    "    # Run the team and stream messages\n",
+    "    stream = agent_team.run_stream(\"What is the weather in New York?\")\n",
+    "    async for response in stream:\n",
+    "        print(response)\n",
+    "\n",
     "\n",
-    "# add the agent to a team\n",
-    "termination = MaxMessageTermination(max_messages=2)\n",
-    "agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)\n",
-    "# Note: if running in a Python file directly you'll need to use asyncio.run(agent_team.run(...)) instead of await agent_team.run(...)\n",
-    "result = await agent_team.run(task=\"What is the weather in New York?\")\n",
-    "print(\"\\n\", result)"
+    "# NOTE: if running this inside a Python script you'll need to use asyncio.run(main()).\n",
+    "await main()"
    ]
   },
   {

From 378b307623f4968be8bb8b1972026cb71dad18cb Mon Sep 17 00:00:00 2001
From: David Luong 
Date: Tue, 5 Nov 2024 13:46:39 -0500
Subject: [PATCH 076/173] [.NET] Enable package vulnerable (#4054)

* wip for vulernable package checks

* edit yml build

* Set value to 'true'

* Change NuGetAudit to NuGetAuditMode

* Change NugetAuditMode to direct

---------

Co-authored-by: Xiaoyun Zhang 
---
 dotnet/Directory.Packages.props | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dotnet/Directory.Packages.props b/dotnet/Directory.Packages.props
index 75580bba007a..a414a5f59dc6 100644
--- a/dotnet/Directory.Packages.props
+++ b/dotnet/Directory.Packages.props
@@ -4,6 +4,8 @@
     1.22.0
     1.22.0-alpha
     9.0.0-preview.9.24525.1
+
+    direct
   
   
     

From 5be7ac7b12c763e988b48308ddc729773fb6f67f Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 5 Nov 2024 21:40:46 -0800
Subject: [PATCH 077/173] Move reset from a message to a command (#4073)

---
 .github/workflows/checks.yml                       | 14 ++++++--------
 .../autogen_agentchat/agents/_assistant_agent.py   | 10 +++++-----
 .../autogen_agentchat/agents/_base_chat_agent.py   |  5 +++++
 .../agents/_code_executor_agent.py                 |  4 ++++
 .../src/autogen_agentchat/base/_chat_agent.py      |  4 ++++
 .../src/autogen_agentchat/messages.py              | 10 +---------
 .../teams/_group_chat/_chat_agent_container.py     |  8 +++++++-
 .../autogen_agentchat/teams/_group_chat/_events.py |  6 ++++++
 .../teams/_group_chat/_selector_group_chat.py      |  5 ++---
 .../autogen-agentchat/tests/test_group_chat.py     |  6 ++++++
 .../agentchat-user-guide/tutorial/agents.ipynb     |  8 ++++++--
 .../tutorial/selector-group-chat.ipynb             |  9 ++++++---
 12 files changed, 58 insertions(+), 31 deletions(-)

diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 667317870b94..73e48edb1469 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -177,11 +177,9 @@ jobs:
           source ${{ github.workspace }}/python/.venv/bin/activate
           poe gen-proto
         working-directory: ./python
-      - name: Evaluate if there are changes
-        run: |
-          if [[ `git status --porcelain` ]]; then
-            echo "There are changes that need to be generated and commit for the proto files"
-            git --no-pager diff
-            exit 1
-          fi
-        shell: bash
+      - name: Check if there are uncommited changes
+        id: changes
+        uses: UnicornGlobal/has-changes-action@v1.0.11
+      - name: Process changes
+        if: steps.changes.outputs.changed == 1
+        run: echo "There are changes in the proto files. Please commit them."
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 862b15e07f12..348b4f104bc0 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -23,7 +23,6 @@
     ChatMessage,
     HandoffMessage,
     InnerMessage,
-    ResetMessage,
     TextMessage,
     ToolCallMessage,
     ToolCallResultMessage,
@@ -221,10 +220,7 @@ async def on_messages_stream(
     ) -> AsyncGenerator[InnerMessage | Response, None]:
         # Add messages to the model context.
         for msg in messages:
-            if isinstance(msg, ResetMessage):
-                self._model_context.clear()
-            else:
-                self._model_context.append(UserMessage(content=msg.content, source=msg.source))
+            self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
         # Inner messages.
         inner_messages: List[InnerMessage] = []
@@ -301,3 +297,7 @@ async def _execute_tool_call(
             return FunctionExecutionResult(content=result_as_str, call_id=tool_call.id)
         except Exception as e:
             return FunctionExecutionResult(content=f"Error: {e}", call_id=tool_call.id)
+
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        """Reset the assistant agent to its initialization state."""
+        self._model_context.clear()
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index bbfc1ce1e0ab..811430564137 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -89,3 +89,8 @@ async def run_stream(
             else:
                 messages.append(message)
                 yield message
+
+    @abstractmethod
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        """Resets the agent to its initialization state."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
index 8c21d53fb8b1..4b7848bbd2ee 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_code_executor_agent.py
@@ -38,3 +38,7 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             return Response(chat_message=TextMessage(content=result.output, source=self.name))
         else:
             return Response(chat_message=TextMessage(content="No code blocks found in the thread.", source=self.name))
+
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        """It it's a no-op as the code executor agent has no mutable state."""
+        pass
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index ce73352daecc..2db6d5023f42 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -50,3 +50,7 @@ def on_messages_stream(
         """Handles incoming messages and returns a stream of inner messages and
         and the final item is the response."""
         ...
+
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        """Resets the agent to its initialization state."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index c2d2b7abf5cc..280b5322485a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -48,13 +48,6 @@ class HandoffMessage(BaseMessage):
     """The handoff message to the target agent."""
 
 
-class ResetMessage(BaseMessage):
-    """A message requesting reset of the recipient's state in the current conversation."""
-
-    content: str
-    """The content for the reset message."""
-
-
 class ToolCallMessage(BaseMessage):
     """A message signaling the use of tools."""
 
@@ -73,7 +66,7 @@ class ToolCallResultMessage(BaseMessage):
 """Messages for intra-agent monologues."""
 
 
-ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage | ResetMessage
+ChatMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage
 """Messages for agent-to-agent communication."""
 
 
@@ -87,7 +80,6 @@ class ToolCallResultMessage(BaseMessage):
     "MultiModalMessage",
     "StopMessage",
     "HandoffMessage",
-    "ResetMessage",
     "ToolCallMessage",
     "ToolCallResultMessage",
     "ChatMessage",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index 49325c39f044..689748338153 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -5,7 +5,7 @@
 
 from ...base import ChatAgent, Response
 from ...messages import ChatMessage
-from ._events import GroupChatAgentResponse, GroupChatMessage, GroupChatRequestPublish, GroupChatStart
+from ._events import GroupChatAgentResponse, GroupChatMessage, GroupChatRequestPublish, GroupChatReset, GroupChatStart
 from ._sequential_routed_agent import SequentialRoutedAgent
 
 
@@ -37,6 +37,12 @@ async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: Mess
         """Handle an agent response event by appending the content to the buffer."""
         self._message_buffer.append(message.agent_response.chat_message)
 
+    @event
+    async def handle_reset(self, message: GroupChatReset, ctx: MessageContext) -> None:
+        """Handle a reset event by resetting the agent."""
+        self._message_buffer.clear()
+        await self._agent.reset(ctx.cancellation_token)
+
     @event
     async def handle_request(self, message: GroupChatRequestPublish, ctx: MessageContext) -> None:
         """Handle a content request event by passing the messages in the buffer
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
index 0b146c88667e..5e1635bb8521 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
@@ -36,3 +36,9 @@ class GroupChatTermination(BaseModel):
 
     message: StopMessage
     """The stop message that indicates the reason of termination."""
+
+
+class GroupChatReset(BaseModel):
+    """A request to reset the agents in the group chat."""
+
+    ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index a70f8494624f..39c763c48dcb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -10,7 +10,6 @@
     AgentMessage,
     HandoffMessage,
     MultiModalMessage,
-    ResetMessage,
     StopMessage,
     TextMessage,
     ToolCallMessage,
@@ -71,8 +70,8 @@ async def select_speaker(self, thread: List[AgentMessage]) -> str:
         # Construct the history of the conversation.
         history_messages: List[str] = []
         for msg in thread:
-            if isinstance(msg, ToolCallMessage | ToolCallResultMessage | ResetMessage):
-                # Ignore tool call messages and reset messages.
+            if isinstance(msg, ToolCallMessage | ToolCallResultMessage):
+                # Ignore tool call messages.
                 continue
             # The agent type must be the same as the topic type, which we use as the agent name.
             message = f"{msg.source}:"
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 8f05c3f4977e..5b37d166b1b9 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -82,6 +82,9 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             assert self._last_message is not None
             return Response(chat_message=TextMessage(content=self._last_message, source=self.name))
 
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        self._last_message = None
+
 
 class _StopAgent(_EchoAgent):
     def __init__(self, name: str, description: str, *, stop_at: int = 1) -> None:
@@ -575,6 +578,9 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
             )
         )
 
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        pass
+
 
 @pytest.mark.asyncio
 async def test_swarm_handoff() -> None:
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index d367ba29b7e0..2075591368e3 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -235,7 +235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -257,6 +257,7 @@
     "    StopMessage,\n",
     "    TextMessage,\n",
     ")\n",
+    "from autogen_core.base import CancellationToken\n",
     "\n",
     "\n",
     "class UserProxyAgent(BaseChatAgent):\n",
@@ -273,6 +274,9 @@
     "            return Response(chat_message=StopMessage(content=\"User has terminated the conversation.\", source=self.name))\n",
     "        return Response(chat_message=TextMessage(content=user_input, source=self.name))\n",
     "\n",
+    "    async def reset(self, cancellation_token: CancellationToken) -> None:\n",
+    "        pass\n",
+    "\n",
     "\n",
     "user_proxy_agent = UserProxyAgent(name=\"user_proxy_agent\")\n",
     "\n",
@@ -317,7 +321,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index bcf8c6afc5ee..5ca7a0dc0e87 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -64,7 +64,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -80,7 +80,10 @@
     "        user_input = await asyncio.get_event_loop().run_in_executor(None, input, \"Enter your response: \")\n",
     "        if \"TERMINATE\" in user_input:\n",
     "            return Response(chat_message=StopMessage(content=\"User has terminated the conversation.\", source=self.name))\n",
-    "        return Response(chat_message=TextMessage(content=user_input, source=self.name))"
+    "        return Response(chat_message=TextMessage(content=user_input, source=self.name))\n",
+    "\n",
+    "    async def reset(self, cancellation_token: CancellationToken) -> None:\n",
+    "        pass"
    ]
   },
   {
@@ -278,7 +281,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,

From 4be1c9cf76a6a76f231925a6afe2ac5f566446de Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Tue, 5 Nov 2024 22:04:37 -0800
Subject: [PATCH 078/173] Update Python version to 0.4.0.dev4 (#4068)

* Update version to dev4
---
 .github/workflows/docs.yml                           |  1 +
 README.md                                            |  2 +-
 docs/switcher.json                                   |  9 +++++++--
 python/packages/autogen-agentchat/pyproject.toml     |  4 ++--
 python/packages/autogen-core/docs/src/index.md       |  4 ++--
 .../packages/autogen-core/docs/src/packages/index.md | 12 ++++++------
 .../user-guide/agentchat-user-guide/installation.md  |  2 +-
 python/packages/autogen-core/pyproject.toml          |  2 +-
 python/packages/autogen-ext/pyproject.toml           |  4 ++--
 python/uv.lock                                       |  6 +++---
 10 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 4e469df1730d..26c58a5ce786 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -36,6 +36,7 @@ jobs:
             { ref: "v0.4.0.dev1", dest-dir: "0.4.0.dev1" },
             { ref: "v0.4.0.dev2", dest-dir: "0.4.0.dev2" },
             { ref: "v0.4.0.dev3", dest-dir: "0.4.0.dev3" },
+            { ref: "v0.4.0.dev4", dest-dir: "0.4.0.dev4" },
           ]
     steps:
       - name: Checkout
diff --git a/README.md b/README.md
index 049612da46be..9084b693875b 100644
--- a/README.md
+++ b/README.md
@@ -101,7 +101,7 @@ We look forward to your contributions!
 First install the packages:
 
 ```bash
-pip install 'autogen-agentchat==0.4.0.dev3' 'autogen-ext[docker]==0.4.0.dev3'
+pip install 'autogen-agentchat==0.4.0.dev4' 'autogen-ext[docker]==0.4.0.dev4'
 ```
 
 The following code uses code execution, you need to have [Docker installed](https://docs.docker.com/engine/install/)
diff --git a/docs/switcher.json b/docs/switcher.json
index 8bde73629168..bc12b8a77b6e 100644
--- a/docs/switcher.json
+++ b/docs/switcher.json
@@ -26,7 +26,12 @@
     {
         "name": "0.4.0.dev3",
         "version": "0.4.0.dev3",
-        "url": "/autogen/0.4.0.dev3/",
+        "url": "/autogen/0.4.0.dev3/"
+    },
+    {
+        "name": "0.4.0.dev4",
+        "version": "0.4.0.dev4",
+        "url": "/autogen/0.4.0.dev4/",
         "preferred": true
     }
-]
+]
\ No newline at end of file
diff --git a/python/packages/autogen-agentchat/pyproject.toml b/python/packages/autogen-agentchat/pyproject.toml
index 755959b5abf8..d1f09ca3c0fe 100644
--- a/python/packages/autogen-agentchat/pyproject.toml
+++ b/python/packages/autogen-agentchat/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-agentchat"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen agents and teams library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0.dev3",
+    "autogen-core==0.4.0.dev4",
 ]
 
 [tool.uv]
diff --git a/python/packages/autogen-core/docs/src/index.md b/python/packages/autogen-core/docs/src/index.md
index 21a6fa35a922..00cbf70dd904 100644
--- a/python/packages/autogen-core/docs/src/index.md
+++ b/python/packages/autogen-core/docs/src/index.md
@@ -61,7 +61,7 @@ AgentChat 
 High-level API that includes preset agents and teams for building multi-agent systems.
 
 ```sh
-pip install autogen-agentchat==0.4.0.dev3
+pip install 'autogen-agentchat==0.4.0.dev4'
 ```
 
 💡 *Start here if you are looking for an API similar to AutoGen 0.2*
@@ -82,7 +82,7 @@ Get Started
 Provides building blocks for creating asynchronous, event driven multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0.dev3
+pip install 'autogen-core==0.4.0.dev4'
 ```
 
 +++
diff --git a/python/packages/autogen-core/docs/src/packages/index.md b/python/packages/autogen-core/docs/src/packages/index.md
index 7dd616108414..a7f47a7f9ba9 100644
--- a/python/packages/autogen-core/docs/src/packages/index.md
+++ b/python/packages/autogen-core/docs/src/packages/index.md
@@ -29,10 +29,10 @@ myst:
 Library that is at a similar level of abstraction as AutoGen 0.2, including default agents and group chat.
 
 ```sh
-pip install autogen-agentchat==0.4.0.dev3
+pip install 'autogen-agentchat==0.4.0.dev4'
 ```
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/agentchat-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_agentchat/autogen_agentchat.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-agentchat/0.4.0.dev4/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-agentchat)
 :::
 
 (pkg-info-autogen-core)=
@@ -44,10 +44,10 @@ pip install autogen-agentchat==0.4.0.dev3
 Implements the core functionality of the AutoGen framework, providing basic building blocks for creating multi-agent systems.
 
 ```sh
-pip install autogen-core==0.4.0.dev3
+pip install 'autogen-core==0.4.0.dev4'
 ```
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/core-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_core/autogen_core.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-core/0.4.0.dev4/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-core)
 :::
 
 (pkg-info-autogen-ext)=
@@ -59,7 +59,7 @@ pip install autogen-core==0.4.0.dev3
 Implementations of core components that interface with external services, or use extra dependencies. For example, Docker based code execution.
 
 ```sh
-pip install autogen-ext==0.4.0.dev3
+pip install 'autogen-ext==0.4.0.dev4'
 ```
 
 Extras:
@@ -69,7 +69,7 @@ Extras:
 - `docker` needed for {py:class}`~autogen_ext.code_executors.DockerCommandLineCodeExecutor`
 - `openai` needed for {py:class}`~autogen_ext.models.OpenAIChatCompletionClient`
 
-[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev3/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
+[{fas}`circle-info;pst-color-primary` User Guide](/user-guide/extensions-user-guide/index.md) | [{fas}`file-code;pst-color-primary` API Reference](/reference/python/autogen_ext/autogen_ext.rst) | [{fab}`python;pst-color-primary` PyPI](https://pypi.org/project/autogen-ext/0.4.0.dev4/) | [{fab}`github;pst-color-primary` Source](https://github.com/microsoft/autogen/tree/main/python/packages/autogen-ext)
 :::
 
 (pkg-info-autogen-magentic-one)=
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
index 0b005a2b3a38..d195009e1d54 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/installation.md
@@ -61,7 +61,7 @@ Install the `autogen-agentchat` package using pip:
 
 ```bash
 
-pip install autogen-agentchat==0.4.0.dev3
+pip install 'autogen-agentchat==0.4.0.dev4'
 ```
 
 ## Install Docker for Code Execution
diff --git a/python/packages/autogen-core/pyproject.toml b/python/packages/autogen-core/pyproject.toml
index bc0b614cff06..a3b87a183f02 100644
--- a/python/packages/autogen-core/pyproject.toml
+++ b/python/packages/autogen-core/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-core"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 license = {file = "LICENSE-CODE"}
 description = "Foundational interfaces and agent runtime implementation for AutoGen"
 readme = "README.md"
diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index 9740f3d20889..34bdc8fb7fbc 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autogen-ext"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 license = {file = "LICENSE-CODE"}
 description = "AutoGen extensions library"
 readme = "README.md"
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "autogen-core==0.4.0.dev3",
+    "autogen-core==0.4.0.dev4",
 ]
 
 
diff --git a/python/uv.lock b/python/uv.lock
index bb7c34ec7c0d..d2720b4a08ce 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -362,7 +362,7 @@ wheels = [
 
 [[package]]
 name = "autogen-agentchat"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 source = { editable = "packages/autogen-agentchat" }
 dependencies = [
     { name = "autogen-core" },
@@ -373,7 +373,7 @@ requires-dist = [{ name = "autogen-core", editable = "packages/autogen-core" }]
 
 [[package]]
 name = "autogen-core"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 source = { editable = "packages/autogen-core" }
 dependencies = [
     { name = "aiohttp" },
@@ -486,7 +486,7 @@ dev = [
 
 [[package]]
 name = "autogen-ext"
-version = "0.4.0.dev3"
+version = "0.4.0.dev4"
 source = { editable = "packages/autogen-ext" }
 dependencies = [
     { name = "autogen-core" },

From 2382ff9248586041d327f59cd9333f47f406b065 Mon Sep 17 00:00:00 2001
From: Mahesh Subramanian 
Date: Wed, 6 Nov 2024 11:07:13 -0700
Subject: [PATCH 079/173] chore(typo): Fixing a typo in the agent identity
 document (#4070)

---
 .../core-concepts/agent-identity-and-lifecycle.md               | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
index 95f1a8f05522..4a4439500635 100644
--- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
+++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/core-concepts/agent-identity-and-lifecycle.md
@@ -24,7 +24,7 @@ It associates an agent with a specific
 factory function, which produces instances of agents
 of the same agent type.
 For example, different factory functions can produce the same
-agent class but with different constructor perameters.
+agent class but with different constructor parameters.
 The agent key is an instance identifier
 for the given agent type.
 Agent IDs can be converted to and from strings. the format of this string is:

From 930e61306a2c4fe03b923e361fcfa21f32d9efb6 Mon Sep 17 00:00:00 2001
From: Mark Sze <66362098+marklysze@users.noreply.github.com>
Date: Thu, 7 Nov 2024 08:17:00 +1100
Subject: [PATCH 080/173] Update README.md (#4078)

---
 python/packages/autogen-magentic-one/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/python/packages/autogen-magentic-one/README.md b/python/packages/autogen-magentic-one/README.md
index c5216af7a41e..67f7d65de6a3 100644
--- a/python/packages/autogen-magentic-one/README.md
+++ b/python/packages/autogen-magentic-one/README.md
@@ -57,7 +57,7 @@ You can install the Magentic-One package and then run the example code to see ho
 1. Clone the code and install the package:
 
 ```bash
-git clone -b staging https://github.com/microsoft/autogen.git
+git clone https://github.com/microsoft/autogen.git
 cd autogen/python/packages/autogen-magentic-one
 pip install -e .
 ```
@@ -85,10 +85,10 @@ playwright install --with-deps chromium
   python examples/example.py --logs_dir ./my_logs
 
   # Enable human-in-the-loop mode
-  python examples/example.py -logs_dir ./my_logs --hil_mode
+  python examples/example.py --logs_dir ./my_logs --hil_mode
 
   # Save screenshots of browser
-  python examples/example.py -logs_dir ./my_logs --save_screenshots
+  python examples/example.py --logs_dir ./my_logs --save_screenshots
   ```
 
   Arguments:

From 2e3155be2af30e41a0dc31bd3b9852bfcfcaf917 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Thu, 7 Nov 2024 16:00:35 -0800
Subject: [PATCH 081/173] AgentChat pause, resume, and reset (#4088)

* AgentChat pause and resume a task
Resolves #3859

* Add

* Update usage

* Update usage

* WIP to address stateful group chat

* Refactor group chat to add reset and flags for running

* documentation
---
 README.md                                     |   2 +-
 .../agents/_base_chat_agent.py                |  38 ++-
 .../src/autogen_agentchat/base/_task.py       |  16 +-
 .../src/autogen_agentchat/base/_team.py       |   4 +-
 .../src/autogen_agentchat/teams/__init__.py   |   2 +
 .../teams/_group_chat/_base_group_chat.py     | 309 +++++++++++++-----
 .../_group_chat/_base_group_chat_manager.py   |  51 ++-
 .../_group_chat/_chat_agent_container.py      |   3 +-
 .../teams/_group_chat/_events.py              |   4 +-
 .../_group_chat/_round_robin_group_chat.py    |  10 +-
 .../teams/_group_chat/_selector_group_chat.py |  10 +-
 .../teams/_group_chat/_swarm_group_chat.py    |  10 +-
 .../tests/test_assistant_agent.py             |   8 +-
 .../tests/test_group_chat.py                  |  78 +++--
 .../examples/company-research.ipynb           |   4 +-
 .../examples/literature-review.ipynb          |   2 +-
 .../agentchat-user-guide/quickstart.ipynb     |   4 +-
 .../tutorial/selector-group-chat.ipynb        |   2 +-
 .../agentchat-user-guide/tutorial/teams.ipynb |  10 +-
 .../tutorial/termination.ipynb                |   8 +-
 20 files changed, 404 insertions(+), 171 deletions(-)

diff --git a/README.md b/README.md
index 9084b693875b..5875a89a1789 100644
--- a/README.md
+++ b/README.md
@@ -124,7 +124,7 @@ async def main() -> None:
         termination = TextMentionTermination("TERMINATE")
         group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent], termination_condition=termination)
         stream = group_chat.run_stream(
-            "Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
+            task="Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
         )
         async for message in stream:
             print(message)
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index 811430564137..a11f4a2d6f82 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -53,41 +53,49 @@ async def on_messages_stream(
 
     async def run(
         self,
-        task: str,
         *,
+        task: str | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> TaskResult:
         """Run the agent with the given task and return the result."""
         if cancellation_token is None:
             cancellation_token = CancellationToken()
-        first_message = TextMessage(content=task, source="user")
-        response = await self.on_messages([first_message], cancellation_token)
-        messages: List[AgentMessage] = [first_message]
+        input_messages: List[ChatMessage] = []
+        output_messages: List[AgentMessage] = []
+        if task is not None:
+            msg = TextMessage(content=task, source="user")
+            input_messages.append(msg)
+            output_messages.append(msg)
+        response = await self.on_messages(input_messages, cancellation_token)
         if response.inner_messages is not None:
-            messages += response.inner_messages
-        messages.append(response.chat_message)
-        return TaskResult(messages=messages)
+            output_messages += response.inner_messages
+        output_messages.append(response.chat_message)
+        return TaskResult(messages=output_messages)
 
     async def run_stream(
         self,
-        task: str,
         *,
+        task: str | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the agent with the given task and return a stream of messages
         and the final task result as the last item in the stream."""
         if cancellation_token is None:
             cancellation_token = CancellationToken()
-        first_message = TextMessage(content=task, source="user")
-        yield first_message
-        messages: List[AgentMessage] = [first_message]
-        async for message in self.on_messages_stream([first_message], cancellation_token):
+        input_messages: List[ChatMessage] = []
+        output_messages: List[AgentMessage] = []
+        if task is not None:
+            msg = TextMessage(content=task, source="user")
+            input_messages.append(msg)
+            output_messages.append(msg)
+            yield msg
+        async for message in self.on_messages_stream(input_messages, cancellation_token):
             if isinstance(message, Response):
                 yield message.chat_message
-                messages.append(message.chat_message)
-                yield TaskResult(messages=messages)
+                output_messages.append(message.chat_message)
+                yield TaskResult(messages=output_messages)
             else:
-                messages.append(message)
+                output_messages.append(message)
                 yield message
 
     @abstractmethod
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 1c33f7ecc185..7bb6d1e08f42 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -22,19 +22,27 @@ class TaskRunner(Protocol):
 
     async def run(
         self,
-        task: str,
         *,
+        task: str | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> TaskResult:
-        """Run the task."""
+        """Run the task and return the result.
+
+        The runner is stateful and a subsequent call to this method will continue
+        from where the previous call left off. If the task is not specified,
+        the runner will continue with the current task."""
         ...
 
     def run_stream(
         self,
-        task: str,
         *,
+        task: str | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the task and produces a stream of messages and the final result
-        :class:`TaskResult` as the last item in the stream."""
+        :class:`TaskResult` as the last item in the stream.
+
+        The runner is stateful and a subsequent call to this method will continue
+        from where the previous call left off. If the task is not specified,
+        the runner will continue with the current task."""
         ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
index e112a3b512ed..198d50179f1f 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_team.py
@@ -4,4 +4,6 @@
 
 
 class Team(TaskRunner, Protocol):
-    pass
+    async def reset(self) -> None:
+        """Reset the team and all its participants to its initial state."""
+        ...
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
index a2dd74d61b32..a0ac136042fb 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/__init__.py
@@ -1,8 +1,10 @@
+from ._group_chat._base_group_chat import BaseGroupChat
 from ._group_chat._round_robin_group_chat import RoundRobinGroupChat
 from ._group_chat._selector_group_chat import SelectorGroupChat
 from ._group_chat._swarm_group_chat import Swarm
 
 __all__ = [
+    "BaseGroupChat",
     "RoundRobinGroupChat",
     "SelectorGroupChat",
     "Swarm",
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index cc5c0e58138a..4090804392d4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -21,7 +21,7 @@
 from ...messages import AgentMessage, TextMessage
 from ._base_group_chat_manager import BaseGroupChatManager
 from ._chat_agent_container import ChatAgentContainer
-from ._events import GroupChatMessage, GroupChatStart, GroupChatTermination
+from ._events import GroupChatMessage, GroupChatReset, GroupChatStart, GroupChatTermination
 
 event_logger = logging.getLogger(EVENT_LOGGER_NAME)
 
@@ -44,10 +44,31 @@ def __init__(
         if len(participants) != len(set(participant.name for participant in participants)):
             raise ValueError("The participant names must be unique.")
         self._participants = participants
-        self._team_id = str(uuid.uuid4())
         self._base_group_chat_manager_class = group_chat_manager_class
         self._termination_condition = termination_condition
-        self._message_thread: List[AgentMessage] = []
+
+        # Constants for the group chat.
+        self._team_id = str(uuid.uuid4())
+        self._group_topic_type = "group_topic"
+        self._output_topic_type = "output_topic"
+        self._group_chat_manager_topic_type = "group_chat_manager"
+        self._participant_topic_types: List[str] = [participant.name for participant in participants]
+        self._participant_descriptions: List[str] = [participant.description for participant in participants]
+        self._collector_agent_type = "collect_output_messages"
+
+        # Constants for the closure agent to collect the output messages.
+        self._stop_reason: str | None = None
+        self._output_message_queue: asyncio.Queue[AgentMessage | None] = asyncio.Queue()
+
+        # Create a runtime for the team.
+        # TODO: The runtime should be created by a managed context.
+        self._runtime = SingleThreadedAgentRuntime()
+
+        # Flag to track if the group chat has been initialized.
+        self._initialized = False
+
+        # Flag to track if the group chat is running.
+        self._is_running = False
 
     @abstractmethod
     def _create_group_chat_manager_factory(
@@ -56,7 +77,6 @@ def _create_group_chat_manager_factory(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], BaseGroupChatManager]: ...
 
@@ -75,89 +95,46 @@ def _factory() -> ChatAgentContainer:
 
         return _factory
 
-    async def run(
-        self,
-        task: str,
-        *,
-        cancellation_token: CancellationToken | None = None,
-    ) -> TaskResult:
-        """Run the team and return the result. The base implementation uses
-        :meth:`run_stream` to run the team and then returns the final result."""
-        async for message in self.run_stream(
-            task,
-            cancellation_token=cancellation_token,
-        ):
-            if isinstance(message, TaskResult):
-                return message
-        raise AssertionError("The stream should have returned the final result.")
-
-    async def run_stream(
-        self,
-        task: str,
-        *,
-        cancellation_token: CancellationToken | None = None,
-    ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
-        """Run the team and produces a stream of messages and the final result
-        of the type :class:`TaskResult` as the last item in the stream."""
-
-        # TODO: runtime is currently a local variable, but it should be stored in
-        # a managed context so it can be accessed by all nested teams. Also, the runtime
-        # should be not be started or stopped by the team, but by the context.
-
-        # Create the runtime.
-        runtime = SingleThreadedAgentRuntime()
-
+    async def _init(self, runtime: AgentRuntime) -> None:
         # Constants for the group chat manager.
-        group_chat_manager_agent_type = AgentType("group_chat_manager")
-        group_chat_manager_topic_type = group_chat_manager_agent_type.type
-        group_topic_type = "round_robin_group_topic"
-        output_topic_type = "output_topic"
+        group_chat_manager_agent_type = AgentType(self._group_chat_manager_topic_type)
 
         # Register participants.
-        participant_topic_types: List[str] = []
-        participant_descriptions: List[str] = []
-        for participant in self._participants:
-            # Use the participant name as the agent type and topic type.
-            agent_type = participant.name
-            topic_type = participant.name
+        for participant, participant_topic_type in zip(self._participants, self._participant_topic_types, strict=False):
+            # Use the participant topic type as the agent type.
+            agent_type = participant_topic_type
             # Register the participant factory.
             await ChatAgentContainer.register(
                 runtime,
                 type=agent_type,
-                factory=self._create_participant_factory(group_topic_type, output_topic_type, participant),
+                factory=self._create_participant_factory(self._group_topic_type, self._output_topic_type, participant),
             )
             # Add subscriptions for the participant.
-            await runtime.add_subscription(TypeSubscription(topic_type=topic_type, agent_type=agent_type))
-            await runtime.add_subscription(TypeSubscription(topic_type=group_topic_type, agent_type=agent_type))
-            # Add the participant to the lists.
-            participant_descriptions.append(participant.description)
-            participant_topic_types.append(topic_type)
+            await runtime.add_subscription(TypeSubscription(topic_type=participant_topic_type, agent_type=agent_type))
+            await runtime.add_subscription(TypeSubscription(topic_type=self._group_topic_type, agent_type=agent_type))
 
         # Register the group chat manager.
         await self._base_group_chat_manager_class.register(
             runtime,
             type=group_chat_manager_agent_type.type,
             factory=self._create_group_chat_manager_factory(
-                group_topic_type=group_topic_type,
-                output_topic_type=output_topic_type,
-                participant_topic_types=participant_topic_types,
-                participant_descriptions=participant_descriptions,
-                message_thread=self._message_thread,
+                group_topic_type=self._group_topic_type,
+                output_topic_type=self._output_topic_type,
+                participant_topic_types=self._participant_topic_types,
+                participant_descriptions=self._participant_descriptions,
                 termination_condition=self._termination_condition,
             ),
         )
         # Add subscriptions for the group chat manager.
         await runtime.add_subscription(
-            TypeSubscription(topic_type=group_chat_manager_topic_type, agent_type=group_chat_manager_agent_type.type)
+            TypeSubscription(
+                topic_type=self._group_chat_manager_topic_type, agent_type=group_chat_manager_agent_type.type
+            )
         )
         await runtime.add_subscription(
-            TypeSubscription(topic_type=group_topic_type, agent_type=group_chat_manager_agent_type.type)
+            TypeSubscription(topic_type=self._group_topic_type, agent_type=group_chat_manager_agent_type.type)
         )
 
-        # Create a closure agent to collect the output messages.
-        stop_reason: str | None = None
-        output_message_queue: asyncio.Queue[AgentMessage | None] = asyncio.Queue()
-
         async def collect_output_messages(
             _runtime: AgentRuntime,
             id: AgentId,
@@ -166,34 +143,142 @@ async def collect_output_messages(
         ) -> None:
             event_logger.info(message.message)
             if isinstance(message, GroupChatTermination):
-                nonlocal stop_reason
-                stop_reason = message.message.content
+                self._stop_reason = message.message.content
                 return
-            await output_message_queue.put(message.message)
+            await self._output_message_queue.put(message.message)
 
         await ClosureAgent.register(
             runtime,
-            type="collect_output_messages",
+            type=self._collector_agent_type,
             closure=collect_output_messages,
             subscriptions=lambda: [
-                TypeSubscription(topic_type=output_topic_type, agent_type="collect_output_messages"),
+                TypeSubscription(topic_type=self._output_topic_type, agent_type=self._collector_agent_type),
             ],
         )
+        self._initialized = True
+
+    async def run(
+        self,
+        *,
+        task: str | None = None,
+        cancellation_token: CancellationToken | None = None,
+    ) -> TaskResult:
+        """Run the team and return the result. The base implementation uses
+        :meth:`run_stream` to run the team and then returns the final result.
+
+        Example using the :class:`~autogen_agentchat.teams.RoundRobinGroupChat` team:
+
+
+        .. code-block:: python
+
+            import asyncio
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.task import MaxMessageTermination
+            from autogen_agentchat.teams import RoundRobinGroupChat
+            from autogen_ext.models import OpenAIChatCompletionClient
+
+
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                agent1 = AssistantAgent("Assistant1", model_client=model_client)
+                agent2 = AssistantAgent("Assistant2", model_client=model_client)
+                termination = MaxMessageTermination(3)
+                team = RoundRobinGroupChat([agent1, agent2], termination_condition=termination)
+
+                result = await team.run(task="Count from 1 to 10, respond one at a time.")
+                print(result)
+
+                # Reset the termination condition.
+                await termination.reset()
+
+                # Run the team again without a task.
+                result = await team.run()
+                print(result)
+
+
+            asyncio.run(main())
+        """
+        result: TaskResult | None = None
+        async for message in self.run_stream(
+            task=task,
+            cancellation_token=cancellation_token,
+        ):
+            if isinstance(message, TaskResult):
+                result = message
+        if result is not None:
+            return result
+        raise AssertionError("The stream should have returned the final result.")
+
+    async def run_stream(
+        self,
+        *,
+        task: str | None = None,
+        cancellation_token: CancellationToken | None = None,
+    ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
+        """Run the team and produces a stream of messages and the final result
+        of the type :class:`TaskResult` as the last item in the stream.
+
+        Example using the :class:`~autogen_agentchat.teams.RoundRobinGroupChat` team:
+
+        .. code-block:: python
+
+            import asyncio
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.task import MaxMessageTermination
+            from autogen_agentchat.teams import RoundRobinGroupChat
+            from autogen_ext.models import OpenAIChatCompletionClient
+
+
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                agent1 = AssistantAgent("Assistant1", model_client=model_client)
+                agent2 = AssistantAgent("Assistant2", model_client=model_client)
+                termination = MaxMessageTermination(3)
+                team = RoundRobinGroupChat([agent1, agent2], termination_condition=termination)
+
+                stream = team.run_stream(task="Count from 1 to 10, respond one at a time.")
+                async for message in stream:
+                    print(message)
+
+                # Reset the termination condition.
+                await termination.reset()
+
+                # Run the team again without a task.
+                stream = team.run_stream()
+                async for message in stream:
+                    print(message)
+
+
+            asyncio.run(main())
+        """
+
+        if self._is_running:
+            raise ValueError("The team is already running, it cannot run again until it is stopped.")
+        self._is_running = True
 
         # Start the runtime.
-        runtime.start()
+        # TODO: The runtime should be started by a managed context.
+        self._runtime.start()
+
+        if not self._initialized:
+            await self._init(self._runtime)
 
-        # Run the team by publishing the task to the group chat manager.
-        first_chat_message = TextMessage(content=task, source="user")
-        await runtime.publish_message(
+        # Run the team by publishing the start message.
+        if task is None:
+            first_chat_message = None
+        else:
+            first_chat_message = TextMessage(content=task, source="user")
+        await self._runtime.publish_message(
             GroupChatStart(message=first_chat_message),
-            topic_id=TopicId(type=group_topic_type, source=self._team_id),
+            topic_id=TopicId(type=self._group_topic_type, source=self._team_id),
         )
 
         # Start a coroutine to stop the runtime and signal the output message queue is complete.
         async def stop_runtime() -> None:
-            await runtime.stop_when_idle()
-            await output_message_queue.put(None)
+            await self._runtime.stop_when_idle()
+            await self._output_message_queue.put(None)
 
         shutdown_task = asyncio.create_task(stop_runtime())
 
@@ -201,7 +286,7 @@ async def stop_runtime() -> None:
         output_messages: List[AgentMessage] = []
         # Yield the messsages until the queue is empty.
         while True:
-            message = await output_message_queue.get()
+            message = await self._output_message_queue.get()
             if message is None:
                 break
             yield message
@@ -211,4 +296,74 @@ async def stop_runtime() -> None:
         await shutdown_task
 
         # Yield the final result.
-        yield TaskResult(messages=output_messages, stop_reason=stop_reason)
+        yield TaskResult(messages=output_messages, stop_reason=self._stop_reason)
+
+        # Indicate that the team is no longer running.
+        self._is_running = False
+
+    async def reset(self) -> None:
+        """Reset the team and its participants to their initial state.
+
+        This includes the termination condition. The team must be stopped before it can be reset.
+
+        Raises:
+            RuntimeError: If the team has not been initialized or is currently running.
+
+        Example using the :class:`~autogen_agentchat.teams.RoundRobinGroupChat` team:
+
+        .. code-block:: python
+
+            import asyncio
+            from autogen_agentchat.agents import AssistantAgent
+            from autogen_agentchat.task import MaxMessageTermination
+            from autogen_agentchat.teams import RoundRobinGroupChat
+            from autogen_ext.models import OpenAIChatCompletionClient
+
+
+            async def main() -> None:
+                model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+                agent1 = AssistantAgent("Assistant1", model_client=model_client)
+                agent2 = AssistantAgent("Assistant2", model_client=model_client)
+                termination = MaxMessageTermination(3)
+                team = RoundRobinGroupChat([agent1, agent2], termination_condition=termination)
+                stream = team.run_stream(task="Count from 1 to 10, respond one at a time.")
+                async for message in stream:
+                    print(message)
+
+                # Reset the team.
+                await team.reset()
+                stream = team.run_stream(task="Count from 1 to 10, respond one at a time.")
+                async for message in stream:
+                    print(message)
+
+
+            asyncio.run(main())
+        """
+
+        if not self._initialized:
+            raise RuntimeError("The group chat has not been initialized. It must be run before it can be reset.")
+
+        if self._is_running:
+            raise RuntimeError("The group chat is currently running. It must be stopped before it can be reset.")
+        self._is_running = True
+
+        # Start the runtime.
+        self._runtime.start()
+
+        # Send a reset message to the group chat.
+        await self._runtime.publish_message(
+            GroupChatReset(),
+            topic_id=TopicId(type=self._group_topic_type, source=self._team_id),
+        )
+
+        # Stop the runtime.
+        await self._runtime.stop_when_idle()
+
+        # Reset the output message queue.
+        self._stop_reason = None
+        while not self._output_message_queue.empty():
+            self._output_message_queue.get_nowait()
+
+        # Indicate that the team is no longer running.
+        self._is_running = False
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
index ab10c2b864c5..ebbd9d5c8070 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat_manager.py
@@ -6,7 +6,13 @@
 
 from ...base import TerminationCondition
 from ...messages import AgentMessage, StopMessage
-from ._events import GroupChatAgentResponse, GroupChatRequestPublish, GroupChatStart, GroupChatTermination
+from ._events import (
+    GroupChatAgentResponse,
+    GroupChatRequestPublish,
+    GroupChatReset,
+    GroupChatStart,
+    GroupChatTermination,
+)
 from ._sequential_routed_agent import SequentialRoutedAgent
 
 
@@ -28,7 +34,6 @@ def __init__(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None = None,
     ):
         super().__init__(description="Group chat manager")
@@ -42,16 +47,13 @@ def __init__(
             raise ValueError("The group topic type must not be in the participant topic types.")
         self._participant_topic_types = participant_topic_types
         self._participant_descriptions = participant_descriptions
-        self._message_thread = message_thread
+        self._message_thread: List[AgentMessage] = []
         self._termination_condition = termination_condition
 
     @event
     async def handle_start(self, message: GroupChatStart, ctx: MessageContext) -> None:
         """Handle the start of a group chat by selecting a speaker to start the conversation."""
 
-        # Log the start message.
-        await self.publish_message(message, topic_id=DefaultTopicId(type=self._output_topic_type))
-
         # Check if the conversation has already terminated.
         if self._termination_condition is not None and self._termination_condition.terminated:
             early_stop_message = StopMessage(
@@ -63,18 +65,23 @@ async def handle_start(self, message: GroupChatStart, ctx: MessageContext) -> No
             # Stop the group chat.
             return
 
-        # Append the user message to the message thread.
-        self._message_thread.append(message.message)
+        if message.message is not None:
+            # Log the start message.
+            await self.publish_message(message, topic_id=DefaultTopicId(type=self._output_topic_type))
 
-        # Check if the conversation should be terminated.
-        if self._termination_condition is not None:
-            stop_message = await self._termination_condition([message.message])
-            if stop_message is not None:
-                await self.publish_message(
-                    GroupChatTermination(message=stop_message), topic_id=DefaultTopicId(type=self._output_topic_type)
-                )
-                # Stop the group chat.
-                return
+            # Append the user message to the message thread.
+            self._message_thread.append(message.message)
+
+            # Check if the conversation should be terminated.
+            if self._termination_condition is not None:
+                stop_message = await self._termination_condition([message.message])
+                if stop_message is not None:
+                    await self.publish_message(
+                        GroupChatTermination(message=stop_message),
+                        topic_id=DefaultTopicId(type=self._output_topic_type),
+                    )
+                    # Stop the group chat.
+                    return
 
         speaker_topic_type = await self.select_speaker(self._message_thread)
         await self.publish_message(GroupChatRequestPublish(), topic_id=DefaultTopicId(type=speaker_topic_type))
@@ -104,11 +111,21 @@ async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: Mess
         speaker_topic_type = await self.select_speaker(self._message_thread)
         await self.publish_message(GroupChatRequestPublish(), topic_id=DefaultTopicId(type=speaker_topic_type))
 
+    @event
+    async def handle_reset(self, message: GroupChatReset, ctx: MessageContext) -> None:
+        # Reset the group chat manager.
+        await self.reset()
+
     @abstractmethod
     async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants and return the
         topic type of the selected speaker."""
         ...
 
+    @abstractmethod
+    async def reset(self) -> None:
+        """Reset the group chat manager."""
+        ...
+
     async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> None:
         raise ValueError(f"Unhandled message in group chat manager: {type(message)}")
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
index 689748338153..19739dfdf924 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_chat_agent_container.py
@@ -30,7 +30,8 @@ def __init__(self, parent_topic_type: str, output_topic_type: str, agent: ChatAg
     @event
     async def handle_start(self, message: GroupChatStart, ctx: MessageContext) -> None:
         """Handle a start event by appending the content to the buffer."""
-        self._message_buffer.append(message.message)
+        if message.message is not None:
+            self._message_buffer.append(message.message)
 
     @event
     async def handle_agent_response(self, message: GroupChatAgentResponse, ctx: MessageContext) -> None:
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
index 5e1635bb8521..4ae4d892cace 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_events.py
@@ -7,8 +7,8 @@
 class GroupChatStart(BaseModel):
     """A request to start a group chat."""
 
-    message: ChatMessage
-    """The user message that started the group chat."""
+    message: ChatMessage | None = None
+    """An optional user message to start the group chat."""
 
 
 class GroupChatAgentResponse(BaseModel):
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
index 4f355b58e66c..9638051e732b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_round_robin_group_chat.py
@@ -15,7 +15,6 @@ def __init__(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> None:
         super().__init__(
@@ -23,11 +22,16 @@ def __init__(
             output_topic_type,
             participant_topic_types,
             participant_descriptions,
-            message_thread,
             termination_condition,
         )
         self._next_speaker_index = 0
 
+    async def reset(self) -> None:
+        self._message_thread.clear()
+        if self._termination_condition is not None:
+            await self._termination_condition.reset()
+        self._next_speaker_index = 0
+
     async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants in a round-robin fashion."""
         current_speaker_index = self._next_speaker_index
@@ -124,7 +128,6 @@ def _create_group_chat_manager_factory(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], RoundRobinGroupChatManager]:
         def _factory() -> RoundRobinGroupChatManager:
@@ -133,7 +136,6 @@ def _factory() -> RoundRobinGroupChatManager:
                 output_topic_type,
                 participant_topic_types,
                 participant_descriptions,
-                message_thread,
                 termination_condition,
             )
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
index 39c763c48dcb..7e8f35832a62 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_selector_group_chat.py
@@ -32,7 +32,6 @@ def __init__(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
         model_client: ChatCompletionClient,
         selector_prompt: str,
@@ -44,7 +43,6 @@ def __init__(
             output_topic_type,
             participant_topic_types,
             participant_descriptions,
-            message_thread,
             termination_condition,
         )
         self._model_client = model_client
@@ -53,6 +51,12 @@ def __init__(
         self._allow_repeated_speaker = allow_repeated_speaker
         self._selector_func = selector_func
 
+    async def reset(self) -> None:
+        self._message_thread.clear()
+        if self._termination_condition is not None:
+            await self._termination_condition.reset()
+        self._previous_speaker = None
+
     async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Selects the next speaker in a group chat using a ChatCompletion client,
         with the selector function as override if it returns a speaker name.
@@ -340,7 +344,6 @@ def _create_group_chat_manager_factory(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], BaseGroupChatManager]:
         return lambda: SelectorGroupChatManager(
@@ -348,7 +351,6 @@ def _create_group_chat_manager_factory(
             output_topic_type,
             participant_topic_types,
             participant_descriptions,
-            message_thread,
             termination_condition,
             self._model_client,
             self._selector_prompt,
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
index bf464b526a7d..f3116d75feab 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_swarm_group_chat.py
@@ -19,7 +19,6 @@ def __init__(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> None:
         super().__init__(
@@ -27,11 +26,16 @@ def __init__(
             output_topic_type,
             participant_topic_types,
             participant_descriptions,
-            message_thread,
             termination_condition,
         )
         self._current_speaker = participant_topic_types[0]
 
+    async def reset(self) -> None:
+        self._message_thread.clear()
+        if self._termination_condition is not None:
+            await self._termination_condition.reset()
+        self._current_speaker = self._participant_topic_types[0]
+
     async def select_speaker(self, thread: List[AgentMessage]) -> str:
         """Select a speaker from the participants based on handoff message."""
         if len(thread) > 0 and isinstance(thread[-1], HandoffMessage):
@@ -108,7 +112,6 @@ def _create_group_chat_manager_factory(
         output_topic_type: str,
         participant_topic_types: List[str],
         participant_descriptions: List[str],
-        message_thread: List[AgentMessage],
         termination_condition: TerminationCondition | None,
     ) -> Callable[[], SwarmGroupChatManager]:
         def _factory() -> SwarmGroupChatManager:
@@ -117,7 +120,6 @@ def _factory() -> SwarmGroupChatManager:
                 output_topic_type,
                 participant_topic_types,
                 participant_descriptions,
-                message_thread,
                 termination_condition,
             )
 
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index 5e133b91a23d..d847744ba13d 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -110,7 +110,7 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
         tools=[_pass_function, _fail_function, FunctionTool(_echo_function, description="Echo")],
     )
-    result = await tool_use_agent.run("task")
+    result = await tool_use_agent.run(task="task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
     assert result.messages[0].models_usage is None
@@ -128,7 +128,7 @@ async def test_run_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore
     index = 0
-    async for message in tool_use_agent.run_stream("task"):
+    async for message in tool_use_agent.run_stream(task="task"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
@@ -178,7 +178,7 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
         handoffs=[handoff],
     )
     assert HandoffMessage in tool_use_agent.produced_message_types
-    result = await tool_use_agent.run("task")
+    result = await tool_use_agent.run(task="task")
     assert len(result.messages) == 4
     assert isinstance(result.messages[0], TextMessage)
     assert result.messages[0].models_usage is None
@@ -196,7 +196,7 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
     # Test streaming.
     mock._curr_index = 0  # pyright: ignore
     index = 0
-    async for message in tool_use_agent.run_stream("task"):
+    async for message in tool_use_agent.run_stream(task="task"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index 5b37d166b1b9..f51d86eecb64 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -157,7 +157,7 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
             participants=[coding_assistant_agent, code_executor_agent], termination_condition=termination
         )
         result = await team.run(
-            "Write a program that prints 'Hello, world!'",
+            task="Write a program that prints 'Hello, world!'",
         )
         expected_messages = [
             "Write a program that prints 'Hello, world!'",
@@ -179,9 +179,9 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         # Test streaming.
         mock.reset()
         index = 0
-        await termination.reset()
+        await team.reset()
         async for message in team.run_stream(
-            "Write a program that prints 'Hello, world!'",
+            task="Write a program that prints 'Hello, world!'",
         ):
             if isinstance(message, TaskResult):
                 assert message == result
@@ -256,7 +256,7 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     termination = TextMentionTermination("TERMINATE")
     team = RoundRobinGroupChat(participants=[tool_use_agent, echo_agent], termination_condition=termination)
     result = await team.run(
-        "Write a program that prints 'Hello, world!'",
+        task="Write a program that prints 'Hello, world!'",
     )
 
     assert len(result.messages) == 6
@@ -284,9 +284,9 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
     tool_use_agent._model_context.clear()  # pyright: ignore
     mock.reset()
     index = 0
-    await termination.reset()
+    await team.reset()
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'",
+        task="Write a program that prints 'Hello, world!'",
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -295,6 +295,40 @@ async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch
         index += 1
 
 
+@pytest.mark.asyncio
+async def test_round_robin_group_chat_with_resume_and_reset() -> None:
+    agent_1 = _EchoAgent("agent_1", description="echo agent 1")
+    agent_2 = _EchoAgent("agent_2", description="echo agent 2")
+    agent_3 = _EchoAgent("agent_3", description="echo agent 3")
+    agent_4 = _EchoAgent("agent_4", description="echo agent 4")
+    termination = MaxMessageTermination(3)
+    team = RoundRobinGroupChat(participants=[agent_1, agent_2, agent_3, agent_4], termination_condition=termination)
+    result = await team.run(
+        task="Write a program that prints 'Hello, world!'",
+    )
+    assert len(result.messages) == 3
+    assert result.messages[1].source == "agent_1"
+    assert result.messages[2].source == "agent_2"
+    assert result.stop_reason is not None
+
+    # Resume.
+    await termination.reset()
+    result = await team.run()
+    assert len(result.messages) == 3
+    assert result.messages[0].source == "agent_3"
+    assert result.messages[1].source == "agent_4"
+    assert result.messages[2].source == "agent_1"
+    assert result.stop_reason is not None
+
+    # Reset.
+    await team.reset()
+    result = await team.run(task="Write a program that prints 'Hello, world!'")
+    assert len(result.messages) == 3
+    assert result.messages[1].source == "agent_1"
+    assert result.messages[2].source == "agent_2"
+    assert result.stop_reason is not None
+
+
 @pytest.mark.asyncio
 async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     model = "gpt-4o-2024-05-13"
@@ -363,7 +397,7 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
         termination_condition=termination,
     )
     result = await team.run(
-        "Write a program that prints 'Hello, world!'",
+        task="Write a program that prints 'Hello, world!'",
     )
     assert len(result.messages) == 6
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -378,9 +412,9 @@ async def test_selector_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
     mock.reset()
     agent1._count = 0  # pyright: ignore
     index = 0
-    await termination.reset()
+    await team.reset()
     async for message in team.run_stream(
-        "Write a program that prints 'Hello, world!'",
+        task="Write a program that prints 'Hello, world!'",
     ):
         if isinstance(message, TaskResult):
             assert message == result
@@ -416,7 +450,7 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
         model_client=OpenAIChatCompletionClient(model=model, api_key=""),
     )
     result = await team.run(
-        "Write a program that prints 'Hello, world!'",
+        task="Write a program that prints 'Hello, world!'",
     )
     assert len(result.messages) == 5
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
@@ -432,8 +466,8 @@ async def test_selector_group_chat_two_speakers(monkeypatch: pytest.MonkeyPatch)
     mock.reset()
     agent1._count = 0  # pyright: ignore
     index = 0
-    await termination.reset()
-    async for message in team.run_stream("Write a program that prints 'Hello, world!'"):
+    await team.reset()
+    async for message in team.run_stream(task="Write a program that prints 'Hello, world!'"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
@@ -488,7 +522,7 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
         termination_condition=termination,
         allow_repeated_speaker=True,
     )
-    result = await team.run("Write a program that prints 'Hello, world!'")
+    result = await team.run(task="Write a program that prints 'Hello, world!'")
     assert len(result.messages) == 4
     assert result.messages[0].content == "Write a program that prints 'Hello, world!'"
     assert result.messages[1].source == "agent2"
@@ -499,8 +533,8 @@ async def test_selector_group_chat_two_speakers_allow_repeated(monkeypatch: pyte
     # Test streaming.
     mock.reset()
     index = 0
-    await termination.reset()
-    async for message in team.run_stream("Write a program that prints 'Hello, world!'"):
+    await team.reset()
+    async for message in team.run_stream(task="Write a program that prints 'Hello, world!'"):
         if isinstance(message, TaskResult):
             assert message == result
         else:
@@ -549,7 +583,7 @@ def _select_agent(messages: Sequence[AgentMessage]) -> str | None:
         selector_func=_select_agent,
         termination_condition=termination,
     )
-    result = await team.run("task")
+    result = await team.run(task="task")
     assert len(result.messages) == 6
     assert result.messages[1].source == "agent1"
     assert result.messages[2].source == "agent2"
@@ -590,7 +624,7 @@ async def test_swarm_handoff() -> None:
 
     termination = MaxMessageTermination(6)
     team = Swarm([second_agent, first_agent, third_agent], termination_condition=termination)
-    result = await team.run("task")
+    result = await team.run(task="task")
     assert len(result.messages) == 6
     assert result.messages[0].content == "task"
     assert result.messages[1].content == "Transferred to third_agent."
@@ -605,8 +639,8 @@ async def test_swarm_handoff() -> None:
 
     # Test streaming.
     index = 0
-    await termination.reset()
-    stream = team.run_stream("task")
+    await team.reset()
+    stream = team.run_stream(task="task")
     async for message in stream:
         if isinstance(message, TaskResult):
             assert message == result
@@ -680,7 +714,7 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     agent2 = _HandOffAgent("agent2", description="agent 2", next_agent="agent1")
     termination = TextMentionTermination("TERMINATE")
     team = Swarm([agent1, agent2], termination_condition=termination)
-    result = await team.run("task")
+    result = await team.run(task="task")
     assert len(result.messages) == 7
     assert result.messages[0].content == "task"
     assert isinstance(result.messages[1], ToolCallMessage)
@@ -695,8 +729,8 @@ async def test_swarm_handoff_using_tool_calls(monkeypatch: pytest.MonkeyPatch) -
     agent1._model_context.clear()  # pyright: ignore
     mock.reset()
     index = 0
-    await termination.reset()
-    stream = team.run_stream("task")
+    await team.reset()
+    stream = team.run_stream(task="task")
     async for message in stream:
         if isinstance(message, TaskResult):
             assert message == result
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
index ce5844f4dec1..21d10aadc5de 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/company-research.ipynb
@@ -401,7 +401,7 @@
     }
    ],
    "source": [
-    "result = await team.run(\"Write a financial report on American airlines\")\n",
+    "result = await team.run(task=\"Write a financial report on American airlines\")\n",
     "print(result)"
    ]
   }
@@ -422,7 +422,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
index cefb6e6f49ce..94f08abdb43a 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/examples/literature-review.ipynb
@@ -355,7 +355,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 1a5875325de3..833c57624fad 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -71,7 +71,7 @@
     "    agent_team = RoundRobinGroupChat([weather_agent], termination_condition=termination)\n",
     "\n",
     "    # Run the team and stream messages\n",
-    "    stream = agent_team.run_stream(\"What is the weather in New York?\")\n",
+    "    stream = agent_team.run_stream(task=\"What is the weather in New York?\")\n",
     "    async for response in stream:\n",
     "        print(response)\n",
     "\n",
@@ -114,7 +114,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
index 5ca7a0dc0e87..6be1e1334bd7 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/selector-group-chat.ipynb
@@ -261,7 +261,7 @@
     "    model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
     "    termination_condition=termination,\n",
     ")\n",
-    "await team.run(\"Help user plan a trip and book a flight.\")"
+    "await team.run(task=\"Help user plan a trip and book a flight.\")"
    ]
   }
  ],
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
index b85f1223cb04..c52e6643964f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/teams.ipynb
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -105,7 +105,7 @@
    "source": [
     "termination = MaxMessageTermination(max_messages=1)\n",
     "round_robin_team = RoundRobinGroupChat([tool_use_agent, writing_assistant_agent], termination_condition=termination)\n",
-    "round_robin_team_result = await round_robin_team.run(\"Write a Haiku about the weather in Paris\")"
+    "round_robin_team_result = await round_robin_team.run(task=\"Write a Haiku about the weather in Paris\")"
    ]
   },
   {
@@ -134,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -177,7 +177,7 @@
     "    [tool_use_agent, writing_assistant_agent], model_client=model_client, termination_condition=termination\n",
     ")\n",
     "\n",
-    "llm_team_result = await llm_team.run(\"What is the weather in paris right now? Also write a haiku about it.\")"
+    "llm_team_result = await llm_team.run(task=\"What is the weather in paris right now? Also write a haiku about it.\")"
    ]
   },
   {
@@ -208,7 +208,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
index 301ce6663426..e10942491286 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/termination.ipynb
@@ -70,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -110,7 +110,7 @@
    "source": [
     "max_msg_termination = MaxMessageTermination(max_messages=3)\n",
     "round_robin_team = RoundRobinGroupChat([writing_assistant_agent], termination_condition=max_msg_termination)\n",
-    "round_robin_team_result = await round_robin_team.run(\"Write a unique, Haiku about the weather in Paris\")"
+    "round_robin_team_result = await round_robin_team.run(task=\"Write a unique, Haiku about the weather in Paris\")"
    ]
   },
   {
@@ -174,7 +174,7 @@
     "text_termination = TextMentionTermination(\"TERMINATE\")\n",
     "round_robin_team = RoundRobinGroupChat([writing_assistant_agent], termination_condition=text_termination)\n",
     "\n",
-    "round_robin_team_result = await round_robin_team.run(\"Write a unique, Haiku about the weather in Paris\")"
+    "round_robin_team_result = await round_robin_team.run(task=\"Write a unique, Haiku about the weather in Paris\")"
    ]
   }
  ],
@@ -194,7 +194,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.12.6"
   }
  },
  "nbformat": 4,

From 9e388925d47dd26c6137b6a95c434c0d88f6a1db Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Thu, 7 Nov 2024 16:47:53 -0800
Subject: [PATCH 082/173] Initial web surfer implementation in extension
 (#4071)

* Initial web surfer implementation in extension

* Moved model client to constructor for consistency.

* Fixed uv lock.

* Merge branch 'main' into websurfer

* fix ruff
---
 python/packages/autogen-ext/pyproject.toml    |   5 +
 .../src/autogen_ext/agents/__init__.py        |   3 +
 .../autogen_ext/agents/web_surfer/__init__.py |   0
 .../autogen_ext/agents/web_surfer/_events.py  |  11 +
 .../web_surfer/_multimodal_web_surfer.py      | 808 ++++++++++++++++++
 .../agents/web_surfer/_set_of_mark.py         |  96 +++
 .../agents/web_surfer/_tool_definitions.py    | 289 +++++++
 .../autogen_ext/agents/web_surfer/_types.py   | 106 +++
 .../autogen_ext/agents/web_surfer/_utils.py   |  25 +
 .../agents/web_surfer/page_script.js          | 376 ++++++++
 python/uv.lock                                |   6 +
 11 files changed, 1725 insertions(+)
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/__init__.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/__init__.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_events.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_multimodal_web_surfer.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_set_of_mark.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_tool_definitions.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_types.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_utils.py
 create mode 100644 python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/page_script.js

diff --git a/python/packages/autogen-ext/pyproject.toml b/python/packages/autogen-ext/pyproject.toml
index 34bdc8fb7fbc..5452e2fae6ab 100644
--- a/python/packages/autogen-ext/pyproject.toml
+++ b/python/packages/autogen-ext/pyproject.toml
@@ -27,6 +27,10 @@ langchain = ["langchain_core~= 0.3.3"]
 azure = ["azure-core", "azure-identity"]
 docker = ["docker~=7.0"]
 openai = ["openai>=1.3"]
+web-surfer = [
+    "playwright>=1.48.0",
+    "pillow>=11.0.0",
+]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/autogen_ext"]
@@ -38,6 +42,7 @@ dev-dependencies = []
 [tool.ruff]
 extend = "../../pyproject.toml"
 include = ["src/**", "tests/*.py"]
+exclude = ["src/autogen_ext/agents/web_surfer/*.js"]
 
 [tool.pyright]
 extends = "../../pyproject.toml"
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/__init__.py b/python/packages/autogen-ext/src/autogen_ext/agents/__init__.py
new file mode 100644
index 000000000000..d89a890ab2bf
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/__init__.py
@@ -0,0 +1,3 @@
+from .web_surfer._multimodal_web_surfer import MultimodalWebSurfer
+
+__all__ = ["MultimodalWebSurfer"]
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/__init__.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_events.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_events.py
new file mode 100644
index 000000000000..3468f416f67e
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_events.py
@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+from typing import Any, Dict
+
+
+@dataclass
+class WebSurferEvent:
+    source: str
+    message: str
+    url: str
+    action: str | None = None
+    arguments: Dict[str, Any] | None = None
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_multimodal_web_surfer.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_multimodal_web_surfer.py
new file mode 100644
index 000000000000..a5281f621ded
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_multimodal_web_surfer.py
@@ -0,0 +1,808 @@
+import base64
+import hashlib
+import io
+import json
+import logging
+import os
+import pathlib
+import re
+import time
+import traceback
+from typing import (
+    Any,
+    BinaryIO,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+)
+
+# Any, Callable, Dict, List, Literal, Tuple
+from urllib.parse import quote_plus  # parse_qs, quote, unquote, urlparse, urlunparse
+
+import aiofiles
+import PIL.Image
+from autogen_agentchat.agents import BaseChatAgent
+from autogen_agentchat.base import Response
+from autogen_agentchat.messages import ChatMessage, MultiModalMessage, TextMessage
+from autogen_core.application.logging import EVENT_LOGGER_NAME
+from autogen_core.base import CancellationToken
+from autogen_core.components import FunctionCall
+from autogen_core.components import Image as AGImage
+from autogen_core.components.models import (
+    AssistantMessage,
+    ChatCompletionClient,
+    LLMMessage,
+    SystemMessage,
+    UserMessage,
+)
+from playwright._impl._errors import Error as PlaywrightError
+from playwright._impl._errors import TimeoutError
+from playwright.async_api import BrowserContext, Download, Page, Playwright, async_playwright
+
+from ._events import WebSurferEvent
+from ._set_of_mark import add_set_of_mark
+from ._tool_definitions import (
+    TOOL_CLICK,
+    TOOL_HISTORY_BACK,
+    TOOL_PAGE_DOWN,
+    TOOL_PAGE_UP,
+    TOOL_READ_PAGE_AND_ANSWER,
+    # TOOL_SCROLL_ELEMENT_DOWN,
+    # TOOL_SCROLL_ELEMENT_UP,
+    TOOL_SLEEP,
+    TOOL_SUMMARIZE_PAGE,
+    TOOL_TYPE,
+    TOOL_VISIT_URL,
+    TOOL_WEB_SEARCH,
+)
+from ._types import (
+    InteractiveRegion,
+    UserContent,
+    VisualViewport,
+    interactiveregion_from_dict,
+    visualviewport_from_dict,
+)
+from ._utils import message_content_to_str
+
+# Viewport dimensions
+VIEWPORT_HEIGHT = 900
+VIEWPORT_WIDTH = 1440
+
+# Size of the image we send to the MLM
+# Current values represent a 0.85 scaling to fit within the GPT-4v short-edge constraints (768px)
+MLM_HEIGHT = 765
+MLM_WIDTH = 1224
+
+SCREENSHOT_TOKENS = 1105
+
+
+class MultimodalWebSurfer(BaseChatAgent):
+    """(In preview) A multimodal agent that acts as a web surfer that can search the web and visit web pages."""
+
+    DEFAULT_DESCRIPTION = "A helpful assistant with access to a web browser. Ask them to perform web searches, open pages, and interact with content (e.g., clicking links, scrolling the viewport, etc., filling in form fields, etc.) It can also summarize the entire page, or answer questions based on the content of the page. It can also be asked to sleep and wait for pages to load, in cases where the pages seem to be taking a while to load."
+
+    DEFAULT_START_PAGE = "https://www.bing.com/"
+
+    def __init__(
+        self,
+        name: str,
+        model_client: ChatCompletionClient,
+        description: str = DEFAULT_DESCRIPTION,
+    ):
+        """To instantiate properly please make sure to call MultimodalWebSurfer.init"""
+        super().__init__(name, description)
+        self._model_client = model_client
+
+        self._chat_history: List[LLMMessage] = []
+
+        # Call init to set these
+        self._playwright: Playwright | None = None
+        self._context: BrowserContext | None = None
+        self._page: Page | None = None
+        self._last_download: Download | None = None
+        self._prior_metadata_hash: str | None = None
+        self.logger = logging.getLogger(EVENT_LOGGER_NAME + f".{self.name}.MultimodalWebSurfer")
+
+        # Read page_script
+        self._page_script: str = ""
+        with open(os.path.join(os.path.abspath(os.path.dirname(__file__)), "page_script.js"), "rt") as fh:
+            self._page_script = fh.read()
+
+        # Define the download handler
+        def _download_handler(download: Download) -> None:
+            self._last_download = download
+
+        self._download_handler = _download_handler
+
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        return [MultiModalMessage]
+
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        for chat_message in messages:
+            self._chat_history.append(UserMessage(content=chat_message.content, source=chat_message.source))
+
+        try:
+            _, content = await self.__generate_reply(cancellation_token=cancellation_token)
+            if isinstance(content, str):
+                return Response(chat_message=TextMessage(content=content, source=self.name))
+            else:
+                return Response(chat_message=MultiModalMessage(content=content, source=self.name))
+        except BaseException:
+            return Response(
+                chat_message=TextMessage(content=f"Web surfing error:\n\n{traceback.format_exc()}", source=self.name)
+            )
+
+    async def init(
+        self,
+        headless: bool = True,
+        browser_channel: str | None = None,
+        browser_data_dir: str | None = None,
+        start_page: str | None = None,
+        downloads_folder: str | None = None,
+        debug_dir: str | None = os.getcwd(),
+        to_save_screenshots: bool = False,
+    ) -> None:
+        """
+        Initialize the MultimodalWebSurfer.
+
+        Args:
+            headless (bool): Whether to run the browser in headless mode. Defaults to True.
+            browser_channel (str | type[DEFAULT_CHANNEL]): The browser channel to use. Defaults to DEFAULT_CHANNEL.
+            browser_data_dir (str | None): The directory to store browser data. Defaults to None.
+            start_page (str | None): The initial page to visit. Defaults to DEFAULT_START_PAGE.
+            downloads_folder (str | None): The folder to save downloads. Defaults to None.
+            debug_dir (str | None): The directory to save debug information. Defaults to the current working directory.
+            to_save_screenshots (bool): Whether to save screenshots. Defaults to False.
+        """
+        self.start_page = start_page or self.DEFAULT_START_PAGE
+        self.downloads_folder = downloads_folder
+        self.to_save_screenshots = to_save_screenshots
+        self._chat_history.clear()
+        self._last_download = None
+        self._prior_metadata_hash = None
+
+        # Create the playwright self
+        launch_args: Dict[str, Any] = {"headless": headless}
+        if browser_channel is not None:
+            launch_args["channel"] = browser_channel
+        self._playwright = await async_playwright().start()
+
+        # Create the context -- are we launching persistent?
+        if browser_data_dir is None:
+            browser = await self._playwright.chromium.launch(**launch_args)
+            self._context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 Edg/122.0.0.0"
+            )
+        else:
+            self._context = await self._playwright.chromium.launch_persistent_context(browser_data_dir, **launch_args)
+
+        # Create the page
+        self._context.set_default_timeout(60000)  # One minute
+        self._page = await self._context.new_page()
+        assert self._page is not None
+        # self._page.route(lambda x: True, self._route_handler)
+        self._page.on("download", self._download_handler)
+        await self._page.set_viewport_size({"width": VIEWPORT_WIDTH, "height": VIEWPORT_HEIGHT})
+        await self._page.add_init_script(
+            path=os.path.join(os.path.abspath(os.path.dirname(__file__)), "page_script.js")
+        )
+        await self._page.goto(self.start_page)
+        await self._page.wait_for_load_state()
+
+        # Prepare the debug directory -- which stores the screenshots generated throughout the process
+        await self._set_debug_dir(debug_dir)
+
+    async def _sleep(self, duration: Union[int, float]) -> None:
+        assert self._page is not None
+        await self._page.wait_for_timeout(duration * 1000)
+
+    async def _set_debug_dir(self, debug_dir: str | None) -> None:
+        assert self._page is not None
+        self.debug_dir = debug_dir
+        if self.debug_dir is None:
+            return
+
+        if not os.path.isdir(self.debug_dir):
+            os.mkdir(self.debug_dir)
+        current_timestamp = "_" + int(time.time()).__str__()
+        screenshot_png_name = "screenshot" + current_timestamp + ".png"
+        debug_html = os.path.join(self.debug_dir, "screenshot" + current_timestamp + ".html")
+        if self.to_save_screenshots:
+            async with aiofiles.open(debug_html, "wt") as file:
+                await file.write(
+                    f"""
+    
+    
+        
+        
+    
+    
+    """.strip(),
+                )
+        if self.to_save_screenshots:
+            await self._page.screenshot(path=os.path.join(self.debug_dir, screenshot_png_name))
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.name,
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+            self.logger.info(
+                f"Multimodal Web Surfer debug screens: {pathlib.Path(os.path.abspath(debug_html)).as_uri()}\n"
+            )
+
+    async def _reset(self, cancellation_token: CancellationToken) -> None:
+        assert self._page is not None
+        self._chat_history.clear()
+        await self._visit_page(self.start_page)
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot" + current_timestamp + ".png"
+            await self._page.screenshot(path=os.path.join(self.debug_dir, screenshot_png_name))  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.name,
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+
+        self.logger.info(
+            WebSurferEvent(
+                source=self.name,
+                url=self._page.url,
+                message="Resetting browser.",
+            )
+        )
+
+    def _target_name(self, target: str, rects: Dict[str, InteractiveRegion]) -> str | None:
+        try:
+            return rects[target]["aria_name"].strip()
+        except KeyError:
+            return None
+
+    def _format_target_list(self, ids: List[str], rects: Dict[str, InteractiveRegion]) -> List[str]:
+        targets: List[str] = []
+        for r in list(set(ids)):
+            if r in rects:
+                # Get the role
+                aria_role = rects[r].get("role", "").strip()
+                if len(aria_role) == 0:
+                    aria_role = rects[r].get("tag_name", "").strip()
+
+                # Get the name
+                aria_name = re.sub(r"[\n\r]+", " ", rects[r].get("aria_name", "")).strip()
+
+                # What are the actions?
+                actions = ['"click"']
+                if rects[r]["role"] in ["textbox", "searchbox", "search"]:
+                    actions = ['"input_text"']
+                actions_str = "[" + ",".join(actions) + "]"
+
+                targets.append(f'{{"id": {r}, "name": "{aria_name}", "role": "{aria_role}", "tools": {actions_str} }}')
+
+        return targets
+
+    async def _execute_tool(
+        self,
+        message: List[FunctionCall],
+        rects: Dict[str, InteractiveRegion],
+        tool_names: str,
+        use_ocr: bool = True,
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> Tuple[bool, UserContent]:
+        name = message[0].name
+        args = json.loads(message[0].arguments)
+        action_description = ""
+        assert self._page is not None
+        self.logger.info(
+            WebSurferEvent(
+                source=self.name,
+                url=self._page.url,
+                action=name,
+                arguments=args,
+                message=f"{name}( {json.dumps(args)} )",
+            )
+        )
+
+        if name == "visit_url":
+            url = args.get("url")
+            action_description = f"I typed '{url}' into the browser address bar."
+            # Check if the argument starts with a known protocol
+            if url.startswith(("https://", "http://", "file://", "about:")):
+                await self._visit_page(url)
+            # If the argument contains a space, treat it as a search query
+            elif " " in url:
+                await self._visit_page(f"https://www.bing.com/search?q={quote_plus(url)}&FORM=QBLH")
+            # Otherwise, prefix with https://
+            else:
+                await self._visit_page("https://" + url)
+
+        elif name == "history_back":
+            action_description = "I clicked the browser back button."
+            await self._back()
+
+        elif name == "web_search":
+            query = args.get("query")
+            action_description = f"I typed '{query}' into the browser search bar."
+            await self._visit_page(f"https://www.bing.com/search?q={quote_plus(query)}&FORM=QBLH")
+
+        elif name == "page_up":
+            action_description = "I scrolled up one page in the browser."
+            await self._page_up()
+
+        elif name == "page_down":
+            action_description = "I scrolled down one page in the browser."
+            await self._page_down()
+
+        elif name == "click":
+            target_id = str(args.get("target_id"))
+            target_name = self._target_name(target_id, rects)
+            if target_name:
+                action_description = f"I clicked '{target_name}'."
+            else:
+                action_description = "I clicked the control."
+            await self._click_id(target_id)
+
+        elif name == "input_text":
+            input_field_id = str(args.get("input_field_id"))
+            text_value = str(args.get("text_value"))
+            input_field_name = self._target_name(input_field_id, rects)
+            if input_field_name:
+                action_description = f"I typed '{text_value}' into '{input_field_name}'."
+            else:
+                action_description = f"I input '{text_value}'."
+            await self._fill_id(input_field_id, text_value)
+
+        elif name == "scroll_element_up":
+            target_id = str(args.get("target_id"))
+            target_name = self._target_name(target_id, rects)
+
+            if target_name:
+                action_description = f"I scrolled '{target_name}' up."
+            else:
+                action_description = "I scrolled the control up."
+
+            await self._scroll_id(target_id, "up")
+
+        elif name == "scroll_element_down":
+            target_id = str(args.get("target_id"))
+            target_name = self._target_name(target_id, rects)
+
+            if target_name:
+                action_description = f"I scrolled '{target_name}' down."
+            else:
+                action_description = "I scrolled the control down."
+
+            await self._scroll_id(target_id, "down")
+
+        elif name == "sleep":
+            action_description = "I am waiting a short period of time before taking further action."
+            await self._sleep(3)  # There's a 2s sleep below too
+
+        else:
+            raise ValueError(f"Unknown tool '{name}'. Please choose from:\n\n{tool_names}")
+
+        await self._page.wait_for_load_state()
+        await self._sleep(3)
+
+        # Handle downloads
+        if self._last_download is not None and self.downloads_folder is not None:
+            fname = os.path.join(self.downloads_folder, self._last_download.suggested_filename)
+            # TODO: Fix this type
+            await self._last_download.save_as(fname)  # type: ignore
+            page_body = f"Download Successful
Successfully downloaded '{self._last_download.suggested_filename}' to local path:

{fname}
"
+            await self._page.goto(
+                "data:text/html;base64," + base64.b64encode(page_body.encode("utf-8")).decode("utf-8")
+            )
+            await self._page.wait_for_load_state()
+
+        # Handle metadata
+        page_metadata = json.dumps(await self._get_page_metadata(), indent=4)
+        metadata_hash = hashlib.md5(page_metadata.encode("utf-8")).hexdigest()
+        if metadata_hash != self._prior_metadata_hash:
+            page_metadata = (
+                "\nThe following metadata was extracted from the webpage:\n\n" + page_metadata.strip() + "\n"
+            )
+        else:
+            page_metadata = ""
+        self._prior_metadata_hash = metadata_hash
+
+        # Describe the viewport of the new page in words
+        viewport = await self._get_visual_viewport()
+        percent_visible = int(viewport["height"] * 100 / viewport["scrollHeight"])
+        percent_scrolled = int(viewport["pageTop"] * 100 / viewport["scrollHeight"])
+        if percent_scrolled < 1:  # Allow some rounding error
+            position_text = "at the top of the page"
+        elif percent_scrolled + percent_visible >= 99:  # Allow some rounding error
+            position_text = "at the bottom of the page"
+        else:
+            position_text = str(percent_scrolled) + "% down from the top of the page"
+
+        new_screenshot = await self._page.screenshot()
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot" + current_timestamp + ".png"
+            async with aiofiles.open(os.path.join(self.debug_dir, screenshot_png_name), "wb") as file:  # type: ignore
+                await file.write(new_screenshot)  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.name,
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+
+        ocr_text = (
+            await self._get_ocr_text(new_screenshot, cancellation_token=cancellation_token) if use_ocr is True else ""
+        )
+
+        # Return the complete observation
+        message_content = ""  # message.content or ""
+        page_title = await self._page.title()
+
+        return False, [
+            f"{message_content}\n\n{action_description}\n\nHere is a screenshot of [{page_title}]({self._page.url}). The viewport shows {percent_visible}% of the webpage, and is positioned {position_text}.{page_metadata}\nAutomatic OCR of the page screenshot has detected the following text:\n\n{ocr_text}".strip(),
+            AGImage.from_pil(PIL.Image.open(io.BytesIO(new_screenshot))),
+        ]
+
+    async def __generate_reply(self, cancellation_token: CancellationToken) -> Tuple[bool, UserContent]:
+        assert self._page is not None
+        """Generates the actual reply. First calls the LLM to figure out which tool to use, then executes the tool."""
+
+        # Clone the messages to give context, removing old screenshots
+        history: List[LLMMessage] = []
+        for m in self._chat_history:
+            if isinstance(m.content, str):
+                history.append(m)
+            elif isinstance(m.content, list):
+                content = message_content_to_str(m.content)
+                if isinstance(m, UserMessage):
+                    history.append(UserMessage(content=content, source=m.source))
+                elif isinstance(m, AssistantMessage):
+                    history.append(AssistantMessage(content=content, source=m.source))
+                elif isinstance(m, SystemMessage):
+                    history.append(SystemMessage(content=content))
+
+        # Ask the page for interactive elements, then prepare the state-of-mark screenshot
+        rects = await self._get_interactive_rects()
+        viewport = await self._get_visual_viewport()
+        screenshot = await self._page.screenshot()
+        som_screenshot, visible_rects, rects_above, rects_below = add_set_of_mark(screenshot, rects)
+
+        if self.to_save_screenshots:
+            current_timestamp = "_" + int(time.time()).__str__()
+            screenshot_png_name = "screenshot_som" + current_timestamp + ".png"
+            som_screenshot.save(os.path.join(self.debug_dir, screenshot_png_name))  # type: ignore
+            self.logger.info(
+                WebSurferEvent(
+                    source=self.name,
+                    url=self._page.url,
+                    message="Screenshot: " + screenshot_png_name,
+                )
+            )
+        # What tools are available?
+        tools = [
+            TOOL_VISIT_URL,
+            TOOL_HISTORY_BACK,
+            TOOL_CLICK,
+            TOOL_TYPE,
+            TOOL_SUMMARIZE_PAGE,
+            TOOL_READ_PAGE_AND_ANSWER,
+            TOOL_SLEEP,
+        ]
+
+        # Can we reach Bing to search?
+        # if self._navigation_allow_list("https://www.bing.com/"):
+        tools.append(TOOL_WEB_SEARCH)
+
+        # We can scroll up
+        if viewport["pageTop"] > 5:
+            tools.append(TOOL_PAGE_UP)
+
+        # Can scroll down
+        if (viewport["pageTop"] + viewport["height"] + 5) < viewport["scrollHeight"]:
+            tools.append(TOOL_PAGE_DOWN)
+
+        # Focus hint
+        focused = await self._get_focused_rect_id()
+        focused_hint = ""
+        if focused:
+            name = self._target_name(focused, rects)
+            if name:
+                name = f"(and name '{name}') "
+
+            role = "control"
+            try:
+                role = rects[focused]["role"]
+            except KeyError:
+                pass
+
+            focused_hint = f"\nThe {role} with ID {focused} {name}currently has the input focus.\n\n"
+
+        # Everything visible
+        visible_targets = "\n".join(self._format_target_list(visible_rects, rects)) + "\n\n"
+
+        # Everything else
+        other_targets: List[str] = []
+        other_targets.extend(self._format_target_list(rects_above, rects))
+        other_targets.extend(self._format_target_list(rects_below, rects))
+
+        if len(other_targets) > 0:
+            other_targets_str = (
+                "Additional valid interaction targets (not shown) include:\n" + "\n".join(other_targets) + "\n\n"
+            )
+        else:
+            other_targets_str = ""
+
+        # If there are scrollable elements, then add the corresponding tools
+        # has_scrollable_elements = False
+        # if has_scrollable_elements:
+        #    tools.append(TOOL_SCROLL_ELEMENT_UP)
+        #    tools.append(TOOL_SCROLL_ELEMENT_DOWN)
+
+        tool_names = "\n".join([t["name"] for t in tools])
+
+        text_prompt = f"""
+Consider the following screenshot of a web browser, which is open to the page '{self._page.url}'. In this screenshot, interactive elements are outlined in bounding boxes of different colors. Each bounding box has a numeric ID label in the same color. Additional information about each visible label is listed below:
+
+{visible_targets}{other_targets_str}{focused_hint}You are to respond to the user's most recent request by selecting an appropriate tool the following set, or by answering the question directly if possible:
+
+{tool_names}
+
+When deciding between tools, consider if the request can be best addressed by:
+    - the contents of the current viewport (in which case actions like clicking links, clicking buttons, or inputting text might be most appropriate)
+    - contents found elsewhere on the full webpage (in which case actions like scrolling, summarization, or full-page Q&A might be most appropriate)
+    - on some other website entirely (in which case actions like performing a new web search might be the best option)
+""".strip()
+
+        # Scale the screenshot for the MLM, and close the original
+        scaled_screenshot = som_screenshot.resize((MLM_WIDTH, MLM_HEIGHT))
+        som_screenshot.close()
+        if self.to_save_screenshots:
+            scaled_screenshot.save(os.path.join(self.debug_dir, "screenshot_scaled.png"))  # type: ignore
+
+        # Add the multimodal message and make the request
+        history.append(UserMessage(content=[text_prompt, AGImage.from_pil(scaled_screenshot)], source=self.name))
+        response = await self._model_client.create(
+            history, tools=tools, extra_create_args={"tool_choice": "auto"}, cancellation_token=cancellation_token
+        )  # , "parallel_tool_calls": False})
+        message = response.content
+
+        self._last_download = None
+
+        if isinstance(message, str):
+            # Answer directly
+            return False, message
+        elif isinstance(message, list):
+            # Take an action
+            return await self._execute_tool(message, rects, tool_names, cancellation_token=cancellation_token)
+        else:
+            # Not sure what happened here
+            raise AssertionError(f"Unknown response format '{message}'")
+
+    async def _get_interactive_rects(self) -> Dict[str, InteractiveRegion]:
+        assert self._page is not None
+
+        # Read the regions from the DOM
+        try:
+            await self._page.evaluate(self._page_script)
+        except Exception:
+            pass
+        result = cast(
+            Dict[str, Dict[str, Any]], await self._page.evaluate("MultimodalWebSurfer.getInteractiveRects();")
+        )
+
+        # Convert the results into appropriate types
+        assert isinstance(result, dict)
+        typed_results: Dict[str, InteractiveRegion] = {}
+        for k in result:
+            assert isinstance(k, str)
+            typed_results[k] = interactiveregion_from_dict(result[k])
+
+        return typed_results
+
+    async def _get_visual_viewport(self) -> VisualViewport:
+        assert self._page is not None
+        try:
+            await self._page.evaluate(self._page_script)
+        except Exception:
+            pass
+        return visualviewport_from_dict(await self._page.evaluate("MultimodalWebSurfer.getVisualViewport();"))
+
+    async def _get_focused_rect_id(self) -> str:
+        assert self._page is not None
+        try:
+            await self._page.evaluate(self._page_script)
+        except Exception:
+            pass
+        result = await self._page.evaluate("MultimodalWebSurfer.getFocusedElementId();")
+        return str(result)
+
+    async def _get_page_metadata(self) -> Dict[str, Any]:
+        assert self._page is not None
+        try:
+            await self._page.evaluate(self._page_script)
+        except Exception:
+            pass
+        result = await self._page.evaluate("MultimodalWebSurfer.getPageMetadata();")
+        assert isinstance(result, dict)
+        return cast(Dict[str, Any], result)
+
+    async def _get_page_markdown(self) -> str:
+        assert self._page is not None
+        html = await self._page.evaluate("document.documentElement.outerHTML;")
+        # TODO: fix types
+        res = self._markdown_converter.convert_stream(io.StringIO(html), file_extension=".html", url=self._page.url)  # type: ignore
+        return res.text_content  # type: ignore
+
+    async def _on_new_page(self, page: Page) -> None:
+        self._page = page
+        assert self._page is not None
+        # self._page.route(lambda x: True, self._route_handler)
+        self._page.on("download", self._download_handler)
+        await self._page.set_viewport_size({"width": VIEWPORT_WIDTH, "height": VIEWPORT_HEIGHT})
+        await self._sleep(0.2)
+        self._prior_metadata_hash = None
+        await self._page.add_init_script(
+            path=os.path.join(os.path.abspath(os.path.dirname(__file__)), "page_script.js")
+        )
+        await self._page.wait_for_load_state()
+
+    async def _back(self) -> None:
+        assert self._page is not None
+        await self._page.go_back()
+
+    async def _visit_page(self, url: str) -> None:
+        assert self._page is not None
+        try:
+            # Regular webpage
+            await self._page.goto(url)
+            await self._page.wait_for_load_state()
+            self._prior_metadata_hash = None
+        except Exception as e_outer:
+            # Downloaded file
+            if self.downloads_folder and "net::ERR_ABORTED" in str(e_outer):
+                async with self._page.expect_download() as download_info:
+                    try:
+                        await self._page.goto(url)
+                    except Exception as e_inner:
+                        if "net::ERR_ABORTED" in str(e_inner):
+                            pass
+                        else:
+                            raise e_inner
+                    download = await download_info.value
+                    fname = os.path.join(self.downloads_folder, download.suggested_filename)
+                    await download.save_as(fname)
+                    message = f"
Successfully downloaded '{download.suggested_filename}' to local path:

{fname}
"
+                    await self._page.goto(
+                        "data:text/html;base64," + base64.b64encode(message.encode("utf-8")).decode("utf-8")
+                    )
+                    self._last_download = None  # Since we already handled it
+            else:
+                raise e_outer
+
+    async def _page_down(self) -> None:
+        assert self._page is not None
+        await self._page.evaluate(f"window.scrollBy(0, {VIEWPORT_HEIGHT-50});")
+
+    async def _page_up(self) -> None:
+        assert self._page is not None
+        await self._page.evaluate(f"window.scrollBy(0, -{VIEWPORT_HEIGHT-50});")
+
+    async def _click_id(self, identifier: str) -> None:
+        assert self._page is not None
+        target = self._page.locator(f"[__elementId='{identifier}']")
+
+        # See if it exists
+        try:
+            await target.wait_for(timeout=100)
+        except TimeoutError:
+            raise ValueError("No such element.") from None
+
+        # Click it
+        await target.scroll_into_view_if_needed()
+        box = cast(Dict[str, Union[int, float]], await target.bounding_box())
+        try:
+            # Give it a chance to open a new page
+            # TODO: Having trouble with these types
+            async with self._page.expect_event("popup", timeout=1000) as page_info:  # type: ignore
+                await self._page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2, delay=10)
+                # If we got this far without error, than a popup or new tab opened. Handle it.
+
+                new_page = await page_info.value  # type: ignore
+
+                assert isinstance(new_page, Page)
+                await self._on_new_page(new_page)
+
+                self.logger.info(
+                    WebSurferEvent(
+                        source=self.name,
+                        url=self._page.url,
+                        message="New tab or window.",
+                    )
+                )
+
+        except TimeoutError:
+            pass
+
+    async def _fill_id(self, identifier: str, value: str) -> None:
+        assert self._page is not None
+        target = self._page.locator(f"[__elementId='{identifier}']")
+
+        # See if it exists
+        try:
+            await target.wait_for(timeout=100)
+        except TimeoutError:
+            raise ValueError("No such element.") from None
+
+        # Fill it
+        await target.scroll_into_view_if_needed()
+        await target.focus()
+        try:
+            await target.fill(value)
+        except PlaywrightError:
+            await target.press_sequentially(value)
+        await target.press("Enter")
+
+    async def _scroll_id(self, identifier: str, direction: str) -> None:
+        assert self._page is not None
+        await self._page.evaluate(
+            f"""
+        (function() {{
+            let elm = document.querySelector("[__elementId='{identifier}']");
+            if (elm) {{
+                if ("{direction}" == "up") {{
+                    elm.scrollTop = Math.max(0, elm.scrollTop - elm.clientHeight);
+                }}
+                else {{
+                    elm.scrollTop = Math.min(elm.scrollHeight - elm.clientHeight, elm.scrollTop + elm.clientHeight);
+                }}
+            }}
+        }})();
+    """
+        )
+
+    async def _get_ocr_text(
+        self, image: bytes | io.BufferedIOBase | PIL.Image.Image, cancellation_token: Optional[CancellationToken] = None
+    ) -> str:
+        scaled_screenshot = None
+        if isinstance(image, PIL.Image.Image):
+            scaled_screenshot = image.resize((MLM_WIDTH, MLM_HEIGHT))
+        else:
+            pil_image = None
+            if not isinstance(image, io.BufferedIOBase):
+                pil_image = PIL.Image.open(io.BytesIO(image))
+            else:
+                # TODO: Not sure why this cast was needed, but by this point screenshot is a binary file-like object
+                pil_image = PIL.Image.open(cast(BinaryIO, image))
+            scaled_screenshot = pil_image.resize((MLM_WIDTH, MLM_HEIGHT))
+            pil_image.close()
+
+        # Add the multimodal message and make the request
+        messages: List[LLMMessage] = []
+        messages.append(
+            UserMessage(
+                content=[
+                    "Please transcribe all visible text on this page, including both main content and the labels of UI elements.",
+                    AGImage.from_pil(scaled_screenshot),
+                ],
+                source=self.name,
+            )
+        )
+        response = await self._model_client.create(messages, cancellation_token=cancellation_token)
+        scaled_screenshot.close()
+        assert isinstance(response.content, str)
+        return response.content
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_set_of_mark.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_set_of_mark.py
new file mode 100644
index 000000000000..07656ce16bfb
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_set_of_mark.py
@@ -0,0 +1,96 @@
+import io
+import random
+from typing import BinaryIO, Dict, List, Tuple, cast
+
+from PIL import Image, ImageDraw, ImageFont
+
+from ._types import DOMRectangle, InteractiveRegion
+
+TOP_NO_LABEL_ZONE = 20  # Don't print any labels close the top of the page
+
+
+def add_set_of_mark(
+    screenshot: bytes | Image.Image | io.BufferedIOBase, ROIs: Dict[str, InteractiveRegion]
+) -> Tuple[Image.Image, List[str], List[str], List[str]]:
+    if isinstance(screenshot, Image.Image):
+        return _add_set_of_mark(screenshot, ROIs)
+
+    if isinstance(screenshot, bytes):
+        screenshot = io.BytesIO(screenshot)
+
+    # TODO: Not sure why this cast was needed, but by this point screenshot is a binary file-like object
+    image = Image.open(cast(BinaryIO, screenshot))
+    comp, visible_rects, rects_above, rects_below = _add_set_of_mark(image, ROIs)
+    image.close()
+    return comp, visible_rects, rects_above, rects_below
+
+
+def _add_set_of_mark(
+    screenshot: Image.Image, ROIs: Dict[str, InteractiveRegion]
+) -> Tuple[Image.Image, List[str], List[str], List[str]]:
+    visible_rects: List[str] = list()
+    rects_above: List[str] = list()  # Scroll up to see
+    rects_below: List[str] = list()  # Scroll down to see
+
+    fnt = ImageFont.load_default(14)
+    base = screenshot.convert("L").convert("RGBA")
+    overlay = Image.new("RGBA", base.size)
+
+    draw = ImageDraw.Draw(overlay)
+    for r in ROIs:
+        for rect in ROIs[r]["rects"]:
+            # Empty rectangles
+            if not rect:
+                continue
+            if rect["width"] * rect["height"] == 0:
+                continue
+
+            mid = ((rect["right"] + rect["left"]) / 2.0, (rect["top"] + rect["bottom"]) / 2.0)
+
+            if 0 <= mid[0] and mid[0] < base.size[0]:
+                if mid[1] < 0:
+                    rects_above.append(r)
+                elif mid[1] >= base.size[1]:
+                    rects_below.append(r)
+                else:
+                    visible_rects.append(r)
+                    _draw_roi(draw, int(r), fnt, rect)
+
+    comp = Image.alpha_composite(base, overlay)
+    overlay.close()
+    return comp, visible_rects, rects_above, rects_below
+
+
+def _draw_roi(
+    draw: ImageDraw.ImageDraw, idx: int, font: ImageFont.FreeTypeFont | ImageFont.ImageFont, rect: DOMRectangle
+) -> None:
+    color = _color(idx)
+    luminance = color[0] * 0.3 + color[1] * 0.59 + color[2] * 0.11
+    text_color = (0, 0, 0, 255) if luminance > 90 else (255, 255, 255, 255)
+
+    roi = ((rect["left"], rect["top"]), (rect["right"], rect["bottom"]))
+
+    label_location = (rect["right"], rect["top"])
+    label_anchor = "rb"
+
+    if label_location[1] <= TOP_NO_LABEL_ZONE:
+        label_location = (rect["right"], rect["bottom"])
+        label_anchor = "rt"
+
+    draw.rectangle(roi, outline=color, fill=(color[0], color[1], color[2], 48), width=2)
+
+    # TODO: Having trouble with these types being partially Unknown.
+    bbox = draw.textbbox(label_location, str(idx), font=font, anchor=label_anchor, align="center")  # type: ignore
+    bbox = (bbox[0] - 3, bbox[1] - 3, bbox[2] + 3, bbox[3] + 3)
+    draw.rectangle(bbox, fill=color)
+
+    # TODO: Having trouble with these types being partially Unknown.
+    draw.text(label_location, str(idx), fill=text_color, font=font, anchor=label_anchor, align="center")  # type: ignore
+
+
+def _color(identifier: int) -> Tuple[int, int, int, int]:
+    rnd = random.Random(int(identifier))
+    color = [rnd.randint(0, 255), rnd.randint(125, 255), rnd.randint(0, 50)]
+    rnd.shuffle(color)
+    color.append(255)
+    return cast(Tuple[int, int, int, int], tuple(color))
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_tool_definitions.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_tool_definitions.py
new file mode 100644
index 000000000000..b662f4101d8a
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_tool_definitions.py
@@ -0,0 +1,289 @@
+from typing import Any, Dict
+
+# TODO Why does pylance fail if I import from autogen_core.components.tools instead?
+from autogen_core.components.tools._base import ParametersSchema, ToolSchema
+
+
+def _load_tool(tooldef: Dict[str, Any]) -> ToolSchema:
+    return ToolSchema(
+        name=tooldef["function"]["name"],
+        description=tooldef["function"]["description"],
+        parameters=ParametersSchema(
+            type="object",
+            properties=tooldef["function"]["parameters"]["properties"],
+            required=tooldef["function"]["parameters"]["required"],
+        ),
+    )
+
+
+TOOL_VISIT_URL: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "visit_url",
+            "description": "Navigate directly to a provided URL using the browser's address bar. Prefer this tool over other navigation techniques in cases where the user provides a fully-qualified URL (e.g., choose it over clicking links, or inputing queries into search boxes).",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "url": {
+                        "type": "string",
+                        "description": "The URL to visit in the browser.",
+                    },
+                },
+                "required": ["reasoning", "url"],
+            },
+        },
+    }
+)
+
+TOOL_WEB_SEARCH: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Performs a web search on Bing.com with the given query.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "query": {
+                        "type": "string",
+                        "description": "The web search query to use.",
+                    },
+                },
+                "required": ["reasoning", "query"],
+            },
+        },
+    }
+)
+
+TOOL_HISTORY_BACK: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "history_back",
+            "description": "Navigates back one page in the browser's history. This is equivalent to clicking the browser back button.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                },
+                "required": ["reasoning"],
+            },
+        },
+    }
+)
+
+TOOL_PAGE_UP: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "page_up",
+            "description": "Scrolls the entire browser viewport one page UP towards the beginning.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                },
+                "required": ["reasoning"],
+            },
+        },
+    }
+)
+
+TOOL_PAGE_DOWN: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "page_down",
+            "description": "Scrolls the entire browser viewport one page DOWN towards the end.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                },
+                "required": ["reasoning"],
+            },
+        },
+    }
+)
+
+TOOL_CLICK: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "click",
+            "description": "Clicks the mouse on the target with the given id.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "target_id": {
+                        "type": "integer",
+                        "description": "The numeric id of the target to click.",
+                    },
+                },
+                "required": ["reasoning", "target_id"],
+            },
+        },
+    }
+)
+
+TOOL_TYPE: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "input_text",
+            "description": "Types the given text value into the specified field.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "input_field_id": {
+                        "type": "integer",
+                        "description": "The numeric id of the input field to receive the text.",
+                    },
+                    "text_value": {
+                        "type": "string",
+                        "description": "The text to type into the input field.",
+                    },
+                },
+                "required": ["reasoning", "input_field_id", "text_value"],
+            },
+        },
+    }
+)
+
+TOOL_SCROLL_ELEMENT_DOWN: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "scroll_element_down",
+            "description": "Scrolls a given html element (e.g., a div or a menu) DOWN.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "target_id": {
+                        "type": "integer",
+                        "description": "The numeric id of the target to scroll down.",
+                    },
+                },
+                "required": ["reasoning", "target_id"],
+            },
+        },
+    }
+)
+
+TOOL_SCROLL_ELEMENT_UP: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "scroll_element_up",
+            "description": "Scrolls a given html element (e.g., a div or a menu) UP.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "target_id": {
+                        "type": "integer",
+                        "description": "The numeric id of the target to scroll UP.",
+                    },
+                },
+                "required": ["reasoning", "target_id"],
+            },
+        },
+    }
+)
+
+TOOL_READ_PAGE_AND_ANSWER: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "answer_question",
+            "description": "Uses AI to answer a question about the current webpage's content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                    "question": {
+                        "type": "string",
+                        "description": "The question to answer.",
+                    },
+                },
+                "required": ["reasoning", "question"],
+            },
+        },
+    }
+)
+
+TOOL_SUMMARIZE_PAGE: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "summarize_page",
+            "description": "Uses AI to summarize the entire page.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                },
+                "required": ["reasoning"],
+            },
+        },
+    }
+)
+
+TOOL_SLEEP: ToolSchema = _load_tool(
+    {
+        "type": "function",
+        "function": {
+            "name": "sleep",
+            "description": "Wait a short period of time. Call this function if the page has not yet fully loaded, or if it is determined that a small delay would increase the task's chances of success.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "reasoning": {
+                        "type": "string",
+                        "description": "A short explanation of the reasoning for calling this tool and taking this action.",
+                    },
+                },
+                "required": ["reasoning"],
+            },
+        },
+    }
+)
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_types.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_types.py
new file mode 100644
index 000000000000..f7fa2cdea78f
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_types.py
@@ -0,0 +1,106 @@
+from typing import Any, Dict, List, TypedDict, Union
+
+from autogen_core.components import FunctionCall, Image
+from autogen_core.components.models import FunctionExecutionResult
+
+UserContent = Union[str, List[Union[str, Image]]]
+AssistantContent = Union[str, List[FunctionCall]]
+FunctionExecutionContent = List[FunctionExecutionResult]
+SystemContent = str
+
+
+class DOMRectangle(TypedDict):
+    x: Union[int, float]
+    y: Union[int, float]
+    width: Union[int, float]
+    height: Union[int, float]
+    top: Union[int, float]
+    right: Union[int, float]
+    bottom: Union[int, float]
+    left: Union[int, float]
+
+
+class VisualViewport(TypedDict):
+    height: Union[int, float]
+    width: Union[int, float]
+    offsetLeft: Union[int, float]
+    offsetTop: Union[int, float]
+    pageLeft: Union[int, float]
+    pageTop: Union[int, float]
+    scale: Union[int, float]
+    clientWidth: Union[int, float]
+    clientHeight: Union[int, float]
+    scrollWidth: Union[int, float]
+    scrollHeight: Union[int, float]
+
+
+class InteractiveRegion(TypedDict):
+    tag_name: str
+    role: str
+    aria_name: str
+    v_scrollable: bool
+    rects: List[DOMRectangle]
+
+
+# Helper functions for dealing with JSON. Not sure there's a better way?
+
+
+def _get_str(d: Any, k: str) -> str:
+    val = d[k]
+    assert isinstance(val, str)
+    return val
+
+
+def _get_number(d: Any, k: str) -> Union[int, float]:
+    val = d[k]
+    assert isinstance(val, int) or isinstance(val, float)
+    return val
+
+
+def _get_bool(d: Any, k: str) -> bool:
+    val = d[k]
+    assert isinstance(val, bool)
+    return val
+
+
+def domrectangle_from_dict(rect: Dict[str, Any]) -> DOMRectangle:
+    return DOMRectangle(
+        x=_get_number(rect, "x"),
+        y=_get_number(rect, "y"),
+        width=_get_number(rect, "width"),
+        height=_get_number(rect, "height"),
+        top=_get_number(rect, "top"),
+        right=_get_number(rect, "right"),
+        bottom=_get_number(rect, "bottom"),
+        left=_get_number(rect, "left"),
+    )
+
+
+def interactiveregion_from_dict(region: Dict[str, Any]) -> InteractiveRegion:
+    typed_rects: List[DOMRectangle] = []
+    for rect in region["rects"]:
+        typed_rects.append(domrectangle_from_dict(rect))
+
+    return InteractiveRegion(
+        tag_name=_get_str(region, "tag_name"),
+        role=_get_str(region, "role"),
+        aria_name=_get_str(region, "aria-name"),
+        v_scrollable=_get_bool(region, "v-scrollable"),
+        rects=typed_rects,
+    )
+
+
+def visualviewport_from_dict(viewport: Dict[str, Any]) -> VisualViewport:
+    return VisualViewport(
+        height=_get_number(viewport, "height"),
+        width=_get_number(viewport, "width"),
+        offsetLeft=_get_number(viewport, "offsetLeft"),
+        offsetTop=_get_number(viewport, "offsetTop"),
+        pageLeft=_get_number(viewport, "pageLeft"),
+        pageTop=_get_number(viewport, "pageTop"),
+        scale=_get_number(viewport, "scale"),
+        clientWidth=_get_number(viewport, "clientWidth"),
+        clientHeight=_get_number(viewport, "clientHeight"),
+        scrollWidth=_get_number(viewport, "scrollWidth"),
+        scrollHeight=_get_number(viewport, "scrollHeight"),
+    )
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_utils.py b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_utils.py
new file mode 100644
index 000000000000..ddafc8d92bb7
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/_utils.py
@@ -0,0 +1,25 @@
+from typing import List
+
+from autogen_core.components import Image
+
+from ._types import AssistantContent, FunctionExecutionContent, SystemContent, UserContent
+
+
+# Convert UserContent to a string
+def message_content_to_str(
+    message_content: UserContent | AssistantContent | SystemContent | FunctionExecutionContent,
+) -> str:
+    if isinstance(message_content, str):
+        return message_content
+    elif isinstance(message_content, List):
+        converted: List[str] = list()
+        for item in message_content:
+            if isinstance(item, str):
+                converted.append(item.rstrip())
+            elif isinstance(item, Image):
+                converted.append("")
+            else:
+                converted.append(str(item).rstrip())
+        return "\n".join(converted)
+    else:
+        raise AssertionError("Unexpected response type.")
diff --git a/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/page_script.js b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/page_script.js
new file mode 100644
index 000000000000..95b32d5b9902
--- /dev/null
+++ b/python/packages/autogen-ext/src/autogen_ext/agents/web_surfer/page_script.js
@@ -0,0 +1,376 @@
+var MultimodalWebSurfer = MultimodalWebSurfer || (function() {
+  let nextLabel = 10;
+
+  let roleMapping = {
+      "a": "link",
+      "area": "link",
+      "button": "button",
+      "input, type=button": "button",
+      "input, type=checkbox": "checkbox",
+      "input, type=email": "textbox",
+      "input, type=number": "spinbutton",
+      "input, type=radio": "radio",
+      "input, type=range": "slider",
+      "input, type=reset": "button",
+      "input, type=search": "searchbox",
+      "input, type=submit": "button",
+      "input, type=tel": "textbox",
+      "input, type=text": "textbox",
+      "input, type=url": "textbox",
+      "search": "search",
+      "select": "combobox",
+      "option": "option",
+      "textarea": "textbox"
+  };
+
+  let getCursor = function(elm) {
+      return window.getComputedStyle(elm)["cursor"];
+  };
+
+  let getInteractiveElements = function() {
+
+      let results = []
+      let roles = ["scrollbar", "searchbox", "slider", "spinbutton", "switch", "tab", "treeitem", "button", "checkbox", "gridcell", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "progressbar", "radio", "textbox", "combobox", "menu", "tree", "treegrid", "grid", "listbox", "radiogroup", "widget"];
+      let inertCursors = ["auto", "default", "none", "text", "vertical-text", "not-allowed", "no-drop"];
+
+      // Get the main interactive elements
+      let nodeList = document.querySelectorAll("input, select, textarea, button, [href], [onclick], [contenteditable], [tabindex]:not([tabindex='-1'])");
+      for (let i=0; i -1) {
+                  results.push(nodeList[i]);
+	      }
+	  }
+      }
+
+      // Any element that changes the cursor to something implying interactivity
+      nodeList = document.querySelectorAll("*");
+      for (let i=0; i= 0) {
+             continue;
+         }
+
+         // Move up to the first instance of this cursor change
+         parent = node.parentNode;
+         while (parent && getCursor(parent) == cursor) {
+             node = parent;
+	     parent = node.parentNode;
+         }
+
+         // Add the node if it is new
+         if (results.indexOf(node) == -1) {
+             results.push(node);
+         }
+      }
+
+      return results;
+  };
+
+  let labelElements = function(elements) {
+      for (let i=0; i= 1;
+
+	 let record = {
+             "tag_name": ariaRole[1],
+	     "role": ariaRole[0],
+	     "aria-name": ariaName,
+	     "v-scrollable": vScrollable,
+	     "rects": []
+	 };
+
+         for (const rect of rects) {
+	     let x = rect.left + rect.width/2;
+             let y = rect.top + rect.height/2;
+             if (isTopmost(elements[i], x, y)) {
+		 record["rects"].push(JSON.parse(JSON.stringify(rect)));
+             }
+         }
+
+	 if (record["rects"].length > 0) {
+             results[key] = record;
+         }
+      }
+      return results;
+  };
+
+  let getVisualViewport = function() {
+      let vv = window.visualViewport;
+      let de = document.documentElement;
+      return {
+          "height":     vv ? vv.height : 0,
+	  "width":      vv ? vv.width : 0,
+	  "offsetLeft": vv ? vv.offsetLeft : 0,
+	  "offsetTop":  vv ? vv.offsetTop : 0,
+	  "pageLeft":   vv ? vv.pageLeft  : 0,
+	  "pageTop":    vv ? vv.pageTop : 0,
+	  "scale":      vv ? vv.scale : 0,
+	  "clientWidth":  de ? de.clientWidth : 0,
+	  "clientHeight": de ? de.clientHeight : 0,
+	  "scrollWidth":  de ? de.scrollWidth : 0,
+	  "scrollHeight": de ? de.scrollHeight : 0
+      };
+  };
+
+  let _getMetaTags = function() {
+      let meta = document.querySelectorAll("meta");
+      let results = {};
+      for (let i = 0; i {
+                         addValue(information, propName, childInfo);
+                     });
+                 }
+
+             } else if (child.hasAttribute('itemprop')) {
+                 const itemProp = child.getAttribute('itemprop');
+                 itemProp.split(' ').forEach(propName => {
+                     if (propName === 'url') {
+                         addValue(information, propName, child.href);
+                     } else {
+                         addValue(information, propName, sanitize(child.getAttribute("content") || child.content || child.textContent || child.src || ""));
+                     }
+                 });
+                 traverseItem(child, information);
+             } else {
+                 traverseItem(child, information);
+             }
+         }
+      }
+
+      const microdata = [];
+
+      document.querySelectorAll("[itemscope]").forEach(function(elem, i) {
+         const itemType = elem.getAttribute('itemtype');
+         const information = {
+             itemType: itemType
+         };
+         traverseItem(elem, information);
+         microdata.push(information);
+      });
+
+      return microdata;
+   };
+
+   let getPageMetadata = function() {
+       let jsonld = _getJsonLd();
+       let metaTags = _getMetaTags();
+       let microdata = _getMicrodata();
+       let results = {}
+       if (jsonld.length > 0) {
+           try {
+               results["jsonld"] = JSON.parse(jsonld);
+           }
+	   catch (e) {
+               results["jsonld"] = jsonld;
+	   }
+       }
+       if (microdata.length > 0) {
+	   results["microdata"] = microdata;
+       }
+       for (let key in metaTags) {
+	   if (metaTags.hasOwnProperty(key)) {
+	       results["meta_tags"] = metaTags;
+	       break;
+           }
+       }
+       return results;
+   };
+
+   return {
+       getInteractiveRects: getInteractiveRects,
+       getVisualViewport: getVisualViewport,
+       getFocusedElementId: getFocusedElementId,
+       getPageMetadata: getPageMetadata,
+   };
+})();
diff --git a/python/uv.lock b/python/uv.lock
index d2720b4a08ce..977c1bfed768 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -515,6 +515,10 @@ langchain-tools = [
 openai = [
     { name = "openai" },
 ]
+web-surfer = [
+    { name = "pillow" },
+    { name = "playwright" },
+]
 
 [package.metadata]
 requires-dist = [
@@ -527,6 +531,8 @@ requires-dist = [
     { name = "langchain-core", marker = "extra == 'langchain'", specifier = "~=0.3.3" },
     { name = "langchain-core", marker = "extra == 'langchain-tools'", specifier = "~=0.3.3" },
     { name = "openai", marker = "extra == 'openai'", specifier = ">=1.3" },
+    { name = "pillow", marker = "extra == 'web-surfer'", specifier = ">=11.0.0" },
+    { name = "playwright", marker = "extra == 'web-surfer'", specifier = ">=1.48.0" },
 ]
 
 [[package]]

From 5fa38b0166269203d77a425b2fd45e79351f602e Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Thu, 7 Nov 2024 21:38:41 -0800
Subject: [PATCH 083/173] Add task type that are messages to enable multi-modal
 tasks. (#4091)

* Add task type that are messages to enable multi-modal tasks.

* fix test
---
 .../agents/_base_chat_agent.py                | 31 ++++++++++-------
 .../src/autogen_agentchat/base/_task.py       |  6 ++--
 .../teams/_group_chat/_base_group_chat.py     | 13 ++++----
 .../tests/test_assistant_agent.py             | 33 ++++++++++++++++++-
 .../tests/test_group_chat.py                  | 21 ++++++++++++
 5 files changed, 82 insertions(+), 22 deletions(-)

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index a11f4a2d6f82..fb95d997b9f7 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -4,7 +4,7 @@
 from autogen_core.base import CancellationToken
 
 from ..base import ChatAgent, Response, TaskResult
-from ..messages import AgentMessage, ChatMessage, InnerMessage, TextMessage
+from ..messages import AgentMessage, ChatMessage, InnerMessage, MultiModalMessage, TextMessage
 
 
 class BaseChatAgent(ChatAgent, ABC):
@@ -54,7 +54,7 @@ async def on_messages_stream(
     async def run(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> TaskResult:
         """Run the agent with the given task and return the result."""
@@ -62,10 +62,13 @@ async def run(
             cancellation_token = CancellationToken()
         input_messages: List[ChatMessage] = []
         output_messages: List[AgentMessage] = []
-        if task is not None:
-            msg = TextMessage(content=task, source="user")
-            input_messages.append(msg)
-            output_messages.append(msg)
+        if isinstance(task, str):
+            text_msg = TextMessage(content=task, source="user")
+            input_messages.append(text_msg)
+            output_messages.append(text_msg)
+        elif isinstance(task, TextMessage | MultiModalMessage):
+            input_messages.append(task)
+            output_messages.append(task)
         response = await self.on_messages(input_messages, cancellation_token)
         if response.inner_messages is not None:
             output_messages += response.inner_messages
@@ -75,7 +78,7 @@ async def run(
     async def run_stream(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the agent with the given task and return a stream of messages
@@ -84,11 +87,15 @@ async def run_stream(
             cancellation_token = CancellationToken()
         input_messages: List[ChatMessage] = []
         output_messages: List[AgentMessage] = []
-        if task is not None:
-            msg = TextMessage(content=task, source="user")
-            input_messages.append(msg)
-            output_messages.append(msg)
-            yield msg
+        if isinstance(task, str):
+            text_msg = TextMessage(content=task, source="user")
+            input_messages.append(text_msg)
+            output_messages.append(text_msg)
+            yield text_msg
+        elif isinstance(task, TextMessage | MultiModalMessage):
+            input_messages.append(task)
+            output_messages.append(task)
+            yield task
         async for message in self.on_messages_stream(input_messages, cancellation_token):
             if isinstance(message, Response):
                 yield message.chat_message
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
index 7bb6d1e08f42..0a5e37dce26b 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_task.py
@@ -3,7 +3,7 @@
 
 from autogen_core.base import CancellationToken
 
-from ..messages import AgentMessage
+from ..messages import AgentMessage, MultiModalMessage, TextMessage
 
 
 @dataclass
@@ -23,7 +23,7 @@ class TaskRunner(Protocol):
     async def run(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> TaskResult:
         """Run the task and return the result.
@@ -36,7 +36,7 @@ async def run(
     def run_stream(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the task and produces a stream of messages and the final result
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
index 4090804392d4..46a579292116 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/teams/_group_chat/_base_group_chat.py
@@ -18,7 +18,7 @@
 
 from ... import EVENT_LOGGER_NAME
 from ...base import ChatAgent, TaskResult, Team, TerminationCondition
-from ...messages import AgentMessage, TextMessage
+from ...messages import AgentMessage, MultiModalMessage, TextMessage
 from ._base_group_chat_manager import BaseGroupChatManager
 from ._chat_agent_container import ChatAgentContainer
 from ._events import GroupChatMessage, GroupChatReset, GroupChatStart, GroupChatTermination
@@ -160,7 +160,7 @@ async def collect_output_messages(
     async def run(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> TaskResult:
         """Run the team and return the result. The base implementation uses
@@ -213,7 +213,7 @@ async def main() -> None:
     async def run_stream(
         self,
         *,
-        task: str | None = None,
+        task: str | TextMessage | MultiModalMessage | None = None,
         cancellation_token: CancellationToken | None = None,
     ) -> AsyncGenerator[AgentMessage | TaskResult, None]:
         """Run the team and produces a stream of messages and the final result
@@ -266,10 +266,11 @@ async def main() -> None:
             await self._init(self._runtime)
 
         # Run the team by publishing the start message.
-        if task is None:
-            first_chat_message = None
-        else:
+        first_chat_message: TextMessage | MultiModalMessage | None = None
+        if isinstance(task, str):
             first_chat_message = TextMessage(content=task, source="user")
+        elif isinstance(task, TextMessage | MultiModalMessage):
+            first_chat_message = task
         await self._runtime.publish_message(
             GroupChatStart(message=first_chat_message),
             topic_id=TopicId(type=self._group_topic_type, source=self._team_id),
diff --git a/python/packages/autogen-agentchat/tests/test_assistant_agent.py b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
index d847744ba13d..98ee8c3990d8 100644
--- a/python/packages/autogen-agentchat/tests/test_assistant_agent.py
+++ b/python/packages/autogen-agentchat/tests/test_assistant_agent.py
@@ -8,7 +8,14 @@
 from autogen_agentchat.agents import AssistantAgent, Handoff
 from autogen_agentchat.base import TaskResult
 from autogen_agentchat.logging import FileLogHandler
-from autogen_agentchat.messages import HandoffMessage, TextMessage, ToolCallMessage, ToolCallResultMessage
+from autogen_agentchat.messages import (
+    HandoffMessage,
+    MultiModalMessage,
+    TextMessage,
+    ToolCallMessage,
+    ToolCallResultMessage,
+)
+from autogen_core.components import Image
 from autogen_core.components.tools import FunctionTool
 from autogen_ext.models import OpenAIChatCompletionClient
 from openai.resources.chat.completions import AsyncCompletions
@@ -202,3 +209,27 @@ async def test_handoffs(monkeypatch: pytest.MonkeyPatch) -> None:
         else:
             assert message == result.messages[index]
         index += 1
+
+
+@pytest.mark.asyncio
+async def test_multi_modal_task(monkeypatch: pytest.MonkeyPatch) -> None:
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="Hello", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+    agent = AssistantAgent(name="assistant", model_client=OpenAIChatCompletionClient(model=model, api_key=""))
+    # Generate a random base64 image.
+    img_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADElEQVR4nGP4//8/AAX+Av4N70a4AAAAAElFTkSuQmCC"
+    result = await agent.run(task=MultiModalMessage(source="user", content=["Test", Image.from_base64(img_base64)]))
+    assert len(result.messages) == 2
diff --git a/python/packages/autogen-agentchat/tests/test_group_chat.py b/python/packages/autogen-agentchat/tests/test_group_chat.py
index f51d86eecb64..b2a200e22a62 100644
--- a/python/packages/autogen-agentchat/tests/test_group_chat.py
+++ b/python/packages/autogen-agentchat/tests/test_group_chat.py
@@ -18,6 +18,7 @@
     AgentMessage,
     ChatMessage,
     HandoffMessage,
+    MultiModalMessage,
     StopMessage,
     TextMessage,
     ToolCallMessage,
@@ -189,6 +190,26 @@ async def test_round_robin_group_chat(monkeypatch: pytest.MonkeyPatch) -> None:
                 assert message == result.messages[index]
             index += 1
 
+        # Test message input.
+        # Text message.
+        mock.reset()
+        index = 0
+        await team.reset()
+        result_2 = await team.run(
+            task=TextMessage(content="Write a program that prints 'Hello, world!'", source="user")
+        )
+        assert result == result_2
+
+        # Test multi-modal message.
+        mock.reset()
+        index = 0
+        await team.reset()
+        result_2 = await team.run(
+            task=MultiModalMessage(content=["Write a program that prints 'Hello, world!'"], source="user")
+        )
+        assert result.messages[0].content == result_2.messages[0].content[0]
+        assert result.messages[1:] == result_2.messages[1:]
+
 
 @pytest.mark.asyncio
 async def test_round_robin_group_chat_with_tools(monkeypatch: pytest.MonkeyPatch) -> None:

From 621b17ebbe4648b2ca9844fd427a8fd0a9c5f273 Mon Sep 17 00:00:00 2001
From: Diego Colombo 
Date: Fri, 8 Nov 2024 14:16:24 +0000
Subject: [PATCH 084/173] Simplify publish events in agent (#4093)

* simplify publishing imessage contracts

use new api

complete adoption

remove unused project

more delete

more delete

* rename methods

* formatting

* Add task type that are messages to enable multi-modal tasks. (#4091)

* Add task type that are messages to enable multi-modal tasks.

* fix test

---------

Co-authored-by: Eric Zhu 
---
 dotnet/AutoGen.sln                            |  7 -----
 .../Hello/HelloAIAgents/HelloAIAgent.cs       | 16 ++++------
 dotnet/samples/Hello/HelloAIAgents/Program.cs | 12 ++++----
 dotnet/samples/Hello/HelloAgent/Program.cs    | 15 ++++------
 .../samples/Hello/HelloAgentState/Program.cs  | 12 ++++----
 .../DevTeam.Agents/Developer/Developer.cs     |  8 ++---
 .../DeveloperLead/DeveloperLead.cs            |  8 ++---
 .../ProductManager/ProductManager.cs          |  8 ++---
 .../DevTeam.Backend/Agents/AzureGenie.cs      |  4 +--
 .../DevTeam.Backend/Agents/Sandbox.cs         |  2 +-
 .../Abstractions/IAgentBase.cs                |  2 +-
 .../src/Microsoft.AutoGen/Agents/AgentBase.cs | 11 +++++--
 .../Microsoft.AutoGen/Agents/AgentWorker.cs   |  2 +-
 .../IOAgent/ConsoleAgent/ConsoleAgent.cs      |  8 ++---
 .../IOAgent/ConsoleAgent/IHandleConsole.cs    | 11 +++----
 .../Agents/IOAgent/FileAgent/FileAgent.cs     | 16 +++++-----
 .../Agents/Agents/IOAgent/IOAgent.cs          |  8 ++---
 .../Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs |  8 ++---
 .../CloudEvents/CloudEventExtensions.cs       | 30 -------------------
 ...soft.AutoGen.Extensions.CloudEvents.csproj | 17 -----------
 .../CloudEvents/Protos/states.proto           |  9 ------
 21 files changed, 75 insertions(+), 139 deletions(-)
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Microsoft.AutoGen.Extensions.CloudEvents.csproj
 delete mode 100644 dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Protos/states.proto

diff --git a/dotnet/AutoGen.sln b/dotnet/AutoGen.sln
index 4f82713b5adb..8557f178401b 100644
--- a/dotnet/AutoGen.sln
+++ b/dotnet/AutoGen.sln
@@ -84,8 +84,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Abstracti
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Extensions.SemanticKernel", "src\Microsoft.AutoGen\Extensions\SemanticKernel\Microsoft.AutoGen.Extensions.SemanticKernel.csproj", "{952827D4-8D4C-4327-AE4D-E8D25811EF35}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Extensions.CloudEvents", "src\Microsoft.AutoGen\Extensions\CloudEvents\Microsoft.AutoGen.Extensions.CloudEvents.csproj", "{21C9EC49-E848-4EAE-932F-0862D44F7A80}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.Runtime", "src\Microsoft.AutoGen\Runtime\Microsoft.AutoGen.Runtime.csproj", "{A905E29A-7110-497F-ADC5-2CE2A148FEA0}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.AutoGen.ServiceDefaults", "src\Microsoft.AutoGen\ServiceDefaults\Microsoft.AutoGen.ServiceDefaults.csproj", "{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE}"
@@ -266,10 +264,6 @@ Global
 		{952827D4-8D4C-4327-AE4D-E8D25811EF35}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{952827D4-8D4C-4327-AE4D-E8D25811EF35}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{952827D4-8D4C-4327-AE4D-E8D25811EF35}.Release|Any CPU.Build.0 = Release|Any CPU
-		{21C9EC49-E848-4EAE-932F-0862D44F7A80}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{21C9EC49-E848-4EAE-932F-0862D44F7A80}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{21C9EC49-E848-4EAE-932F-0862D44F7A80}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{21C9EC49-E848-4EAE-932F-0862D44F7A80}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -391,7 +385,6 @@ Global
 		{FD87BD33-4616-460B-AC85-A412BA08BB78} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{E0C991D9-0DB8-471C-ADC9-5FB16E2A0106} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{952827D4-8D4C-4327-AE4D-E8D25811EF35} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
-		{21C9EC49-E848-4EAE-932F-0862D44F7A80} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{A905E29A-7110-497F-ADC5-2CE2A148FEA0} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{D7E9D90B-5595-4E72-A90A-6DE20D9AB7AE} = {18BF8DD7-0585-48BF-8F97-AD333080CE06}
 		{668726B9-77BC-45CF-B576-0F0773BF1615} = {686480D7-8FEC-4ED3-9C5D-CEBE1057A7ED}
diff --git a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
index f7939da7d68e..fd3c517f3384 100644
--- a/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/HelloAIAgent.cs
@@ -20,16 +20,10 @@ public class HelloAIAgent(
     {
         var prompt = "Please write a limerick greeting someone with the name " + item.Message;
         var response = await client.CompleteAsync(prompt);
-        var evt = new Output
-        {
-            Message = response.Message.Text
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt).ConfigureAwait(false);
-        var goodbye = new ConversationClosed
-        {
-            UserId = this.AgentId.Key,
-            UserMessage = "Goodbye"
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(goodbye).ConfigureAwait(false);
+        var evt = new Output { Message = response.Message.Text };
+        await PublishMessageAsync(evt).ConfigureAwait(false);
+
+        var goodbye = new ConversationClosed { UserId = this.AgentId.Key, UserMessage = "Goodbye" };
+        await PublishMessageAsync(goodbye).ConfigureAwait(false);
     }
 }
diff --git a/dotnet/samples/Hello/HelloAIAgents/Program.cs b/dotnet/samples/Hello/HelloAIAgents/Program.cs
index ebede82bb4fb..8285e0800f59 100644
--- a/dotnet/samples/Hello/HelloAIAgents/Program.cs
+++ b/dotnet/samples/Hello/HelloAIAgents/Program.cs
@@ -46,14 +46,14 @@ public async Task Handle(NewMessageReceived item)
             var evt = new Output
             {
                 Message = response
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(evt).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(evt).ConfigureAwait(false);
             var goodbye = new ConversationClosed
             {
                 UserId = this.AgentId.Key,
                 UserMessage = "Goodbye"
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(goodbye).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(goodbye).ConfigureAwait(false);
         }
         public async Task Handle(ConversationClosed item)
         {
@@ -61,8 +61,8 @@ public async Task Handle(ConversationClosed item)
             var evt = new Output
             {
                 Message = goodbye
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(evt).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(evt).ConfigureAwait(false);
             //sleep30 seconds
             await Task.Delay(30000).ConfigureAwait(false);
             await AgentsApp.ShutdownAsync().ConfigureAwait(false);
diff --git a/dotnet/samples/Hello/HelloAgent/Program.cs b/dotnet/samples/Hello/HelloAgent/Program.cs
index 02ad838dea0d..4e96c7f99b24 100644
--- a/dotnet/samples/Hello/HelloAgent/Program.cs
+++ b/dotnet/samples/Hello/HelloAgent/Program.cs
@@ -37,17 +37,14 @@ public class HelloAgent(
         public async Task Handle(NewMessageReceived item)
         {
             var response = await SayHello(item.Message).ConfigureAwait(false);
-            var evt = new Output
-            {
-                Message = response
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(evt).ConfigureAwait(false);
+            var evt = new Output { Message = response };
+            await PublishMessageAsync(evt).ConfigureAwait(false);
             var goodbye = new ConversationClosed
             {
                 UserId = this.AgentId.Key,
                 UserMessage = "Goodbye"
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(goodbye).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(goodbye).ConfigureAwait(false);
         }
         public async Task Handle(ConversationClosed item)
         {
@@ -55,8 +52,8 @@ public async Task Handle(ConversationClosed item)
             var evt = new Output
             {
                 Message = goodbye
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(evt).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(evt).ConfigureAwait(false);
 
             // Signal shutdown.
             hostApplicationLifetime.StopApplication();
diff --git a/dotnet/samples/Hello/HelloAgentState/Program.cs b/dotnet/samples/Hello/HelloAgentState/Program.cs
index c1e00e4d6322..d02112685033 100644
--- a/dotnet/samples/Hello/HelloAgentState/Program.cs
+++ b/dotnet/samples/Hello/HelloAgentState/Program.cs
@@ -31,20 +31,20 @@ public async Task Handle(NewMessageReceived item)
             var evt = new Output
             {
                 Message = response
-            }.ToCloudEvent(this.AgentId.Key);
+            };
             var entry = "We said hello to " + item.Message;
             await Store(new AgentState
             {
                 AgentId = this.AgentId,
                 TextData = entry
             }).ConfigureAwait(false);
-            await PublishEvent(evt).ConfigureAwait(false);
+            await PublishMessageAsync(evt).ConfigureAwait(false);
             var goodbye = new ConversationClosed
             {
                 UserId = this.AgentId.Key,
                 UserMessage = "Goodbye"
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(goodbye).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(goodbye).ConfigureAwait(false);
         }
         public async Task Handle(ConversationClosed item)
         {
@@ -54,8 +54,8 @@ public async Task Handle(ConversationClosed item)
             var evt = new Output
             {
                 Message = goodbye
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(evt).ConfigureAwait(false);
+            };
+            await PublishMessageAsync(evt).ConfigureAwait(false);
             //sleep
             await Task.Delay(10000).ConfigureAwait(false);
             await AgentsApp.ShutdownAsync().ConfigureAwait(false);
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
index 42a1cc97dec9..5b6682248213 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/Developer/Developer.cs
@@ -24,8 +24,8 @@ public async Task Handle(CodeGenerationRequested item)
             Repo = item.Repo,
             IssueNumber = item.IssueNumber,
             Code = code
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public async Task Handle(CodeChainClosed item)
@@ -35,8 +35,8 @@ public async Task Handle(CodeChainClosed item)
         var evt = new CodeCreated
         {
             Code = lastCode
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public async Task GenerateCode(string ask)
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
index f66fed5078ea..71301dd3d3b2 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/DeveloperLead/DeveloperLead.cs
@@ -25,8 +25,8 @@ public async Task Handle(DevPlanRequested item)
             Repo = item.Repo,
             IssueNumber = item.IssueNumber,
             Plan = plan
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public async Task Handle(DevPlanChainClosed item)
@@ -36,8 +36,8 @@ public async Task Handle(DevPlanChainClosed item)
         var evt = new DevPlanCreated
         {
             Plan = lastPlan
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
     public async Task CreatePlan(string ask)
     {
diff --git a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
index 140f573c7160..a97b333567a6 100644
--- a/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
+++ b/dotnet/samples/dev-team/DevTeam.Agents/ProductManager/ProductManager.cs
@@ -22,8 +22,8 @@ public async Task Handle(ReadmeChainClosed item)
         var evt = new ReadmeCreated
         {
             Readme = lastReadme
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public async Task Handle(ReadmeRequested item)
@@ -35,8 +35,8 @@ public async Task Handle(ReadmeRequested item)
             Org = item.Org,
             Repo = item.Repo,
             IssueNumber = item.IssueNumber
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public async Task CreateReadme(string ask)
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
index 258e0d1c2cf3..7dac8163a7ba 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/AzureGenie.cs
@@ -20,7 +20,7 @@ public async Task Handle(ReadmeCreated item)
         // TODO: Not sure we need to store the files if we use ACA Sessions
         //                //var data = item.ToData();
         //               // await Store(data["org"], data["repo"],  data.TryParseLong("parentNumber"),  data.TryParseLong("issueNumber"), "readme", "md", "output", data["readme"]);
-        //                await PublishEvent(new Event
+        //                await PublishEventAsync(new Event
         //                {
         //                    Namespace = item.Namespace,
         //                    Type = nameof(EventTypes.ReadmeStored),
@@ -36,7 +36,7 @@ public async Task Handle(CodeCreated item)
         //                //var data = item.ToData();
         //               // await Store(data["org"], data["repo"],  data.TryParseLong("parentNumber"),  data.TryParseLong("issueNumber"), "run", "sh", "output", data["code"]);
         //               // await RunInSandbox(data["org"], data["repo"],  data.TryParseLong("parentNumber"),  data.TryParseLong("issueNumber"));
-        //                await PublishEvent(new Event
+        //                await PublishEventAsync(new Event
         //                {
         //                    Namespace = item.Namespace,
         //                    Type = nameof(EventTypes.SandboxRunCreated),
diff --git a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
index 2090ca39e731..306ebc945a49 100644
--- a/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
+++ b/dotnet/samples/dev-team/DevTeam.Backend/Agents/Sandbox.cs
@@ -50,7 +50,7 @@
 //             if (await _azService.IsSandboxCompleted(sandboxId))
 //             {
 //                 await _azService.DeleteSandbox(sandboxId);
-//                 await PublishEvent(new Event
+//                 await PublishEventAsync(new Event
 //                 {
 //                     Namespace = this.GetPrimaryKeyString(),
 //                     Type = nameof(GithubFlowEventType.SandboxRunFinished),
diff --git a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
index 6b41594932a5..2e767e7213aa 100644
--- a/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Abstractions/IAgentBase.cs
@@ -17,5 +17,5 @@ public interface IAgentBase
     void ReceiveMessage(Message message);
     Task Store(AgentState state);
     Task Read(AgentId agentId) where T : IMessage, new();
-    ValueTask PublishEvent(CloudEvent item);
+    ValueTask PublishEventAsync(CloudEvent item, CancellationToken token = default);
 }
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
index baa7ee201edd..3932e007b374 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentBase.cs
@@ -197,9 +197,16 @@ static async ((AgentBase Agent, RpcRequest Request, TaskCompletionSource(T message, string? source = null, CancellationToken token = default) where T : IMessage
     {
-        var activity = s_source.StartActivity($"PublishEvent '{item.Type}'", ActivityKind.Client, Activity.Current?.Context ?? default);
+        var src = string.IsNullOrWhiteSpace(source) ? this.AgentId.Key : source;
+        var evt = message.ToCloudEvent(src);
+        await PublishEventAsync(evt, token).ConfigureAwait(false);
+    }
+
+    public async ValueTask PublishEventAsync(CloudEvent item, CancellationToken token = default)
+    {
+        var activity = s_source.StartActivity($"PublishEventAsync '{item.Type}'", ActivityKind.Client, Activity.Current?.Context ?? default);
         activity?.SetTag("peer.service", $"{item.Type}/{item.Source}");
 
         // TODO: fix activity
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
index 30ebda6e7196..a82065609091 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/AgentWorker.cs
@@ -12,7 +12,7 @@ public sealed class AgentWorker(IAgentWorkerRuntime runtime, DistributedContextP
     [FromKeyedServices("EventTypes")] EventTypes eventTypes, ILogger logger)
     : AgentBase(new AgentContext(new AgentId("client", Guid.NewGuid().ToString()), runtime, logger, distributedContextPropagator), eventTypes)
 {
-    public async ValueTask PublishEventAsync(CloudEvent evt) => await PublishEvent(evt);
+    public async ValueTask PublishEventAsync(CloudEvent evt) => await base.PublishEventAsync(evt);
 
     public async ValueTask PublishEventAsync(string topic, IMessage evt)
     {
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
index 9470b0fb05d9..d7c32c2479dc 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/ConsoleAgent.cs
@@ -27,8 +27,8 @@ public override async Task Handle(Input item)
         var evt = new InputProcessed
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public override async Task Handle(Output item)
@@ -40,8 +40,8 @@ public override async Task Handle(Output item)
         var evt = new OutputWritten
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public override Task ProcessInput(string message)
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
index a103aa5e3fe7..60df58e928c4 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/ConsoleAgent/IHandleConsole.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // IHandleConsole.cs
 
+using Google.Protobuf;
 using Microsoft.AutoGen.Abstractions;
 
 namespace Microsoft.AutoGen.Agents;
@@ -9,7 +10,7 @@ public interface IHandleConsole : IHandle, IHandle
 {
     string Route { get; }
     AgentId AgentId { get; }
-    ValueTask PublishEvent(CloudEvent item);
+    ValueTask PublishMessageAsync(T message, string? source = null, CancellationToken token = default) where T : IMessage;
 
     async Task IHandle.Handle(Output item)
     {
@@ -20,8 +21,8 @@ async Task IHandle.Handle(Output item)
         var evt = new OutputWritten
         {
             Route = "console"
-        }.ToCloudEvent(AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
     async Task IHandle.Handle(Input item)
     {
@@ -33,8 +34,8 @@ async Task IHandle.Handle(Input item)
         var evt = new InputProcessed
         {
             Route = "console"
-        }.ToCloudEvent(AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
     static Task ProcessOutput(string message)
     {
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
index bcc52bba43d5..217c2e56e726 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/FileAgent/FileAgent.cs
@@ -29,8 +29,8 @@ public override async Task Handle(Input item)
             var err = new IOError
             {
                 Message = errorMessage
-            }.ToCloudEvent(this.AgentId.Key);
-            await PublishEvent(err);
+            };
+            await PublishMessageAsync(err);
             return;
         }
         string content;
@@ -42,8 +42,8 @@ public override async Task Handle(Input item)
         var evt = new InputProcessed
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
     public override async Task Handle(Output item)
     {
@@ -54,16 +54,16 @@ public override async Task Handle(Output item)
         var evt = new OutputWritten
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
     public override async Task ProcessInput(string message)
     {
         var evt = new InputProcessed
         {
             Route = _route,
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
         return message;
     }
     public override Task ProcessOutput(string message)
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
index 34c9ef3067c2..6d470b345a41 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/IOAgent.cs
@@ -17,8 +17,8 @@ public virtual async Task Handle(Input item)
         var evt = new InputProcessed
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public virtual async Task Handle(Output item)
@@ -26,8 +26,8 @@ public virtual async Task Handle(Output item)
         var evt = new OutputWritten
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public abstract Task ProcessInput(string message);
diff --git a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
index 76b57b598beb..69b8d177bedb 100644
--- a/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
+++ b/dotnet/src/Microsoft.AutoGen/Agents/Agents/IOAgent/WebAPIAgent/WebAPIAgent.cs
@@ -61,8 +61,8 @@ public override async Task Handle(Input item)
         var evt = new InputProcessed
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public override async Task Handle(Output item)
@@ -71,8 +71,8 @@ public override async Task Handle(Output item)
         var evt = new OutputWritten
         {
             Route = _route
-        }.ToCloudEvent(this.AgentId.Key);
-        await PublishEvent(evt);
+        };
+        await PublishMessageAsync(evt);
     }
 
     public override Task ProcessInput(string message)
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs b/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
deleted file mode 100644
index 23c2edb26e15..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/CloudEventExtensions.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// CloudEventExtensions.cs
-
-using Google.Protobuf;
-using Google.Protobuf.WellKnownTypes;
-using Microsoft.AutoGen.Abstractions;
-
-namespace Microsoft.AutoGen.Runtime;
-
-public static class CloudEventExtensions
-
-{
-    public static CloudEvent ToCloudEvent(this T message, string source) where T : IMessage
-    {
-        return new CloudEvent
-        {
-            ProtoData = Any.Pack(message),
-            Type = message.Descriptor.FullName,
-            Source = source,
-            Id = Guid.NewGuid().ToString()
-
-        };
-    }
-
-    public static T FromCloudEvent(this CloudEvent cloudEvent) where T : IMessage, new()
-    {
-        return cloudEvent.ProtoData.Unpack();
-    }
-}
-
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Microsoft.AutoGen.Extensions.CloudEvents.csproj b/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Microsoft.AutoGen.Extensions.CloudEvents.csproj
deleted file mode 100644
index 45186a6709b6..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Microsoft.AutoGen.Extensions.CloudEvents.csproj
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-  
-    
-  
-
-  
-    net8.0
-    enable
-    enable
-  
-
-  
-    
-  
-
-
diff --git a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Protos/states.proto b/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Protos/states.proto
deleted file mode 100644
index 315a9c614c36..000000000000
--- a/dotnet/src/Microsoft.AutoGen/Extensions/CloudEvents/Protos/states.proto
+++ /dev/null
@@ -1,9 +0,0 @@
-syntax = "proto3";
-
-package devteam;
-
-option csharp_namespace = "Microsoft.AutoGen.Extensions.CloudEvents";
-
-message CloudEventsState {
-  string cloudevent = 1;
-}

From 111e69142b9c1f44b7d150b87a7b3fbffa6e6ea5 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 8 Nov 2024 12:18:07 -0800
Subject: [PATCH 085/173] Fix worker sample in core (#4104)

---
 .../samples/worker/run_worker_pub_sub.py      | 10 ++++---
 .../samples/worker/run_worker_rpc.py          | 26 +++++++++----------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/python/packages/autogen-core/samples/worker/run_worker_pub_sub.py b/python/packages/autogen-core/samples/worker/run_worker_pub_sub.py
index b30ccadc3176..616346770f14 100644
--- a/python/packages/autogen-core/samples/worker/run_worker_pub_sub.py
+++ b/python/packages/autogen-core/samples/worker/run_worker_pub_sub.py
@@ -4,8 +4,8 @@
 from typing import Any, NoReturn
 
 from autogen_core.application import WorkerAgentRuntime
-from autogen_core.base import MessageContext
-from autogen_core.components import DefaultTopicId, RoutedAgent, default_subscription, message_handler
+from autogen_core.base import MessageContext, try_get_known_serializers_for_type
+from autogen_core.components import DefaultSubscription, DefaultTopicId, RoutedAgent, message_handler
 
 
 @dataclass
@@ -33,7 +33,6 @@ class ReturnedFeedback:
     content: str
 
 
-@default_subscription
 class ReceiveAgent(RoutedAgent):
     def __init__(self) -> None:
         super().__init__("Receive Agent")
@@ -50,7 +49,6 @@ async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> NoRet
         print(f"Unhandled message: {message}")
 
 
-@default_subscription
 class GreeterAgent(RoutedAgent):
     def __init__(self) -> None:
         super().__init__("Greeter Agent")
@@ -70,9 +68,13 @@ async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> NoRet
 async def main() -> None:
     runtime = WorkerAgentRuntime(host_address="localhost:50051")
     runtime.start()
+    for t in [AskToGreet, Greeting, ReturnedGreeting, Feedback, ReturnedFeedback]:
+        runtime.add_message_serializer(try_get_known_serializers_for_type(t))
 
     await ReceiveAgent.register(runtime, "receiver", ReceiveAgent)
+    await runtime.add_subscription(DefaultSubscription(agent_type="receiver"))
     await GreeterAgent.register(runtime, "greeter", GreeterAgent)
+    await runtime.add_subscription(DefaultSubscription(agent_type="greeter"))
 
     await runtime.publish_message(AskToGreet("Hello World!"), topic_id=DefaultTopicId())
 
diff --git a/python/packages/autogen-core/samples/worker/run_worker_rpc.py b/python/packages/autogen-core/samples/worker/run_worker_rpc.py
index d481989a7799..804474ee0057 100644
--- a/python/packages/autogen-core/samples/worker/run_worker_rpc.py
+++ b/python/packages/autogen-core/samples/worker/run_worker_rpc.py
@@ -1,12 +1,10 @@
 import asyncio
 import logging
 from dataclasses import dataclass
-from typing import Any, NoReturn
 
 from autogen_core.application import WorkerAgentRuntime
 from autogen_core.base import (
     AgentId,
-    AgentInstantiationContext,
     MessageContext,
 )
 from autogen_core.components import DefaultSubscription, DefaultTopicId, RoutedAgent, message_handler
@@ -39,34 +37,34 @@ async def on_greet(self, message: Greeting, ctx: MessageContext) -> Greeting:
     async def on_feedback(self, message: Feedback, ctx: MessageContext) -> None:
         print(f"Feedback received: {message.content}")
 
-    async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> NoReturn:  # type: ignore
-        print(f"Unhandled message: {message}")
-
 
 class GreeterAgent(RoutedAgent):
-    def __init__(self, receive_agent_id: AgentId) -> None:
+    def __init__(self, receive_agent_type: str) -> None:
         super().__init__("Greeter Agent")
-        self._receive_agent_id = receive_agent_id
+        self._receive_agent_id = AgentId(receive_agent_type, self.id.key)
 
     @message_handler
     async def on_ask(self, message: AskToGreet, ctx: MessageContext) -> None:
         response = await self.send_message(Greeting(f"Hello, {message.content}!"), recipient=self._receive_agent_id)
         await self.publish_message(Feedback(f"Feedback: {response.content}"), topic_id=DefaultTopicId())
 
-    async def on_unhandled_message(self, message: Any, ctx: MessageContext) -> NoReturn:  # type: ignore
-        print(f"Unhandled message: {message}")
-
 
 async def main() -> None:
     runtime = WorkerAgentRuntime(host_address="localhost:50051")
     runtime.start()
 
-    await runtime.register("receiver", lambda: ReceiveAgent(), lambda: [DefaultSubscription()])
-    await runtime.register(
+    await ReceiveAgent.register(
+        runtime,
+        "receiver",
+        lambda: ReceiveAgent(),
+    )
+    await runtime.add_subscription(DefaultSubscription(agent_type="receiver"))
+    await GreeterAgent.register(
+        runtime,
         "greeter",
-        lambda: GreeterAgent(AgentId("receiver", AgentInstantiationContext.current_agent_id().key)),
-        lambda: [DefaultSubscription()],
+        lambda: GreeterAgent("receiver"),
     )
+    await runtime.add_subscription(DefaultSubscription(agent_type="greeter"))
     await runtime.publish_message(AskToGreet("Hello World!"), topic_id=DefaultTopicId())
 
     await runtime.stop_when_signal()

From 3f28aa88744dcb2315544743f7cf5a61be89906f Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 8 Nov 2024 16:41:34 -0800
Subject: [PATCH 086/173] SocietyOfMind agent for nested teams (#4110)

* Initial implementation of SOM agent

* add tests

* edit prompt

* Update prompt

* lint
---
 .../src/autogen_agentchat/agents/__init__.py  |   2 +
 .../agents/_assistant_agent.py                |   6 +-
 .../agents/_base_chat_agent.py                |   4 +-
 .../agents/_society_of_mind_agent.py          | 160 ++++++++++++++++++
 .../src/autogen_agentchat/base/_chat_agent.py |   6 +-
 .../tests/test_society_of_mind_agent.py       |  80 +++++++++
 6 files changed, 250 insertions(+), 8 deletions(-)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
 create mode 100644 python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py

diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
index 7eb35962b5c4..cd435bf0228a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/__init__.py
@@ -2,6 +2,7 @@
 from ._base_chat_agent import BaseChatAgent
 from ._code_executor_agent import CodeExecutorAgent
 from ._coding_assistant_agent import CodingAssistantAgent
+from ._society_of_mind_agent import SocietyOfMindAgent
 from ._tool_use_assistant_agent import ToolUseAssistantAgent
 
 __all__ = [
@@ -11,4 +12,5 @@
     "CodeExecutorAgent",
     "CodingAssistantAgent",
     "ToolUseAssistantAgent",
+    "SocietyOfMindAgent",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index 348b4f104bc0..d18e755fea1a 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -20,9 +20,9 @@
 from .. import EVENT_LOGGER_NAME
 from ..base import Response
 from ..messages import (
+    AgentMessage,
     ChatMessage,
     HandoffMessage,
-    InnerMessage,
     TextMessage,
     ToolCallMessage,
     ToolCallResultMessage,
@@ -217,13 +217,13 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
 
     async def on_messages_stream(
         self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
-    ) -> AsyncGenerator[InnerMessage | Response, None]:
+    ) -> AsyncGenerator[AgentMessage | Response, None]:
         # Add messages to the model context.
         for msg in messages:
             self._model_context.append(UserMessage(content=msg.content, source=msg.source))
 
         # Inner messages.
-        inner_messages: List[InnerMessage] = []
+        inner_messages: List[AgentMessage] = []
 
         # Generate an inference result based on the current model context.
         llm_messages = self._system_messages + self._model_context
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
index fb95d997b9f7..bc337de9d4e4 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_base_chat_agent.py
@@ -4,7 +4,7 @@
 from autogen_core.base import CancellationToken
 
 from ..base import ChatAgent, Response, TaskResult
-from ..messages import AgentMessage, ChatMessage, InnerMessage, MultiModalMessage, TextMessage
+from ..messages import AgentMessage, ChatMessage, MultiModalMessage, TextMessage
 
 
 class BaseChatAgent(ChatAgent, ABC):
@@ -42,7 +42,7 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
 
     async def on_messages_stream(
         self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
-    ) -> AsyncGenerator[InnerMessage | Response, None]:
+    ) -> AsyncGenerator[AgentMessage | Response, None]:
         """Handles incoming messages and returns a stream of messages and
         and the final item is the response. The base implementation in :class:`BaseChatAgent`
         simply calls :meth:`on_messages` and yields the messages in the response."""
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
new file mode 100644
index 000000000000..5b2f05000dc0
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_society_of_mind_agent.py
@@ -0,0 +1,160 @@
+from typing import AsyncGenerator, List, Sequence
+
+from autogen_core.base import CancellationToken
+from autogen_core.components import Image
+from autogen_core.components.models import ChatCompletionClient
+from autogen_core.components.models._types import SystemMessage
+
+from autogen_agentchat.base import Response
+
+from ..base import TaskResult, Team
+from ..messages import (
+    AgentMessage,
+    ChatMessage,
+    HandoffMessage,
+    MultiModalMessage,
+    StopMessage,
+    TextMessage,
+)
+from ._base_chat_agent import BaseChatAgent
+
+
+class SocietyOfMindAgent(BaseChatAgent):
+    """An agent that uses an inner team of agents to generate responses.
+
+    Each time the agent's :meth:`on_messages` or :meth:`on_messages_stream`
+    method is called, it runs the inner team of agents and then uses the
+    model client to generate a response based on the inner team's messages.
+    Once the response is generated, the agent resets the inner team by
+    calling :meth:`Team.reset`.
+
+    Args:
+        name (str): The name of the agent.
+        team (Team): The team of agents to use.
+        model_client (ChatCompletionClient): The model client to use for preparing responses.
+        description (str, optional): The description of the agent.
+
+
+    Example:
+
+    .. code-block:: python
+
+        import asyncio
+        from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
+        from autogen_ext.models import OpenAIChatCompletionClient
+        from autogen_agentchat.teams import RoundRobinGroupChat
+        from autogen_agentchat.task import MaxMessageTermination
+
+
+        async def main() -> None:
+            model_client = OpenAIChatCompletionClient(model="gpt-4o")
+
+            agent1 = AssistantAgent("assistant1", model_client=model_client, system_message="You are a helpful assistant.")
+            agent2 = AssistantAgent("assistant2", model_client=model_client, system_message="You are a helpful assistant.")
+            inner_termination = MaxMessageTermination(3)
+            inner_team = RoundRobinGroupChat([agent1, agent2], termination_condition=inner_termination)
+
+            society_of_mind_agent = SocietyOfMindAgent("society_of_mind", team=inner_team, model_client=model_client)
+
+            agent3 = AssistantAgent("assistant3", model_client=model_client, system_message="You are a helpful assistant.")
+            agent4 = AssistantAgent("assistant4", model_client=model_client, system_message="You are a helpful assistant.")
+            outter_termination = MaxMessageTermination(10)
+            team = RoundRobinGroupChat([society_of_mind_agent, agent3, agent4], termination_condition=outter_termination)
+
+            stream = team.run_stream(task="Tell me a one-liner joke.")
+            async for message in stream:
+                print(message)
+
+
+        asyncio.run(main())
+    """
+
+    def __init__(
+        self,
+        name: str,
+        team: Team,
+        model_client: ChatCompletionClient,
+        *,
+        description: str = "An agent that uses an inner team of agents to generate responses.",
+        task_prompt: str = "{transcript}\nContinue.",
+        response_prompt: str = "Here is a transcript of conversation so far:\n{transcript}\n\\Provide a response to the original request.",
+    ) -> None:
+        super().__init__(name=name, description=description)
+        self._team = team
+        self._model_client = model_client
+        if "{transcript}" not in task_prompt:
+            raise ValueError("The task prompt must contain the '{transcript}' placeholder for the transcript.")
+        self._task_prompt = task_prompt
+        if "{transcript}" not in response_prompt:
+            raise ValueError("The response prompt must contain the '{transcript}' placeholder for the transcript.")
+        self._response_prompt = response_prompt
+
+    @property
+    def produced_message_types(self) -> List[type[ChatMessage]]:
+        return [TextMessage]
+
+    async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken) -> Response:
+        # Call the stream method and collect the messages.
+        response: Response | None = None
+        async for msg in self.on_messages_stream(messages, cancellation_token):
+            if isinstance(msg, Response):
+                response = msg
+        assert response is not None
+        return response
+
+    async def on_messages_stream(
+        self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
+    ) -> AsyncGenerator[AgentMessage | Response, None]:
+        # Build the context.
+        delta = list(messages)
+        task: str | None = None
+        if len(delta) > 0:
+            task = self._task_prompt.format(transcript=self._create_transcript(delta))
+
+        # Run the team of agents.
+        result: TaskResult | None = None
+        inner_messages: List[AgentMessage] = []
+        async for inner_msg in self._team.run_stream(task=task, cancellation_token=cancellation_token):
+            if isinstance(inner_msg, TaskResult):
+                result = inner_msg
+            else:
+                yield inner_msg
+                inner_messages.append(inner_msg)
+        assert result is not None
+
+        if len(inner_messages) < 2:
+            # The first message is the task message so we need at least 2 messages.
+            yield Response(
+                chat_message=TextMessage(source=self.name, content="No response."), inner_messages=inner_messages
+            )
+        else:
+            prompt = self._response_prompt.format(transcript=self._create_transcript(inner_messages[1:]))
+            completion = await self._model_client.create(
+                messages=[SystemMessage(content=prompt)], cancellation_token=cancellation_token
+            )
+            assert isinstance(completion.content, str)
+            yield Response(
+                chat_message=TextMessage(source=self.name, content=completion.content, models_usage=completion.usage),
+                inner_messages=inner_messages,
+            )
+
+        # Reset the team.
+        await self._team.reset()
+
+    async def reset(self, cancellation_token: CancellationToken) -> None:
+        await self._team.reset()
+
+    def _create_transcript(self, messages: Sequence[AgentMessage]) -> str:
+        transcript = ""
+        for message in messages:
+            if isinstance(message, TextMessage | StopMessage | HandoffMessage):
+                transcript += f"{message.source}: {message.content}\n"
+            elif isinstance(message, MultiModalMessage):
+                for content in message.content:
+                    if isinstance(content, Image):
+                        transcript += f"{message.source}: [Image]\n"
+                    else:
+                        transcript += f"{message.source}: {content}\n"
+            else:
+                raise ValueError(f"Unexpected message type: {message} in {self.__class__.__name__}")
+        return transcript
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
index 2db6d5023f42..3bf54f99994e 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/base/_chat_agent.py
@@ -3,7 +3,7 @@
 
 from autogen_core.base import CancellationToken
 
-from ..messages import ChatMessage, InnerMessage
+from ..messages import AgentMessage, ChatMessage
 from ._task import TaskRunner
 
 
@@ -14,7 +14,7 @@ class Response:
     chat_message: ChatMessage
     """A chat message produced by the agent as the response."""
 
-    inner_messages: List[InnerMessage] | None = None
+    inner_messages: List[AgentMessage] | None = None
     """Inner messages produced by the agent."""
 
 
@@ -46,7 +46,7 @@ async def on_messages(self, messages: Sequence[ChatMessage], cancellation_token:
 
     def on_messages_stream(
         self, messages: Sequence[ChatMessage], cancellation_token: CancellationToken
-    ) -> AsyncGenerator[InnerMessage | Response, None]:
+    ) -> AsyncGenerator[AgentMessage | Response, None]:
         """Handles incoming messages and returns a stream of inner messages and
         and the final item is the response."""
         ...
diff --git a/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py b/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py
new file mode 100644
index 000000000000..0b9f635ac7f6
--- /dev/null
+++ b/python/packages/autogen-agentchat/tests/test_society_of_mind_agent.py
@@ -0,0 +1,80 @@
+import asyncio
+from typing import Any, AsyncGenerator, List
+
+import pytest
+from autogen_agentchat.agents import AssistantAgent, SocietyOfMindAgent
+from autogen_agentchat.task import MaxMessageTermination
+from autogen_agentchat.teams import RoundRobinGroupChat
+from autogen_ext.models import OpenAIChatCompletionClient
+from openai.resources.chat.completions import AsyncCompletions
+from openai.types.chat.chat_completion import ChatCompletion, Choice
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+from openai.types.chat.chat_completion_message import ChatCompletionMessage
+from openai.types.completion_usage import CompletionUsage
+
+
+class _MockChatCompletion:
+    def __init__(self, chat_completions: List[ChatCompletion]) -> None:
+        self._saved_chat_completions = chat_completions
+        self._curr_index = 0
+
+    async def mock_create(
+        self, *args: Any, **kwargs: Any
+    ) -> ChatCompletion | AsyncGenerator[ChatCompletionChunk, None]:
+        await asyncio.sleep(0.1)
+        completion = self._saved_chat_completions[self._curr_index]
+        self._curr_index += 1
+        return completion
+
+
+@pytest.mark.asyncio
+async def test_society_of_mind_agent(monkeypatch: pytest.MonkeyPatch) -> None:
+    model = "gpt-4o-2024-05-13"
+    chat_completions = [
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="1", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="2", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
+        ),
+        ChatCompletion(
+            id="id2",
+            choices=[
+                Choice(finish_reason="stop", index=0, message=ChatCompletionMessage(content="3", role="assistant"))
+            ],
+            created=0,
+            model=model,
+            object="chat.completion",
+            usage=CompletionUsage(prompt_tokens=10, completion_tokens=5, total_tokens=0),
+        ),
+    ]
+    mock = _MockChatCompletion(chat_completions)
+    monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create)
+    model_client = OpenAIChatCompletionClient(model="gpt-4o", api_key="")
+
+    agent1 = AssistantAgent("assistant1", model_client=model_client, system_message="You are a helpful assistant.")
+    agent2 = AssistantAgent("assistant2", model_client=model_client, system_message="You are a helpful assistant.")
+    inner_termination = MaxMessageTermination(3)
+    inner_team = RoundRobinGroupChat([agent1, agent2], termination_condition=inner_termination)
+    society_of_mind_agent = SocietyOfMindAgent("society_of_mind", team=inner_team, model_client=model_client)
+    response = await society_of_mind_agent.run(task="Count to 10.")
+    assert len(response.messages) == 5
+    assert response.messages[0].source == "user"
+    assert response.messages[1].source == "user"
+    assert response.messages[2].source == "assistant1"
+    assert response.messages[3].source == "assistant2"
+    assert response.messages[4].source == "society_of_mind"

From f40b0c27307696a996817f9cf52bd16ac8eae291 Mon Sep 17 00:00:00 2001
From: Eric Zhu 
Date: Fri, 8 Nov 2024 19:02:19 -0800
Subject: [PATCH 087/173] Add Console function to stream result to pretty print
 console output (#4115)

---
 README.md                                     |  7 ++--
 .../src/autogen_agentchat/messages.py         |  2 +-
 .../src/autogen_agentchat/task/__init__.py    |  2 ++
 .../src/autogen_agentchat/task/_console.py    | 35 +++++++++++++++++++
 .../agentchat-user-guide/quickstart.ipynb     | 32 +++++++++++------
 5 files changed, 63 insertions(+), 15 deletions(-)
 create mode 100644 python/packages/autogen-agentchat/src/autogen_agentchat/task/_console.py

diff --git a/README.md b/README.md
index 5875a89a1789..a9bf5ff6a49f 100644
--- a/README.md
+++ b/README.md
@@ -109,11 +109,11 @@ and running on your machine.
 
 ```python
 import asyncio
-from autogen_ext.code_executor.docker_executor import DockerCommandLineCodeExecutor
+from autogen_ext.code_executors import DockerCommandLineCodeExecutor
 from autogen_ext.models import OpenAIChatCompletionClient
 from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent
 from autogen_agentchat.teams import RoundRobinGroupChat
-from autogen_agentchat.task import TextMentionTermination
+from autogen_agentchat.task import TextMentionTermination, Console
 
 async def main() -> None:
     async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor:
@@ -126,8 +126,7 @@ async def main() -> None:
         stream = group_chat.run_stream(
             task="Create a plot of NVDIA and TSLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'."
         )
-        async for message in stream:
-            print(message)
+        await Console(stream)
 
 asyncio.run(main())
 ```
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
index 280b5322485a..604ef5b5b2e6 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/messages.py
@@ -70,7 +70,7 @@ class ToolCallResultMessage(BaseMessage):
 """Messages for agent-to-agent communication."""
 
 
-AgentMessage = InnerMessage | ChatMessage
+AgentMessage = TextMessage | MultiModalMessage | StopMessage | HandoffMessage | ToolCallMessage | ToolCallResultMessage
 """All message types."""
 
 
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
index 0c1415d3bd1e..710a255bfadc 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/__init__.py
@@ -1,3 +1,4 @@
+from ._console import Console
 from ._terminations import MaxMessageTermination, StopMessageTermination, TextMentionTermination, TokenUsageTermination
 
 __all__ = [
@@ -5,4 +6,5 @@
     "TextMentionTermination",
     "StopMessageTermination",
     "TokenUsageTermination",
+    "Console",
 ]
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/task/_console.py b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_console.py
new file mode 100644
index 000000000000..71344eb7afd9
--- /dev/null
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/task/_console.py
@@ -0,0 +1,35 @@
+import sys
+import time
+from typing import AsyncGenerator
+
+from autogen_core.components.models import RequestUsage
+
+from autogen_agentchat.base import TaskResult
+from autogen_agentchat.messages import AgentMessage
+
+
+async def Console(stream: AsyncGenerator[AgentMessage | TaskResult, None]) -> None:
+    """Consume the stream from  :meth:`~autogen_agentchat.teams.Team.run_stream`
+    and print the messages to the console."""
+
+    start_time = time.time()
+    total_usage = RequestUsage(prompt_tokens=0, completion_tokens=0)
+    async for message in stream:
+        if isinstance(message, TaskResult):
+            duration = time.time() - start_time
+            output = (
+                f"{'-' * 10} Summary {'-' * 10}\n"
+                f"Number of messages: {len(message.messages)}\n"
+                f"Finish reason: {message.stop_reason}\n"
+                f"Total prompt tokens: {total_usage.prompt_tokens}\n"
+                f"Total completion tokens: {total_usage.completion_tokens}\n"
+                f"Duration: {duration:.2f} seconds\n"
+            )
+            sys.stdout.write(output)
+        else:
+            output = f"{'-' * 10} {message.source} {'-' * 10}\n{message.content}\n"
+            if message.models_usage:
+                output += f"[Prompt tokens: {message.models_usage.prompt_tokens}, Completion tokens: {message.models_usage.completion_tokens}]\n"
+                total_usage.completion_tokens += message.models_usage.completion_tokens
+                total_usage.prompt_tokens += message.models_usage.prompt_tokens
+            sys.stdout.write(output)
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
index 833c57624fad..57a2af3f21d5 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/quickstart.ipynb
@@ -35,18 +35,31 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "source='user' models_usage=None content='What is the weather in New York?'\n",
-      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=79, completion_tokens=15) content=[FunctionCall(id='call_CntvzLVL7iYJwPP2WWeBKNHc', arguments='{\"city\":\"New York\"}', name='get_weather')]\n",
-      "source='weather_agent' models_usage=None content=[FunctionExecutionResult(content='The weather in New York is 73 degrees and Sunny.', call_id='call_CntvzLVL7iYJwPP2WWeBKNHc')]\n",
-      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=90, completion_tokens=14) content='The weather in New York is currently 73 degrees and sunny.'\n",
-      "source='weather_agent' models_usage=RequestUsage(prompt_tokens=137, completion_tokens=4) content='TERMINATE'\n",
-      "TaskResult(messages=[TextMessage(source='user', models_usage=None, content='What is the weather in New York?'), ToolCallMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=79, completion_tokens=15), content=[FunctionCall(id='call_CntvzLVL7iYJwPP2WWeBKNHc', arguments='{\"city\":\"New York\"}', name='get_weather')]), ToolCallResultMessage(source='weather_agent', models_usage=None, content=[FunctionExecutionResult(content='The weather in New York is 73 degrees and Sunny.', call_id='call_CntvzLVL7iYJwPP2WWeBKNHc')]), TextMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=90, completion_tokens=14), content='The weather in New York is currently 73 degrees and sunny.'), TextMessage(source='weather_agent', models_usage=RequestUsage(prompt_tokens=137, completion_tokens=4), content='TERMINATE')], stop_reason=\"Text 'TERMINATE' mentioned\")\n"
+      "---------- user ----------\n",
+      "What is the weather in New York?\n",
+      "---------- weather_agent ----------\n",
+      "[FunctionCall(id='call_AhTZ2q3TNL8x0qs00e3wIZ7y', arguments='{\"city\":\"New York\"}', name='get_weather')]\n",
+      "[Prompt tokens: 79, Completion tokens: 15]\n",
+      "---------- weather_agent ----------\n",
+      "[FunctionExecutionResult(content='The weather in New York is 73 degrees and Sunny.', call_id='call_AhTZ2q3TNL8x0qs00e3wIZ7y')]\n",
+      "---------- weather_agent ----------\n",
+      "The weather in New York is currently 73 degrees and sunny.\n",
+      "[Prompt tokens: 90, Completion tokens: 14]\n",
+      "---------- weather_agent ----------\n",
+      "TERMINATE\n",
+      "[Prompt tokens: 137, Completion tokens: 4]\n",
+      "---------- Summary ----------\n",
+      "Number of messages: 5\n",
+      "Finish reason: Text 'TERMINATE' mentioned\n",
+      "Total prompt tokens: 306\n",
+      "Total completion tokens: 33\n",
+      "Duration: 1.43 seconds\n"
      ]
     }
    ],
    "source": [
     "from autogen_agentchat.agents import AssistantAgent\n",
-    "from autogen_agentchat.task import TextMentionTermination\n",
+    "from autogen_agentchat.task import Console, TextMentionTermination\n",
     "from autogen_agentchat.teams import RoundRobinGroupChat\n",
     "from autogen_ext.models import OpenAIChatCompletionClient\n",
     "\n",
@@ -72,8 +85,7 @@
     "\n",
     "    # Run the team and stream messages\n",
     "    stream = agent_team.run_stream(task=\"What is the weather in New York?\")\n",
-    "    async for response in stream:\n",
-    "        print(response)\n",
+    "    await Console(stream)\n",
     "\n",
     "\n",
     "# NOTE: if running this inside a Python script you'll need to use asyncio.run(main()).\n",
@@ -114,7 +126,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.6"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,

From 0e985d4b40443a802455433cbf0140be4c4ab9db Mon Sep 17 00:00:00 2001
From: Victor Dibia 
Date: Sat, 9 Nov 2024 14:32:24 -0800
Subject: [PATCH 088/173] v1 of AutoGen Studio on AgentChat  (#4097)

* add skeleton worflow manager

* add test notebook

* update test nb

* add sample team spec

* refactor requirements to agentchat and ext

* add base provider to return agentchat agents from json spec

* initial api refactor, update dbmanager

* api refactor

* refactor tests

* ags api tutorial update

* ui refactor

* general refactor

* minor refactor updates

* backend api refaactor

* ui refactor and update

* implement v1 for streaming connection with ui updates

* backend refactor

* ui refactor

* minor ui tweak

* minor refactor and tweaks

* general refactor

* update tests

* sync uv.lock with main

* uv lock update
---
 python/packages/autogen-studio/.gitignore     |     4 +
 .../autogen-studio/autogenstudio/__init__.py  |     3 +-
 .../autogenstudio/chatmanager.py              |   179 -
 .../autogen-studio/autogenstudio/cli.py       |    12 +-
 .../autogenstudio/database/__init__.py        |     6 +-
 .../autogenstudio/database/alembic.ini        |   116 -
 .../database/component_factory.py             |   355 +
 .../autogenstudio/database/config_manager.py  |   322 +
 .../autogenstudio/database/db_manager.py      |   424 +
 .../autogenstudio/database/dbmanager.py       |   491 -
 .../autogenstudio/database/migrations/README  |     1 -
 .../autogenstudio/database/migrations/env.py  |    80 -
 .../database/migrations/script.py.mako        |    27 -
 .../autogenstudio/database/schema_manager.py  |   505 +
 .../autogenstudio/database/utils.py           |   361 -
 .../autogen-studio/autogenstudio/datamodel.py |   297 -
 .../autogenstudio/datamodel/__init__.py       |     2 +
 .../autogenstudio/datamodel/db.py             |   282 +
 .../autogenstudio/datamodel/types.py          |   136 +
 .../autogenstudio/teammanager.py              |    67 +
 .../autogenstudio/utils/dbdefaults.json       |   242 -
 .../autogenstudio/utils/utils.py              |   346 +-
 .../autogen-studio/autogenstudio/web/app.py   |   576 +-
 .../autogenstudio/web/config.py               |    18 +
 .../autogen-studio/autogenstudio/web/deps.py  |   201 +
 .../autogenstudio/web/initialization.py       |   110 +
 .../migrations => web/managers}/__init__.py   |     0
 .../autogenstudio/web/managers/connection.py  |   247 +
 .../autogenstudio/web/routes/__init__.py      |     0
 .../autogenstudio/web/routes/agents.py        |   181 +
 .../autogenstudio/web/routes/models.py        |    95 +
 .../autogenstudio/web/routes/runs.py          |    76 +
 .../autogenstudio/web/routes/sessions.py      |   114 +
 .../autogenstudio/web/routes/teams.py         |   146 +
 .../autogenstudio/web/routes/tools.py         |   103 +
 .../autogenstudio/web/routes/ws.py            |    74 +
 .../websocket_connection_manager.py           |   135 -
 .../autogenstudio/workflowmanager.py          |  1066 --
 .../autogen-studio/frontend/.env.default      |     2 +-
 .../autogen-studio/frontend/.gitignore        |     8 +-
 .../packages/autogen-studio/frontend/LICENSE  |    21 -
 .../autogen-studio/frontend/README.md         |     4 +-
 .../autogen-studio/frontend/gatsby-config.ts  |    14 +-
 .../autogen-studio/frontend/package.json      |    70 +-
 .../autogen-studio/frontend/postcss.config.js |    10 +-
 .../frontend/src/components/atoms.tsx         |   873 -
 .../frontend/src/components/contentheader.tsx |   157 +
 .../frontend/src/components/footer.tsx        |     2 +-
 .../frontend/src/components/icons.tsx         |    56 +-
 .../frontend/src/components/layout.tsx        |   120 +-
 .../frontend/src/components/sidebar.tsx       |   148 +
 .../frontend/src/components/types.ts          |   127 -
 .../frontend/src/components/types/app.ts      |     5 +
 .../src/components/types/datamodel.ts         |    86 +
 .../frontend/src/components/utils.ts          |   568 +-
 .../src/components/views/builder/agents.tsx   |   385 -
 .../src/components/views/builder/build.tsx    |    81 -
 .../src/components/views/builder/models.tsx   |   403 -
 .../src/components/views/builder/skills.tsx   |   380 -
 .../views/builder/utils/agentconfig.tsx       |   517 -
 .../components/views/builder/utils/export.tsx |   207 -
 .../views/builder/utils/modelconfig.tsx       |   388 -
 .../views/builder/utils/selectors.tsx         |  1359 --
 .../views/builder/utils/skillconfig.tsx       |   295 -
 .../views/builder/utils/workflowconfig.tsx    |   279 -
 .../src/components/views/builder/workflow.tsx |   428 -
 .../src/components/views/gallery/gallery.tsx  |   207 -
 .../components/views/playground/chat/chat.tsx |   449 +
 .../views/playground/chat/chatinput.tsx       |   128 +
 .../views/playground/chat/messagelist.tsx     |   139 +
 .../views/playground/chat/thread.tsx          |   212 +
 .../components/views/playground/chat/types.ts |    47 +
 .../components/views/playground/chatbox.tsx   |   824 -
 .../components/views/playground/metadata.tsx  |   242 -
 .../src/components/views/playground/ra.tsx    |    94 -
 .../components/views/playground/sessions.tsx  |   460 -
 .../components/views/playground/sidebar.tsx   |    49 -
 .../views/playground/utils/charts/bar.tsx     |    58 -
 .../views/playground/utils/profiler.tsx       |   125 -
 .../views/playground/utils/selectors.tsx      |   122 -
 .../src/components/views/shared/markdown.tsx  |    20 +
 .../src/components/views/shared/monaco.tsx    |    48 +
 .../components/views/shared/session/api.ts    |   115 +
 .../views/shared/session/editor.tsx           |   157 +
 .../components/views/shared/session/list.tsx  |    76 +
 .../views/shared/session/manager.tsx          |   190 +
 .../components/views/shared/session/types.ts  |    24 +
 .../src/components/views/shared/team/api.ts   |   127 +
 .../components/views/shared/team/editor.tsx   |   171 +
 .../src/components/views/shared/team/list.tsx |    76 +
 .../components/views/shared/team/manager.tsx  |   153 +
 .../src/components/views/shared/team/types.ts |    17 +
 .../frontend/src/hooks/store.tsx              |    67 +-
 .../frontend/src/images/icon.png              |     4 +-
 .../frontend/src/images/landing/nodata.svg    |     1 +
 .../svgs => src/images/landing}/welcome.svg   |     2 +-
 .../autogen-studio/frontend/src/index.d.ts    |     3 +
 .../autogen-studio/frontend/src/pages/404.tsx |    15 +-
 .../frontend/src/pages/build.tsx              |     3 +-
 .../frontend/src/pages/gallery/index.tsx      |    28 -
 .../frontend/src/pages/index.tsx              |     4 +-
 .../frontend/src/pages/settings.tsx           |    35 +
 .../frontend/src/styles/global.css            |    79 +-
 .../frontend/tailwind.config.js               |     7 +-
 .../autogen-studio/frontend/tsconfig.json     |   114 +-
 .../autogen-studio/frontend/yarn.lock         | 13455 ++++++++++++++++
 .../autogen-studio/notebooks/team.json        |    32 +
 .../notebooks/travel_groupchat.json           |   273 -
 .../autogen-studio/notebooks/tutorial.ipynb   |   225 +-
 .../autogen-studio/notebooks/two_agent.json   |   112 -
 python/packages/autogen-studio/pyproject.toml |     4 +-
 .../test/test_save_skills_to_file.py          |    56 -
 .../autogen-studio/test/test_skills_prompt.py |    47 -
 .../packages/autogen-studio/tests/__init__.py |     0
 .../tests/test_component_factory.py           |   246 +
 .../autogen-studio/tests/test_db_manager.py   |   183 +
 python/uv.lock                                |   586 -
 117 files changed, 20720 insertions(+), 13584 deletions(-)
 delete mode 100644 python/packages/autogen-studio/autogenstudio/chatmanager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/alembic.ini
 create mode 100644 python/packages/autogen-studio/autogenstudio/database/component_factory.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/database/config_manager.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/database/db_manager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/dbmanager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/migrations/README
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/migrations/env.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/migrations/script.py.mako
 create mode 100644 python/packages/autogen-studio/autogenstudio/database/schema_manager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/database/utils.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/datamodel.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/datamodel/__init__.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/datamodel/db.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/datamodel/types.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/teammanager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/utils/dbdefaults.json
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/config.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/deps.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/initialization.py
 rename python/packages/autogen-studio/autogenstudio/{database/migrations => web/managers}/__init__.py (100%)
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/managers/connection.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/__init__.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/agents.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/models.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/runs.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/sessions.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/teams.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/tools.py
 create mode 100644 python/packages/autogen-studio/autogenstudio/web/routes/ws.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/websocket_connection_manager.py
 delete mode 100644 python/packages/autogen-studio/autogenstudio/workflowmanager.py
 delete mode 100644 python/packages/autogen-studio/frontend/LICENSE
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/atoms.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/contentheader.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/sidebar.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/types.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/components/types/app.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/components/types/datamodel.ts
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/agents.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/build.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/models.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/skills.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/agentconfig.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/export.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/modelconfig.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/selectors.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/skillconfig.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/utils/workflowconfig.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/builder/workflow.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/gallery/gallery.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chat/chatinput.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chat/messagelist.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chat/thread.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chat/types.ts
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/chatbox.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/metadata.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/ra.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/sessions.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/sidebar.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/utils/charts/bar.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/utils/profiler.tsx
 delete mode 100644 python/packages/autogen-studio/frontend/src/components/views/playground/utils/selectors.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/markdown.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/monaco.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/session/api.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/session/editor.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/session/list.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/session/manager.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/session/types.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/team/api.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/team/editor.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/team/list.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/team/manager.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/components/views/shared/team/types.ts
 create mode 100644 python/packages/autogen-studio/frontend/src/images/landing/nodata.svg
 rename python/packages/autogen-studio/frontend/{static/images/svgs => src/images/landing}/welcome.svg (98%)
 create mode 100644 python/packages/autogen-studio/frontend/src/index.d.ts
 delete mode 100644 python/packages/autogen-studio/frontend/src/pages/gallery/index.tsx
 create mode 100644 python/packages/autogen-studio/frontend/src/pages/settings.tsx
 create mode 100644 python/packages/autogen-studio/frontend/yarn.lock
 create mode 100644 python/packages/autogen-studio/notebooks/team.json
 delete mode 100644 python/packages/autogen-studio/notebooks/travel_groupchat.json
 delete mode 100644 python/packages/autogen-studio/notebooks/two_agent.json
 delete mode 100644 python/packages/autogen-studio/test/test_save_skills_to_file.py
 delete mode 100644 python/packages/autogen-studio/test/test_skills_prompt.py
 create mode 100644 python/packages/autogen-studio/tests/__init__.py
 create mode 100644 python/packages/autogen-studio/tests/test_component_factory.py
 create mode 100644 python/packages/autogen-studio/tests/test_db_manager.py

diff --git a/python/packages/autogen-studio/.gitignore b/python/packages/autogen-studio/.gitignore
index 549ce16b6db9..cf5c0a525432 100644
--- a/python/packages/autogen-studio/.gitignore
+++ b/python/packages/autogen-studio/.gitignore
@@ -2,6 +2,8 @@ database.sqlite
 .cache/*
 autogenstudio/web/files/user/*
 autogenstudio/test
+autogenstudio/database/alembic.ini 
+autogenstudio/database/alembic/*
 autogenstudio/web/files/ui/*
 OAI_CONFIG_LIST
 scratch/
@@ -10,8 +12,10 @@ autogenstudio/web/ui/*
 autogenstudio/web/skills/user/*
 .release.sh
 .nightly.sh
+notebooks/test
 
 notebooks/work_dir/*
+notebooks/test.db
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
diff --git a/python/packages/autogen-studio/autogenstudio/__init__.py b/python/packages/autogen-studio/autogenstudio/__init__.py
index acc477c5cd88..833950913331 100644
--- a/python/packages/autogen-studio/autogenstudio/__init__.py
+++ b/python/packages/autogen-studio/autogenstudio/__init__.py
@@ -1,4 +1,3 @@
-from .chatmanager import *
 from .datamodel import *
 from .version import __version__
-from .workflowmanager import *
+from .teammanager import *
diff --git a/python/packages/autogen-studio/autogenstudio/chatmanager.py b/python/packages/autogen-studio/autogenstudio/chatmanager.py
deleted file mode 100644
index e8ed3abfd627..000000000000
--- a/python/packages/autogen-studio/autogenstudio/chatmanager.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import os
-from datetime import datetime
-from queue import Queue
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-from loguru import logger
-
-from .datamodel import Message
-from .websocket_connection_manager import WebSocketConnectionManager
-from .workflowmanager import WorkflowManager
-
-
-class AutoGenChatManager:
-    """
-    This class handles the automated generation and management of chat interactions
-    using an automated workflow configuration and message queue.
-    """
-
-    def __init__(
-        self, message_queue: Queue, websocket_manager: WebSocketConnectionManager = None, human_input_timeout: int = 180
-    ) -> None:
-        """
-        Initializes the AutoGenChatManager with a message queue.
-
-        :param message_queue: A queue to use for sending messages asynchronously.
-        """
-        self.message_queue = message_queue
-        self.websocket_manager = websocket_manager
-        self.a_human_input_timeout = human_input_timeout
-
-    def send(self, message: dict) -> None:
-        """
-        Sends a message by putting it into the message queue.
-
-        :param message: The message string to be sent.
-        """
-        if self.message_queue is not None:
-            self.message_queue.put_nowait(message)
-
-    async def a_send(self, message: dict) -> None:
-        """
-        Asynchronously sends a message via the WebSocketManager class
-
-        :param message: The message string to be sent.
-        """
-        for connection, socket_client_id in self.websocket_manager.active_connections:
-            if message["connection_id"] == socket_client_id:
-                logger.info(
-                    f"Sending message to connection_id: {message['connection_id']}. Connection ID: {socket_client_id}"
-                )
-                await self.websocket_manager.send_message(message, connection)
-            else:
-                logger.info(
-                    f"Skipping message for connection_id: {message['connection_id']}. Connection ID: {socket_client_id}"
-                )
-
-    async def a_prompt_for_input(self, prompt: dict, timeout: int = 60) -> str:
-        """
-        Sends the user a prompt and waits for a response asynchronously via the WebSocketManager class
-
-        :param message: The message string to be sent.
-        """
-
-        for connection, socket_client_id in self.websocket_manager.active_connections:
-            if prompt["connection_id"] == socket_client_id:
-                logger.info(
-                    f"Sending message to connection_id: {prompt['connection_id']}. Connection ID: {socket_client_id}"
-                )
-                try:
-                    result = await self.websocket_manager.get_input(prompt, connection, timeout)
-                    return result
-                except Exception as e:
-                    return f"Error: {e}\nTERMINATE"
-            else:
-                logger.info(
-                    f"Skipping message for connection_id: {prompt['connection_id']}. Connection ID: {socket_client_id}"
-                )
-
-    def chat(
-        self,
-        message: Message,
-        history: List[Dict[str, Any]],
-        workflow: Any = None,
-        connection_id: Optional[str] = None,
-        user_dir: Optional[str] = None,
-        **kwargs,
-    ) -> Message:
-        """
-        Processes an incoming message according to the agent's workflow configuration
-        and generates a response.
-
-        :param message: An instance of `Message` representing an incoming message.
-        :param history: A list of dictionaries, each representing a past interaction.
-        :param flow_config: An instance of `AgentWorkFlowConfig`. If None, defaults to a standard configuration.
-        :param connection_id: An optional connection identifier.
-        :param kwargs: Additional keyword arguments.
-        :return: An instance of `Message` representing a response.
-        """
-
-        # create a working director for workflow based on user_dir/session_id/time_hash
-        work_dir = os.path.join(
-            user_dir,
-            str(message.session_id),
-            datetime.now().strftime("%Y%m%d_%H-%M-%S"),
-        )
-        os.makedirs(work_dir, exist_ok=True)
-
-        # if no flow config is provided, use the default
-        if workflow is None:
-            raise ValueError("Workflow must be specified")
-
-        workflow_manager = WorkflowManager(
-            workflow=workflow,
-            history=history,
-            work_dir=work_dir,
-            send_message_function=self.send,
-            a_send_message_function=self.a_send,
-            connection_id=connection_id,
-        )
-
-        message_text = message.content.strip()
-        result_message: Message = workflow_manager.run(message=f"{message_text}", clear_history=False, history=history)
-
-        result_message.user_id = message.user_id
-        result_message.session_id = message.session_id
-        return result_message
-
-    async def a_chat(
-        self,
-        message: Message,
-        history: List[Dict[str, Any]],
-        workflow: Any = None,
-        connection_id: Optional[str] = None,
-        user_dir: Optional[str] = None,
-        **kwargs,
-    ) -> Message:
-        """
-        Processes an incoming message according to the agent's workflow configuration
-        and generates a response.
-
-        :param message: An instance of `Message` representing an incoming message.
-        :param history: A list of dictionaries, each representing a past interaction.
-        :param flow_config: An instance of `AgentWorkFlowConfig`. If None, defaults to a standard configuration.
-        :param connection_id: An optional connection identifier.
-        :param kwargs: Additional keyword arguments.
-        :return: An instance of `Message` representing a response.
-        """
-
-        # create a working director for workflow based on user_dir/session_id/time_hash
-        work_dir = os.path.join(
-            user_dir,
-            str(message.session_id),
-            datetime.now().strftime("%Y%m%d_%H-%M-%S"),
-        )
-        os.makedirs(work_dir, exist_ok=True)
-
-        # if no flow config is provided, use the default
-        if workflow is None:
-            raise ValueError("Workflow must be specified")
-
-        workflow_manager = WorkflowManager(
-            workflow=workflow,
-            history=history,
-            work_dir=work_dir,
-            send_message_function=self.send,
-            a_send_message_function=self.a_send,
-            a_human_input_function=self.a_prompt_for_input,
-            a_human_input_timeout=self.a_human_input_timeout,
-            connection_id=connection_id,
-        )
-
-        message_text = message.content.strip()
-        result_message: Message = await workflow_manager.a_run(
-            message=f"{message_text}", clear_history=False, history=history
-        )
-
-        result_message.user_id = message.user_id
-        result_message.session_id = message.session_id
-        return result_message
diff --git a/python/packages/autogen-studio/autogenstudio/cli.py b/python/packages/autogen-studio/autogenstudio/cli.py
index 81fee7991455..b8612f4ad97b 100644
--- a/python/packages/autogen-studio/autogenstudio/cli.py
+++ b/python/packages/autogen-studio/autogenstudio/cli.py
@@ -15,10 +15,11 @@ def ui(
     host: str = "127.0.0.1",
     port: int = 8081,
     workers: int = 1,
-    reload: Annotated[bool, typer.Option("--reload")] = False,
+    reload: Annotated[bool, typer.Option("--reload")] = True,
     docs: bool = True,
     appdir: str = None,
     database_uri: Optional[str] = None,
+    upgrade_database: bool = False,
 ):
     """
     Run the AutoGen Studio UI.
@@ -30,7 +31,7 @@ def ui(
         reload (bool, optional): Whether to reload the UI on code changes. Defaults to False.
         docs (bool, optional): Whether to generate API docs. Defaults to False.
         appdir (str, optional): Path to the AutoGen Studio app directory. Defaults to None.
-        database-uri (str, optional): Database URI to connect to. Defaults to None. Examples include sqlite:///autogenstudio.db, postgresql://user:password@localhost/autogenstudio.
+        database-uri (str, optional): Database URI to connect to. Defaults to None.
     """
 
     os.environ["AUTOGENSTUDIO_API_DOCS"] = str(docs)
@@ -38,6 +39,8 @@ def ui(
         os.environ["AUTOGENSTUDIO_APPDIR"] = appdir
     if database_uri:
         os.environ["AUTOGENSTUDIO_DATABASE_URI"] = database_uri
+    if upgrade_database:
+        os.environ["AUTOGENSTUDIO_UPGRADE_DATABASE"] = "1"
 
     uvicorn.run(
         "autogenstudio.web.app:app",
@@ -45,6 +48,11 @@ def ui(
         port=port,
         workers=workers,
         reload=reload,
+        reload_excludes=[
+            "**/alembic/*",
+            "**/alembic.ini",
+            "**/versions/*"
+        ] if reload else None
     )
 
 
diff --git a/python/packages/autogen-studio/autogenstudio/database/__init__.py b/python/packages/autogen-studio/autogenstudio/database/__init__.py
index 0518c24ba4fa..ac87c41f0bd7 100644
--- a/python/packages/autogen-studio/autogenstudio/database/__init__.py
+++ b/python/packages/autogen-studio/autogenstudio/database/__init__.py
@@ -1,3 +1,3 @@
-# from .dbmanager import *
-from .dbmanager import *
-from .utils import *
+from .db_manager import DatabaseManager
+from .component_factory import ComponentFactory
+from .config_manager import ConfigurationManager
diff --git a/python/packages/autogen-studio/autogenstudio/database/alembic.ini b/python/packages/autogen-studio/autogenstudio/database/alembic.ini
deleted file mode 100644
index cd413a26066c..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/alembic.ini
+++ /dev/null
@@ -1,116 +0,0 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts
-script_location = migrations
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the
-# "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to migrations/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "version_path_separator" below.
-# version_locations = %(here)s/bar:%(here)s/bat:migrations/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-sqlalchemy.url = driver://user:pass@localhost/dbname
-
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = --fix REVISION_SCRIPT_FILENAME
-
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARN
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S
diff --git a/python/packages/autogen-studio/autogenstudio/database/component_factory.py b/python/packages/autogen-studio/autogenstudio/database/component_factory.py
new file mode 100644
index 000000000000..708a292d6da4
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/database/component_factory.py
@@ -0,0 +1,355 @@
+import os
+from pathlib import Path
+from typing import List, Literal, Union, Optional, Dict, Any, Type
+from datetime import datetime
+import json
+from autogen_agentchat.task import MaxMessageTermination, TextMentionTermination, StopMessageTermination
+import yaml
+import logging
+from packaging import version
+
+from ..datamodel import (
+    TeamConfig, AgentConfig, ModelConfig, ToolConfig,
+    TeamTypes, AgentTypes, ModelTypes, ToolTypes,
+    ComponentType, ComponentConfig, ComponentConfigInput, TerminationConfig, TerminationTypes, Response
+)
+from autogen_agentchat.agents import AssistantAgent
+from autogen_agentchat.teams import RoundRobinGroupChat, SelectorGroupChat
+from autogen_ext.models import OpenAIChatCompletionClient
+from autogen_core.components.tools import FunctionTool
+
+logger = logging.getLogger(__name__)
+
+# Type definitions for supported components
+TeamComponent = Union[RoundRobinGroupChat, SelectorGroupChat]
+AgentComponent = Union[AssistantAgent]  # Will grow with more agent types
+# Will grow with more model types
+ModelComponent = Union[OpenAIChatCompletionClient]
+ToolComponent = Union[FunctionTool]  # Will grow with more tool types
+TerminationComponent = Union[MaxMessageTermination,
+                             StopMessageTermination, TextMentionTermination]
+
+# Config type definitions
+
+Component = Union[TeamComponent, AgentComponent, ModelComponent, ToolComponent]
+
+
+ReturnType = Literal['object', 'dict', 'config']
+Component = Union[RoundRobinGroupChat, SelectorGroupChat,
+                  AssistantAgent, OpenAIChatCompletionClient, FunctionTool]
+
+
+class ComponentFactory:
+    """Creates and manages agent components with versioned configuration loading"""
+
+    SUPPORTED_VERSIONS = {
+        ComponentType.TEAM: ["1.0.0"],
+        ComponentType.AGENT: ["1.0.0"],
+        ComponentType.MODEL: ["1.0.0"],
+        ComponentType.TOOL: ["1.0.0"],
+        ComponentType.TERMINATION: ["1.0.0"]
+    }
+
+    def __init__(self):
+        self._model_cache: Dict[str, OpenAIChatCompletionClient] = {}
+        self._tool_cache: Dict[str, FunctionTool] = {}
+        self._last_cache_clear = datetime.now()
+
+    async def load(self, component: ComponentConfigInput, return_type: ReturnType = 'object') -> Union[Component, dict, ComponentConfig]:
+        """
+        Universal loader for any component type
+
+        Args:
+            component: Component configuration (file path, dict, or ComponentConfig)
+            return_type: Type of return value ('object', 'dict', or 'config')
+
+        Returns:
+            Component instance, config dict, or ComponentConfig based on return_type
+
+        Raises:
+            ValueError: If component type is unknown or version unsupported
+        """
+        try:
+            # Load and validate config
+            if isinstance(component, (str, Path)):
+                component_dict = await self._load_from_file(component)
+                config = self._dict_to_config(component_dict)
+            elif isinstance(component, dict):
+                config = self._dict_to_config(component)
+            else:
+                config = component
+
+            # Validate version
+            if not self._is_version_supported(config.component_type, config.version):
+                raise ValueError(
+                    f"Unsupported version {config.version} for "
+                    f"component type {config.component_type}. "
+                    f"Supported versions: {self.SUPPORTED_VERSIONS[config.component_type]}"
+                )
+
+            # Return early if dict or config requested
+            if return_type == 'dict':
+                return config.model_dump()
+            elif return_type == 'config':
+                return config
+
+            # Otherwise create and return component instance
+            handlers = {
+                ComponentType.TEAM: self.load_team,
+                ComponentType.AGENT: self.load_agent,
+                ComponentType.MODEL: self.load_model,
+                ComponentType.TOOL: self.load_tool,
+                ComponentType.TERMINATION: self.load_termination
+            }
+
+            handler = handlers.get(config.component_type)
+            if not handler:
+                raise ValueError(
+                    f"Unknown component type: {config.component_type}")
+
+            return await handler(config)
+
+        except Exception as e:
+            logger.error(f"Failed to load component: {str(e)}")
+            raise
+
+    async def load_directory(self, directory: Union[str, Path], check_exists: bool = False, return_type: ReturnType = 'object') -> List[Union[Component, dict, ComponentConfig]]:
+        """
+        Import all component configurations from a directory.
+        """
+        components = []
+        try:
+            directory = Path(directory)
+            # Using Path.iterdir() instead of os.listdir
+            for path in list(directory.glob("*")):
+                if path.suffix.lower().endswith(('.json', '.yaml', '.yml')):
+                    try:
+                        component = await self.load(path, return_type)
+                        components.append(component)
+                    except Exception as e:
+                        logger.info(
+                            f"Failed to load component: {str(e)}, {path}")
+
+            return components
+        except Exception as e:
+            logger.info(f"Failed to load directory: {str(e)}")
+            return components
+
+    def _dict_to_config(self, config_dict: dict) -> ComponentConfig:
+        """Convert dictionary to appropriate config type based on component_type"""
+        if "component_type" not in config_dict:
+            raise ValueError("component_type is required in configuration")
+
+        config_types = {
+            ComponentType.TEAM: TeamConfig,
+            ComponentType.AGENT: AgentConfig,
+            ComponentType.MODEL: ModelConfig,
+            ComponentType.TOOL: ToolConfig,
+            ComponentType.TERMINATION: TerminationConfig  # Add mapping for termination
+        }
+
+        component_type = ComponentType(config_dict["component_type"])
+        config_class = config_types.get(component_type)
+
+        if not config_class:
+            raise ValueError(f"Unknown component type: {component_type}")
+
+        return config_class(**config_dict)
+
+    async def load_termination(self, config: TerminationConfig) -> TerminationComponent:
+        """Create termination condition instance from configuration."""
+        try:
+            if config.termination_type == TerminationTypes.MAX_MESSAGES:
+                return MaxMessageTermination(max_messages=config.max_messages)
+            elif config.termination_type == TerminationTypes.STOP_MESSAGE:
+                return StopMessageTermination()
+            elif config.termination_type == TerminationTypes.TEXT_MENTION:
+                if not config.text:
+                    raise ValueError(
+                        "text parameter required for TextMentionTermination")
+                return TextMentionTermination(text=config.text)
+            else:
+                raise ValueError(
+                    f"Unsupported termination type: {config.termination_type}")
+        except Exception as e:
+            logger.error(f"Failed to create termination condition: {str(e)}")
+            raise ValueError(
+                f"Termination condition creation failed: {str(e)}")
+
+    async def load_team(self, config: TeamConfig) -> TeamComponent:
+        """Create team instance from configuration."""
+        try:
+            # Load participants (agents)
+            participants = []
+            for participant in config.participants:
+                agent = await self.load(participant)
+                participants.append(agent)
+
+            # Load model client if specified
+            model_client = None
+            if config.model_client:
+                model_client = await self.load(config.model_client)
+
+            # Load termination condition if specified
+            termination = None
+            if config.termination_condition:
+                # Now we can use the universal load() method since termination is a proper component
+                termination = await self.load(config.termination_condition)
+
+            # Create team based on type
+            if config.team_type == TeamTypes.ROUND_ROBIN:
+                return RoundRobinGroupChat(
+                    participants=participants,
+                    termination_condition=termination
+                )
+            elif config.team_type == TeamTypes.SELECTOR:
+                if not model_client:
+                    raise ValueError(
+                        "SelectorGroupChat requires a model_client")
+                return SelectorGroupChat(
+                    participants=participants,
+                    model_client=model_client,
+                    termination_condition=termination
+                )
+            else:
+                raise ValueError(f"Unsupported team type: {config.team_type}")
+
+        except Exception as e:
+            logger.error(f"Failed to create team {config.name}: {str(e)}")
+            raise ValueError(f"Team creation failed: {str(e)}")
+
+    async def load_agent(self, config: AgentConfig) -> AgentComponent:
+        """Create agent instance from configuration."""
+        try:
+            # Load model client if specified
+            model_client = None
+            if config.model_client:
+                model_client = await self.load(config.model_client)
+            system_message = config.system_message if config.system_message else "You are a helpful assistant"
+            # Load tools if specified
+            tools = []
+            if config.tools:
+                for tool_config in config.tools:
+                    tool = await self.load(tool_config)
+                    tools.append(tool)
+
+            if config.agent_type == AgentTypes.ASSISTANT:
+                return AssistantAgent(
+                    name=config.name,
+                    model_client=model_client,
+                    tools=tools,
+                    system_message=system_message
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported agent type: {config.agent_type}")
+
+        except Exception as e:
+            logger.error(f"Failed to create agent {config.name}: {str(e)}")
+            raise ValueError(f"Agent creation failed: {str(e)}")
+
+    async def load_model(self, config: ModelConfig) -> ModelComponent:
+        """Create model instance from configuration."""
+        try:
+            # Check cache first
+            cache_key = str(config.model_dump())
+            if cache_key in self._model_cache:
+                logger.debug(f"Using cached model for {config.model}")
+                return self._model_cache[cache_key]
+
+            if config.model_type == ModelTypes.OPENAI:
+                model = OpenAIChatCompletionClient(
+                    model=config.model,
+                    api_key=config.api_key,
+                    base_url=config.base_url
+                )
+                self._model_cache[cache_key] = model
+                return model
+            else:
+                raise ValueError(
+                    f"Unsupported model type: {config.model_type}")
+
+        except Exception as e:
+            logger.error(f"Failed to create model {config.model}: {str(e)}")
+            raise ValueError(f"Model creation failed: {str(e)}")
+
+    async def load_tool(self, config: ToolConfig) -> ToolComponent:
+        """Create tool instance from configuration."""
+        try:
+            # Validate required fields
+            if not all([config.name, config.description, config.content, config.tool_type]):
+                raise ValueError("Tool configuration missing required fields")
+
+            # Check cache first
+            cache_key = str(config.model_dump())
+            if cache_key in self._tool_cache:
+                logger.debug(f"Using cached tool '{config.name}'")
+                return self._tool_cache[cache_key]
+
+            if config.tool_type == ToolTypes.PYTHON_FUNCTION:
+                tool = FunctionTool(
+                    name=config.name,
+                    description=config.description,
+                    func=self._func_from_string(config.content)
+                )
+                self._tool_cache[cache_key] = tool
+                return tool
+            else:
+                raise ValueError(f"Unsupported tool type: {config.tool_type}")
+
+        except Exception as e:
+            logger.error(f"Failed to create tool '{config.name}': {str(e)}")
+            raise
+
+    # Helper methods remain largely the same
+    async def _load_from_file(self, path: Union[str, Path]) -> dict:
+        """Load configuration from JSON or YAML file."""
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(f"Config file not found: {path}")
+
+        try:
+            with open(path) as f:
+                if path.suffix == '.json':
+                    return json.load(f)
+                elif path.suffix in ('.yml', '.yaml'):
+                    return yaml.safe_load(f)
+                else:
+                    raise ValueError(f"Unsupported file format: {path.suffix}")
+        except Exception as e:
+            raise ValueError(f"Failed to load file {path}: {str(e)}")
+
+    def _func_from_string(self, content: str) -> callable:
+        """Convert function string to callable."""
+        try:
+            namespace = {}
+            exec(content, namespace)
+            for item in namespace.values():
+                if callable(item) and not isinstance(item, type):
+                    return item
+            raise ValueError("No function found in provided code")
+        except Exception as e:
+            raise ValueError(f"Failed to create function: {str(e)}")
+
+    def _is_version_supported(self, component_type: ComponentType, ver: str) -> bool:
+        """Check if version is supported for component type."""
+        try:
+            v = version.parse(ver)
+            return ver in self.SUPPORTED_VERSIONS[component_type]
+        except version.InvalidVersion:
+            return False
+
+    async def cleanup(self) -> None:
+        """Cleanup resources and clear caches."""
+        for model in self._model_cache.values():
+            if hasattr(model, 'cleanup'):
+                await model.cleanup()
+
+        for tool in self._tool_cache.values():
+            if hasattr(tool, 'cleanup'):
+                await tool.cleanup()
+
+        self._model_cache.clear()
+        self._tool_cache.clear()
+        self._last_cache_clear = datetime.now()
+        logger.info("Cleared all component caches")
diff --git a/python/packages/autogen-studio/autogenstudio/database/config_manager.py b/python/packages/autogen-studio/autogenstudio/database/config_manager.py
new file mode 100644
index 000000000000..be4fa8ad6912
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/database/config_manager.py
@@ -0,0 +1,322 @@
+import logging
+from typing import Optional, Union, Dict, Any, List
+from pathlib import Path
+from loguru import logger
+from ..datamodel import (
+    Model, Team, Agent, Tool,
+    Response, ComponentTypes, LinkTypes,
+    ComponentConfigInput
+)
+
+from .component_factory import ComponentFactory
+from .db_manager import DatabaseManager
+
+
+class ConfigurationManager:
+    """Manages persistence and relationships of components using ComponentFactory for validation"""
+
+    DEFAULT_UNIQUENESS_FIELDS = {
+        ComponentTypes.MODEL: ['model_type', 'model'],
+        ComponentTypes.TOOL: ['name'],
+        ComponentTypes.AGENT: ['agent_type', 'name'],
+        ComponentTypes.TEAM: ['team_type', 'name']
+    }
+
+    def __init__(self, db_manager: DatabaseManager, uniqueness_fields: Dict[ComponentTypes, List[str]] = None):
+        self.db_manager = db_manager
+        self.component_factory = ComponentFactory()
+        self.uniqueness_fields = uniqueness_fields or self.DEFAULT_UNIQUENESS_FIELDS
+
+    async def import_component(self, component_config: ComponentConfigInput, user_id: str, check_exists: bool = False) -> Response:
+        """
+        Import a component configuration, validate it, and store the resulting component.
+
+        Args:
+            component_config: Configuration for the component (file path, dict, or ComponentConfig)
+            user_id: User ID to associate with imported component
+            check_exists: Whether to check for existing components before storing (default: False)
+
+        Returns:
+            Response containing import results or error
+        """
+        try:
+            # Get validated config as dict
+            config = await self.component_factory.load(component_config, return_type='dict')
+
+            # Get component type
+            component_type = self._determine_component_type(config)
+            if not component_type:
+                raise ValueError(
+                    f"Unable to determine component type from config")
+
+            # Check existence if requested
+            if check_exists:
+                existing = self._check_exists(component_type, config, user_id)
+                if existing:
+                    return Response(
+                        message=self._format_exists_message(
+                            component_type, config),
+                        status=True,
+                        data={"id": existing.id}
+                    )
+
+            # Route to appropriate storage method
+            if component_type == ComponentTypes.TEAM:
+                return await self._store_team(config, user_id, check_exists)
+            elif component_type == ComponentTypes.AGENT:
+                return await self._store_agent(config, user_id, check_exists)
+            elif component_type == ComponentTypes.MODEL:
+                return await self._store_model(config, user_id)
+            elif component_type == ComponentTypes.TOOL:
+                return await self._store_tool(config, user_id)
+            else:
+                raise ValueError(
+                    f"Unsupported component type: {component_type}")
+
+        except Exception as e:
+            logger.error(f"Failed to import component: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    async def import_directory(self, directory: Union[str, Path], user_id: str, check_exists: bool = False) -> Response:
+        """
+        Import all component configurations from a directory.
+
+        Args:
+            directory: Path to directory containing configuration files
+            user_id: User ID to associate with imported components
+            check_exists: Whether to check for existing components before storing (default: False)
+
+        Returns:
+            Response containing import results for all files
+        """
+        try:
+            configs = await self.component_factory.load_directory(directory, return_type='dict')
+
+            results = []
+            for config in configs:
+                result = await self.import_component(config, user_id, check_exists)
+                results.append({
+                    "component": self._get_component_type(config),
+                    "status": result.status,
+                    "message": result.message,
+                    "id": result.data.get("id") if result.status else None
+                })
+
+            return Response(
+                message="Directory import complete",
+                status=True,
+                data=results
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to import directory: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    async def _store_team(self, config: dict, user_id: str, check_exists: bool = False) -> Response:
+        """Store team component and manage its relationships with agents"""
+        try:
+            # Store the team
+            team_db = Team(
+                user_id=user_id,
+                config=config
+            )
+            team_result = self.db_manager.upsert(team_db)
+            if not team_result.status:
+                return team_result
+
+            team_id = team_result.data["id"]
+
+            # Handle participants (agents)
+            for participant in config.get("participants", []):
+                if check_exists:
+                    # Check for existing agent
+                    agent_type = self._determine_component_type(participant)
+                    existing_agent = self._check_exists(
+                        agent_type, participant, user_id)
+                    if existing_agent:
+                        # Link existing agent
+                        self.db_manager.link(
+                            LinkTypes.TEAM_AGENT,
+                            team_id,
+                            existing_agent.id
+                        )
+                        logger.info(
+                            f"Linked existing agent to team: {existing_agent}")
+                        continue
+
+                # Store and link new agent
+                agent_result = await self._store_agent(participant, user_id, check_exists)
+                if agent_result.status:
+                    self.db_manager.link(
+                        LinkTypes.TEAM_AGENT,
+                        team_id,
+                        agent_result.data["id"]
+                    )
+
+            return team_result
+
+        except Exception as e:
+            logger.error(f"Failed to store team: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    async def _store_agent(self, config: dict, user_id: str, check_exists: bool = False) -> Response:
+        """Store agent component and manage its relationships with tools and model"""
+        try:
+            # Store the agent
+            agent_db = Agent(
+                user_id=user_id,
+                config=config
+            )
+            agent_result = self.db_manager.upsert(agent_db)
+            if not agent_result.status:
+                return agent_result
+
+            agent_id = agent_result.data["id"]
+
+            # Handle model client
+            if "model_client" in config:
+                if check_exists:
+                    # Check for existing model
+                    model_type = self._determine_component_type(
+                        config["model_client"])
+                    existing_model = self._check_exists(
+                        model_type, config["model_client"], user_id)
+                    if existing_model:
+                        # Link existing model
+                        self.db_manager.link(
+                            LinkTypes.AGENT_MODEL,
+                            agent_id,
+                            existing_model.id
+                        )
+                        logger.info(
+                            f"Linked existing model to agent: {existing_model.config.model_type}")
+                    else:
+                        # Store and link new model
+                        model_result = await self._store_model(config["model_client"], user_id)
+                        if model_result.status:
+                            self.db_manager.link(
+                                LinkTypes.AGENT_MODEL,
+                                agent_id,
+                                model_result.data["id"]
+                            )
+                else:
+                    # Store and link new model without checking
+                    model_result = await self._store_model(config["model_client"], user_id)
+                    if model_result.status:
+                        self.db_manager.link(
+                            LinkTypes.AGENT_MODEL,
+                            agent_id,
+                            model_result.data["id"]
+                        )
+
+            # Handle tools
+            for tool_config in config.get("tools", []):
+                if check_exists:
+                    # Check for existing tool
+                    tool_type = self._determine_component_type(tool_config)
+                    existing_tool = self._check_exists(
+                        tool_type, tool_config, user_id)
+                    if existing_tool:
+                        # Link existing tool
+                        self.db_manager.link(
+                            LinkTypes.AGENT_TOOL,
+                            agent_id,
+                            existing_tool.id
+                        )
+                        logger.info(
+                            f"Linked existing tool to agent: {existing_tool.config.name}")
+                        continue
+
+                # Store and link new tool
+                tool_result = await self._store_tool(tool_config, user_id)
+                if tool_result.status:
+                    self.db_manager.link(
+                        LinkTypes.AGENT_TOOL,
+                        agent_id,
+                        tool_result.data["id"]
+                    )
+
+            return agent_result
+
+        except Exception as e:
+            logger.error(f"Failed to store agent: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    async def _store_model(self, config: dict, user_id: str) -> Response:
+        """Store model component (leaf node - no relationships)"""
+        try:
+            model_db = Model(
+                user_id=user_id,
+                config=config
+            )
+            return self.db_manager.upsert(model_db)
+
+        except Exception as e:
+            logger.error(f"Failed to store model: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    async def _store_tool(self, config: dict, user_id: str) -> Response:
+        """Store tool component (leaf node - no relationships)"""
+        try:
+            tool_db = Tool(
+                user_id=user_id,
+                config=config
+            )
+            return self.db_manager.upsert(tool_db)
+
+        except Exception as e:
+            logger.error(f"Failed to store tool: {str(e)}")
+            return Response(message=str(e), status=False)
+
+    def _check_exists(self, component_type: ComponentTypes, config: dict, user_id: str) -> Optional[Union[Model, Tool, Agent, Team]]:
+        """Check if component exists based on configured uniqueness fields."""
+        fields = self.uniqueness_fields.get(component_type, [])
+        if not fields:
+            return None
+
+        component_class = {
+            ComponentTypes.MODEL: Model,
+            ComponentTypes.TOOL: Tool,
+            ComponentTypes.AGENT: Agent,
+            ComponentTypes.TEAM: Team
+        }.get(component_type)
+
+        components = self.db_manager.get(
+            component_class, {"user_id": user_id}).data
+
+        for component in components:
+            matches = all(
+                component.config.get(field) == config.get(field)
+                for field in fields
+            )
+            if matches:
+                return component
+
+        return None
+
+    def _format_exists_message(self, component_type: ComponentTypes, config: dict) -> str:
+        """Format existence message with identifying fields."""
+        fields = self.uniqueness_fields.get(component_type, [])
+        field_values = [f"{field}='{config.get(field)}'" for field in fields]
+        return f"{component_type.value} with {' and '.join(field_values)} already exists"
+
+    def _determine_component_type(self, config: dict) -> Optional[ComponentTypes]:
+        """Determine component type from configuration dictionary"""
+        if "team_type" in config:
+            return ComponentTypes.TEAM
+        elif "agent_type" in config:
+            return ComponentTypes.AGENT
+        elif "model_type" in config:
+            return ComponentTypes.MODEL
+        elif "tool_type" in config:
+            return ComponentTypes.TOOL
+        return None
+
+    def _get_component_type(self, config: dict) -> str:
+        """Helper to get component type string from config"""
+        component_type = self._determine_component_type(config)
+        return component_type.value if component_type else "unknown"
+
+    async def cleanup(self):
+        """Cleanup resources"""
+        await self.component_factory.cleanup()
diff --git a/python/packages/autogen-studio/autogenstudio/database/db_manager.py b/python/packages/autogen-studio/autogenstudio/database/db_manager.py
new file mode 100644
index 000000000000..b1808f245e2f
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/database/db_manager.py
@@ -0,0 +1,424 @@
+import threading
+from datetime import datetime
+from typing import Optional
+
+from loguru import logger
+from sqlalchemy import exc, text, func
+from sqlmodel import Session, SQLModel, and_, create_engine, select
+from .schema_manager import SchemaManager
+
+from ..datamodel import (
+    Response,
+    LinkTypes
+)
+# from .dbutils import init_db_samples
+
+
+class DatabaseManager:
+    """A class to manage database operations"""
+
+    _init_lock = threading.Lock()
+
+    def __init__(self, engine_uri: str, auto_upgrade: bool = True):
+        connection_args = {
+            "check_same_thread": True} if "sqlite" in engine_uri else {}
+        self.engine = create_engine(engine_uri, connect_args=connection_args)
+        self.schema_manager = SchemaManager(
+            engine=self.engine,
+            auto_upgrade=auto_upgrade,
+        )
+
+        # Check and upgrade on startup
+        upgraded, status = self.schema_manager.check_and_upgrade()
+        if upgraded:
+            logger.info("Database schema was upgraded automatically")
+        else:
+            logger.info(f"Schema status: {status}")
+
+    def reset_db(self, recreate_tables: bool = True):
+        """
+        Reset the database by dropping all tables and optionally recreating them.
+
+        Args:
+            recreate_tables (bool): If True, recreates the tables after dropping them.
+                                Set to False if you want to call create_db_and_tables() separately.
+        """
+        if not self._init_lock.acquire(blocking=False):
+            logger.warning("Database reset already in progress")
+            return Response(
+                message="Database reset already in progress",
+                status=False,
+                data=None
+            )
+
+        try:
+            # Dispose existing connections
+            self.engine.dispose()
+            with Session(self.engine) as session:
+                try:
+                    # Disable foreign key checks for SQLite
+                    if 'sqlite' in str(self.engine.url):
+                        session.exec(text('PRAGMA foreign_keys=OFF'))
+
+                    # Drop all tables
+                    SQLModel.metadata.drop_all(self.engine)
+                    logger.info("All tables dropped successfully")
+
+                    # Re-enable foreign key checks for SQLite
+                    if 'sqlite' in str(self.engine.url):
+                        session.exec(text('PRAGMA foreign_keys=ON'))
+
+                    session.commit()
+
+                except Exception as e:
+                    session.rollback()
+                    raise e
+                finally:
+                    session.close()
+                    self._init_lock.release()
+
+            if recreate_tables:
+                logger.info("Recreating tables...")
+                self.create_db_and_tables()
+
+            return Response(
+                message="Database reset successfully" if recreate_tables else "Database tables dropped successfully",
+                status=True,
+                data=None
+            )
+
+        except Exception as e:
+            error_msg = f"Error while resetting database: {str(e)}"
+            logger.error(error_msg)
+            return Response(
+                message=error_msg,
+                status=False,
+                data=None
+            )
+        finally:
+            if self._init_lock.locked():
+                self._init_lock.release()
+                logger.info("Database reset lock released")
+
+    def create_db_and_tables(self):
+        """Create a new database and tables"""
+        with self._init_lock:
+            try:
+                SQLModel.metadata.create_all(self.engine)
+                logger.info("Database tables created successfully")
+                try:
+                    # init_db_samples(self)
+                    pass
+                except Exception as e:
+                    logger.info(
+                        "Error while initializing database samples: " + str(e))
+            except Exception as e:
+                logger.info("Error while creating database tables:" + str(e))
+
+    def upsert(self, model: SQLModel, return_json: bool = True):
+        """Create or update an entity
+
+        Args:
+            model (SQLModel): The model instance to create or update
+            return_json (bool, optional): If True, returns the model as a dictionary. 
+                If False, returns the SQLModel instance. Defaults to True.
+
+        Returns:
+            Response: Contains status, message and data (either dict or SQLModel based on return_json)
+        """
+        status = True
+        model_class = type(model)
+        existing_model = None
+
+        with Session(self.engine) as session:
+            try:
+                existing_model = session.exec(
+                    select(model_class).where(model_class.id == model.id)).first()
+                if existing_model:
+                    model.updated_at = datetime.now()
+                    for key, value in model.model_dump().items():
+                        setattr(existing_model, key, value)
+                    model = existing_model  # Use the updated existing model
+                    session.add(model)
+                else:
+                    session.add(model)
+                session.commit()
+                session.refresh(model)
+            except Exception as e:
+                session.rollback()
+                logger.error("Error while updating/creating " +
+                             str(model_class.__name__) + ": " + str(e))
+                status = False
+
+        return Response(
+            message=(
+                f"{model_class.__name__} Updated Successfully"
+                if existing_model
+                else f"{model_class.__name__} Created Successfully"
+            ),
+            status=status,
+            data=model.model_dump() if return_json else model,
+        )
+
+    def _model_to_dict(self, model_obj):
+        return {col.name: getattr(model_obj, col.name) for col in model_obj.__table__.columns}
+
+    def get(
+        self,
+        model_class: SQLModel,
+        filters: dict = None,
+        return_json: bool = False,
+        order: str = "desc",
+    ):
+        """List entities"""
+        with Session(self.engine) as session:
+            result = []
+            status = True
+            status_message = ""
+
+            try:
+                statement = select(model_class)
+                if filters:
+                    conditions = [getattr(model_class, col) ==
+                                  value for col, value in filters.items()]
+                    statement = statement.where(and_(*conditions))
+
+                if hasattr(model_class, "created_at") and order:
+                    order_by_clause = getattr(
+                        model_class.created_at, order)()  # Dynamically apply asc/desc
+                    statement = statement.order_by(order_by_clause)
+
+                items = session.exec(statement).all()
+                result = [self._model_to_dict(
+                    item) if return_json else item for item in items]
+                status_message = f"{model_class.__name__} Retrieved Successfully"
+            except Exception as e:
+                session.rollback()
+                status = False
+                status_message = f"Error while fetching {model_class.__name__}"
+                logger.error("Error while getting items: " +
+                             str(model_class.__name__) + " " + str(e))
+
+            return Response(message=status_message, status=status, data=result)
+
+    def delete(self, model_class: SQLModel, filters: dict = None):
+        """Delete an entity"""
+        status_message = ""
+        status = True
+
+        with Session(self.engine) as session:
+            try:
+                statement = select(model_class)
+                if filters:
+                    conditions = [
+                        getattr(model_class, col) == value for col, value in filters.items()]
+                    statement = statement.where(and_(*conditions))
+
+                rows = session.exec(statement).all()
+
+                if rows:
+                    for row in rows:
+                        session.delete(row)
+                    session.commit()
+                    status_message = f"{model_class.__name__} Deleted Successfully"
+                else:
+                    status_message = "Row not found"
+                    logger.info(f"Row with filters {filters} not found")
+
+            except exc.IntegrityError as e:
+                session.rollback()
+                status = False
+                status_message = f"Integrity error: The {model_class.__name__} is linked to another entity and cannot be deleted. {e}"
+                # Log the specific integrity error
+                logger.error(status_message)
+            except Exception as e:
+                session.rollback()
+                status = False
+                status_message = f"Error while deleting: {e}"
+                logger.error(status_message)
+
+        return Response(message=status_message, status=status, data=None)
+
+    def link(
+        self,
+        link_type: LinkTypes,
+        primary_id: int,
+        secondary_id: int,
+        sequence: Optional[int] = None,
+    ):
+        """Link two entities with automatic sequence handling."""
+        with Session(self.engine) as session:
+            try:
+                # Get classes from LinkTypes
+                primary_class = link_type.primary_class
+                secondary_class = link_type.secondary_class
+                link_table = link_type.link_table
+
+                # Get entities
+                primary_entity = session.get(primary_class, primary_id)
+                secondary_entity = session.get(secondary_class, secondary_id)
+
+                if not primary_entity or not secondary_entity:
+                    return Response(message="One or both entities do not exist", status=False)
+
+                # Get field names
+                primary_id_field = f"{primary_class.__name__.lower()}_id"
+                secondary_id_field = f"{secondary_class.__name__.lower()}_id"
+
+                # Check for existing link
+                existing_link = session.exec(
+                    select(link_table).where(
+                        and_(
+                            getattr(link_table, primary_id_field) == primary_id,
+                            getattr(
+                                link_table, secondary_id_field) == secondary_id
+                        )
+                    )
+                ).first()
+
+                if existing_link:
+                    return Response(message="Link already exists", status=False)
+
+                # Get the next sequence number if not provided
+                if sequence is None:
+                    max_seq_result = session.exec(
+                        select(func.max(link_table.sequence)).where(
+                            getattr(link_table, primary_id_field) == primary_id
+                        )
+                    ).first()
+                    sequence = 0 if max_seq_result is None else max_seq_result + 1
+
+                # Create new link
+                new_link = link_table(**{
+                    primary_id_field: primary_id,
+                    secondary_id_field: secondary_id,
+                    'sequence': sequence
+                })
+                session.add(new_link)
+                session.commit()
+
+                return Response(
+                    message=f"Entities linked successfully with sequence {sequence}",
+                    status=True
+                )
+
+            except Exception as e:
+                session.rollback()
+                return Response(message=f"Error linking entities: {str(e)}", status=False)
+
+    def unlink(
+        self,
+        link_type: LinkTypes,
+        primary_id: int,
+        secondary_id: int,
+        sequence: Optional[int] = None
+    ):
+        """Unlink two entities and reorder sequences if needed."""
+        with Session(self.engine) as session:
+            try:
+                # Get classes from LinkTypes
+                primary_class = link_type.primary_class
+                secondary_class = link_type.secondary_class
+                link_table = link_type.link_table
+
+                # Get field names
+                primary_id_field = f"{primary_class.__name__.lower()}_id"
+                secondary_id_field = f"{secondary_class.__name__.lower()}_id"
+
+                # Find existing link
+                statement = select(link_table).where(
+                    and_(
+                        getattr(link_table, primary_id_field) == primary_id,
+                        getattr(link_table, secondary_id_field) == secondary_id
+                    )
+                )
+
+                if sequence is not None:
+                    statement = statement.where(
+                        link_table.sequence == sequence)
+
+                existing_link = session.exec(statement).first()
+
+                if not existing_link:
+                    return Response(message="Link does not exist", status=False)
+
+                deleted_sequence = existing_link.sequence
+                session.delete(existing_link)
+
+                # Reorder sequences for remaining links
+                remaining_links = session.exec(
+                    select(link_table)
+                    .where(getattr(link_table, primary_id_field) == primary_id)
+                    .where(link_table.sequence > deleted_sequence)
+                    .order_by(link_table.sequence)
+                ).all()
+
+                # Decrease sequence numbers to fill the gap
+                for link in remaining_links:
+                    link.sequence -= 1
+
+                session.commit()
+
+                return Response(
+                    message="Entities unlinked successfully and sequences reordered",
+                    status=True
+                )
+
+            except Exception as e:
+                session.rollback()
+                return Response(message=f"Error unlinking entities: {str(e)}", status=False)
+
+    def get_linked_entities(
+        self,
+        link_type: LinkTypes,
+        primary_id: int,
+        return_json: bool = False,
+    ):
+        """Get linked entities based on link type and primary ID, ordered by sequence."""
+        with Session(self.engine) as session:
+            try:
+                # Get classes from LinkTypes
+                primary_class = link_type.primary_class
+                secondary_class = link_type.secondary_class
+                link_table = link_type.link_table
+
+                # Get field names
+                primary_id_field = f"{primary_class.__name__.lower()}_id"
+                secondary_id_field = f"{secondary_class.__name__.lower()}_id"
+
+                # Query both link and entity, ordered by sequence
+                items = session.exec(
+                    select(secondary_class)
+                    .join(link_table, getattr(link_table, secondary_id_field) == secondary_class.id)
+                    .where(getattr(link_table, primary_id_field) == primary_id)
+                    .order_by(link_table.sequence)
+                ).all()
+
+                result = [
+                    item.model_dump() if return_json else item for item in items]
+
+                return Response(
+                    message="Linked entities retrieved successfully",
+                    status=True,
+                    data=result
+                )
+
+            except Exception as e:
+                logger.error(f"Error getting linked entities: {str(e)}")
+                return Response(
+                    message=f"Error getting linked entities: {str(e)}",
+                    status=False,
+                    data=[]
+                )
+    # Add new close method
+
+    async def close(self):
+        """Close database connections and cleanup resources"""
+        logger.info("Closing database connections...")
+        try:
+            # Dispose of the SQLAlchemy engine
+            self.engine.dispose()
+            logger.info("Database connections closed successfully")
+        except Exception as e:
+            logger.error(f"Error closing database connections: {str(e)}")
+            raise
diff --git a/python/packages/autogen-studio/autogenstudio/database/dbmanager.py b/python/packages/autogen-studio/autogenstudio/database/dbmanager.py
deleted file mode 100644
index 6a02a0a7038c..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/dbmanager.py
+++ /dev/null
@@ -1,491 +0,0 @@
-import threading
-from datetime import datetime
-from typing import Optional
-
-from loguru import logger
-from sqlalchemy import exc
-from sqlmodel import Session, SQLModel, and_, create_engine, select
-
-from ..datamodel import (
-    Agent,
-    AgentLink,
-    AgentModelLink,
-    AgentSkillLink,
-    Model,
-    Response,
-    Skill,
-    Workflow,
-    WorkflowAgentLink,
-    WorkflowAgentType,
-)
-from .utils import init_db_samples
-
-valid_link_types = ["agent_model", "agent_skill", "agent_agent", "workflow_agent"]
-
-
-class WorkflowAgentMap(SQLModel):
-    agent: Agent
-    link: WorkflowAgentLink
-
-
-class DBManager:
-    """A class to manage database operations"""
-
-    _init_lock = threading.Lock()  # Class-level lock
-
-    def __init__(self, engine_uri: str):
-        connection_args = {"check_same_thread": True} if "sqlite" in engine_uri else {}
-        self.engine = create_engine(engine_uri, connect_args=connection_args)
-        # run_migration(engine_uri=engine_uri)
-
-    def create_db_and_tables(self):
-        """Create a new database and tables"""
-        with self._init_lock:  # Use the lock
-            try:
-                SQLModel.metadata.create_all(self.engine)
-                try:
-                    init_db_samples(self)
-                except Exception as e:
-                    logger.info("Error while initializing database samples: " + str(e))
-            except Exception as e:
-                logger.info("Error while creating database tables:" + str(e))
-
-    def upsert(self, model: SQLModel):
-        """Create a new entity"""
-        # check if the model exists, update else add
-        status = True
-        model_class = type(model)
-        existing_model = None
-
-        with Session(self.engine) as session:
-            try:
-                existing_model = session.exec(select(model_class).where(model_class.id == model.id)).first()
-                if existing_model:
-                    model.updated_at = datetime.now()
-                    for key, value in model.model_dump().items():
-                        setattr(existing_model, key, value)
-                    model = existing_model
-                    session.add(model)
-                else:
-                    session.add(model)
-                session.commit()
-                session.refresh(model)
-            except Exception as e:
-                session.rollback()
-                logger.error("Error while updating " + str(model_class.__name__) + ": " + str(e))
-                status = False
-
-        response = Response(
-            message=(
-                f"{model_class.__name__} Updated Successfully "
-                if existing_model
-                else f"{model_class.__name__} Created Successfully"
-            ),
-            status=status,
-            data=model.model_dump(),
-        )
-
-        return response
-
-    def _model_to_dict(self, model_obj):
-        return {col.name: getattr(model_obj, col.name) for col in model_obj.__table__.columns}
-
-    def get_items(
-        self,
-        model_class: SQLModel,
-        session: Session,
-        filters: dict = None,
-        return_json: bool = False,
-        order: str = "desc",
-    ):
-        """List all entities"""
-        result = []
-        status = True
-        status_message = ""
-
-        try:
-            if filters:
-                conditions = [getattr(model_class, col) == value for col, value in filters.items()]
-                statement = select(model_class).where(and_(*conditions))
-
-                if hasattr(model_class, "created_at") and order:
-                    if order == "desc":
-                        statement = statement.order_by(model_class.created_at.desc())
-                    else:
-                        statement = statement.order_by(model_class.created_at.asc())
-            else:
-                statement = select(model_class)
-
-            if return_json:
-                result = [self._model_to_dict(row) for row in session.exec(statement).all()]
-            else:
-                result = session.exec(statement).all()
-            status_message = f"{model_class.__name__} Retrieved Successfully"
-        except Exception as e:
-            session.rollback()
-            status = False
-            status_message = f"Error while fetching  {model_class.__name__}"
-            logger.error("Error while getting items: " + str(model_class.__name__) + " " + str(e))
-
-        response: Response = Response(
-            message=status_message,
-            status=status,
-            data=result,
-        )
-        return response
-
-    def get(
-        self,
-        model_class: SQLModel,
-        filters: dict = None,
-        return_json: bool = False,
-        order: str = "desc",
-    ):
-        """List all entities"""
-
-        with Session(self.engine) as session:
-            response = self.get_items(model_class, session, filters, return_json, order)
-        return response
-
-    def delete(self, model_class: SQLModel, filters: dict = None):
-        """Delete an entity"""
-        row = None
-        status_message = ""
-        status = True
-
-        with Session(self.engine) as session:
-            try:
-                if filters:
-                    conditions = [getattr(model_class, col) == value for col, value in filters.items()]
-                    row = session.exec(select(model_class).where(and_(*conditions))).all()
-                else:
-                    row = session.exec(select(model_class)).all()
-                if row:
-                    for row in row:
-                        session.delete(row)
-                    session.commit()
-                    status_message = f"{model_class.__name__} Deleted Successfully"
-                else:
-                    print(f"Row with filters {filters} not found")
-                    logger.info("Row with filters + filters + not found")
-                    status_message = "Row not found"
-            except exc.IntegrityError as e:
-                session.rollback()
-                logger.error("Integrity ... Error while deleting: " + str(e))
-                status_message = f"The {model_class.__name__} is linked to another entity and cannot be deleted."
-                status = False
-            except Exception as e:
-                session.rollback()
-                logger.error("Error while deleting: " + str(e))
-                status_message = f"Error while deleting: {e}"
-                status = False
-            response = Response(
-                message=status_message,
-                status=status,
-                data=None,
-            )
-        return response
-
-    def get_linked_entities(
-        self,
-        link_type: str,
-        primary_id: int,
-        return_json: bool = False,
-        agent_type: Optional[str] = None,
-        sequence_id: Optional[int] = None,
-    ):
-        """
-        Get all entities linked to the primary entity.
-
-        Args:
-            link_type (str): The type of link to retrieve, e.g., "agent_model".
-            primary_id (int): The identifier for the primary model.
-            return_json (bool): Whether to return the result as a JSON object.
-
-        Returns:
-            List[SQLModel]: A list of linked entities.
-        """
-
-        linked_entities = []
-
-        if link_type not in valid_link_types:
-            return []
-
-        status = True
-        status_message = ""
-
-        with Session(self.engine) as session:
-            try:
-                if link_type == "agent_model":
-                    # get the agent
-                    agent = self.get_items(Agent, filters={"id": primary_id}, session=session).data[0]
-                    linked_entities = agent.models
-                elif link_type == "agent_skill":
-                    agent = self.get_items(Agent, filters={"id": primary_id}, session=session).data[0]
-                    linked_entities = agent.skills
-                elif link_type == "agent_agent":
-                    agent = self.get_items(Agent, filters={"id": primary_id}, session=session).data[0]
-                    linked_entities = agent.agents
-                elif link_type == "workflow_agent":
-                    linked_entities = session.exec(
-                        select(WorkflowAgentLink, Agent)
-                        .join(Agent, WorkflowAgentLink.agent_id == Agent.id)
-                        .where(
-                            WorkflowAgentLink.workflow_id == primary_id,
-                        )
-                    ).all()
-
-                    linked_entities = [WorkflowAgentMap(agent=agent, link=link) for link, agent in linked_entities]
-                    linked_entities = sorted(linked_entities, key=lambda x: x.link.sequence_id)  # type: ignore
-            except Exception as e:
-                logger.error("Error while getting linked entities: " + str(e))
-                status_message = f"Error while getting linked entities: {e}"
-                status = False
-            if return_json:
-                linked_entities = [row.model_dump() for row in linked_entities]
-
-        response = Response(
-            message=status_message,
-            status=status,
-            data=linked_entities,
-        )
-
-        return response
-
-    def link(
-        self,
-        link_type: str,
-        primary_id: int,
-        secondary_id: int,
-        agent_type: Optional[str] = None,
-        sequence_id: Optional[int] = None,
-    ) -> Response:
-        """
-        Link two entities together.
-
-        Args:
-            link_type (str): The type of link to create, e.g., "agent_model".
-            primary_id (int): The identifier for the primary model.
-            secondary_id (int): The identifier for the secondary model.
-            agent_type (Optional[str]): The type of agent, e.g., "sender" or receiver.
-
-        Returns:
-            Response: The response of the linking operation, including success status and message.
-        """
-
-        # TBD verify that is creator of the primary entity being linked
-        status = True
-        status_message = ""
-        primary_model = None
-        secondary_model = None
-
-        if link_type not in valid_link_types:
-            status = False
-            status_message = f"Invalid link type: {link_type}. Valid link types are: {valid_link_types}"
-        else:
-            with Session(self.engine) as session:
-                try:
-                    if link_type == "agent_model":
-                        primary_model = session.exec(select(Agent).where(Agent.id == primary_id)).first()
-                        secondary_model = session.exec(select(Model).where(Model.id == secondary_id)).first()
-                        if primary_model is None or secondary_model is None:
-                            status = False
-                            status_message = "One or both entity records do not exist."
-                        else:
-                            # check if the link already exists
-                            existing_link = session.exec(
-                                select(AgentModelLink).where(
-                                    AgentModelLink.agent_id == primary_id,
-                                    AgentModelLink.model_id == secondary_id,
-                                )
-                            ).first()
-                            if existing_link:  # link already exists
-                                return Response(
-                                    message=(
-                                        f"{secondary_model.__class__.__name__} already linked "
-                                        f"to {primary_model.__class__.__name__}"
-                                    ),
-                                    status=False,
-                                )
-                            else:
-                                primary_model.models.append(secondary_model)
-                    elif link_type == "agent_agent":
-                        primary_model = session.exec(select(Agent).where(Agent.id == primary_id)).first()
-                        secondary_model = session.exec(select(Agent).where(Agent.id == secondary_id)).first()
-                        if primary_model is None or secondary_model is None:
-                            status = False
-                            status_message = "One or both entity records do not exist."
-                        else:
-                            # check if the link already exists
-                            existing_link = session.exec(
-                                select(AgentLink).where(
-                                    AgentLink.parent_id == primary_id,
-                                    AgentLink.agent_id == secondary_id,
-                                )
-                            ).first()
-                            if existing_link:
-                                return Response(
-                                    message=(
-                                        f"{secondary_model.__class__.__name__} already linked "
-                                        f"to {primary_model.__class__.__name__}"
-                                    ),
-                                    status=False,
-                                )
-                            else:
-                                primary_model.agents.append(secondary_model)
-
-                    elif link_type == "agent_skill":
-                        primary_model = session.exec(select(Agent).where(Agent.id == primary_id)).first()
-                        secondary_model = session.exec(select(Skill).where(Skill.id == secondary_id)).first()
-                        if primary_model is None or secondary_model is None:
-                            status = False
-                            status_message = "One or both entity records do not exist."
-                        else:
-                            # check if the link already exists
-                            existing_link = session.exec(
-                                select(AgentSkillLink).where(
-                                    AgentSkillLink.agent_id == primary_id,
-                                    AgentSkillLink.skill_id == secondary_id,
-                                )
-                            ).first()
-                            if existing_link:
-                                return Response(
-                                    message=(
-                                        f"{secondary_model.__class__.__name__} already linked "
-                                        f"to {primary_model.__class__.__name__}"
-                                    ),
-                                    status=False,
-                                )
-                            else:
-                                primary_model.skills.append(secondary_model)
-                    elif link_type == "workflow_agent":
-                        primary_model = session.exec(select(Workflow).where(Workflow.id == primary_id)).first()
-                        secondary_model = session.exec(select(Agent).where(Agent.id == secondary_id)).first()
-                        if primary_model is None or secondary_model is None:
-                            status = False
-                            status_message = "One or both entity records do not exist."
-                        else:
-                            # check if the link already exists
-                            existing_link = session.exec(
-                                select(WorkflowAgentLink).where(
-                                    WorkflowAgentLink.workflow_id == primary_id,
-                                    WorkflowAgentLink.agent_id == secondary_id,
-                                    WorkflowAgentLink.agent_type == agent_type,
-                                    WorkflowAgentLink.sequence_id == sequence_id,
-                                )
-                            ).first()
-                            if existing_link:
-                                return Response(
-                                    message=(
-                                        f"{secondary_model.__class__.__name__} already linked "
-                                        f"to {primary_model.__class__.__name__}"
-                                    ),
-                                    status=False,
-                                )
-                            else:
-                                # primary_model.agents.append(secondary_model)
-                                workflow_agent_link = WorkflowAgentLink(
-                                    workflow_id=primary_id,
-                                    agent_id=secondary_id,
-                                    agent_type=agent_type,
-                                    sequence_id=sequence_id,
-                                )
-                                session.add(workflow_agent_link)
-                    # add and commit the link
-                    session.add(primary_model)
-                    session.commit()
-                    status_message = (
-                        f"{secondary_model.__class__.__name__} successfully linked "
-                        f"to {primary_model.__class__.__name__}"
-                    )
-
-                except Exception as e:
-                    session.rollback()
-                    logger.error("Error while linking: " + str(e))
-                    status = False
-                    status_message = f"Error while linking due to an exception: {e}"
-
-        response = Response(
-            message=status_message,
-            status=status,
-        )
-
-        return response
-
-    def unlink(
-        self,
-        link_type: str,
-        primary_id: int,
-        secondary_id: int,
-        agent_type: Optional[str] = None,
-        sequence_id: Optional[int] = 0,
-    ) -> Response:
-        """
-        Unlink two entities.
-
-        Args:
-            link_type (str): The type of link to remove, e.g., "agent_model".
-            primary_id (int): The identifier for the primary model.
-            secondary_id (int): The identifier for the secondary model.
-            agent_type (Optional[str]): The type of agent, e.g., "sender" or receiver.
-
-        Returns:
-            Response: The response of the unlinking operation, including success status and message.
-        """
-        status = True
-        status_message = ""
-        print("primary", primary_id, "secondary", secondary_id, "sequence", sequence_id, "agent_type", agent_type)
-
-        if link_type not in valid_link_types:
-            status = False
-            status_message = f"Invalid link type: {link_type}. Valid link types are: {valid_link_types}"
-            return Response(message=status_message, status=status)
-
-        with Session(self.engine) as session:
-            try:
-                if link_type == "agent_model":
-                    existing_link = session.exec(
-                        select(AgentModelLink).where(
-                            AgentModelLink.agent_id == primary_id,
-                            AgentModelLink.model_id == secondary_id,
-                        )
-                    ).first()
-                elif link_type == "agent_skill":
-                    existing_link = session.exec(
-                        select(AgentSkillLink).where(
-                            AgentSkillLink.agent_id == primary_id,
-                            AgentSkillLink.skill_id == secondary_id,
-                        )
-                    ).first()
-                elif link_type == "agent_agent":
-                    existing_link = session.exec(
-                        select(AgentLink).where(
-                            AgentLink.parent_id == primary_id,
-                            AgentLink.agent_id == secondary_id,
-                        )
-                    ).first()
-                elif link_type == "workflow_agent":
-                    existing_link = session.exec(
-                        select(WorkflowAgentLink).where(
-                            WorkflowAgentLink.workflow_id == primary_id,
-                            WorkflowAgentLink.agent_id == secondary_id,
-                            WorkflowAgentLink.agent_type == agent_type,
-                            WorkflowAgentLink.sequence_id == sequence_id,
-                        )
-                    ).first()
-
-                if existing_link:
-                    session.delete(existing_link)
-                    session.commit()
-                    status_message = "Link removed successfully."
-                else:
-                    status = False
-                    status_message = "Link does not exist."
-
-            except Exception as e:
-                session.rollback()
-                logger.error("Error while unlinking: " + str(e))
-                status = False
-                status_message = f"Error while unlinking due to an exception: {e}"
-
-        return Response(message=status_message, status=status)
diff --git a/python/packages/autogen-studio/autogenstudio/database/migrations/README b/python/packages/autogen-studio/autogenstudio/database/migrations/README
deleted file mode 100644
index 2500aa1bcf72..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/migrations/README
+++ /dev/null
@@ -1 +0,0 @@
-Generic single-database configuration.
diff --git a/python/packages/autogen-studio/autogenstudio/database/migrations/env.py b/python/packages/autogen-studio/autogenstudio/database/migrations/env.py
deleted file mode 100644
index 1431492ad910..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/migrations/env.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import os
-from logging.config import fileConfig
-
-from alembic import context
-from sqlalchemy import engine_from_config, pool
-from sqlmodel import SQLModel
-
-from autogenstudio.datamodel import *
-from autogenstudio.utils import get_db_uri
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-config.set_main_option("sqlalchemy.url", get_db_uri())
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = SQLModel.metadata
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode.
-
-    In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-    connectable = engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    with connectable.connect() as connection:
-        context.configure(connection=connection, target_metadata=target_metadata)
-
-        with context.begin_transaction():
-            context.run_migrations()
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()
diff --git a/python/packages/autogen-studio/autogenstudio/database/migrations/script.py.mako b/python/packages/autogen-studio/autogenstudio/database/migrations/script.py.mako
deleted file mode 100644
index 6ce3351093cf..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/migrations/script.py.mako
+++ /dev/null
@@ -1,27 +0,0 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-import sqlmodel
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision: str = ${repr(up_revision)}
-down_revision: Union[str, None] = ${repr(down_revision)}
-branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
-depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    ${downgrades if downgrades else "pass"}
diff --git a/python/packages/autogen-studio/autogenstudio/database/schema_manager.py b/python/packages/autogen-studio/autogenstudio/database/schema_manager.py
new file mode 100644
index 000000000000..450e0a5d76a3
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/database/schema_manager.py
@@ -0,0 +1,505 @@
+import os
+from pathlib import Path
+import shutil
+from typing import Optional, Tuple, List
+from loguru import logger
+from alembic import command
+from alembic.config import Config
+from alembic.runtime.migration import MigrationContext
+from alembic.script import ScriptDirectory
+from alembic.autogenerate import compare_metadata
+from sqlalchemy import Engine
+from sqlmodel import SQLModel
+
+
+class SchemaManager:
+    """
+    Manages database schema validation and migrations using Alembic.
+    Provides automatic schema validation, migrations, and safe upgrades.
+
+    Args:
+        engine: SQLAlchemy engine instance
+        auto_upgrade: Whether to automatically upgrade schema when differences found
+        init_mode: Controls initialization behavior:
+            - "none": No automatic initialization (raises error if not set up)
+            - "auto": Initialize if not present (default)
+            - "force": Always reinitialize, removing existing configuration
+    """
+
+    def __init__(
+        self,
+        engine: Engine,
+        auto_upgrade: bool = True,
+        init_mode: str = "auto"
+    ):
+        if init_mode not in ["none", "auto", "force"]:
+            raise ValueError("init_mode must be one of: none, auto, force")
+
+        self.engine = engine
+        self.auto_upgrade = auto_upgrade
+
+        # Set up paths relative to this file
+        self.base_dir = Path(__file__).parent
+        self.alembic_dir = self.base_dir / 'alembic'
+        self.alembic_ini_path = self.base_dir / 'alembic.ini'
+
+        # Handle initialization based on mode
+        if init_mode == "none":
+            self._validate_alembic_setup()
+        else:
+            self._ensure_alembic_setup(force=init_mode == "force")
+
+    def _cleanup_existing_alembic(self) -> None:
+        """
+        Safely removes existing Alembic configuration while preserving versions directory.
+        """
+        logger.info(
+            "Cleaning up existing Alembic configuration while preserving versions...")
+
+        # Create a backup of versions directory if it exists
+        if self.alembic_dir.exists() and (self.alembic_dir / 'versions').exists():
+            logger.info("Preserving existing versions directory")
+
+        # Remove alembic directory contents EXCEPT versions
+        if self.alembic_dir.exists():
+            for item in self.alembic_dir.iterdir():
+                if item.name != 'versions':
+                    try:
+                        if item.is_dir():
+                            shutil.rmtree(item)
+                            logger.info(f"Removed directory: {item}")
+                        else:
+                            item.unlink()
+                            logger.info(f"Removed file: {item}")
+                    except Exception as e:
+                        logger.error(f"Failed to remove {item}: {e}")
+
+        # Remove alembic.ini if it exists
+        if self.alembic_ini_path.exists():
+            try:
+                self.alembic_ini_path.unlink()
+                logger.info(
+                    f"Removed existing alembic.ini: {self.alembic_ini_path}")
+            except Exception as e:
+                logger.error(f"Failed to remove alembic.ini: {e}")
+
+    def _ensure_alembic_setup(self, *, force: bool = False) -> None:
+        """
+        Ensures Alembic is properly set up, initializing if necessary.
+
+        Args:
+            force: If True, removes existing configuration and reinitializes
+        """
+        try:
+            self._validate_alembic_setup()
+            if force:
+                logger.info(
+                    "Force initialization requested. Cleaning up existing configuration...")
+                self._cleanup_existing_alembic()
+                self._initialize_alembic()
+        except FileNotFoundError:
+            logger.info("Alembic configuration not found. Initializing...")
+            if self.alembic_dir.exists():
+                logger.warning(
+                    "Found existing alembic directory but missing configuration")
+                self._cleanup_existing_alembic()
+            self._initialize_alembic()
+            logger.info("Alembic initialization complete")
+
+    def _initialize_alembic(self) -> str:
+        """Initializes Alembic configuration in the local directory."""
+        logger.info("Initializing Alembic configuration...")
+
+        # Check if versions exists
+        has_versions = (self.alembic_dir / 'versions').exists()
+        logger.info(f"Existing versions directory found: {has_versions}")
+
+        # Create base directories
+        self.alembic_dir.mkdir(exist_ok=True)
+        if not has_versions:
+            (self.alembic_dir / 'versions').mkdir(exist_ok=True)
+
+        # Write alembic.ini
+        ini_content = self._generate_alembic_ini_content()
+        with open(self.alembic_ini_path, 'w') as f:
+            f.write(ini_content)
+        logger.info("Created alembic.ini")
+
+        if not has_versions:
+            # Only run init if no versions directory
+            config = self.get_alembic_config()
+            command.init(config, str(self.alembic_dir))
+            logger.info("Initialized new Alembic directory structure")
+        else:
+            # Create minimal env.py if it doesn't exist
+            env_path = self.alembic_dir / 'env.py'
+            if not env_path.exists():
+                self._create_minimal_env_py(env_path)
+                logger.info("Created minimal env.py")
+            else:
+                # Update existing env.py
+                self._update_env_py(env_path)
+                logger.info("Updated existing env.py")
+
+        logger.info(f"Alembic setup completed at {self.base_dir}")
+        return str(self.alembic_ini_path)
+
+    def _create_minimal_env_py(self, env_path: Path) -> None:
+        """Creates a minimal env.py file for Alembic."""
+        content = '''
+from logging.config import fileConfig
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+from alembic import context
+from sqlmodel import SQLModel
+
+config = context.config
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = SQLModel.metadata
+
+def run_migrations_offline() -> None:
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=True
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+def run_migrations_online() -> None:
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, 
+            target_metadata=target_metadata,
+            compare_type=True
+        )
+        with context.begin_transaction():
+            context.run_migrations()
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()'''
+
+        with open(env_path, 'w') as f:
+            f.write(content)
+
+    def _generate_alembic_ini_content(self) -> str:
+        """
+        Generates content for alembic.ini file.
+        """
+        return f"""
+[alembic]
+script_location = {self.alembic_dir}
+sqlalchemy.url = {self.engine.url}
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
+""".strip()
+
+    def _update_env_py(self, env_path: Path) -> None:
+        """
+        Updates the env.py file to use SQLModel metadata.
+        """
+        try:
+            with open(env_path, 'r') as f:
+                content = f.read()
+
+            # Add SQLModel import
+            if "from sqlmodel import SQLModel" not in content:
+                content = "from sqlmodel import SQLModel\n" + content
+
+            # Replace target_metadata
+            content = content.replace(
+                "target_metadata = None",
+                "target_metadata = SQLModel.metadata"
+            )
+
+            # Add compare_type=True to context.configure
+            if "context.configure(" in content and "compare_type=True" not in content:
+                content = content.replace(
+                    "context.configure(",
+                    "context.configure(compare_type=True,"
+                )
+
+            with open(env_path, 'w') as f:
+                f.write(content)
+
+            logger.info("Updated env.py with SQLModel metadata")
+        except Exception as e:
+            logger.error(f"Failed to update env.py: {e}")
+            raise
+
+    # Fixed: use keyword-only argument
+    def _ensure_alembic_setup(self, *, force: bool = False) -> None:
+        """
+        Ensures Alembic is properly set up, initializing if necessary.
+
+        Args:
+            force: If True, removes existing configuration and reinitializes
+        """
+        try:
+            self._validate_alembic_setup()
+            if force:
+                logger.info(
+                    "Force initialization requested. Cleaning up existing configuration...")
+                self._cleanup_existing_alembic()
+                self._initialize_alembic()
+        except FileNotFoundError:
+            logger.info("Alembic configuration not found. Initializing...")
+            if self.alembic_dir.exists():
+                logger.warning(
+                    "Found existing alembic directory but missing configuration")
+                self._cleanup_existing_alembic()
+            self._initialize_alembic()
+            logger.info("Alembic initialization complete")
+
+    def _validate_alembic_setup(self) -> None:
+        """Validates that Alembic is properly configured."""
+        if not self.alembic_ini_path.exists():
+            raise FileNotFoundError("Alembic configuration not found")
+
+    def get_alembic_config(self) -> Config:
+        """
+        Gets Alembic configuration.
+
+        Returns:
+            Config: Alembic Config object
+
+        Raises:
+            FileNotFoundError: If alembic.ini cannot be found
+        """
+        if not self.alembic_ini_path.exists():
+            raise FileNotFoundError("Could not find alembic.ini")
+
+        return Config(str(self.alembic_ini_path))
+
+    def get_current_revision(self) -> Optional[str]:
+        """
+        Gets the current database revision.
+
+        Returns:
+            str: Current revision string or None if no revision
+        """
+        with self.engine.connect() as conn:
+            context = MigrationContext.configure(conn)
+            return context.get_current_revision()
+
+    def get_head_revision(self) -> str:
+        """
+        Gets the latest available revision.
+
+        Returns:
+            str: Head revision string
+        """
+        config = self.get_alembic_config()
+        script = ScriptDirectory.from_config(config)
+        return script.get_current_head()
+
+    def get_schema_differences(self) -> List[tuple]:
+        """
+        Detects differences between current database and models.
+
+        Returns:
+            List[tuple]: List of differences found
+        """
+        with self.engine.connect() as conn:
+            context = MigrationContext.configure(conn)
+            diff = compare_metadata(context, SQLModel.metadata)
+            return list(diff)
+
+    def check_schema_status(self) -> Tuple[bool, str]:
+        """
+        Checks if database schema matches current models and migrations.
+
+        Returns:
+            Tuple[bool, str]: (needs_upgrade, status_message)
+        """
+        try:
+            current_rev = self.get_current_revision()
+            head_rev = self.get_head_revision()
+
+            if current_rev != head_rev:
+                return True, f"Database needs upgrade: {current_rev} -> {head_rev}"
+
+            differences = self.get_schema_differences()
+            if differences:
+                changes_desc = "\n".join(str(diff) for diff in differences)
+                return True, f"Unmigrated changes detected:\n{changes_desc}"
+
+            return False, "Database schema is up to date"
+
+        except Exception as e:
+            logger.error(f"Error checking schema status: {str(e)}")
+            return True, f"Error checking schema: {str(e)}"
+
+    def upgrade_schema(self, revision: str = "head") -> bool:
+        """
+        Upgrades database schema to specified revision.
+
+        Args:
+            revision: Target revision (default: "head")
+
+        Returns:
+            bool: True if upgrade successful
+        """
+        try:
+            config = self.get_alembic_config()
+            command.upgrade(config, revision)
+            logger.info(f"Schema upgraded successfully to {revision}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Schema upgrade failed: {str(e)}")
+            return False
+
+    def check_and_upgrade(self) -> Tuple[bool, str]:
+        """
+        Checks schema status and upgrades if necessary (and auto_upgrade is True).
+
+        Returns:
+            Tuple[bool, str]: (action_taken, status_message)
+        """
+        needs_upgrade, status = self.check_schema_status()
+
+        if needs_upgrade:
+            if self.auto_upgrade:
+                if self.upgrade_schema():
+                    return True, "Schema was automatically upgraded"
+                else:
+                    return False, "Automatic schema upgrade failed"
+            else:
+                return False, f"Schema needs upgrade but auto_upgrade is disabled. Status: {status}"
+
+        return False, status
+
+    def generate_revision(self, message: str = "auto") -> Optional[str]:
+        """
+        Generates new migration revision for current schema changes.
+
+        Args:
+            message: Revision message
+
+        Returns:
+            str: Revision ID if successful, None otherwise
+        """
+        try:
+            config = self.get_alembic_config()
+            command.revision(
+                config,
+                message=message,
+                autogenerate=True
+            )
+            return self.get_head_revision()
+
+        except Exception as e:
+            logger.error(f"Failed to generate revision: {str(e)}")
+            return None
+
+    def get_pending_migrations(self) -> List[str]:
+        """
+        Gets list of pending migrations that need to be applied.
+
+        Returns:
+            List[str]: List of pending migration revision IDs
+        """
+        config = self.get_alembic_config()
+        script = ScriptDirectory.from_config(config)
+
+        current = self.get_current_revision()
+        head = self.get_head_revision()
+
+        if current == head:
+            return []
+
+        pending = []
+        for rev in script.iterate_revisions(current, head):
+            pending.append(rev.revision)
+
+        return pending
+
+    def print_status(self) -> None:
+        """Prints current migration status information to logger."""
+        current = self.get_current_revision()
+        head = self.get_head_revision()
+        differences = self.get_schema_differences()
+        pending = self.get_pending_migrations()
+
+        logger.info("=== Database Schema Status ===")
+        logger.info(f"Current revision: {current}")
+        logger.info(f"Head revision: {head}")
+        logger.info(f"Pending migrations: {len(pending)}")
+        for rev in pending:
+            logger.info(f"  - {rev}")
+        logger.info(f"Unmigrated changes: {len(differences)}")
+        for diff in differences:
+            logger.info(f"  - {diff}")
+
+    def ensure_schema_up_to_date(self) -> bool:
+        """
+        Ensures the database schema is up to date, generating and applying migrations if needed.
+
+        Returns:
+            bool: True if schema is up to date or was successfully updated
+        """
+        try:
+            # Check for unmigrated changes
+            differences = self.get_schema_differences()
+            if differences:
+                # Generate new migration
+                revision = self.generate_revision("auto-generated")
+                if not revision:
+                    return False
+                logger.info(f"Generated new migration: {revision}")
+
+            # Apply any pending migrations
+            upgraded, status = self.check_and_upgrade()
+            if not upgraded and "needs upgrade" in status.lower():
+                return False
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to ensure schema is up to date: {e}")
+            return False
diff --git a/python/packages/autogen-studio/autogenstudio/database/utils.py b/python/packages/autogen-studio/autogenstudio/database/utils.py
deleted file mode 100644
index ac77a9161498..000000000000
--- a/python/packages/autogen-studio/autogenstudio/database/utils.py
+++ /dev/null
@@ -1,361 +0,0 @@
-# from .util import get_app_root
-import os
-import time
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from alembic import command, util
-from alembic.config import Config
-from loguru import logger
-
-# from ..utils.db_utils import get_db_uri
-from sqlmodel import Session, create_engine, text
-
-from autogen.agentchat import AssistantAgent
-
-from ..datamodel import (
-    Agent,
-    AgentConfig,
-    AgentType,
-    CodeExecutionConfigTypes,
-    Model,
-    Skill,
-    Workflow,
-    WorkflowAgentLink,
-    WorkFlowType,
-)
-
-
-def workflow_from_id(workflow_id: int, dbmanager: Any):
-    workflow = dbmanager.get(Workflow, filters={"id": workflow_id}).data
-    if not workflow or len(workflow) == 0:
-        raise ValueError("The specified workflow does not exist.")
-    workflow = workflow[0].model_dump(mode="json")
-    workflow_agent_links = dbmanager.get(WorkflowAgentLink, filters={"workflow_id": workflow_id}).data
-
-    def dump_agent(agent: Agent):
-        exclude = []
-        if agent.type != AgentType.groupchat:
-            exclude = [
-                "admin_name",
-                "messages",
-                "max_round",
-                "admin_name",
-                "speaker_selection_method",
-                "allow_repeat_speaker",
-            ]
-        return agent.model_dump(warnings=False, mode="json", exclude=exclude)
-
-    def get_agent(agent_id):
-        with Session(dbmanager.engine) as session:
-            agent: Agent = dbmanager.get_items(Agent, filters={"id": agent_id}, session=session).data[0]
-            agent_dict = dump_agent(agent)
-            agent_dict["skills"] = [Skill.model_validate(skill.model_dump(mode="json")) for skill in agent.skills]
-            model_exclude = [
-                "id",
-                "agent_id",
-                "created_at",
-                "updated_at",
-                "user_id",
-                "description",
-            ]
-            models = [model.model_dump(mode="json", exclude=model_exclude) for model in agent.models]
-            agent_dict["models"] = [model.model_dump(mode="json") for model in agent.models]
-
-            if len(models) > 0:
-                agent_dict["config"]["llm_config"] = agent_dict.get("config", {}).get("llm_config", {})
-                llm_config = agent_dict["config"]["llm_config"]
-                if llm_config:
-                    llm_config["config_list"] = models
-                agent_dict["config"]["llm_config"] = llm_config
-            agent_dict["agents"] = [get_agent(agent.id) for agent in agent.agents]
-            return agent_dict
-
-    agents = []
-    for link in workflow_agent_links:
-        agent_dict = get_agent(link.agent_id)
-        agents.append({"agent": agent_dict, "link": link.model_dump(mode="json")})
-        # workflow[str(link.agent_type.value)] = agent_dict
-    if workflow["type"] == WorkFlowType.sequential.value:
-        # sort agents by sequence_id in link
-        agents = sorted(agents, key=lambda x: x["link"]["sequence_id"])
-    workflow["agents"] = agents
-    return workflow
-
-
-def run_migration(engine_uri: str):
-    database_dir = Path(__file__).parent
-    script_location = database_dir / "migrations"
-
-    engine = create_engine(engine_uri)
-    buffer = open(script_location / "alembic.log", "w")
-    alembic_cfg = Config(stdout=buffer)
-    alembic_cfg.set_main_option("script_location", str(script_location))
-    alembic_cfg.set_main_option("sqlalchemy.url", engine_uri)
-
-    print(f"Running migrations with engine_uri: {engine_uri}")
-
-    should_initialize_alembic = False
-    with Session(engine) as session:
-        try:
-            session.exec(text("SELECT * FROM alembic_version"))
-        except Exception:
-            logger.info("Alembic not initialized")
-            should_initialize_alembic = True
-        else:
-            logger.info("Alembic already initialized")
-
-    if should_initialize_alembic:
-        try:
-            logger.info("Initializing alembic")
-            command.ensure_version(alembic_cfg)
-            command.upgrade(alembic_cfg, "head")
-            logger.info("Alembic initialized")
-        except Exception as exc:
-            logger.error(f"Error initializing alembic: {exc}")
-            raise RuntimeError("Error initializing alembic") from exc
-
-    logger.info(f"Running DB migrations in {script_location}")
-
-    try:
-        buffer.write(f"{datetime.now().isoformat()}: Checking migrations\n")
-        command.check(alembic_cfg)
-    except Exception as exc:
-        if isinstance(exc, (util.exc.CommandError, util.exc.AutogenerateDiffsDetected)):
-            try:
-                command.upgrade(alembic_cfg, "head")
-                time.sleep(3)
-            except Exception as exc:
-                logger.error(f"Error running migrations: {exc}")
-
-    try:
-        buffer.write(f"{datetime.now().isoformat()}: Checking migrations\n")
-        command.check(alembic_cfg)
-    except util.exc.AutogenerateDiffsDetected as exc:
-        logger.info(f"AutogenerateDiffsDetected: {exc}")
-        # raise RuntimeError(
-        #     f"There's a mismatch between the models and the database.\n{exc}")
-    except util.exc.CommandError as exc:
-        logger.error(f"CommandError: {exc}")
-        # raise RuntimeError(f"Error running migrations: {exc}")
-
-
-def init_db_samples(dbmanager: Any):
-    workflows = dbmanager.get(Workflow).data
-    workflow_names = [w.name for w in workflows]
-    if "Default Workflow" in workflow_names and "Travel Planning Workflow" in workflow_names:
-        logger.info("Database already initialized with Default and Travel Planning Workflows")
-        return
-    logger.info("Initializing database with Default and Travel Planning Workflows")
-
-    # models
-    google_gemini_model = Model(
-        model="gemini-1.5-pro-latest",
-        description="Google's Gemini model",
-        user_id="guestuser@gmail.com",
-        api_type="google",
-    )
-    azure_model = Model(
-        model="gpt4-turbo",
-        description="Azure OpenAI  model",
-        user_id="guestuser@gmail.com",
-        api_type="azure",
-        base_url="https://api.your azureendpoint.com/v1",
-    )
-    zephyr_model = Model(
-        model="zephyr",
-        description="Local Huggingface Zephyr model via vLLM, LMStudio or Ollama",
-        base_url="http://localhost:1234/v1",
-        user_id="guestuser@gmail.com",
-        api_type="open_ai",
-    )
-
-    gpt_4_model = Model(
-        model="gpt-4-1106-preview", description="OpenAI GPT-4 model", user_id="guestuser@gmail.com", api_type="open_ai"
-    )
-
-    anthropic_sonnet_model = Model(
-        model="claude-3-5-sonnet-20240620",
-        description="Anthropic's Claude 3.5 Sonnet model",
-        api_type="anthropic",
-        user_id="guestuser@gmail.com",
-    )
-
-    # skills
-    generate_pdf_skill = Skill(
-        name="generate_and_save_pdf",
-        description="Generate and save a pdf file based on the provided input sections.",
-        user_id="guestuser@gmail.com",
-        libraries=["requests", "fpdf", "PIL"],
-        content='import uuid\nimport requests\nfrom fpdf import FPDF\nfrom typing import List, Dict, Optional\nfrom pathlib import Path\nfrom PIL import Image, ImageDraw, ImageOps\nfrom io import BytesIO\n\ndef generate_and_save_pdf(\n    sections: List[Dict[str, Optional[str]]], \n    output_file: str = "report.pdf", \n    report_title: str = "PDF Report"\n) -> None:\n    """\n    Function to generate a beautiful PDF report in A4 paper format. \n\n    :param sections: A list of sections where each section is represented by a dictionary containing:\n                     - title: The title of the section.\n                     - level: The heading level (e.g., "title", "h1", "h2").\n                     - content: The content or body text of the section.\n                     - image: (Optional) The URL or local path to the image.\n    :param output_file: The name of the output PDF file. (default is "report.pdf")\n    :param report_title: The title of the report. (default is "PDF Report")\n    :return: None\n    """\n\n    def get_image(image_url_or_path):\n        if image_url_or_path.startswith("http://") or image_url_or_path.startswith("https://"):\n            response = requests.get(image_url_or_path)\n            if response.status_code == 200:\n                return BytesIO(response.content)\n        elif Path(image_url_or_path).is_file():\n            return open(image_url_or_path, \'rb\')\n        return None\n\n    def add_rounded_corners(img, radius=6):\n        mask = Image.new(\'L\', img.size, 0)\n        draw = ImageDraw.Draw(mask)\n        draw.rounded_rectangle([(0, 0), img.size], radius, fill=255)\n        img = ImageOps.fit(img, mask.size, centering=(0.5, 0.5))\n        img.putalpha(mask)\n        return img\n\n    class PDF(FPDF):\n        def header(self):\n            self.set_font("Arial", "B", 12)\n            self.cell(0, 10, report_title, 0, 1, "C")\n            \n        def chapter_title(self, txt): \n            self.set_font("Arial", "B", 12)\n            self.cell(0, 10, txt, 0, 1, "L")\n            self.ln(2)\n        \n        def chapter_body(self, body):\n            self.set_font("Arial", "", 12)\n            self.multi_cell(0, 10, body)\n            self.ln()\n\n        def add_image(self, img_data):\n            img = Image.open(img_data)\n            img = add_rounded_corners(img)\n            img_path = Path(f"temp_{uuid.uuid4().hex}.png")\n            img.save(img_path, format="PNG")\n            self.image(str(img_path), x=None, y=None, w=190 if img.width > 190 else img.width)\n            self.ln(10)\n            img_path.unlink()\n\n    pdf = PDF()\n    pdf.add_page()\n    font_size = {"title": 16, "h1": 14, "h2": 12, "body": 12}\n\n    for section in sections:\n        title, level, content, image = section.get("title", ""), section.get("level", "h1"), section.get("content", ""), section.get("image")\n        pdf.set_font("Arial", "B" if level in font_size else "", font_size.get(level, font_size["body"]))\n        pdf.chapter_title(title)\n\n        if content: pdf.chapter_body(content)\n        if image:\n            img_data = get_image(image)\n            if img_data:\n                pdf.add_image(img_data)\n                if isinstance(img_data, BytesIO):\n                    img_data.close()\n\n    pdf.output(output_file)\n    print(f"PDF report saved as {output_file}")\n\n# # Example usage\n# sections = [\n#     {\n#         "title": "Introduction - Early Life",\n#         "level": "h1",\n#         "image": "https://picsum.photos/536/354",\n#         "content": ("Marie Curie was born on 7 November 1867 in Warsaw, Poland. "\n#                     "She was the youngest of five children. Both of her parents were teachers. "\n#                     "Her father was a math and physics instructor, and her mother was the head of a private school. "\n#                     "Marie\'s curiosity and brilliance were evident from an early age."),\n#     },\n#     {\n#         "title": "Academic Accomplishments",\n#         "level": "h2",\n#         "content": ("Despite many obstacles, Marie Curie earned degrees in physics and mathematics from the University of Paris. "\n#                     "She conducted groundbreaking research on radioactivity, becoming the first woman to win a Nobel Prize. "\n#                     "Her achievements paved the way for future generations of scientists, particularly women in STEM fields."),\n#     },\n#     {\n#         "title": "Major Discoveries",\n#         "level": "h2",\n#         "image": "https://picsum.photos/536/354",\n#         "content": ("One of Marie Curie\'s most notable discoveries was that of radium and polonium, two radioactive elements. "\n#                     "Her meticulous work not only advanced scientific understanding but also had practical applications in medicine and industry."),\n#     },\n#     {\n#         "title": "Conclusion - Legacy",\n#         "level": "h1",\n#         "content": ("Marie Curie\'s legacy lives on through her contributions to science, her role as a trailblazer for women in STEM, "\n#                     "and the ongoing impact of her discoveries on modern medicine and technology. "\n#                     "Her life and work remain an inspiration to many, demonstrating the power of perseverance and intellectual curiosity."),\n#     },\n# ]\n\n# generate_and_save_pdf_report(sections, "my_report.pdf", "The Life of Marie Curie")',
-    )
-    generate_image_skill = Skill(
-        name="generate_and_save_images",
-        secrets=[{"secret": "OPENAI_API_KEY", "value": None}],
-        libraries=["openai"],
-        description="Generate and save images based on a user's query.",
-        content='\nfrom typing import List\nimport uuid\nimport requests  # to perform HTTP requests\nfrom pathlib import Path\n\nfrom openai import OpenAI\n\n\ndef generate_and_save_images(query: str, image_size: str = "1024x1024") -> List[str]:\n    """\n    Function to paint, draw or illustrate images based on the users query or request. Generates images from a given query using OpenAI\'s DALL-E model and saves them to disk.  Use the code below anytime there is a request to create an image.\n\n    :param query: A natural language description of the image to be generated.\n    :param image_size: The size of the image to be generated. (default is "1024x1024")\n    :return: A list of filenames for the saved images.\n    """\n\n    client = OpenAI()  # Initialize the OpenAI client\n    response = client.images.generate(model="dall-e-3", prompt=query, n=1, size=image_size)  # Generate images\n\n    # List to store the file names of saved images\n    saved_files = []\n\n    # Check if the response is successful\n    if response.data:\n        for image_data in response.data:\n            # Generate a random UUID as the file name\n            file_name = str(uuid.uuid4()) + ".png"  # Assuming the image is a PNG\n            file_path = Path(file_name)\n\n            img_url = image_data.url\n            img_response = requests.get(img_url)\n            if img_response.status_code == 200:\n                # Write the binary content to a file\n                with open(file_path, "wb") as img_file:\n                    img_file.write(img_response.content)\n                    print(f"Image saved to {file_path}")\n                    saved_files.append(str(file_path))\n            else:\n                print(f"Failed to download the image from {img_url}")\n    else:\n        print("No image data found in the response!")\n\n    # Return the list of saved files\n    return saved_files\n\n\n# Example usage of the function:\n# generate_and_save_images("A cute baby sea otter")\n',
-        user_id="guestuser@gmail.com",
-    )
-
-    # agents
-
-    planner_assistant_config = AgentConfig(
-        name="planner_assistant",
-        description="Assistant Agent",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message="You are a helpful assistant that can suggest a travel plan for a user and utilize any context information provided. You are the primary cordinator who will receive suggestions or advice from other agents (local_assistant, language_assistant). You must ensure that the finally plan integrates the suggestions from other agents or team members. YOUR FINAL RESPONSE MUST BE THE COMPLETE PLAN. When the plan is complete and all perspectives are integrated, you can respond with TERMINATE.",
-        code_execution_config=CodeExecutionConfigTypes.none,
-        llm_config={},
-    )
-    planner_assistant = Agent(
-        user_id="guestuser@gmail.com",
-        type=AgentType.assistant,
-        config=planner_assistant_config.model_dump(mode="json"),
-    )
-
-    local_assistant_config = AgentConfig(
-        name="local_assistant",
-        description="Local Assistant Agent",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message="You are a local assistant that can suggest local activities or places to visit for a user and can utilize any context information provided. You can suggest local activities, places to visit, restaurants to eat at, etc. You can also provide information about the weather, local events, etc. You can provide information about the local area, but you cannot suggest a complete travel plan. You can only provide information about the local area.",
-        code_execution_config=CodeExecutionConfigTypes.none,
-        llm_config={},
-    )
-    local_assistant = Agent(
-        user_id="guestuser@gmail.com", type=AgentType.assistant, config=local_assistant_config.model_dump(mode="json")
-    )
-
-    language_assistant_config = AgentConfig(
-        name="language_assistant",
-        description="Language Assistant Agent",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message="You are a helpful assistant that can review travel plans, providing feedback on important/critical tips about how best to address language or communication challenges for the given destination. If the plan already includes language tips, you can mention that the plan is satisfactory, with rationale.",
-        code_execution_config=CodeExecutionConfigTypes.none,
-        llm_config={},
-    )
-    language_assistant = Agent(
-        user_id="guestuser@gmail.com",
-        type=AgentType.assistant,
-        config=language_assistant_config.model_dump(mode="json"),
-    )
-
-    # group chat agent
-    travel_groupchat_config = AgentConfig(
-        name="travel_groupchat",
-        admin_name="groupchat",
-        description="Group Chat Agent Configuration",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message="You are a group chat manager",
-        code_execution_config=CodeExecutionConfigTypes.none,
-        default_auto_reply="TERMINATE",
-        llm_config={},
-        speaker_selection_method="auto",
-    )
-    travel_groupchat_agent = Agent(
-        user_id="guestuser@gmail.com", type=AgentType.groupchat, config=travel_groupchat_config.model_dump(mode="json")
-    )
-
-    user_proxy_config = AgentConfig(
-        name="user_proxy",
-        description="User Proxy Agent Configuration",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message="You are a helpful assistant",
-        code_execution_config=CodeExecutionConfigTypes.local,
-        default_auto_reply="TERMINATE",
-        llm_config=False,
-    )
-    user_proxy = Agent(
-        user_id="guestuser@gmail.com", type=AgentType.userproxy, config=user_proxy_config.model_dump(mode="json")
-    )
-
-    default_assistant_config = AgentConfig(
-        name="default_assistant",
-        description="Assistant Agent",
-        human_input_mode="NEVER",
-        max_consecutive_auto_reply=25,
-        system_message=AssistantAgent.DEFAULT_SYSTEM_MESSAGE,
-        code_execution_config=CodeExecutionConfigTypes.none,
-        llm_config={},
-    )
-    default_assistant = Agent(
-        user_id="guestuser@gmail.com", type=AgentType.assistant, config=default_assistant_config.model_dump(mode="json")
-    )
-
-    # workflows
-    travel_workflow = Workflow(
-        name="Travel Planning Workflow",
-        description="Travel workflow",
-        user_id="guestuser@gmail.com",
-        sample_tasks=["Plan a 3 day trip to Hawaii Islands.", "Plan an eventful and exciting trip to  Uzbeksitan."],
-    )
-    default_workflow = Workflow(
-        name="Default Workflow",
-        description="Default workflow",
-        user_id="guestuser@gmail.com",
-        sample_tasks=[
-            "paint a picture of a glass of ethiopian coffee, freshly brewed in a tall glass cup, on a table right in front of a lush green forest scenery",
-            "Plot the stock price of NVIDIA YTD.",
-        ],
-    )
-
-    with Session(dbmanager.engine) as session:
-        session.add(zephyr_model)
-        session.add(google_gemini_model)
-        session.add(azure_model)
-        session.add(gpt_4_model)
-        session.add(anthropic_sonnet_model)
-        session.add(generate_image_skill)
-        session.add(generate_pdf_skill)
-        session.add(user_proxy)
-        session.add(default_assistant)
-        session.add(travel_groupchat_agent)
-        session.add(planner_assistant)
-        session.add(local_assistant)
-        session.add(language_assistant)
-
-        session.add(travel_workflow)
-        session.add(default_workflow)
-        session.commit()
-
-        dbmanager.link(link_type="agent_model", primary_id=default_assistant.id, secondary_id=gpt_4_model.id)
-        dbmanager.link(link_type="agent_skill", primary_id=default_assistant.id, secondary_id=generate_image_skill.id)
-        dbmanager.link(
-            link_type="workflow_agent", primary_id=default_workflow.id, secondary_id=user_proxy.id, agent_type="sender"
-        )
-        dbmanager.link(
-            link_type="workflow_agent",
-            primary_id=default_workflow.id,
-            secondary_id=default_assistant.id,
-            agent_type="receiver",
-        )
-
-        # link agents to travel groupchat agent
-
-        dbmanager.link(link_type="agent_agent", primary_id=travel_groupchat_agent.id, secondary_id=planner_assistant.id)
-        dbmanager.link(link_type="agent_agent", primary_id=travel_groupchat_agent.id, secondary_id=local_assistant.id)
-        dbmanager.link(
-            link_type="agent_agent", primary_id=travel_groupchat_agent.id, secondary_id=language_assistant.id
-        )
-        dbmanager.link(link_type="agent_agent", primary_id=travel_groupchat_agent.id, secondary_id=user_proxy.id)
-        dbmanager.link(link_type="agent_model", primary_id=travel_groupchat_agent.id, secondary_id=gpt_4_model.id)
-        dbmanager.link(link_type="agent_model", primary_id=planner_assistant.id, secondary_id=gpt_4_model.id)
-        dbmanager.link(link_type="agent_model", primary_id=local_assistant.id, secondary_id=gpt_4_model.id)
-        dbmanager.link(link_type="agent_model", primary_id=language_assistant.id, secondary_id=gpt_4_model.id)
-
-        dbmanager.link(
-            link_type="workflow_agent", primary_id=travel_workflow.id, secondary_id=user_proxy.id, agent_type="sender"
-        )
-        dbmanager.link(
-            link_type="workflow_agent",
-            primary_id=travel_workflow.id,
-            secondary_id=travel_groupchat_agent.id,
-            agent_type="receiver",
-        )
-        logger.info("Successfully initialized database with Default and Travel Planning Workflows")
diff --git a/python/packages/autogen-studio/autogenstudio/datamodel.py b/python/packages/autogen-studio/autogenstudio/datamodel.py
deleted file mode 100644
index ee48818d599f..000000000000
--- a/python/packages/autogen-studio/autogenstudio/datamodel.py
+++ /dev/null
@@ -1,297 +0,0 @@
-from datetime import datetime
-from enum import Enum
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
-
-from sqlalchemy import ForeignKey, Integer, orm
-from sqlmodel import (
-    JSON,
-    Column,
-    DateTime,
-    Field,
-    Relationship,
-    SQLModel,
-    func,
-)
-from sqlmodel import (
-    Enum as SqlEnum,
-)
-
-# added for python3.11 and sqlmodel 0.0.22 incompatibility
-if hasattr(SQLModel, "model_config"):
-    SQLModel.model_config["protected_namespaces"] = ()
-elif hasattr(SQLModel, "Config"):
-
-    class CustomSQLModel(SQLModel):
-        class Config:
-            protected_namespaces = ()
-
-    SQLModel = CustomSQLModel
-else:
-    print("Warning: Unable to set protected_namespaces.")
-
-# pylint: disable=protected-access
-
-
-class MessageMeta(SQLModel, table=False):
-    task: Optional[str] = None
-    messages: Optional[List[Dict[str, Any]]] = None
-    summary_method: Optional[str] = "last"
-    files: Optional[List[dict]] = None
-    time: Optional[datetime] = None
-    log: Optional[List[dict]] = None
-    usage: Optional[List[dict]] = None
-
-
-class Message(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    role: str
-    content: str
-    session_id: Optional[int] = Field(
-        default=None, sa_column=Column(Integer, ForeignKey("session.id", ondelete="CASCADE"))
-    )
-    connection_id: Optional[str] = None
-    meta: Optional[Union[MessageMeta, dict]] = Field(default={}, sa_column=Column(JSON))
-
-
-class Session(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    workflow_id: Optional[int] = Field(default=None, foreign_key="workflow.id")
-    name: Optional[str] = None
-    description: Optional[str] = None
-
-
-class AgentSkillLink(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    agent_id: int = Field(default=None, primary_key=True, foreign_key="agent.id")
-    skill_id: int = Field(default=None, primary_key=True, foreign_key="skill.id")
-
-
-class AgentModelLink(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    agent_id: int = Field(default=None, primary_key=True, foreign_key="agent.id")
-    model_id: int = Field(default=None, primary_key=True, foreign_key="model.id")
-
-
-class Skill(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    version: Optional[str] = "0.0.1"
-    name: str
-    content: str
-    description: Optional[str] = None
-    secrets: Optional[List[dict]] = Field(default_factory=list, sa_column=Column(JSON))
-    libraries: Optional[List[str]] = Field(default_factory=list, sa_column=Column(JSON))
-    agents: List["Agent"] = Relationship(back_populates="skills", link_model=AgentSkillLink)
-
-
-class LLMConfig(SQLModel, table=False):
-    """Data model for LLM Config for AutoGen"""
-
-    config_list: List[Any] = Field(default_factory=list)
-    temperature: float = 0
-    cache_seed: Optional[Union[int, None]] = None
-    timeout: Optional[int] = None
-    max_tokens: Optional[int] = 2048
-    extra_body: Optional[dict] = None
-
-
-class ModelTypes(str, Enum):
-    openai = "open_ai"
-    cerebras = "cerebras"
-    google = "google"
-    azure = "azure"
-    anthropic = "anthropic"
-    mistral = "mistral"
-    together = "together"
-    groq = "groq"
-
-
-class Model(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    version: Optional[str] = "0.0.1"
-    model: str
-    api_key: Optional[str] = None
-    base_url: Optional[str] = None
-    api_type: ModelTypes = Field(default=ModelTypes.openai, sa_column=Column(SqlEnum(ModelTypes)))
-    api_version: Optional[str] = None
-    description: Optional[str] = None
-    agents: List["Agent"] = Relationship(back_populates="models", link_model=AgentModelLink)
-
-
-class CodeExecutionConfigTypes(str, Enum):
-    local = "local"
-    docker = "docker"
-    none = "none"
-
-
-class AgentConfig(SQLModel, table=False):
-    name: Optional[str] = None
-    human_input_mode: str = "NEVER"
-    max_consecutive_auto_reply: int = 10
-    system_message: Optional[str] = None
-    is_termination_msg: Optional[Union[bool, str, Callable]] = None
-    code_execution_config: CodeExecutionConfigTypes = Field(
-        default=CodeExecutionConfigTypes.local, sa_column=Column(SqlEnum(CodeExecutionConfigTypes))
-    )
-    default_auto_reply: Optional[str] = ""
-    description: Optional[str] = None
-    llm_config: Optional[Union[LLMConfig, bool]] = Field(default=False, sa_column=Column(JSON))
-
-    admin_name: Optional[str] = "Admin"
-    messages: Optional[List[Dict]] = Field(default_factory=list)
-    max_round: Optional[int] = 100
-    speaker_selection_method: Optional[str] = "auto"
-    allow_repeat_speaker: Optional[Union[bool, List["AgentConfig"]]] = True
-
-
-class AgentType(str, Enum):
-    assistant = "assistant"
-    userproxy = "userproxy"
-    groupchat = "groupchat"
-
-
-class WorkflowAgentType(str, Enum):
-    sender = "sender"
-    receiver = "receiver"
-    planner = "planner"
-    sequential = "sequential"
-
-
-class WorkflowAgentLink(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    workflow_id: int = Field(default=None, primary_key=True, foreign_key="workflow.id")
-    agent_id: int = Field(default=None, primary_key=True, foreign_key="agent.id")
-    agent_type: WorkflowAgentType = Field(
-        default=WorkflowAgentType.sender,
-        sa_column=Column(SqlEnum(WorkflowAgentType), primary_key=True),
-    )
-    sequence_id: Optional[int] = Field(default=0, primary_key=True)
-
-
-class AgentLink(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    parent_id: Optional[int] = Field(default=None, foreign_key="agent.id", primary_key=True)
-    agent_id: Optional[int] = Field(default=None, foreign_key="agent.id", primary_key=True)
-
-
-class Agent(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    version: Optional[str] = "0.0.1"
-    type: AgentType = Field(default=AgentType.assistant, sa_column=Column(SqlEnum(AgentType)))
-    config: Union[AgentConfig, dict] = Field(default_factory=AgentConfig, sa_column=Column(JSON))
-    skills: List[Skill] = Relationship(back_populates="agents", link_model=AgentSkillLink)
-    models: List[Model] = Relationship(back_populates="agents", link_model=AgentModelLink)
-    workflows: List["Workflow"] = Relationship(link_model=WorkflowAgentLink, back_populates="agents")
-    parents: List["Agent"] = Relationship(
-        back_populates="agents",
-        link_model=AgentLink,
-        sa_relationship_kwargs=dict(
-            primaryjoin="Agent.id==AgentLink.agent_id",
-            secondaryjoin="Agent.id==AgentLink.parent_id",
-        ),
-    )
-    agents: List["Agent"] = Relationship(
-        back_populates="parents",
-        link_model=AgentLink,
-        sa_relationship_kwargs=dict(
-            primaryjoin="Agent.id==AgentLink.parent_id",
-            secondaryjoin="Agent.id==AgentLink.agent_id",
-        ),
-    )
-    task_instruction: Optional[str] = None
-
-
-class WorkFlowType(str, Enum):
-    autonomous = "autonomous"
-    sequential = "sequential"
-
-
-class WorkFlowSummaryMethod(str, Enum):
-    last = "last"
-    none = "none"
-    llm = "llm"
-
-
-class Workflow(SQLModel, table=True):
-    __table_args__ = {"sqlite_autoincrement": True}
-    id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
-    )  # pylint: disable=not-callable
-    updated_at: datetime = Field(
-        default_factory=datetime.now,
-        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
-    )  # pylint: disable=not-callable
-    user_id: Optional[str] = None
-    version: Optional[str] = "0.0.1"
-    name: str
-    description: str
-    agents: List[Agent] = Relationship(back_populates="workflows", link_model=WorkflowAgentLink)
-    type: WorkFlowType = Field(default=WorkFlowType.autonomous, sa_column=Column(SqlEnum(WorkFlowType)))
-    summary_method: Optional[WorkFlowSummaryMethod] = Field(
-        default=WorkFlowSummaryMethod.last,
-        sa_column=Column(SqlEnum(WorkFlowSummaryMethod)),
-    )
-    sample_tasks: Optional[List[str]] = Field(default_factory=list, sa_column=Column(JSON))
-
-
-class Response(SQLModel):
-    message: str
-    status: bool
-    data: Optional[Any] = None
-
-
-class SocketMessage(SQLModel, table=False):
-    connection_id: str
-    data: Dict[str, Any]
-    type: str
diff --git a/python/packages/autogen-studio/autogenstudio/datamodel/__init__.py b/python/packages/autogen-studio/autogenstudio/datamodel/__init__.py
new file mode 100644
index 000000000000..6b7b4098df4b
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/datamodel/__init__.py
@@ -0,0 +1,2 @@
+from .db import *
+from .types import *
diff --git a/python/packages/autogen-studio/autogenstudio/datamodel/db.py b/python/packages/autogen-studio/autogenstudio/datamodel/db.py
new file mode 100644
index 000000000000..2f8210029a9a
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/datamodel/db.py
@@ -0,0 +1,282 @@
+# defines how core data types in autogenstudio are serialized and stored in the database
+
+from datetime import datetime
+from enum import Enum
+from typing import List, Optional, Union, Tuple, Type
+from sqlalchemy import ForeignKey, Integer, UniqueConstraint
+from sqlmodel import JSON, Column,  DateTime, Field, SQLModel, func, Relationship,   SQLModel
+from uuid import UUID, uuid4
+
+from .types import ToolConfig, ModelConfig, AgentConfig, TeamConfig, MessageConfig, MessageMeta
+
+# added for python3.11 and sqlmodel 0.0.22 incompatibility
+if hasattr(SQLModel, "model_config"):
+    SQLModel.model_config["protected_namespaces"] = ()
+elif hasattr(SQLModel, "Config"):
+    class CustomSQLModel(SQLModel):
+        class Config:
+            protected_namespaces = ()
+
+    SQLModel = CustomSQLModel
+else:
+    print("Warning: Unable to set protected_namespaces.")
+
+# pylint: disable=protected-access
+
+
+class ComponentTypes(Enum):
+    TEAM = "team"
+    AGENT = "agent"
+    MODEL = "model"
+    TOOL = "tool"
+
+    @property
+    def model_class(self) -> Type[SQLModel]:
+        return {
+            ComponentTypes.TEAM: Team,
+            ComponentTypes.AGENT: Agent,
+            ComponentTypes.MODEL: Model,
+            ComponentTypes.TOOL: Tool
+        }[self]
+
+
+class LinkTypes(Enum):
+    AGENT_MODEL = "agent_model"
+    AGENT_TOOL = "agent_tool"
+    TEAM_AGENT = "team_agent"
+
+    @property
+    # type: ignore
+    def link_config(self) -> Tuple[Type[SQLModel], Type[SQLModel], Type[SQLModel]]:
+        return {
+            LinkTypes.AGENT_MODEL: (Agent, Model, AgentModelLink),
+            LinkTypes.AGENT_TOOL: (Agent, Tool, AgentToolLink),
+            LinkTypes.TEAM_AGENT: (Team, Agent, TeamAgentLink)
+        }[self]
+
+    @property
+    def primary_class(self) -> Type[SQLModel]:  # type: ignore
+        return self.link_config[0]
+
+    @property
+    def secondary_class(self) -> Type[SQLModel]:  # type: ignore
+        return self.link_config[1]
+
+    @property
+    def link_table(self) -> Type[SQLModel]:  # type: ignore
+        return self.link_config[2]
+
+
+# link models
+class AgentToolLink(SQLModel, table=True):
+    __table_args__ = (
+        UniqueConstraint('agent_id', 'sequence',
+                         name='unique_agent_tool_sequence'),
+        {'sqlite_autoincrement': True}
+    )
+    agent_id: int = Field(default=None, primary_key=True,
+                          foreign_key="agent.id")
+    tool_id: int = Field(default=None, primary_key=True, foreign_key="tool.id")
+    sequence: Optional[int] = Field(default=0, primary_key=True)
+
+
+class AgentModelLink(SQLModel, table=True):
+    __table_args__ = (
+        UniqueConstraint('agent_id', 'sequence',
+                         name='unique_agent_tool_sequence'),
+        {'sqlite_autoincrement': True}
+    )
+    agent_id: int = Field(default=None, primary_key=True,
+                          foreign_key="agent.id")
+    model_id: int = Field(default=None, primary_key=True,
+                          foreign_key="model.id")
+    sequence: Optional[int] = Field(default=0, primary_key=True)
+
+
+class TeamAgentLink(SQLModel, table=True):
+    __table_args__ = (
+        UniqueConstraint('agent_id', 'sequence',
+                         name='unique_agent_tool_sequence'),
+        {'sqlite_autoincrement': True}
+    )
+    team_id: int = Field(default=None, primary_key=True, foreign_key="team.id")
+    agent_id: int = Field(default=None, primary_key=True,
+                          foreign_key="agent.id")
+    sequence: Optional[int] = Field(default=0, primary_key=True)
+
+# database models
+
+
+class Tool(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    config: Union[ToolConfig, dict] = Field(
+        default_factory=ToolConfig, sa_column=Column(JSON))
+    agents: List["Agent"] = Relationship(
+        back_populates="tools", link_model=AgentToolLink)
+
+
+class Model(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    config: Union[ModelConfig, dict] = Field(
+        default_factory=ModelConfig, sa_column=Column(JSON))
+    agents: List["Agent"] = Relationship(
+        back_populates="models", link_model=AgentModelLink)
+
+
+class Team(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    config: Union[TeamConfig, dict] = Field(
+        default_factory=TeamConfig, sa_column=Column(JSON))
+    agents: List["Agent"] = Relationship(
+        back_populates="teams", link_model=TeamAgentLink)
+
+
+class Agent(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    config: Union[AgentConfig, dict] = Field(
+        default_factory=AgentConfig, sa_column=Column(JSON))
+    tools: List[Tool] = Relationship(
+        back_populates="agents", link_model=AgentToolLink)
+    models: List[Model] = Relationship(
+        back_populates="agents", link_model=AgentModelLink)
+    teams: List[Team] = Relationship(
+        back_populates="agents", link_model=TeamAgentLink)
+
+
+class Message(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    config: Union[MessageConfig, dict] = Field(
+        default_factory=MessageConfig, sa_column=Column(JSON))
+    session_id: Optional[int] = Field(
+        default=None, sa_column=Column(Integer, ForeignKey("session.id", ondelete="CASCADE"))
+    )
+    run_id: Optional[UUID] = Field(
+        default=None, foreign_key="run.id"
+    )
+
+    message_meta: Optional[Union[MessageMeta, dict]] = Field(
+        default={}, sa_column=Column(JSON))
+
+
+class Session(SQLModel, table=True):
+    __table_args__ = {"sqlite_autoincrement": True}
+    id: Optional[int] = Field(default=None, primary_key=True)
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now()),
+    )  # pylint: disable=not-callable
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now()),
+    )  # pylint: disable=not-callable
+    user_id: Optional[str] = None
+    version: Optional[str] = "0.0.1"
+    team_id: Optional[int] = Field(
+        default=None, sa_column=Column(Integer, ForeignKey("team.id", ondelete="CASCADE"))
+    )
+    name: Optional[str] = None
+
+
+class RunStatus(str, Enum):
+    CREATED = "created"
+    ACTIVE = "active"
+    COMPLETE = "complete"
+    ERROR = "error"
+    STOPPED = "stopped"
+
+
+class Run(SQLModel, table=True):
+    """Represents a single execution run within a session"""
+    __table_args__ = {"sqlite_autoincrement": True}
+
+    # Primary key using UUID
+    id: UUID = Field(
+        default_factory=uuid4,
+        primary_key=True,
+        index=True
+    )
+
+    # Timestamps using the same pattern as other models
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), server_default=func.now())
+    )
+    updated_at: datetime = Field(
+        default_factory=datetime.now,
+        sa_column=Column(DateTime(timezone=True), onupdate=func.now())
+    )
+
+    # Foreign key to Session
+    session_id: Optional[int] = Field(
+        default=None,
+        sa_column=Column(
+            Integer,
+            ForeignKey("session.id", ondelete="CASCADE"),
+            nullable=False
+        )
+    )
+
+    # Run status and metadata
+    status: RunStatus = Field(default=RunStatus.CREATED)
+    error_message: Optional[str] = None
+
+    # Metadata storage following pattern from Message model
+    run_meta: dict = Field(default={}, sa_column=Column(JSON))
+
+    # Version tracking like other models
+    version: Optional[str] = "0.0.1"
diff --git a/python/packages/autogen-studio/autogenstudio/datamodel/types.py b/python/packages/autogen-studio/autogenstudio/datamodel/types.py
new file mode 100644
index 000000000000..3f059eba1903
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/datamodel/types.py
@@ -0,0 +1,136 @@
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+from autogen_agentchat.base._task import TaskResult
+
+
+class ModelTypes(str, Enum):
+    OPENAI = "OpenAIChatCompletionClient"
+
+
+class ToolTypes(str, Enum):
+    PYTHON_FUNCTION = "PythonFunction"
+
+
+class AgentTypes(str, Enum):
+    ASSISTANT = "AssistantAgent"
+    CODING = "CodingAssistantAgent"
+
+
+class TeamTypes(str, Enum):
+    ROUND_ROBIN = "RoundRobinGroupChat"
+    SELECTOR = "SelectorGroupChat"
+
+
+class TerminationTypes(str, Enum):
+    MAX_MESSAGES = "MaxMessageTermination"
+    STOP_MESSAGE = "StopMessageTermination"
+    TEXT_MENTION = "TextMentionTermination"
+
+
+class ComponentType(str, Enum):
+    TEAM = "team"
+    AGENT = "agent"
+    MODEL = "model"
+    TOOL = "tool"
+    TERMINATION = "termination"
+
+
+class BaseConfig(BaseModel):
+    model_config = {
+        "protected_namespaces": ()
+    }
+    version: str = "1.0.0"
+    component_type: ComponentType
+
+
+class MessageConfig(BaseModel):
+    source: str
+    content: str
+    message_type: Optional[str] = "text"
+
+
+class ModelConfig(BaseConfig):
+    model: str
+    model_type: ModelTypes
+    api_key: Optional[str] = None
+    base_url: Optional[str] = None
+    component_type: ComponentType = ComponentType.MODEL
+
+
+class ToolConfig(BaseConfig):
+    name: str
+    description: str
+    content: str
+    tool_type: ToolTypes
+    component_type: ComponentType = ComponentType.TOOL
+
+
+class AgentConfig(BaseConfig):
+    name: str
+    agent_type: AgentTypes
+    system_message: Optional[str] = None
+    model_client: Optional[ModelConfig] = None
+    tools: Optional[List[ToolConfig]] = None
+    description: Optional[str] = None
+    component_type: ComponentType = ComponentType.AGENT
+
+
+class TerminationConfig(BaseConfig):
+    termination_type: TerminationTypes
+    max_messages: Optional[int] = None
+    text: Optional[str] = None
+    component_type: ComponentType = ComponentType.TERMINATION
+
+
+class TeamConfig(BaseConfig):
+    name: str
+    participants: List[AgentConfig]
+    team_type: TeamTypes
+    model_client: Optional[ModelConfig] = None
+    termination_condition: Optional[TerminationConfig] = None
+    component_type: ComponentType = ComponentType.TEAM
+
+
+class TeamResult(BaseModel):
+    task_result: TaskResult
+    usage: str
+    duration: float
+
+
+class MessageMeta(BaseModel):
+    task: Optional[str] = None
+    task_result: Optional[TaskResult] = None
+    summary_method: Optional[str] = "last"
+    files: Optional[List[dict]] = None
+    time: Optional[datetime] = None
+    log: Optional[List[dict]] = None
+    usage: Optional[List[dict]] = None
+
+# web request/response data models
+
+
+class Response(BaseModel):
+    message: str
+    status: bool
+    data: Optional[Any] = None
+
+
+class SocketMessage(BaseModel):
+    connection_id: str
+    data: Dict[str, Any]
+    type: str
+
+
+ComponentConfig = Union[
+    TeamConfig,
+    AgentConfig,
+    ModelConfig,
+    ToolConfig,
+    TerminationConfig
+]
+
+ComponentConfigInput = Union[str, Path, dict, ComponentConfig]
diff --git a/python/packages/autogen-studio/autogenstudio/teammanager.py b/python/packages/autogen-studio/autogenstudio/teammanager.py
new file mode 100644
index 000000000000..e50f740472d6
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/teammanager.py
@@ -0,0 +1,67 @@
+from typing import AsyncGenerator, Union, Optional
+import time
+from .database import ComponentFactory
+from .datamodel import TeamResult, TaskResult, ComponentConfigInput
+from autogen_agentchat.messages import InnerMessage, ChatMessage
+from autogen_core.base import CancellationToken
+
+
+class TeamManager:
+    def __init__(self) -> None:
+        self.component_factory = ComponentFactory()
+
+    async def run_stream(
+        self,
+        task: str,
+        team_config: ComponentConfigInput,
+        cancellation_token: Optional[CancellationToken] = None
+    ) -> AsyncGenerator[Union[InnerMessage, ChatMessage, TaskResult], None]:
+        """Stream the team's execution results"""
+        start_time = time.time()
+
+        try:
+            # Let factory handle all config processing
+            team = await self.component_factory.load(team_config)
+
+            stream = team.run_stream(
+                task=task,
+                cancellation_token=cancellation_token
+            )
+
+            async for message in stream:
+                if cancellation_token and cancellation_token.is_cancelled():
+                    break
+
+                if isinstance(message, TaskResult):
+                    yield TeamResult(
+                        task_result=message,
+                        usage="",
+                        duration=time.time() - start_time
+                    )
+                else:
+                    yield message
+
+        except Exception as e:
+            raise e
+
+    async def run(
+        self,
+        task: str,
+        team_config: ComponentConfigInput,
+        cancellation_token: Optional[CancellationToken] = None
+    ) -> TeamResult:
+        """Original non-streaming run method with optional cancellation"""
+        start_time = time.time()
+
+        # Let factory handle all config processing
+        team = await self.component_factory.load(team_config)
+        result = await team.run(
+            task=task,
+            cancellation_token=cancellation_token
+        )
+
+        return TeamResult(
+            task_result=result,
+            usage="",
+            duration=time.time() - start_time
+        )
diff --git a/python/packages/autogen-studio/autogenstudio/utils/dbdefaults.json b/python/packages/autogen-studio/autogenstudio/utils/dbdefaults.json
deleted file mode 100644
index 7f36325266ea..000000000000
--- a/python/packages/autogen-studio/autogenstudio/utils/dbdefaults.json
+++ /dev/null
@@ -1,242 +0,0 @@
-{
-  "models": [
-    {
-      "model": "gpt-4",
-      "api_key": "Your Azure API key here",
-      "base_url": "Your Azure base URL here",
-      "api_type": "azure",
-      "api_version": "Your Azure API version here",
-      "description": "Azure Open AI model configuration"
-    },
-    {
-      "model": "gpt-4-1106-preview",
-      "description": "OpenAI model configuration"
-    },
-    {
-      "model": "TheBloke/zephyr-7B-alpha-AWQ",
-      "api_key": "EMPTY",
-      "base_url": "http://localhost:8000/v1",
-      "description": "Local model example with vLLM server endpoint"
-    }
-  ],
-  "agents": [
-    {
-      "type": "userproxy",
-
-      "config": {
-        "name": "userproxy",
-        "human_input_mode": "NEVER",
-        "max_consecutive_auto_reply": 5,
-        "system_message": "You are a helpful assistant.",
-        "default_auto_reply": "TERMINATE",
-        "llm_config": false,
-        "code_execution_config": {
-          "work_dir": null,
-          "use_docker": false
-        },
-        "description": "A user proxy agent that executes code."
-      }
-    },
-    {
-      "type": "assistant",
-      "skills": [
-        {
-          "title": "find_papers_arxiv",
-          "description": "This skill finds relevant papers on arXiv given a query.",
-          "content": "import os\nimport re\nimport json\nimport hashlib\n\n\ndef search_arxiv(query, max_results=10):\n    \"\"\"\n    Searches arXiv for the given query using the arXiv API, then returns the search results. This is a helper function. In most cases, callers will want to use 'find_relevant_papers( query, max_results )' instead.\n\n    Args:\n        query (str): The search query.\n        max_results (int, optional): The maximum number of search results to return. Defaults to 10.\n\n    Returns:\n        jresults (list): A list of dictionaries. Each dictionary contains fields such as 'title', 'authors', 'summary', and 'pdf_url'\n\n    Example:\n        >>> results = search_arxiv(\"attention is all you need\")\n        >>> print(results)\n    \"\"\"\n\n    import arxiv\n\n    key = hashlib.md5((\"search_arxiv(\" + str(max_results) + \")\" + query).encode(\"utf-8\")).hexdigest()\n    # Create the cache if it doesn't exist\n    cache_dir = \".cache\"\n    if not os.path.isdir(cache_dir):\n        os.mkdir(cache_dir)\n\n    fname = os.path.join(cache_dir, key + \".cache\")\n\n    # Cache hit\n    if os.path.isfile(fname):\n        fh = open(fname, \"r\", encoding=\"utf-8\")\n        data = json.loads(fh.read())\n        fh.close()\n        return data\n\n    # Normalize the query, removing operator keywords\n    query = re.sub(r\"[^\\s\\w]\", \" \", query.lower())\n    query = re.sub(r\"\\s(and|or|not)\\s\", \" \", \" \" + query + \" \")\n    query = re.sub(r\"[^\\s\\w]\", \" \", query.lower())\n    query = re.sub(r\"\\s+\", \" \", query).strip()\n\n    search = arxiv.Search(query=query, max_results=max_results, sort_by=arxiv.SortCriterion.Relevance)\n\n    jresults = list()\n    for result in search.results():\n        r = dict()\n        r[\"entry_id\"] = result.entry_id\n        r[\"updated\"] = str(result.updated)\n        r[\"published\"] = str(result.published)\n        r[\"title\"] = result.title\n        r[\"authors\"] = [str(a) for a in result.authors]\n        r[\"summary\"] = result.summary\n        r[\"comment\"] = result.comment\n        r[\"journal_ref\"] = result.journal_ref\n        r[\"doi\"] = result.doi\n        r[\"primary_category\"] = result.primary_category\n        r[\"categories\"] = result.categories\n        r[\"links\"] = [str(link) for link in result.links]\n        r[\"pdf_url\"] = result.pdf_url\n        jresults.append(r)\n\n    if len(jresults) > max_results:\n        jresults = jresults[0:max_results]\n\n    # Save to cache\n    fh = open(fname, \"w\")\n    fh.write(json.dumps(jresults))\n    fh.close()\n    return jresults\n",
-          "file_name": "find_papers_arxiv"
-        },
-        {
-          "title": "generate_images",
-          "description": "This skill generates images from a given query using OpenAI's DALL-E model and saves them to disk.",
-          "content": "from typing import List\nimport uuid\nimport requests  # to perform HTTP requests\nfrom pathlib import Path\n\nfrom openai import OpenAI\n\n\ndef generate_and_save_images(query: str, image_size: str = \"1024x1024\") -> List[str]:\n    \"\"\"\n    Function to paint, draw or illustrate images based on the users query or request. Generates images from a given query using OpenAI's DALL-E model and saves them to disk.  Use the code below anytime there is a request to create an image.\n\n    :param query: A natural language description of the image to be generated.\n    :param image_size: The size of the image to be generated. (default is \"1024x1024\")\n    :return: A list of filenames for the saved images.\n    \"\"\"\n\n    client = OpenAI()  # Initialize the OpenAI client\n    response = client.images.generate(model=\"dall-e-3\", prompt=query, n=1, size=image_size)  # Generate images\n\n    # List to store the file names of saved images\n    saved_files = []\n\n    # Check if the response is successful\n    if response.data:\n        for image_data in response.data:\n            # Generate a random UUID as the file name\n            file_name = str(uuid.uuid4()) + \".png\"  # Assuming the image is a PNG\n            file_path = Path(file_name)\n\n            img_url = image_data.url\n            img_response = requests.get(img_url)\n            if img_response.status_code == 200:\n                # Write the binary content to a file\n                with open(file_path, \"wb\") as img_file:\n                    img_file.write(img_response.content)\n                    print(f\"Image saved to {file_path}\")\n                    saved_files.append(str(file_path))\n            else:\n                print(f\"Failed to download the image from {img_url}\")\n    else:\n        print(\"No image data found in the response!\")\n\n    # Return the list of saved files\n    return saved_files\n\n\n# Example usage of the function:\n# generate_and_save_images(\"A cute baby sea otter\")\n"
-        }
-      ],
-      "config": {
-        "name": "primary_assistant",
-        "description": "A primary assistant agent that writes plans and code to solve tasks.",
-        "llm_config": {
-          "config_list": [
-            {
-              "model": "gpt-4-1106-preview"
-            }
-          ],
-          "temperature": 0.1,
-          "timeout": 600,
-          "cache_seed": null
-        },
-        "human_input_mode": "NEVER",
-        "max_consecutive_auto_reply": 8,
-        "system_message": "You are a helpful AI assistant. Solve tasks using your coding and language skills. In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. If you want the user to save the code in a file before executing it, put # filename:  inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible. Reply 'TERMINATE' in the end when everything is done."
-      }
-    }
-  ],
-  "skills": [
-    {
-      "title": "fetch_profile",
-      "description": "This skill fetches the text content from a personal website.",
-      "content": "from typing import Optional\nimport requests\nfrom bs4 import BeautifulSoup\n\n\ndef fetch_user_profile(url: str) -> Optional[str]:\n    \"\"\"\n    Fetches the text content from a personal website.\n\n    Given a URL of a person's personal website, this function scrapes\n    the content of the page and returns the text found within the .\n\n    Args:\n        url (str): The URL of the person's personal website.\n\n    Returns:\n        Optional[str]: The text content of the website's body, or None if any error occurs.\n    \"\"\"\n    try:\n        # Send a GET request to the URL\n        response = requests.get(url)\n        # Check for successful access to the webpage\n        if response.status_code == 200:\n            # Parse the HTML content of the page using BeautifulSoup\n            soup = BeautifulSoup(response.text, \"html.parser\")\n            # Extract the content of the  tag\n            body_content = soup.find(\"body\")\n            # Return all the text in the body tag, stripping leading/trailing whitespaces\n            return \" \".join(body_content.stripped_strings) if body_content else None\n        else:\n            # Return None if the status code isn't 200 (success)\n            return None\n    except requests.RequestException:\n        # Return None if any request-related exception is caught\n        return None\n"
-    },
-    {
-      "title": "generate_images",
-      "description": "This skill generates images from a given query using OpenAI's DALL-E model and saves them to disk.",
-      "content": "from typing import List\nimport uuid\nimport requests  # to perform HTTP requests\nfrom pathlib import Path\n\nfrom openai import OpenAI\n\n\ndef generate_and_save_images(query: str, image_size: str = \"1024x1024\") -> List[str]:\n    \"\"\"\n    Function to paint, draw or illustrate images based on the users query or request. Generates images from a given query using OpenAI's DALL-E model and saves them to disk.  Use the code below anytime there is a request to create an image.\n\n    :param query: A natural language description of the image to be generated.\n    :param image_size: The size of the image to be generated. (default is \"1024x1024\")\n    :return: A list of filenames for the saved images.\n    \"\"\"\n\n    client = OpenAI()  # Initialize the OpenAI client\n    response = client.images.generate(model=\"dall-e-3\", prompt=query, n=1, size=image_size)  # Generate images\n\n    # List to store the file names of saved images\n    saved_files = []\n\n    # Check if the response is successful\n    if response.data:\n        for image_data in response.data:\n            # Generate a random UUID as the file name\n            file_name = str(uuid.uuid4()) + \".png\"  # Assuming the image is a PNG\n            file_path = Path(file_name)\n\n            img_url = image_data.url\n            img_response = requests.get(img_url)\n            if img_response.status_code == 200:\n                # Write the binary content to a file\n                with open(file_path, \"wb\") as img_file:\n                    img_file.write(img_response.content)\n                    print(f\"Image saved to {file_path}\")\n                    saved_files.append(str(file_path))\n            else:\n                print(f\"Failed to download the image from {img_url}\")\n    else:\n        print(\"No image data found in the response!\")\n\n    # Return the list of saved files\n    return saved_files\n\n\n# Example usage of the function:\n# generate_and_save_images(\"A cute baby sea otter\")\n"
-    }
-  ],
-  "workflows": [
-    {
-      "name": "Travel Agent Group Chat Workflow",
-      "description": "A group chat workflow",
-      "type": "groupchat",
-      "sender": {
-        "type": "userproxy",
-        "config": {
-          "name": "userproxy",
-          "human_input_mode": "NEVER",
-          "max_consecutive_auto_reply": 5,
-          "system_message": "You are a helpful assistant.",
-          "code_execution_config": {
-            "work_dir": null,
-            "use_docker": false
-          }
-        }
-      },
-      "receiver": {
-        "type": "groupchat",
-        "config": {
-          "name": "group_chat_manager",
-          "llm_config": {
-            "config_list": [
-              {
-                "model": "gpt-4-1106-preview"
-              }
-            ],
-            "temperature": 0.1,
-            "timeout": 600,
-            "cache_seed": 42
-          },
-          "human_input_mode": "NEVER",
-          "system_message": "Group chat manager"
-        },
-        "groupchat_config": {
-          "admin_name": "Admin",
-          "max_round": 10,
-          "speaker_selection_method": "auto",
-          "agents": [
-            {
-              "type": "assistant",
-              "config": {
-                "name": "travel_planner",
-                "llm_config": {
-                  "config_list": [
-                    {
-                      "model": "gpt-4-1106-preview"
-                    }
-                  ],
-                  "temperature": 0.1,
-                  "timeout": 600,
-                  "cache_seed": 42
-                },
-                "human_input_mode": "NEVER",
-                "max_consecutive_auto_reply": 8,
-                "system_message": "You are a helpful assistant that can suggest a travel plan for a user. You are the primary cordinator who will receive suggestions or advice from other agents (local_assistant, language_assistant). You must ensure that the finally plan integrates the suggestions from other agents or team members. YOUR FINAL RESPONSE MUST BE THE COMPLETE PLAN. When the plan is complete and all perspectives are integrated, you can respond with TERMINATE."
-              }
-            },
-            {
-              "type": "assistant",
-              "config": {
-                "name": "local_assistant",
-                "llm_config": {
-                  "config_list": [
-                    {
-                      "model": "gpt-4-1106-preview"
-                    }
-                  ],
-                  "temperature": 0.1,
-                  "timeout": 600,
-                  "cache_seed": 42
-                },
-                "human_input_mode": "NEVER",
-                "max_consecutive_auto_reply": 8,
-                "system_message": "You are a helpful assistant that can review travel plans, providing critical feedback on how the trip can be enriched for enjoyment of the local culture. If the plan already includes local experiences, you can mention that the plan is satisfactory, with rationale."
-              }
-            },
-            {
-              "type": "assistant",
-              "config": {
-                "name": "language_assistant",
-                "llm_config": {
-                  "config_list": [
-                    {
-                      "model": "gpt-4-1106-preview"
-                    }
-                  ],
-                  "temperature": 0.1,
-                  "timeout": 600,
-                  "cache_seed": 42
-                },
-                "human_input_mode": "NEVER",
-                "max_consecutive_auto_reply": 8,
-                "system_message": "You are a helpful assistant that can review travel plans, providing feedback on important/critical tips about how best to address language or communication challenges for the given destination. If the plan already includes language tips, you can mention that the plan is satisfactory, with rationale."
-              }
-            }
-          ]
-        }
-      }
-    },
-    {
-      "name": "General Agent Workflow",
-      "description": "This workflow is used for general purpose tasks.",
-      "sender": {
-        "type": "userproxy",
-        "config": {
-          "name": "userproxy",
-          "description": "A user proxy agent that executes code.",
-          "human_input_mode": "NEVER",
-          "max_consecutive_auto_reply": 10,
-          "system_message": "You are a helpful assistant.",
-          "default_auto_reply": "TERMINATE",
-          "llm_config": false,
-          "code_execution_config": {
-            "work_dir": null,
-            "use_docker": false
-          }
-        }
-      },
-      "receiver": {
-        "type": "assistant",
-
-        "skills": [
-          {
-            "title": "find_papers_arxiv",
-            "description": "This skill finds relevant papers on arXiv given a query.",
-            "content": "import os\nimport re\nimport json\nimport hashlib\n\n\ndef search_arxiv(query, max_results=10):\n    \"\"\"\n    Searches arXiv for the given query using the arXiv API, then returns the search results. This is a helper function. In most cases, callers will want to use 'find_relevant_papers( query, max_results )' instead.\n\n    Args:\n        query (str): The search query.\n        max_results (int, optional): The maximum number of search results to return. Defaults to 10.\n\n    Returns:\n        jresults (list): A list of dictionaries. Each dictionary contains fields such as 'title', 'authors', 'summary', and 'pdf_url'\n\n    Example:\n        >>> results = search_arxiv(\"attention is all you need\")\n        >>> print(results)\n    \"\"\"\n\n    import arxiv\n\n    key = hashlib.md5((\"search_arxiv(\" + str(max_results) + \")\" + query).encode(\"utf-8\")).hexdigest()\n    # Create the cache if it doesn't exist\n    cache_dir = \".cache\"\n    if not os.path.isdir(cache_dir):\n        os.mkdir(cache_dir)\n\n    fname = os.path.join(cache_dir, key + \".cache\")\n\n    # Cache hit\n    if os.path.isfile(fname):\n        fh = open(fname, \"r\", encoding=\"utf-8\")\n        data = json.loads(fh.read())\n        fh.close()\n        return data\n\n    # Normalize the query, removing operator keywords\n    query = re.sub(r\"[^\\s\\w]\", \" \", query.lower())\n    query = re.sub(r\"\\s(and|or|not)\\s\", \" \", \" \" + query + \" \")\n    query = re.sub(r\"[^\\s\\w]\", \" \", query.lower())\n    query = re.sub(r\"\\s+\", \" \", query).strip()\n\n    search = arxiv.Search(query=query, max_results=max_results, sort_by=arxiv.SortCriterion.Relevance)\n\n    jresults = list()\n    for result in search.results():\n        r = dict()\n        r[\"entry_id\"] = result.entry_id\n        r[\"updated\"] = str(result.updated)\n        r[\"published\"] = str(result.published)\n        r[\"title\"] = result.title\n        r[\"authors\"] = [str(a) for a in result.authors]\n        r[\"summary\"] = result.summary\n        r[\"comment\"] = result.comment\n        r[\"journal_ref\"] = result.journal_ref\n        r[\"doi\"] = result.doi\n        r[\"primary_category\"] = result.primary_category\n        r[\"categories\"] = result.categories\n        r[\"links\"] = [str(link) for link in result.links]\n        r[\"pdf_url\"] = result.pdf_url\n        jresults.append(r)\n\n    if len(jresults) > max_results:\n        jresults = jresults[0:max_results]\n\n    # Save to cache\n    fh = open(fname, \"w\")\n    fh.write(json.dumps(jresults))\n    fh.close()\n    return jresults\n"
-          },
-          {
-            "title": "generate_images",
-            "description": "This skill generates images from a given query using OpenAI's DALL-E model and saves them to disk.",
-            "content": "from typing import List\nimport uuid\nimport requests  # to perform HTTP requests\nfrom pathlib import Path\n\nfrom openai import OpenAI\n\n\ndef generate_and_save_images(query: str, image_size: str = \"1024x1024\") -> List[str]:\n    \"\"\"\n    Function to paint, draw or illustrate images based on the users query or request. Generates images from a given query using OpenAI's DALL-E model and saves them to disk.  Use the code below anytime there is a request to create an image.\n\n    :param query: A natural language description of the image to be generated.\n    :param image_size: The size of the image to be generated. (default is \"1024x1024\")\n    :return: A list of filenames for the saved images.\n    \"\"\"\n\n    client = OpenAI()  # Initialize the OpenAI client\n    response = client.images.generate(model=\"dall-e-3\", prompt=query, n=1, size=image_size)  # Generate images\n\n    # List to store the file names of saved images\n    saved_files = []\n\n    # Check if the response is successful\n    if response.data:\n        for image_data in response.data:\n            # Generate a random UUID as the file name\n            file_name = str(uuid.uuid4()) + \".png\"  # Assuming the image is a PNG\n            file_path = Path(file_name)\n\n            img_url = image_data.url\n            img_response = requests.get(img_url)\n            if img_response.status_code == 200:\n                # Write the binary content to a file\n                with open(file_path, \"wb\") as img_file:\n                    img_file.write(img_response.content)\n                    print(f\"Image saved to {file_path}\")\n                    saved_files.append(str(file_path))\n            else:\n                print(f\"Failed to download the image from {img_url}\")\n    else:\n        print(\"No image data found in the response!\")\n\n    # Return the list of saved files\n    return saved_files\n\n\n# Example usage of the function:\n# generate_and_save_images(\"A cute baby sea otter\")\n"
-          }
-        ],
-        "config": {
-          "description": "Default assistant to generate plans and write code to solve tasks.",
-          "name": "primary_assistant",
-          "llm_config": {
-            "config_list": [
-              {
-                "model": "gpt-4-1106-preview"
-              }
-            ],
-            "temperature": 0.1,
-            "timeout": 600,
-            "cache_seed": null
-          },
-          "human_input_mode": "NEVER",
-          "max_consecutive_auto_reply": 15,
-          "system_message": "You are a helpful AI assistant. Solve tasks using your coding and language skills. In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. If you want the user to save the code in a file before executing it, put # filename:  inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible. Reply 'TERMINATE' in the end when everything is done."
-        }
-      },
-      "type": "twoagents"
-    }
-  ]
-}
diff --git a/python/packages/autogen-studio/autogenstudio/utils/utils.py b/python/packages/autogen-studio/autogenstudio/utils/utils.py
index 88f310d6ffc3..419a6e4a66d2 100644
--- a/python/packages/autogen-studio/autogenstudio/utils/utils.py
+++ b/python/packages/autogen-studio/autogenstudio/utils/utils.py
@@ -10,10 +10,8 @@
 from dotenv import load_dotenv
 from loguru import logger
 
-from autogen.coding import DockerCommandLineCodeExecutor, LocalCommandLineCodeExecutor
-from autogen.oai.client import ModelClient, OpenAIWrapper
 
-from ..datamodel import CodeExecutionConfigTypes, Model, Skill
+from ..datamodel import Model
 from ..version import APP_NAME
 
 
@@ -44,26 +42,6 @@ def str_to_datetime(dt_str: str) -> datetime:
     return datetime.fromisoformat(dt_str)
 
 
-def clear_folder(folder_path: str) -> None:
-    """
-    Clear the contents of a folder.
-
-    :param folder_path: The path to the folder to clear.
-    """
-    # exit if the folder does not exist
-    if not os.path.exists(folder_path):
-        return
-    # exit if the folder does not exist
-    if not os.path.exists(folder_path):
-        return
-    for file in os.listdir(folder_path):
-        file_path = os.path.join(folder_path, file)
-        if os.path.isfile(file_path):
-            os.remove(file_path)
-        elif os.path.isdir(file_path):
-            shutil.rmtree(file_path)
-
-
 def get_file_type(file_path: str) -> str:
     """
 
@@ -153,31 +131,6 @@ def get_file_type(file_path: str) -> str:
     return file_type
 
 
-def serialize_file(file_path: str) -> Tuple[str, str]:
-    """
-    Reads a file from a given file path, base64 encodes its content,
-    and returns the base64 encoded string along with the file type.
-
-    The file type is determined by the file extension. If the file extension is not
-    recognized, 'unknown' will be used as the file type.
-
-    :param file_path: The path to the file to be serialized.
-    :return: A tuple containing the base64 encoded string of the file and the file type.
-    """
-
-    file_type = get_file_type(file_path)
-
-    # Read the file and encode its contents
-    try:
-        with open(file_path, "rb") as file:
-            file_content = file.read()
-            base64_encoded_content = base64.b64encode(file_content).decode("utf-8")
-    except Exception as e:
-        raise IOError(f"An error occurred while reading the file: {e}") from e
-
-    return base64_encoded_content, file_type
-
-
 def get_modified_files(start_timestamp: float, end_timestamp: float, source_dir: str) -> List[Dict[str, str]]:
     """
     Identify files from source_dir that were modified within a specified timestamp range.
@@ -200,7 +153,8 @@ def get_modified_files(start_timestamp: float, end_timestamp: float, source_dir:
     for root, dirs, files in os.walk(source_dir):
         # Update directories and files to exclude those to be ignored
         dirs[:] = [d for d in dirs if d not in ignore_files]
-        files[:] = [f for f in files if f not in ignore_files and os.path.splitext(f)[1] not in ignore_extensions]
+        files[:] = [f for f in files if f not in ignore_files and os.path.splitext(f)[
+            1] not in ignore_extensions]
 
         for file in files:
             file_path = os.path.join(root, file)
@@ -209,7 +163,9 @@ def get_modified_files(start_timestamp: float, end_timestamp: float, source_dir:
             # Verify if the file was modified within the given timestamp range
             if start_timestamp <= file_mtime <= end_timestamp:
                 file_relative_path = (
-                    "files/user" + file_path.split("files/user", 1)[1] if "files/user" in file_path else ""
+                    "files/user" +
+                    file_path.split(
+                        "files/user", 1)[1] if "files/user" in file_path else ""
                 )
                 file_type = get_file_type(file_path)
 
@@ -289,138 +245,6 @@ def init_app_folders(app_file_path: str) -> Dict[str, str]:
     return folders
 
 
-def get_skills_prompt(skills: List[Skill], work_dir: str) -> str:
-    """
-    Create a prompt with the content of all skills and write the skills to a file named skills.py in the work_dir.
-
-    :param skills: A dictionary skills
-    :return: A string containing the content of all skills
-    """
-
-    instruction = """
-
-While solving the task you may use functions below which will be available in a file called skills.py .
-To use a function skill.py in code, IMPORT THE FUNCTION FROM skills.py  and then use the function.
-If you need to install python packages, write shell code to
-install via pip and use --quiet option.
-
-         """
-    prompt = ""  # filename:  skills.py
-
-    for skill in skills:
-        if not isinstance(skill, Skill):
-            skill = Skill(**skill)
-        if skill.secrets:
-            for secret in skill.secrets:
-                if secret.get("value") is not None:
-                    os.environ[secret["secret"]] = secret["value"]
-        prompt += f"""
-
-##### Begin of {skill.name} #####
-from skills import {skill.name} # Import the function from skills.py
-
-{skill.content}
-
-#### End of {skill.name} ####
-
-        """
-
-    return instruction + prompt
-
-
-def save_skills_to_file(skills: List[Skill], work_dir: str) -> None:
-    """
-    Write the skills to a file named skills.py in the work_dir.
-
-    :param skills: A dictionary skills
-    """
-
-    # TBD: Double check for duplicate skills?
-
-    # check if work_dir exists
-    if not os.path.exists(work_dir):
-        os.makedirs(work_dir)
-
-    skills_content = ""
-    for skill in skills:
-        if not isinstance(skill, Skill):
-            skill = Skill(**skill)
-
-        skills_content += f"""
-
-##### Begin of {skill.name} #####
-
-{skill.content}
-
-#### End of {skill.name} ####
-
-        """
-
-    # overwrite skills.py in work_dir
-    with open(os.path.join(work_dir, "skills.py"), "w", encoding="utf-8") as f:
-        f.write(skills_content)
-
-
-def delete_files_in_folder(folders: Union[str, List[str]]) -> None:
-    """
-    Delete all files and directories in the specified folders.
-
-    :param folders: A list of folders or a single folder string
-    """
-
-    if isinstance(folders, str):
-        folders = [folders]
-
-    for folder in folders:
-        # Check if the folder exists
-        if not os.path.isdir(folder):
-            continue
-
-        # List all the entries in the directory
-        for entry in os.listdir(folder):
-            # Get the full path
-            path = os.path.join(folder, entry)
-            try:
-                if os.path.isfile(path) or os.path.islink(path):
-                    # Remove the file or link
-                    os.remove(path)
-                elif os.path.isdir(path):
-                    # Remove the directory and all its content
-                    shutil.rmtree(path)
-            except Exception as e:
-                # Print the error message and skip
-                logger.info(f"Failed to delete {path}. Reason: {e}")
-
-
-def extract_successful_code_blocks(messages: List[Dict[str, str]]) -> List[str]:
-    """
-    Parses through a list of messages containing code blocks and execution statuses,
-    returning the array of code blocks that executed successfully and retains
-    the backticks for Markdown rendering.
-
-    Parameters:
-    messages (List[Dict[str, str]]): A list of message dictionaries containing 'content' and 'role' keys.
-
-    Returns:
-    List[str]: A list containing the code blocks that were successfully executed, including backticks.
-    """
-    successful_code_blocks = []
-    # Regex pattern to capture code blocks enclosed in triple backticks.
-    code_block_regex = r"```[\s\S]*?```"
-
-    for i, row in enumerate(messages):
-        message = row["message"]
-        if message["role"] == "user" and "execution succeeded" in message["content"]:
-            if i > 0 and messages[i - 1]["message"]["role"] == "assistant":
-                prev_content = messages[i - 1]["message"]["content"]
-                # Find all matches for code blocks
-                code_blocks = re.findall(code_block_regex, prev_content)
-                # Add the code blocks with backticks
-                successful_code_blocks.extend(code_blocks)
-
-    return successful_code_blocks
-
-
 def sanitize_model(model: Model):
     """
     Sanitize model dictionary to remove None values and empty strings and only keep valid keys.
@@ -429,7 +253,8 @@ def sanitize_model(model: Model):
         model = model.model_dump()
     valid_keys = ["model", "base_url", "api_key", "api_type", "api_version"]
     # only add key if value is not None
-    sanitized_model = {k: v for k, v in model.items() if (v is not None and v != "") and k in valid_keys}
+    sanitized_model = {k: v for k, v in model.items() if (
+        v is not None and v != "") and k in valid_keys}
     return sanitized_model
 
 
@@ -440,134 +265,29 @@ def test_model(model: Model):
 
     print("Testing model", model)
 
-    sanitized_model = sanitize_model(model)
-    client = OpenAIWrapper(config_list=[sanitized_model])
-    response = client.create(
-        messages=[
-            {
-                "role": "system",
-                "content": "You are a helpful assistant that can add numbers. ONLY RETURN THE RESULT.",
-            },
-            {
-                "role": "user",
-                "content": "2+2=",
-            },
-        ],
-        cache_seed=None,
-    )
-    return response.choices[0].message.content
-
-
-def load_code_execution_config(code_execution_type: CodeExecutionConfigTypes, work_dir: str):
-    """
-    Load the code execution configuration based on the code execution type.
-
-    :param code_execution_type: The code execution type.
-    :param work_dir: The working directory to store code execution files.
-    :return: The code execution configuration.
-
-    """
-    work_dir = Path(work_dir)
-    work_dir.mkdir(exist_ok=True)
-    executor = None
-    if code_execution_type == CodeExecutionConfigTypes.local:
-        executor = LocalCommandLineCodeExecutor(work_dir=work_dir)
-    elif code_execution_type == CodeExecutionConfigTypes.docker:
-        try:
-            executor = DockerCommandLineCodeExecutor(work_dir=work_dir)
-        except Exception as e:
-            logger.error(f"Error initializing Docker executor: {e}")
-            return False
-    elif code_execution_type == CodeExecutionConfigTypes.none:
-        return False
-    else:
-        raise ValueError(f"Invalid code execution type: {code_execution_type}")
-    code_execution_config = {
-        "executor": executor,
-    }
-    return code_execution_config
-
 
-def summarize_chat_history(task: str, messages: List[Dict[str, str]], client: ModelClient):
-    """
-    Summarize the chat history using the model endpoint and returning the response.
-    """
-    summarization_system_prompt = f"""
-    You are a helpful assistant that is able to review the chat history between a set of agents (userproxy agents, assistants etc) as they try to address a given TASK and provide a summary. Be SUCCINCT but also comprehensive enough to allow others (who cannot see the chat history) understand and recreate the solution.
-
-    The task requested by the user is:
-    ===
-    {task}
-    ===
-    The summary should focus on extracting the actual solution to the task from the chat history (assuming the task was addressed) such that any other agent reading the summary will understand what the actual solution is. Use a neutral tone and DO NOT directly mention the agents. Instead only focus on the actions that were carried out (e.g. do not say 'assistant agent generated some code visualization code ..'  instead say say 'visualization code was generated ..'. The answer should be framed as a response to the user task. E.g. if the task is "What is the height of the Eiffel tower", the summary should be "The height of the Eiffel Tower is ...").
-    """
-    summarization_prompt = [
-        {
-            "role": "system",
-            "content": summarization_system_prompt,
-        },
-        {
-            "role": "user",
-            "content": f"Summarize the following chat history. {str(messages)}",
-        },
-    ]
-    response = client.create(messages=summarization_prompt, cache_seed=None)
-    return response.choices[0].message.content
-
-
-def get_autogen_log(db_path="logs.db"):
-    """
-    Fetches data the autogen logs database.
-    Args:
-        dbname (str): Name of the database file. Defaults to "logs.db".
-        table (str): Name of the table to query. Defaults to "chat_completions".
-
-    Returns:
-        list: A list of dictionaries, where each dictionary represents a row from the table.
-    """
-    import json
-    import sqlite3
-
-    con = sqlite3.connect(db_path)
-    query = """
-        SELECT
-            chat_completions.*,
-            agents.name AS agent_name
-        FROM
-            chat_completions
-        JOIN
-            agents ON chat_completions.wrapper_id = agents.wrapper_id
-    """
-    cursor = con.execute(query)
-    rows = cursor.fetchall()
-    column_names = [description[0] for description in cursor.description]
-    data = [dict(zip(column_names, row)) for row in rows]
-    for row in data:
-        response = json.loads(row["response"])
-        print(response)
-        total_tokens = response.get("usage", {}).get("total_tokens", 0)
-        row["total_tokens"] = total_tokens
-    con.close()
-    return data
-
-
-def find_key_value(d, target_key):
-    """
-    Recursively search for a key in a nested dictionary and return its value.
-    """
-    if d is None:
-        return None
-
-    if isinstance(d, dict):
-        if target_key in d:
-            return d[target_key]
-        for k in d:
-            item = find_key_value(d[k], target_key)
-            if item is not None:
-                return item
-    elif isinstance(d, list):
-        for i in d:
-            item = find_key_value(i, target_key)
-            if item is not None:
-                return item
-    return None
+# def summarize_chat_history(task: str, messages: List[Dict[str, str]], client: ModelClient):
+#     """
+#     Summarize the chat history using the model endpoint and returning the response.
+#     """
+#     summarization_system_prompt = f"""
+#     You are a helpful assistant that is able to review the chat history between a set of agents (userproxy agents, assistants etc) as they try to address a given TASK and provide a summary. Be SUCCINCT but also comprehensive enough to allow others (who cannot see the chat history) understand and recreate the solution.
+
+#     The task requested by the user is:
+#     ===
+#     {task}
+#     ===
+#     The summary should focus on extracting the actual solution to the task from the chat history (assuming the task was addressed) such that any other agent reading the summary will understand what the actual solution is. Use a neutral tone and DO NOT directly mention the agents. Instead only focus on the actions that were carried out (e.g. do not say 'assistant agent generated some code visualization code ..'  instead say say 'visualization code was generated ..'. The answer should be framed as a response to the user task. E.g. if the task is "What is the height of the Eiffel tower", the summary should be "The height of the Eiffel Tower is ...").
+#     """
+#     summarization_prompt = [
+#         {
+#             "role": "system",
+#             "content": summarization_system_prompt,
+#         },
+#         {
+#             "role": "user",
+#             "content": f"Summarize the following chat history. {str(messages)}",
+#         },
+#     ]
+#     response = client.create(messages=summarization_prompt, cache_seed=None)
+#     return response.choices[0].message.content
diff --git a/python/packages/autogen-studio/autogenstudio/web/app.py b/python/packages/autogen-studio/autogenstudio/web/app.py
index d86e2dc439fd..8a0c2ce19ab4 100644
--- a/python/packages/autogen-studio/autogenstudio/web/app.py
+++ b/python/packages/autogen-studio/autogenstudio/web/app.py
@@ -1,93 +1,63 @@
-import asyncio
+# api/app.py
 import os
-import queue
-import threading
-import traceback
-from contextlib import asynccontextmanager
-from typing import Any, Union
-
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+# import logging
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
 from loguru import logger
-from openai import OpenAIError
-
-from ..chatmanager import AutoGenChatManager
-from ..database import workflow_from_id
-from ..database.dbmanager import DBManager
-from ..datamodel import Agent, Message, Model, Response, Session, Skill, Workflow
-from ..profiler import Profiler
-from ..utils import check_and_cast_datetime_fields, init_app_folders, sha256_hash, test_model
-from ..version import VERSION
-from ..websocket_connection_manager import WebSocketConnectionManager
-
-profiler = Profiler()
-managers = {"chat": None}  # manage calls to autogen
-# Create thread-safe queue for messages between api thread and autogen threads
-message_queue = queue.Queue()
-active_connections = []
-active_connections_lock = asyncio.Lock()
-websocket_manager = WebSocketConnectionManager(
-    active_connections=active_connections,
-    active_connections_lock=active_connections_lock,
-)
-
-
-def message_handler():
-    while True:
-        message = message_queue.get()
-        logger.info(
-            "** Processing Agent Message on Queue: Active Connections: "
-            + str([client_id for _, client_id in websocket_manager.active_connections])
-            + " **"
-        )
-        for connection, socket_client_id in websocket_manager.active_connections:
-            if message["connection_id"] == socket_client_id:
-                logger.info(
-                    f"Sending message to connection_id: {message['connection_id']}. Connection ID: {socket_client_id}"
-                )
-                asyncio.run(websocket_manager.send_message(message, connection))
-            else:
-                logger.info(
-                    f"Skipping message for connection_id: {message['connection_id']}. Connection ID: {socket_client_id}"
-                )
-        message_queue.task_done()
 
+from .routes import sessions, runs, teams, agents, models, tools, ws
+from .deps import init_managers, cleanup_managers
+from .config import settings
+from .initialization import AppInitializer
+from ..version import VERSION
 
-message_handler_thread = threading.Thread(target=message_handler, daemon=True)
-message_handler_thread.start()
+# Configure logging
+# logger = logging.getLogger(__name__)
+# logging.basicConfig(level=logging.INFO)
 
 
+# Initialize application
 app_file_path = os.path.dirname(os.path.abspath(__file__))
-folders = init_app_folders(app_file_path)
-ui_folder_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ui")
-
-database_engine_uri = folders["database_engine_uri"]
-dbmanager = DBManager(engine_uri=database_engine_uri)
-
-HUMAN_INPUT_TIMEOUT_SECONDS = 180
+initializer = AppInitializer(settings, app_file_path)
 
 
 @asynccontextmanager
-async def lifespan(app: FastAPI):
-    print("***** App started *****")
-    managers["chat"] = AutoGenChatManager(
-        message_queue=message_queue,
-        websocket_manager=websocket_manager,
-        human_input_timeout=HUMAN_INPUT_TIMEOUT_SECONDS,
-    )
-    dbmanager.create_db_and_tables()
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """
+    Lifecycle manager for the FastAPI application.
+    Handles initialization and cleanup of application resources.
+    """
+    # Startup
+    logger.info("Initializing application...")
+    try:
+        # Initialize managers (DB, Connection, Team)
+        await init_managers(initializer.database_uri, initializer.config_dir)
+        logger.info("Managers initialized successfully")
+
+        # Any other initialization code
+        logger.info("Application startup complete")
 
-    yield
-    # Close all active connections
-    await websocket_manager.disconnect_all()
-    print("***** App stopped *****")
+    except Exception as e:
+        logger.error(f"Failed to initialize application: {str(e)}")
+        raise
 
+    yield  # Application runs here
 
-app = FastAPI(lifespan=lifespan)
+    # Shutdown
+    try:
+        logger.info("Cleaning up application resources...")
+        await cleanup_managers()
+        logger.info("Application shutdown complete")
+    except Exception as e:
+        logger.error(f"Error during shutdown: {str(e)}")
 
+# Create FastAPI application
+app = FastAPI(lifespan=lifespan, debug=True)
 
-# allow cross origin requests for testing on localhost:800* ports only
+# CORS middleware configuration
 app.add_middleware(
     CORSMiddleware,
     allow_origins=[
@@ -101,412 +71,114 @@ async def lifespan(app: FastAPI):
     allow_headers=["*"],
 )
 
-show_docs = os.environ.get("AUTOGENSTUDIO_API_DOCS", "False").lower() == "true"
-docs_url = "/docs" if show_docs else None
+# Create API router with version and documentation
 api = FastAPI(
     root_path="/api",
     title="AutoGen Studio API",
     version=VERSION,
-    docs_url=docs_url,
-    description="AutoGen Studio is a low-code tool for building and testing multi-agent workflows using AutoGen.",
+    description="AutoGen Studio is a low-code tool for building and testing multi-agent workflows.",
+    docs_url="/docs" if settings.API_DOCS else None,
 )
-# mount an api route such that the main route serves the ui and the /api
-app.mount("/api", api)
 
-app.mount("/", StaticFiles(directory=ui_folder_path, html=True), name="ui")
-api.mount(
-    "/files",
-    StaticFiles(directory=folders["files_static_root"], html=True),
-    name="files",
+# Include all routers with their prefixes
+api.include_router(
+    sessions.router,
+    prefix="/sessions",
+    tags=["sessions"],
+    responses={404: {"description": "Not found"}},
 )
 
+api.include_router(
+    runs.router,
+    prefix="/runs",
+    tags=["runs"],
+    responses={404: {"description": "Not found"}},
+)
 
-# manage websocket connections
-
-
-def create_entity(model: Any, model_class: Any, filters: dict = None):
-    """Create a new entity"""
-    model = check_and_cast_datetime_fields(model)
-    try:
-        response: Response = dbmanager.upsert(model)
-        return response.model_dump(mode="json")
-
-    except Exception as ex_error:
-        print(ex_error)
-        return {
-            "status": False,
-            "message": f"Error occurred while creating {model_class.__name__}: " + str(ex_error),
-        }
-
-
-def list_entity(
-    model_class: Any,
-    filters: dict = None,
-    return_json: bool = True,
-    order: str = "desc",
-):
-    """List all entities for a user"""
-    return dbmanager.get(model_class, filters=filters, return_json=return_json, order=order)
-
-
-def delete_entity(model_class: Any, filters: dict = None):
-    """Delete an entity"""
-
-    return dbmanager.delete(filters=filters, model_class=model_class)
-
-
-@api.get("/skills")
-async def list_skills(user_id: str):
-    """List all skills for a user"""
-    filters = {"user_id": user_id}
-    return list_entity(Skill, filters=filters)
-
-
-@api.post("/skills")
-async def create_skill(skill: Skill):
-    """Create a new skill"""
-    filters = {"user_id": skill.user_id}
-    return create_entity(skill, Skill, filters=filters)
-
-
-@api.delete("/skills/delete")
-async def delete_skill(skill_id: int, user_id: str):
-    """Delete a skill"""
-    filters = {"id": skill_id, "user_id": user_id}
-    return delete_entity(Skill, filters=filters)
-
-
-@api.get("/models")
-async def list_models(user_id: str):
-    """List all models for a user"""
-    filters = {"user_id": user_id}
-    return list_entity(Model, filters=filters)
-
-
-@api.post("/models")
-async def create_model(model: Model):
-    """Create a new model"""
-    return create_entity(model, Model)
-
-
-@api.post("/models/test")
-async def test_model_endpoint(model: Model):
-    """Test a model"""
-    try:
-        response = test_model(model)
-        return {
-            "status": True,
-            "message": "Model tested successfully",
-            "data": response,
-        }
-    except (OpenAIError, Exception) as ex_error:
-        return {
-            "status": False,
-            "message": "Error occurred while testing model: " + str(ex_error),
-        }
-
-
-@api.delete("/models/delete")
-async def delete_model(model_id: int, user_id: str):
-    """Delete a model"""
-    filters = {"id": model_id, "user_id": user_id}
-    return delete_entity(Model, filters=filters)
-
-
-@api.get("/agents")
-async def list_agents(user_id: str):
-    """List all agents for a user"""
-    filters = {"user_id": user_id}
-    return list_entity(Agent, filters=filters)
-
-
-@api.post("/agents")
-async def create_agent(agent: Agent):
-    """Create a new agent"""
-    return create_entity(agent, Agent)
-
-
-@api.delete("/agents/delete")
-async def delete_agent(agent_id: int, user_id: str):
-    """Delete an agent"""
-    filters = {"id": agent_id, "user_id": user_id}
-    return delete_entity(Agent, filters=filters)
-
-
-@api.post("/agents/link/model/{agent_id}/{model_id}")
-async def link_agent_model(agent_id: int, model_id: int):
-    """Link a model to an agent"""
-    return dbmanager.link(link_type="agent_model", primary_id=agent_id, secondary_id=model_id)
-
-
-@api.delete("/agents/link/model/{agent_id}/{model_id}")
-async def unlink_agent_model(agent_id: int, model_id: int):
-    """Unlink a model from an agent"""
-    return dbmanager.unlink(link_type="agent_model", primary_id=agent_id, secondary_id=model_id)
-
-
-@api.get("/agents/link/model/{agent_id}")
-async def get_agent_models(agent_id: int):
-    """Get all models linked to an agent"""
-    return dbmanager.get_linked_entities("agent_model", agent_id, return_json=True)
-
-
-@api.post("/agents/link/skill/{agent_id}/{skill_id}")
-async def link_agent_skill(agent_id: int, skill_id: int):
-    """Link an a skill to an agent"""
-    return dbmanager.link(link_type="agent_skill", primary_id=agent_id, secondary_id=skill_id)
-
-
-@api.delete("/agents/link/skill/{agent_id}/{skill_id}")
-async def unlink_agent_skill(agent_id: int, skill_id: int):
-    """Unlink an a skill from an agent"""
-    return dbmanager.unlink(link_type="agent_skill", primary_id=agent_id, secondary_id=skill_id)
-
-
-@api.get("/agents/link/skill/{agent_id}")
-async def get_agent_skills(agent_id: int):
-    """Get all skills linked to an agent"""
-    return dbmanager.get_linked_entities("agent_skill", agent_id, return_json=True)
-
-
-@api.post("/agents/link/agent/{primary_agent_id}/{secondary_agent_id}")
-async def link_agent_agent(primary_agent_id: int, secondary_agent_id: int):
-    """Link an agent to another agent"""
-    return dbmanager.link(
-        link_type="agent_agent",
-        primary_id=primary_agent_id,
-        secondary_id=secondary_agent_id,
-    )
-
-
-@api.delete("/agents/link/agent/{primary_agent_id}/{secondary_agent_id}")
-async def unlink_agent_agent(primary_agent_id: int, secondary_agent_id: int):
-    """Unlink an agent from another agent"""
-    return dbmanager.unlink(
-        link_type="agent_agent",
-        primary_id=primary_agent_id,
-        secondary_id=secondary_agent_id,
-    )
-
-
-@api.get("/agents/link/agent/{agent_id}")
-async def get_linked_agents(agent_id: int):
-    """Get all agents linked to an agent"""
-    return dbmanager.get_linked_entities("agent_agent", agent_id, return_json=True)
-
-
-@api.get("/workflows")
-async def list_workflows(user_id: str):
-    """List all workflows for a user"""
-    filters = {"user_id": user_id}
-    return list_entity(Workflow, filters=filters)
-
-
-@api.get("/workflows/{workflow_id}")
-async def get_workflow(workflow_id: int, user_id: str):
-    """Get a workflow"""
-    filters = {"id": workflow_id, "user_id": user_id}
-    return list_entity(Workflow, filters=filters)
-
-
-@api.get("/workflows/export/{workflow_id}")
-async def export_workflow(workflow_id: int, user_id: str):
-    """Export a user workflow"""
-    response = Response(message="Workflow exported successfully", status=True, data=None)
-    try:
-        workflow_details = workflow_from_id(workflow_id, dbmanager=dbmanager)
-        response.data = workflow_details
-    except Exception as ex_error:
-        response.message = "Error occurred while exporting workflow: " + str(ex_error)
-        response.status = False
-    return response.model_dump(mode="json")
-
-
-@api.post("/workflows")
-async def create_workflow(workflow: Workflow):
-    """Create a new workflow"""
-    return create_entity(workflow, Workflow)
-
-
-@api.delete("/workflows/delete")
-async def delete_workflow(workflow_id: int, user_id: str):
-    """Delete a workflow"""
-    filters = {"id": workflow_id, "user_id": user_id}
-    return delete_entity(Workflow, filters=filters)
-
-
-@api.post("/workflows/link/agent/{workflow_id}/{agent_id}/{agent_type}")
-async def link_workflow_agent(workflow_id: int, agent_id: int, agent_type: str):
-    """Link an agent to a workflow"""
-    return dbmanager.link(
-        link_type="workflow_agent",
-        primary_id=workflow_id,
-        secondary_id=agent_id,
-        agent_type=agent_type,
-    )
-
-
-@api.post("/workflows/link/agent/{workflow_id}/{agent_id}/{agent_type}/{sequence_id}")
-async def link_workflow_agent_sequence(workflow_id: int, agent_id: int, agent_type: str, sequence_id: int):
-    """Link an agent to a workflow"""
-    print("Sequence ID: ", sequence_id)
-    return dbmanager.link(
-        link_type="workflow_agent",
-        primary_id=workflow_id,
-        secondary_id=agent_id,
-        agent_type=agent_type,
-        sequence_id=sequence_id,
-    )
-
-
-@api.delete("/workflows/link/agent/{workflow_id}/{agent_id}/{agent_type}")
-async def unlink_workflow_agent(workflow_id: int, agent_id: int, agent_type: str):
-    """Unlink an agent from a workflow"""
-    return dbmanager.unlink(
-        link_type="workflow_agent",
-        primary_id=workflow_id,
-        secondary_id=agent_id,
-        agent_type=agent_type,
-    )
-
-
-@api.delete("/workflows/link/agent/{workflow_id}/{agent_id}/{agent_type}/{sequence_id}")
-async def unlink_workflow_agent_sequence(workflow_id: int, agent_id: int, agent_type: str, sequence_id: int):
-    """Unlink an agent from a workflow sequence"""
-    return dbmanager.unlink(
-        link_type="workflow_agent",
-        primary_id=workflow_id,
-        secondary_id=agent_id,
-        agent_type=agent_type,
-        sequence_id=sequence_id,
-    )
-
-
-@api.get("/workflows/link/agent/{workflow_id}")
-async def get_linked_workflow_agents(workflow_id: int):
-    """Get all agents linked to a workflow"""
-    return dbmanager.get_linked_entities(
-        link_type="workflow_agent",
-        primary_id=workflow_id,
-        return_json=True,
-    )
-
-
-@api.get("/profiler/{message_id}")
-async def profile_agent_task_run(message_id: int):
-    """Profile an agent task run"""
-    try:
-        agent_message = dbmanager.get(Message, filters={"id": message_id}).data[0]
-
-        profile = profiler.profile(agent_message)
-        return {
-            "status": True,
-            "message": "Agent task run profiled successfully",
-            "data": profile,
-        }
-    except Exception as ex_error:
-        return {
-            "status": False,
-            "message": "Error occurred while profiling agent task run: " + str(ex_error),
-        }
-
-
-@api.get("/sessions")
-async def list_sessions(user_id: str):
-    """List all sessions for a user"""
-    filters = {"user_id": user_id}
-    return list_entity(Session, filters=filters)
-
-
-@api.post("/sessions")
-async def create_session(session: Session):
-    """Create a new session"""
-    return create_entity(session, Session)
+api.include_router(
+    teams.router,
+    prefix="/teams",
+    tags=["teams"],
+    responses={404: {"description": "Not found"}},
+)
 
+api.include_router(
+    agents.router,
+    prefix="/agents",
+    tags=["agents"],
+    responses={404: {"description": "Not found"}},
+)
 
-@api.delete("/sessions/delete")
-async def delete_session(session_id: int, user_id: str):
-    """Delete a session"""
-    filters = {"id": session_id, "user_id": user_id}
-    return delete_entity(Session, filters=filters)
+api.include_router(
+    models.router,
+    prefix="/models",
+    tags=["models"],
+    responses={404: {"description": "Not found"}},
+)
 
+api.include_router(
+    tools.router,
+    prefix="/tools",
+    tags=["tools"],
+    responses={404: {"description": "Not found"}},
+)
 
-@api.get("/sessions/{session_id}/messages")
-async def list_messages(user_id: str, session_id: int):
-    """List all messages for a use session"""
-    filters = {"user_id": user_id, "session_id": session_id}
-    return list_entity(Message, filters=filters, order="asc", return_json=True)
+api.include_router(
+    ws.router,
+    prefix="/ws",
+    tags=["websocket"],
+    responses={404: {"description": "Not found"}},
+)
 
 
-@api.post("/sessions/{session_id}/workflow/{workflow_id}/run")
-async def run_session_workflow(message: Message, session_id: int, workflow_id: int):
-    """Runs a workflow on provided message"""
-    try:
-        user_message_history = (
-            dbmanager.get(
-                Message,
-                filters={"user_id": message.user_id, "session_id": message.session_id},
-                return_json=True,
-            ).data
-            if session_id is not None
-            else []
-        )
-        # save incoming message
-        dbmanager.upsert(message)
-        user_dir = os.path.join(folders["files_static_root"], "user", sha256_hash(message.user_id))
-        os.makedirs(user_dir, exist_ok=True)
-        workflow = workflow_from_id(workflow_id, dbmanager=dbmanager)
-        agent_response: Message = await managers["chat"].a_chat(
-            message=message,
-            history=user_message_history,
-            user_dir=user_dir,
-            workflow=workflow,
-            connection_id=message.connection_id,
-        )
-
-        response: Response = dbmanager.upsert(agent_response)
-        return response.model_dump(mode="json")
-    except Exception as ex_error:
-        return {
-            "status": False,
-            "message": "Error occurred while processing message: " + str(ex_error),
-        }
+# Version endpoint
 
 
 @api.get("/version")
 async def get_version():
+    """Get API version"""
     return {
         "status": True,
         "message": "Version retrieved successfully",
         "data": {"version": VERSION},
     }
 
+# Health check endpoint
+
+
+@api.get("/health")
+async def health_check():
+    """API health check endpoint"""
+    return {
+        "status": True,
+        "message": "Service is healthy",
+    }
+
+# Mount static file directories
+app.mount("/api", api)
+app.mount(
+    "/files",
+    StaticFiles(directory=initializer.static_root, html=True),
+    name="files",
+)
+app.mount("/", StaticFiles(directory=initializer.ui_root, html=True), name="ui")
 
-# websockets
+# Error handlers
 
 
-async def process_socket_message(data: dict, websocket: WebSocket, client_id: str):
-    print(f"Client says: {data['type']}")
-    if data["type"] == "user_message":
-        user_message = Message(**data["data"])
-        session_id = data["data"].get("session_id", None)
-        workflow_id = data["data"].get("workflow_id", None)
-        response = await run_session_workflow(message=user_message, session_id=session_id, workflow_id=workflow_id)
-        response_socket_message = {
-            "type": "agent_response",
-            "data": response,
-            "connection_id": client_id,
-        }
-        await websocket_manager.send_message(response_socket_message, websocket)
+@app.exception_handler(500)
+async def internal_error_handler(request, exc):
+    logger.error(f"Internal error: {str(exc)}")
+    return {
+        "status": False,
+        "message": "Internal server error",
+        "detail": str(exc) if settings.API_DOCS else "Internal server error"
+    }
 
 
-@api.websocket("/ws/{client_id}")
-async def websocket_endpoint(websocket: WebSocket, client_id: str):
-    await websocket_manager.connect(websocket, client_id)
-    try:
-        while True:
-            data = await websocket.receive_json()
-            await process_socket_message(data, websocket, client_id)
-    except WebSocketDisconnect:
-        print(f"Client #{client_id} is disconnected")
-        await websocket_manager.disconnect(websocket)
+def create_app() -> FastAPI:
+    """
+    Factory function to create and configure the FastAPI application.
+    Useful for testing and different deployment scenarios.
+    """
+    return app
diff --git a/python/packages/autogen-studio/autogenstudio/web/config.py b/python/packages/autogen-studio/autogenstudio/web/config.py
new file mode 100644
index 000000000000..128edada9bf3
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/config.py
@@ -0,0 +1,18 @@
+# api/config.py
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    DATABASE_URI: str = "sqlite:///./autogen.db"
+    API_DOCS: bool = False
+    CLEANUP_INTERVAL: int = 300  # 5 minutes
+    SESSION_TIMEOUT: int = 3600  # 1 hour
+    CONFIG_DIR: str = "configs"  # Default config directory relative to app_root
+    DEFAULT_USER_ID: str = "guestuser@gmail.com"
+    UPGRADE_DATABASE: bool = False
+
+    class Config:
+        env_prefix = "AUTOGENSTUDIO_"
+
+
+settings = Settings()
diff --git a/python/packages/autogen-studio/autogenstudio/web/deps.py b/python/packages/autogen-studio/autogenstudio/web/deps.py
new file mode 100644
index 000000000000..b4c08e952aeb
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/deps.py
@@ -0,0 +1,201 @@
+# api/deps.py
+from typing import Optional
+from fastapi import Depends, HTTPException, status
+import logging
+from contextlib import contextmanager
+
+from ..database import DatabaseManager
+from .managers.connection import WebSocketManager
+from ..teammanager import TeamManager
+from .config import settings
+from ..database import ConfigurationManager
+
+logger = logging.getLogger(__name__)
+
+# Global manager instances
+_db_manager: Optional[DatabaseManager] = None
+_websocket_manager: Optional[WebSocketManager] = None
+_team_manager: Optional[TeamManager] = None
+
+# Context manager for database sessions
+
+
+@contextmanager
+def get_db_context():
+    """Provide a transactional scope around a series of operations."""
+    if not _db_manager:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Database manager not initialized"
+        )
+    try:
+        yield _db_manager
+    except Exception as e:
+        logger.error(f"Database operation failed: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Database operation failed"
+        )
+
+# Dependency providers
+
+
+async def get_db() -> DatabaseManager:
+    """Dependency provider for database manager"""
+    if not _db_manager:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Database manager not initialized"
+        )
+    return _db_manager
+
+
+async def get_websocket_manager() -> WebSocketManager:
+    """Dependency provider for connection manager"""
+    if not _websocket_manager:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Connection manager not initialized"
+        )
+    return _websocket_manager
+
+
+async def get_team_manager() -> TeamManager:
+    """Dependency provider for team manager"""
+    if not _team_manager:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Team manager not initialized"
+        )
+    return _team_manager
+
+# Authentication dependency
+
+
+async def get_current_user(
+    # Add your authentication logic here
+    # For example: token: str = Depends(oauth2_scheme)
+) -> str:
+    """
+    Dependency for getting the current authenticated user.
+    Replace with your actual authentication logic.
+    """
+    # Implement your user authentication here
+    return "user_id"  # Replace with actual user identification
+
+# Manager initialization and cleanup
+
+
+async def init_managers(database_uri: str, config_dir: str) -> None:
+    """Initialize all manager instances"""
+    global _db_manager, _websocket_manager, _team_manager
+
+    logger.info("Initializing managers...")
+
+    try:
+        # Initialize database manager
+        _db_manager = DatabaseManager(
+            engine_uri=database_uri, auto_upgrade=settings.UPGRADE_DATABASE)
+        _db_manager.create_db_and_tables()
+
+        # init default team config
+
+        _team_config_manager = ConfigurationManager(db_manager=_db_manager)
+        import_result = await _team_config_manager.import_directory(
+            config_dir, settings.DEFAULT_USER_ID, check_exists=True)
+
+        # Initialize connection manager
+        _websocket_manager = WebSocketManager(
+            db_manager=_db_manager
+        )
+        logger.info("Connection manager initialized")
+
+        # Initialize team manager
+        _team_manager = TeamManager()
+        logger.info("Team manager initialized")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize managers: {str(e)}")
+        await cleanup_managers()  # Cleanup any partially initialized managers
+        raise
+
+
+async def cleanup_managers() -> None:
+    """Cleanup and shutdown all manager instances"""
+    global _db_manager, _websocket_manager, _team_manager
+
+    logger.info("Cleaning up managers...")
+
+    # Cleanup connection manager first to ensure all active connections are closed
+    if _websocket_manager:
+        try:
+            await _websocket_manager.cleanup()
+        except Exception as e:
+            logger.error(f"Error cleaning up connection manager: {str(e)}")
+        finally:
+            _websocket_manager = None
+
+    # TeamManager doesn't need explicit cleanup since WebSocketManager handles it
+    _team_manager = None
+
+    # Cleanup database manager last
+    if _db_manager:
+        try:
+            await _db_manager.close()
+        except Exception as e:
+            logger.error(f"Error cleaning up database manager: {str(e)}")
+        finally:
+            _db_manager = None
+
+    logger.info("All managers cleaned up")
+
+# Utility functions for dependency management
+
+
+def get_manager_status() -> dict:
+    """Get the initialization status of all managers"""
+    return {
+        "database_manager": _db_manager is not None,
+        "websocket_manager": _websocket_manager is not None,
+        "team_manager": _team_manager is not None
+    }
+
+# Combined dependencies
+
+
+async def get_managers():
+    """Get all managers in one dependency"""
+    return {
+        "db": await get_db(),
+        "connection": await get_websocket_manager(),
+        "team": await get_team_manager()
+    }
+
+# Error handling for manager operations
+
+
+class ManagerOperationError(Exception):
+    """Custom exception for manager operation errors"""
+
+    def __init__(self, manager_name: str, operation: str, detail: str):
+        self.manager_name = manager_name
+        self.operation = operation
+        self.detail = detail
+        super().__init__(f"{manager_name} failed during {operation}: {detail}")
+
+# Dependency for requiring specific managers
+
+
+def require_managers(*manager_names: str):
+    """Decorator to require specific managers for a route"""
+    async def dependency():
+        status = get_manager_status()
+        missing = [name for name in manager_names if not status.get(
+            f"{name}_manager")]
+        if missing:
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail=f"Required managers not available: {', '.join(missing)}"
+            )
+        return True
+    return Depends(dependency)
diff --git a/python/packages/autogen-studio/autogenstudio/web/initialization.py b/python/packages/autogen-studio/autogenstudio/web/initialization.py
new file mode 100644
index 000000000000..e938d222062d
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/initialization.py
@@ -0,0 +1,110 @@
+# api/initialization.py
+import os
+from pathlib import Path
+from typing import Dict
+from pydantic import BaseModel
+from loguru import logger
+from dotenv import load_dotenv
+
+from .config import Settings
+
+
+class _AppPaths(BaseModel):
+    """Internal model representing all application paths"""
+    app_root: Path
+    static_root: Path
+    user_files: Path
+    ui_root: Path
+    config_dir: Path
+    database_uri: str
+
+
+class AppInitializer:
+    """Handles application initialization including paths and environment setup"""
+
+    def __init__(self, settings: Settings, app_path: str):
+        """
+        Initialize the application structure.
+
+        Args:
+            settings: Application settings
+            app_path: Path to the application code directory
+        """
+        self.settings = settings
+        self._app_path = Path(app_path)
+        self._paths = self._init_paths()
+        self._create_directories()
+        self._load_environment()
+        logger.info(f"Initialized application data folder: {self.app_root}")
+
+    def _get_app_root(self) -> Path:
+        """Determine application root directory"""
+        if app_dir := os.getenv("AUTOGENSTUDIO_APPDIR"):
+            return Path(app_dir)
+        return Path.home() / ".autogenstudio"
+
+    def _get_database_uri(self, app_root: Path) -> str:
+        """Generate database URI based on settings or environment"""
+        if db_uri := os.getenv("AUTOGENSTUDIO_DATABASE_URI"):
+            return db_uri
+        return self.settings.DATABASE_URI.replace(
+            "./", str(app_root) + "/"
+        )
+
+    def _init_paths(self) -> _AppPaths:
+        """Initialize and return AppPaths instance"""
+        app_root = self._get_app_root()
+        return _AppPaths(
+            app_root=app_root,
+            static_root=app_root / "files",
+            user_files=app_root / "files" / "user",
+            ui_root=self._app_path / "ui",
+            config_dir=app_root / self.settings.CONFIG_DIR,
+            database_uri=self._get_database_uri(app_root)
+        )
+
+    def _create_directories(self) -> None:
+        """Create all required directories"""
+        self.app_root.mkdir(parents=True, exist_ok=True)
+        dirs = [self.static_root, self.user_files,
+                self.ui_root, self.config_dir]
+        for path in dirs:
+            path.mkdir(parents=True, exist_ok=True)
+
+    def _load_environment(self) -> None:
+        """Load environment variables from .env file if it exists"""
+        env_file = self.app_root / ".env"
+        if env_file.exists():
+            logger.info(f"Loading environment variables from {env_file}")
+            load_dotenv(str(env_file))
+
+    # Properties for accessing paths
+    @property
+    def app_root(self) -> Path:
+        """Root directory for the application"""
+        return self._paths.app_root
+
+    @property
+    def static_root(self) -> Path:
+        """Directory for static files"""
+        return self._paths.static_root
+
+    @property
+    def user_files(self) -> Path:
+        """Directory for user files"""
+        return self._paths.user_files
+
+    @property
+    def ui_root(self) -> Path:
+        """Directory for UI files"""
+        return self._paths.ui_root
+
+    @property
+    def config_dir(self) -> Path:
+        """Directory for configuration files"""
+        return self._paths.config_dir
+
+    @property
+    def database_uri(self) -> str:
+        """Database connection URI"""
+        return self._paths.database_uri
diff --git a/python/packages/autogen-studio/autogenstudio/database/migrations/__init__.py b/python/packages/autogen-studio/autogenstudio/web/managers/__init__.py
similarity index 100%
rename from python/packages/autogen-studio/autogenstudio/database/migrations/__init__.py
rename to python/packages/autogen-studio/autogenstudio/web/managers/__init__.py
diff --git a/python/packages/autogen-studio/autogenstudio/web/managers/connection.py b/python/packages/autogen-studio/autogenstudio/web/managers/connection.py
new file mode 100644
index 000000000000..b46887b7ac1a
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/managers/connection.py
@@ -0,0 +1,247 @@
+# managers/connection.py
+from fastapi import WebSocket, WebSocketDisconnect
+from typing import Dict, Optional, Any
+from uuid import UUID
+import logging
+from datetime import datetime, timezone
+
+from ...datamodel import Run, RunStatus, TeamResult
+from ...database import DatabaseManager
+from autogen_agentchat.messages import InnerMessage, ChatMessage
+from autogen_core.base import CancellationToken
+
+logger = logging.getLogger(__name__)
+
+
+class WebSocketManager:
+    """Manages WebSocket connections and message streaming for team task execution"""
+
+    def __init__(self, db_manager: DatabaseManager):
+        self.db_manager = db_manager
+        self._connections: Dict[UUID, WebSocket] = {}
+        self._cancellation_tokens: Dict[UUID, CancellationToken] = {}
+
+    async def connect(self, websocket: WebSocket, run_id: UUID) -> bool:
+        """Initialize WebSocket connection for a run
+
+        Args:
+            websocket: The WebSocket connection to initialize
+            run_id: UUID of the run to associate with this connection
+
+        Returns:
+            bool: True if connection was successful, False otherwise
+        """
+        try:
+            await websocket.accept()
+            self._connections[run_id] = websocket
+
+            run = await self._get_run(run_id)
+            if run:
+                run.status = RunStatus.ACTIVE
+                self.db_manager.upsert(run)
+
+            await self._send_message(run_id, {
+                "type": "system",
+                "status": "connected",
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            })
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Connection error for run {run_id}: {e}")
+            return False
+
+    async def start_stream(
+        self,
+        run_id: UUID,
+        team_manager: Any,
+        task: str,
+        team_config: dict
+    ) -> None:
+        """Start streaming task execution
+
+        Args:
+            run_id: UUID of the run
+            team_manager: Instance of the team manager
+            task: Task string to execute
+            team_config: Team configuration dictionary
+        """
+        if run_id not in self._connections:
+            raise ValueError(f"No active connection for run {run_id}")
+
+        cancellation_token = CancellationToken()
+        self._cancellation_tokens[run_id] = cancellation_token
+
+        try:
+            async for message in team_manager.run_stream(
+                task=task,
+                team_config=team_config,
+                cancellation_token=cancellation_token
+            ):
+
+                if cancellation_token.is_cancelled():
+                    logger.info(f"Stream cancelled for run {run_id}")
+                    break
+
+                formatted_message = self._format_message(message)
+                if formatted_message:
+                    await self._send_message(run_id, formatted_message)
+
+            # Only send completion if not cancelled
+            if not cancellation_token.is_cancelled():
+                # await self._send_message(run_id, {
+                #     "type": "completion",
+                #     "status": "complete",
+                #     "timestamp": datetime.now(timezone.utc).isoformat()
+                # })
+                await self._update_run_status(run_id, RunStatus.COMPLETE)
+            else:
+                await self._send_message(run_id, {
+                    "type": "completion",
+                    "status": "cancelled",
+                    "timestamp": datetime.now(timezone.utc).isoformat()
+                })
+                await self._update_run_status(run_id, RunStatus.STOPPED)
+
+        except Exception as e:
+            logger.error(f"Stream error for run {run_id}: {e}")
+            await self._handle_stream_error(run_id, e)
+
+        finally:
+            self._cancellation_tokens.pop(run_id, None)
+
+    async def stop_run(self, run_id: UUID) -> None:
+        """Stop a running task"""
+        if run_id in self._cancellation_tokens:
+            logger.info(f"Stopping run {run_id}")
+            self._cancellation_tokens[run_id].cancel()
+
+            # Send final message if connection still exists
+            if run_id in self._connections:
+                try:
+                    await self._send_message(run_id, {
+                        "type": "completion",
+                        "status": "cancelled",
+                        "timestamp": datetime.now(timezone.utc).isoformat()
+                    })
+                except Exception:
+                    pass
+
+    async def disconnect(self, run_id: UUID) -> None:
+        """Clean up connection and associated resources"""
+        logger.info(f"Disconnecting run {run_id}")
+
+        # First cancel any running tasks
+        await self.stop_run(run_id)
+
+        # Then clean up resources without trying to close the socket again
+        if run_id in self._connections:
+            self._connections.pop(run_id, None)
+            self._cancellation_tokens.pop(run_id, None)
+
+    async def _send_message(self, run_id: UUID, message: dict) -> None:
+        """Send a message through the WebSocket
+
+        Args:
+            run_id: UUID of the run
+            message: Message dictionary to send
+        """
+        try:
+            if run_id in self._connections:
+                await self._connections[run_id].send_json(message)
+        except WebSocketDisconnect:
+            logger.warning(
+                f"WebSocket disconnected while sending message for run {run_id}")
+            await self.disconnect(run_id)
+        except Exception as e:
+            logger.error(f"Error sending message for run {run_id}: {e}")
+            await self._handle_stream_error(run_id, e)
+
+    async def _handle_stream_error(self, run_id: UUID, error: Exception) -> None:
+        """Handle stream errors consistently
+
+        Args:
+            run_id: UUID of the run
+            error: Exception that occurred
+        """
+        try:
+            await self._send_message(run_id, {
+                "type": "completion",
+                "status": "error",
+                "error": str(error),
+                "timestamp": datetime.now(timezone.utc).isoformat()
+            })
+        except Exception as send_error:
+            logger.error(
+                f"Failed to send error message for run {run_id}: {send_error}")
+
+        await self._update_run_status(run_id, RunStatus.ERROR, str(error))
+
+    def _format_message(self, message: Any) -> Optional[dict]:
+        """Format message for WebSocket transmission
+
+        Args:
+            message: Message to format
+
+        Returns:
+            Optional[dict]: Formatted message or None if formatting fails
+        """
+        try:
+            if isinstance(message, (InnerMessage, ChatMessage)):
+                return {
+                    "type": "message",
+                    "data": message.model_dump()
+                }
+            elif isinstance(message, TeamResult):
+                return {
+                    "type": "result",
+                    "data": message.model_dump(),
+                    "status": "complete",
+                }
+            return None
+        except Exception as e:
+            logger.error(f"Message formatting error: {e}")
+            return None
+
+    async def _get_run(self, run_id: UUID) -> Optional[Run]:
+        """Get run from database
+
+        Args:
+            run_id: UUID of the run to retrieve
+
+        Returns:
+            Optional[Run]: Run object if found, None otherwise
+        """
+        response = self.db_manager.get(
+            Run, filters={"id": run_id}, return_json=False)
+        return response.data[0] if response.status and response.data else None
+
+    async def _update_run_status(
+        self,
+        run_id: UUID,
+        status: RunStatus,
+        error: Optional[str] = None
+    ) -> None:
+        """Update run status in database
+
+        Args:
+            run_id: UUID of the run to update
+            status: New status to set
+            error: Optional error message
+        """
+        run = await self._get_run(run_id)
+        if run:
+            run.status = status
+            run.error_message = error
+            self.db_manager.upsert(run)
+
+    @property
+    def active_connections(self) -> set[UUID]:
+        """Get set of active run IDs"""
+        return set(self._connections.keys())
+
+    @property
+    def active_runs(self) -> set[UUID]:
+        """Get set of runs with active cancellation tokens"""
+        return set(self._cancellation_tokens.keys())
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/__init__.py b/python/packages/autogen-studio/autogenstudio/web/routes/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/agents.py b/python/packages/autogen-studio/autogenstudio/web/routes/agents.py
new file mode 100644
index 000000000000..183dbf2a5bee
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/agents.py
@@ -0,0 +1,181 @@
+# api/routes/agents.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict
+from ..deps import get_db
+from ...datamodel import Agent, Model, Tool
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_agents(
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all agents for a user"""
+    response = db.get(Agent, filters={"user_id": user_id})
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.get("/{agent_id}")
+async def get_agent(
+    agent_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Get a specific agent"""
+    response = db.get(
+        Agent,
+        filters={"id": agent_id, "user_id": user_id}
+    )
+    if not response.status or not response.data:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    return {
+        "status": True,
+        "data": response.data[0]
+    }
+
+
+@router.post("/")
+async def create_agent(
+    agent: Agent,
+    db=Depends(get_db)
+) -> Dict:
+    """Create a new agent"""
+    response = db.upsert(agent)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.delete("/{agent_id}")
+async def delete_agent(
+    agent_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Delete an agent"""
+    response = db.delete(
+        filters={"id": agent_id, "user_id": user_id},
+        model_class=Agent
+    )
+    return {
+        "status": True,
+        "message": "Agent deleted successfully"
+    }
+
+# Agent-Model link endpoints
+
+
+@router.post("/{agent_id}/models/{model_id}")
+async def link_agent_model(
+    agent_id: int,
+    model_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Link a model to an agent"""
+    response = db.link(
+        link_type="agent_model",
+        primary_id=agent_id,
+        secondary_id=model_id
+    )
+    return {
+        "status": True,
+        "message": "Model linked to agent successfully"
+    }
+
+
+@router.delete("/{agent_id}/models/{model_id}")
+async def unlink_agent_model(
+    agent_id: int,
+    model_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Unlink a model from an agent"""
+    response = db.unlink(
+        link_type="agent_model",
+        primary_id=agent_id,
+        secondary_id=model_id
+    )
+    return {
+        "status": True,
+        "message": "Model unlinked from agent successfully"
+    }
+
+
+@router.get("/{agent_id}/models")
+async def get_agent_models(
+    agent_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Get all models linked to an agent"""
+    response = db.get_linked_entities(
+        link_type="agent_model",
+        primary_id=agent_id,
+        return_json=True
+    )
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+# Agent-Tool link endpoints
+
+
+@router.post("/{agent_id}/tools/{tool_id}")
+async def link_agent_tool(
+    agent_id: int,
+    tool_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Link a tool to an agent"""
+    response = db.link(
+        link_type="agent_tool",
+        primary_id=agent_id,
+        secondary_id=tool_id
+    )
+    return {
+        "status": True,
+        "message": "Tool linked to agent successfully"
+    }
+
+
+@router.delete("/{agent_id}/tools/{tool_id}")
+async def unlink_agent_tool(
+    agent_id: int,
+    tool_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Unlink a tool from an agent"""
+    response = db.unlink(
+        link_type="agent_tool",
+        primary_id=agent_id,
+        secondary_id=tool_id
+    )
+    return {
+        "status": True,
+        "message": "Tool unlinked from agent successfully"
+    }
+
+
+@router.get("/{agent_id}/tools")
+async def get_agent_tools(
+    agent_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Get all tools linked to an agent"""
+    response = db.get_linked_entities(
+        link_type="agent_tool",
+        primary_id=agent_id,
+        return_json=True
+    )
+    return {
+        "status": True,
+        "data": response.data
+    }
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/models.py b/python/packages/autogen-studio/autogenstudio/web/routes/models.py
new file mode 100644
index 000000000000..9b57e6255458
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/models.py
@@ -0,0 +1,95 @@
+# api/routes/models.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict
+from openai import OpenAIError
+from ..deps import get_db
+from ...datamodel import Model
+from ...utils import test_model
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_models(
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all models for a user"""
+    response = db.get(Model, filters={"user_id": user_id})
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.get("/{model_id}")
+async def get_model(
+    model_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Get a specific model"""
+    response = db.get(
+        Model,
+        filters={"id": model_id, "user_id": user_id}
+    )
+    if not response.status or not response.data:
+        raise HTTPException(status_code=404, detail="Model not found")
+    return {
+        "status": True,
+        "data": response.data[0]
+    }
+
+
+@router.post("/")
+async def create_model(
+    model: Model,
+    db=Depends(get_db)
+) -> Dict:
+    """Create a new model"""
+    response = db.upsert(model)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.delete("/{model_id}")
+async def delete_model(
+    model_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Delete a model"""
+    response = db.delete(
+        filters={"id": model_id, "user_id": user_id},
+        model_class=Model
+    )
+    return {
+        "status": True,
+        "message": "Model deleted successfully"
+    }
+
+
+@router.post("/test")
+async def test_model_endpoint(model: Model) -> Dict:
+    """Test a model configuration"""
+    try:
+        response = test_model(model)
+        return {
+            "status": True,
+            "message": "Model tested successfully",
+            "data": response
+        }
+    except OpenAIError as e:
+        raise HTTPException(
+            status_code=400,
+            detail=f"OpenAI API error: {str(e)}"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error testing model: {str(e)}"
+        )
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/runs.py b/python/packages/autogen-studio/autogenstudio/web/routes/runs.py
new file mode 100644
index 000000000000..7fb5e7475ac0
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/runs.py
@@ -0,0 +1,76 @@
+# /api/runs routes
+from fastapi import APIRouter, Body, Depends, HTTPException
+from uuid import UUID
+from typing import Dict
+
+from pydantic import BaseModel
+from ..deps import get_db, get_websocket_manager, get_team_manager
+from ...datamodel import Run, Session, Message, Team, RunStatus, MessageConfig
+
+from ...teammanager import TeamManager
+from autogen_core.base import CancellationToken
+
+router = APIRouter()
+
+
+class CreateRunRequest(BaseModel):
+    session_id: int
+    user_id: str
+
+
+@router.post("/")
+async def create_run(
+    request: CreateRunRequest,
+    db=Depends(get_db),
+) -> Dict:
+    """Create a new run"""
+    session_response = db.get(
+        Session,
+        filters={"id": request.session_id, "user_id": request.user_id},
+        return_json=False
+    )
+    if not session_response.status or not session_response.data:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    try:
+
+        run = db.upsert(Run(session_id=request.session_id), return_json=False)
+        return {
+            "status":  run.status,
+            "data": {"run_id": str(run.data.id)}
+        }
+
+        # }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{run_id}/start")
+async def start_run(
+    run_id: UUID,
+    message: Message = Body(...),
+    ws_manager=Depends(get_websocket_manager),
+    team_manager=Depends(get_team_manager),
+    db=Depends(get_db),
+) -> Dict:
+    """Start streaming task execution"""
+
+    if isinstance(message.config, dict):
+        message.config = MessageConfig(**message.config)
+
+    session = db.get(Session, filters={
+                     "id": message.session_id}, return_json=False)
+
+    team = db.get(
+        Team, filters={"id": session.data[0].team_id}, return_json=False)
+
+    try:
+        await ws_manager.start_stream(run_id, team_manager, message.config.content, team.data[0].config)
+        return {
+            "status": True,
+            "message": "Stream started successfully",
+            "data": {"run_id": str(run_id)}
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/sessions.py b/python/packages/autogen-studio/autogenstudio/web/routes/sessions.py
new file mode 100644
index 000000000000..f74ee6288154
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/sessions.py
@@ -0,0 +1,114 @@
+# api/routes/sessions.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict
+from ..deps import get_db
+from ...datamodel import Session, Message
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_sessions(
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all sessions for a user"""
+    response = db.get(Session, filters={"user_id": user_id})
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.get("/{session_id}")
+async def get_session(
+    session_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Get a specific session"""
+    response = db.get(
+        Session,
+        filters={"id": session_id, "user_id": user_id}
+    )
+    if not response.status or not response.data:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return {
+        "status": True,
+        "data": response.data[0]
+    }
+
+
+@router.post("/")
+async def create_session(
+    session: Session,
+    db=Depends(get_db)
+) -> Dict:
+    """Create a new session"""
+    response = db.upsert(session)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.put("/{session_id}")
+async def update_session(
+    session_id: int,
+    user_id: str,
+    session: Session,
+    db=Depends(get_db)
+) -> Dict:
+    """Update an existing session"""
+    # First verify the session belongs to user
+    existing = db.get(
+        Session,
+        filters={"id": session_id, "user_id": user_id}
+    )
+    if not existing.status or not existing.data:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Update the session
+    response = db.upsert(session)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+
+    return {
+        "status": True,
+        "data": response.data,
+        "message": "Session updated successfully"
+    }
+
+
+@router.delete("/{session_id}")
+async def delete_session(
+    session_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Delete a session"""
+    response = db.delete(
+        filters={"id": session_id, "user_id": user_id},
+        model_class=Session
+    )
+    return {
+        "status": True,
+        "message": "Session deleted successfully"
+    }
+
+
+@router.get("/{session_id}/messages")
+async def list_messages(
+    session_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all messages for a session"""
+    filters = {"session_id": session_id, "user_id": user_id}
+    response = db.get(Message, filters=filters, order="asc")
+    return {
+        "status": True,
+        "data": response.data
+    }
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/teams.py b/python/packages/autogen-studio/autogenstudio/web/routes/teams.py
new file mode 100644
index 000000000000..854c195d3c71
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/teams.py
@@ -0,0 +1,146 @@
+# api/routes/teams.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict
+from ..deps import get_db
+from ...datamodel import Team
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_teams(
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all teams for a user"""
+    response = db.get(Team, filters={"user_id": user_id})
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.get("/{team_id}")
+async def get_team(
+    team_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Get a specific team"""
+    response = db.get(
+        Team,
+        filters={"id": team_id, "user_id": user_id}
+    )
+    if not response.status or not response.data:
+        raise HTTPException(status_code=404, detail="Team not found")
+    return {
+        "status": True,
+        "data": response.data[0]
+    }
+
+
+@router.post("/")
+async def create_team(
+    team: Team,
+    db=Depends(get_db)
+) -> Dict:
+    """Create a new team"""
+    response = db.upsert(team)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.delete("/{team_id}")
+async def delete_team(
+    team_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Delete a team"""
+    response = db.delete(
+        filters={"id": team_id, "user_id": user_id},
+        model_class=Team
+    )
+    return {
+        "status": True,
+        "message": "Team deleted successfully"
+    }
+
+# Team-Agent link endpoints
+
+
+@router.post("/{team_id}/agents/{agent_id}")
+async def link_team_agent(
+    team_id: int,
+    agent_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Link an agent to a team"""
+    response = db.link(
+        link_type="team_agent",
+        primary_id=team_id,
+        secondary_id=agent_id
+    )
+    return {
+        "status": True,
+        "message": "Agent linked to team successfully"
+    }
+
+
+@router.post("/{team_id}/agents/{agent_id}/{sequence_id}")
+async def link_team_agent_sequence(
+    team_id: int,
+    agent_id: int,
+    sequence_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Link an agent to a team with sequence"""
+    response = db.link(
+        link_type="team_agent",
+        primary_id=team_id,
+        secondary_id=agent_id,
+        sequence_id=sequence_id
+    )
+    return {
+        "status": True,
+        "message": "Agent linked to team with sequence successfully"
+    }
+
+
+@router.delete("/{team_id}/agents/{agent_id}")
+async def unlink_team_agent(
+    team_id: int,
+    agent_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Unlink an agent from a team"""
+    response = db.unlink(
+        link_type="team_agent",
+        primary_id=team_id,
+        secondary_id=agent_id
+    )
+    return {
+        "status": True,
+        "message": "Agent unlinked from team successfully"
+    }
+
+
+@router.get("/{team_id}/agents")
+async def get_team_agents(
+    team_id: int,
+    db=Depends(get_db)
+) -> Dict:
+    """Get all agents linked to a team"""
+    response = db.get_linked_entities(
+        link_type="team_agent",
+        primary_id=team_id,
+        return_json=True
+    )
+    return {
+        "status": True,
+        "data": response.data
+    }
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/tools.py b/python/packages/autogen-studio/autogenstudio/web/routes/tools.py
new file mode 100644
index 000000000000..d73b626038ad
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/tools.py
@@ -0,0 +1,103 @@
+# api/routes/tools.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict
+from ..deps import get_db
+from ...datamodel import Tool
+
+router = APIRouter()
+
+
+@router.get("/")
+async def list_tools(
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """List all tools for a user"""
+    response = db.get(Tool, filters={"user_id": user_id})
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.get("/{tool_id}")
+async def get_tool(
+    tool_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Get a specific tool"""
+    response = db.get(
+        Tool,
+        filters={"id": tool_id, "user_id": user_id}
+    )
+    if not response.status or not response.data:
+        raise HTTPException(status_code=404, detail="Tool not found")
+    return {
+        "status": True,
+        "data": response.data[0]
+    }
+
+
+@router.post("/")
+async def create_tool(
+    tool: Tool,
+    db=Depends(get_db)
+) -> Dict:
+    """Create a new tool"""
+    response = db.upsert(tool)
+    if not response.status:
+        raise HTTPException(status_code=400, detail=response.message)
+    return {
+        "status": True,
+        "data": response.data
+    }
+
+
+@router.delete("/{tool_id}")
+async def delete_tool(
+    tool_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Delete a tool"""
+    response = db.delete(
+        filters={"id": tool_id, "user_id": user_id},
+        model_class=Tool
+    )
+    return {
+        "status": True,
+        "message": "Tool deleted successfully"
+    }
+
+
+@router.post("/{tool_id}/test")
+async def test_tool(
+    tool_id: int,
+    user_id: str,
+    db=Depends(get_db)
+) -> Dict:
+    """Test a tool configuration"""
+    # Get tool
+    tool_response = db.get(
+        Tool,
+        filters={"id": tool_id, "user_id": user_id}
+    )
+    if not tool_response.status or not tool_response.data:
+        raise HTTPException(status_code=404, detail="Tool not found")
+
+    tool = tool_response.data[0]
+
+    try:
+        # Implement tool testing logic here
+        # This would depend on the tool type and configuration
+        return {
+            "status": True,
+            "message": "Tool tested successfully",
+            "data": {"tool_id": tool_id}
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error testing tool: {str(e)}"
+        )
diff --git a/python/packages/autogen-studio/autogenstudio/web/routes/ws.py b/python/packages/autogen-studio/autogenstudio/web/routes/ws.py
new file mode 100644
index 000000000000..8fd6844ff3ad
--- /dev/null
+++ b/python/packages/autogen-studio/autogenstudio/web/routes/ws.py
@@ -0,0 +1,74 @@
+# api/ws.py
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Depends, HTTPException
+from typing import Dict
+from uuid import UUID
+import logging
+import json
+from datetime import datetime
+
+from ..deps import get_websocket_manager, get_db, get_team_manager
+from ...datamodel import Run, RunStatus
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+@router.websocket("/runs/{run_id}")
+async def run_websocket(
+    websocket: WebSocket,
+    run_id: UUID,
+    ws_manager=Depends(get_websocket_manager),
+    db=Depends(get_db),
+    team_manager=Depends(get_team_manager)
+):
+    """WebSocket endpoint for run communication"""
+    # Verify run exists and is in valid state
+    run_response = db.get(Run, filters={"id": run_id}, return_json=False)
+    if not run_response.status or not run_response.data:
+        await websocket.close(code=4004, reason="Run not found")
+        return
+
+    run = run_response.data[0]
+    if run.status not in [RunStatus.CREATED, RunStatus.ACTIVE]:
+        await websocket.close(code=4003, reason="Run not in valid state")
+        return
+
+    # Connect websocket
+    connected = await ws_manager.connect(websocket, run_id)
+    if not connected:
+        await websocket.close(code=4002, reason="Failed to establish connection")
+        return
+
+    try:
+        logger.info(f"WebSocket connection established for run {run_id}")
+
+        while True:
+            try:
+                raw_message = await websocket.receive_text()
+                message = json.loads(raw_message)
+
+                if message.get("type") == "stop":
+                    logger.info(f"Received stop request for run {run_id}")
+                    await ws_manager.stop_run(run_id)
+                    break
+
+                elif message.get("type") == "ping":
+                    await websocket.send_json({
+                        "type": "pong",
+                        "timestamp": datetime.utcnow().isoformat()
+                    })
+
+            except json.JSONDecodeError:
+                logger.warning(f"Invalid JSON received: {raw_message}")
+                await websocket.send_json({
+                    "type": "error",
+                    "error": "Invalid message format",
+                    "timestamp": datetime.utcnow().isoformat()
+                })
+
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected for run {run_id}")
+    except Exception as e:
+        logger.error(f"WebSocket error: {str(e)}")
+    finally:
+        await ws_manager.disconnect(run_id)
diff --git a/python/packages/autogen-studio/autogenstudio/websocket_connection_manager.py b/python/packages/autogen-studio/autogenstudio/websocket_connection_manager.py
deleted file mode 100644
index 73f7ef896811..000000000000
--- a/python/packages/autogen-studio/autogenstudio/websocket_connection_manager.py
+++ /dev/null
@@ -1,135 +0,0 @@
-import asyncio
-from typing import Any, Dict, List, Optional, Tuple, Union
-
-import websockets
-from fastapi import WebSocket, WebSocketDisconnect
-
-
-class WebSocketConnectionManager:
-    """
-    Manages WebSocket connections including sending, broadcasting, and managing the lifecycle of connections.
-    """
-
-    def __init__(
-        self,
-        active_connections: List[Tuple[WebSocket, str]] = None,
-        active_connections_lock: asyncio.Lock = None,
-    ) -> None:
-        """
-        Initializes WebSocketConnectionManager with an optional list of active WebSocket connections.
-
-        :param active_connections: A list of tuples, each containing a WebSocket object and its corresponding client_id.
-        """
-        if active_connections is None:
-            active_connections = []
-        self.active_connections_lock = active_connections_lock
-        self.active_connections: List[Tuple[WebSocket, str]] = active_connections
-
-    async def connect(self, websocket: WebSocket, client_id: str) -> None:
-        """
-        Accepts a new WebSocket connection and appends it to the active connections list.
-
-        :param websocket: The WebSocket instance representing a client connection.
-        :param client_id: A string representing the unique identifier of the client.
-        """
-        await websocket.accept()
-        async with self.active_connections_lock:
-            self.active_connections.append((websocket, client_id))
-            print(f"New Connection: {client_id}, Total: {len(self.active_connections)}")
-
-    async def disconnect(self, websocket: WebSocket) -> None:
-        """
-        Disconnects and removes a WebSocket connection from the active connections list.
-
-        :param websocket: The WebSocket instance to remove.
-        """
-        async with self.active_connections_lock:
-            try:
-                self.active_connections = [conn for conn in self.active_connections if conn[0] != websocket]
-                print(f"Connection Closed. Total: {len(self.active_connections)}")
-            except ValueError:
-                print("Error: WebSocket connection not found")
-
-    async def disconnect_all(self) -> None:
-        """
-        Disconnects all active WebSocket connections.
-        """
-        for connection, _ in self.active_connections[:]:
-            await self.disconnect(connection)
-
-    async def send_message(self, message: Union[Dict, str], websocket: WebSocket) -> None:
-        """
-        Sends a JSON message to a single WebSocket connection.
-
-        :param message: A JSON serializable dictionary containing the message to send.
-        :param websocket: The WebSocket instance through which to send the message.
-        """
-        try:
-            async with self.active_connections_lock:
-                await websocket.send_json(message)
-        except WebSocketDisconnect:
-            print("Error: Tried to send a message to a closed WebSocket")
-            await self.disconnect(websocket)
-        except websockets.exceptions.ConnectionClosedOK:
-            print("Error: WebSocket connection closed normally")
-            await self.disconnect(websocket)
-        except Exception as e:
-            print(f"Error in sending message: {str(e)}", message)
-            await self.disconnect(websocket)
-
-    async def get_input(self, prompt: Union[Dict, str], websocket: WebSocket, timeout: int = 60) -> str:
-        """
-        Sends a JSON message to a single WebSocket connection as a prompt for user input.
-        Waits on a user response or until the given timeout elapses.
-
-        :param prompt: A JSON serializable dictionary containing the message to send.
-        :param websocket: The WebSocket instance through which to send the message.
-        """
-        response = "Error: Unexpected response.\nTERMINATE"
-        try:
-            async with self.active_connections_lock:
-                await websocket.send_json(prompt)
-                result = await asyncio.wait_for(websocket.receive_json(), timeout=timeout)
-                data = result.get("data")
-                if data:
-                    response = data.get("content", "Error: Unexpected response format\nTERMINATE")
-                else:
-                    response = "Error: Unexpected response format\nTERMINATE"
-
-        except asyncio.TimeoutError:
-            response = f"The user was timed out after {timeout} seconds of inactivity.\nTERMINATE"
-        except WebSocketDisconnect:
-            print("Error: Tried to send a message to a closed WebSocket")
-            await self.disconnect(websocket)
-            response = "The user was disconnected\nTERMINATE"
-        except websockets.exceptions.ConnectionClosedOK:
-            print("Error: WebSocket connection closed normally")
-            await self.disconnect(websocket)
-            response = "The user was disconnected\nTERMINATE"
-        except Exception as e:
-            print(f"Error in sending message: {str(e)}", prompt)
-            await self.disconnect(websocket)
-            response = f"Error: {e}\nTERMINATE"
-
-        return response
-
-    async def broadcast(self, message: Dict) -> None:
-        """
-        Broadcasts a JSON message to all active WebSocket connections.
-
-        :param message: A JSON serializable dictionary containing the message to broadcast.
-        """
-        # Create a message dictionary with the desired format
-        message_dict = {"message": message}
-
-        for connection, _ in self.active_connections[:]:
-            try:
-                if connection.client_state == websockets.protocol.State.OPEN:
-                    # Call send_message method with the message dictionary and current WebSocket connection
-                    await self.send_message(message_dict, connection)
-                else:
-                    print("Error: WebSocket connection is closed")
-                    await self.disconnect(connection)
-            except (WebSocketDisconnect, websockets.exceptions.ConnectionClosedOK) as e:
-                print(f"Error: WebSocket disconnected or closed({str(e)})")
-                await self.disconnect(connection)
diff --git a/python/packages/autogen-studio/autogenstudio/workflowmanager.py b/python/packages/autogen-studio/autogenstudio/workflowmanager.py
deleted file mode 100644
index 2da3b58b7cec..000000000000
--- a/python/packages/autogen-studio/autogenstudio/workflowmanager.py
+++ /dev/null
@@ -1,1066 +0,0 @@
-import json
-import os
-import time
-from datetime import datetime
-from typing import Any, Coroutine, Dict, List, Optional, Union
-
-import autogen
-
-from .datamodel import (
-    Agent,
-    AgentType,
-    CodeExecutionConfigTypes,
-    Message,
-    SocketMessage,
-    Workflow,
-    WorkFlowSummaryMethod,
-    WorkFlowType,
-)
-from .utils import (
-    clear_folder,
-    find_key_value,
-    get_modified_files,
-    get_skills_prompt,
-    load_code_execution_config,
-    sanitize_model,
-    save_skills_to_file,
-    summarize_chat_history,
-)
-
-
-class AutoWorkflowManager:
-    """
-    WorkflowManager class to load agents from a provided configuration and run a chat between them.
-    """
-
-    def __init__(
-        self,
-        workflow: Union[Dict, str],
-        history: Optional[List[Message]] = None,
-        work_dir: str = None,
-        clear_work_dir: bool = True,
-        send_message_function: Optional[callable] = None,
-        a_send_message_function: Optional[Coroutine] = None,
-        a_human_input_function: Optional[callable] = None,
-        a_human_input_timeout: Optional[int] = 60,
-        connection_id: Optional[str] = None,
-    ) -> None:
-        """
-        Initializes the WorkflowManager with agents specified in the config and optional message history.
-
-        Args:
-            workflow (Union[Dict, str]): The workflow configuration. This can be a dictionary or a string which is a path to a JSON file.
-            history (Optional[List[Message]]): The message history.
-            work_dir (str): The working directory.
-            clear_work_dir (bool): If set to True, clears the working directory.
-            send_message_function (Optional[callable]): The function to send messages.
-            a_send_message_function (Optional[Coroutine]): Async coroutine to send messages.
-            a_human_input_function (Optional[callable]): Async coroutine to prompt the user for input.
-            a_human_input_timeout (Optional[int]): A time (in seconds) to wait for user input.  After this time, the a_human_input_function will timeout and end the conversation.
-            connection_id (Optional[str]): The connection identifier.
-        """
-        if isinstance(workflow, str):
-            if os.path.isfile(workflow):
-                with open(workflow, "r") as file:
-                    self.workflow = json.load(file)
-            else:
-                raise FileNotFoundError(f"The file {workflow} does not exist.")
-        elif isinstance(workflow, dict):
-            self.workflow = workflow
-        else:
-            raise ValueError("The 'workflow' parameter should be either a dictionary or a valid JSON file path")
-
-        # TODO - improved typing for workflow
-        self.workflow_skills = []
-        self.send_message_function = send_message_function
-        self.a_send_message_function = a_send_message_function
-        self.a_human_input_function = a_human_input_function
-        self.a_human_input_timeout = a_human_input_timeout
-        self.connection_id = connection_id
-        self.work_dir = work_dir or "work_dir"
-        self.code_executor_pool = {
-            CodeExecutionConfigTypes.local: load_code_execution_config(
-                CodeExecutionConfigTypes.local, work_dir=self.work_dir
-            ),
-            CodeExecutionConfigTypes.docker: load_code_execution_config(
-                CodeExecutionConfigTypes.docker, work_dir=self.work_dir
-            ),
-        }
-        if clear_work_dir:
-            clear_folder(self.work_dir)
-        self.agent_history = []
-        self.history = history or []
-        self.sender = None
-        self.receiver = None
-
-    def _run_workflow(self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False) -> None:
-        """
-        Runs the workflow based on the provided configuration.
-
-        Args:
-            message: The initial message to start the chat.
-            history: A list of messages to populate the agents' history.
-            clear_history: If set to True, clears the chat history before initiating.
-
-        """
-        for agent in self.workflow.get("agents", []):
-            if agent.get("link").get("agent_type") == "sender":
-                self.sender = self.load(agent.get("agent"))
-            elif agent.get("link").get("agent_type") == "receiver":
-                self.receiver = self.load(agent.get("agent"))
-        if self.sender and self.receiver:
-            # save all agent skills to skills.py
-            save_skills_to_file(self.workflow_skills, self.work_dir)
-            if history:
-                self._populate_history(history)
-            self.sender.initiate_chat(
-                self.receiver,
-                message=message,
-                clear_history=clear_history,
-            )
-        else:
-            raise ValueError("Sender and receiver agents are not defined in the workflow configuration.")
-
-    async def _a_run_workflow(
-        self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False
-    ) -> None:
-        """
-        Asynchronously runs the workflow based on the provided configuration.
-
-        Args:
-            message: The initial message to start the chat.
-            history: A list of messages to populate the agents' history.
-            clear_history: If set to True, clears the chat history before initiating.
-
-        """
-        for agent in self.workflow.get("agents", []):
-            if agent.get("link").get("agent_type") == "sender":
-                self.sender = self.load(agent.get("agent"))
-            elif agent.get("link").get("agent_type") == "receiver":
-                self.receiver = self.load(agent.get("agent"))
-        if self.sender and self.receiver:
-            # save all agent skills to skills.py
-            save_skills_to_file(self.workflow_skills, self.work_dir)
-            if history:
-                self._populate_history(history)
-            await self.sender.a_initiate_chat(
-                self.receiver,
-                message=message,
-                clear_history=clear_history,
-            )
-        else:
-            raise ValueError("Sender and receiver agents are not defined in the workflow configuration.")
-
-    def _serialize_agent(
-        self,
-        agent: Agent,
-        mode: str = "python",
-        include: Optional[List[str]] = {"config"},
-        exclude: Optional[List[str]] = None,
-    ) -> Dict:
-        """ """
-        # exclude = ["id","created_at", "updated_at","user_id","type"]
-        exclude = exclude or {}
-        include = include or {}
-        if agent.type != AgentType.groupchat:
-            exclude.update(
-                {
-                    "config": {
-                        "admin_name",
-                        "messages",
-                        "max_round",
-                        "admin_name",
-                        "speaker_selection_method",
-                        "allow_repeat_speaker",
-                    }
-                }
-            )
-        else:
-            include = {
-                "config": {
-                    "admin_name",
-                    "messages",
-                    "max_round",
-                    "admin_name",
-                    "speaker_selection_method",
-                    "allow_repeat_speaker",
-                }
-            }
-        result = agent.model_dump(warnings=False, exclude=exclude, include=include, mode=mode)
-        return result["config"]
-
-    def process_message(
-        self,
-        sender: autogen.Agent,
-        receiver: autogen.Agent,
-        message: Dict,
-        request_reply: bool = False,
-        silent: bool = False,
-        sender_type: str = "agent",
-    ) -> None:
-        """
-        Processes the message and adds it to the agent history.
-
-        Args:
-
-            sender: The sender of the message.
-            receiver: The receiver of the message.
-            message: The message content.
-            request_reply: If set to True, the message will be added to agent history.
-            silent: determining verbosity.
-            sender_type: The type of the sender of the message.
-        """
-
-        message = message if isinstance(message, dict) else {"content": message, "role": "user"}
-        message_payload = {
-            "recipient": receiver.name,
-            "sender": sender.name,
-            "message": message,
-            "timestamp": datetime.now().isoformat(),
-            "sender_type": sender_type,
-            "connection_id": self.connection_id,
-            "message_type": "agent_message",
-        }
-        # if the agent will respond to the message, or the message is sent by a groupchat agent.
-        # This avoids adding groupchat broadcast messages to the history (which are sent with request_reply=False),
-        # or when agent populated from history
-        if request_reply is not False or sender_type == "groupchat":
-            self.agent_history.append(message_payload)  # add to history
-            if self.send_message_function:  # send over the message queue
-                socket_msg = SocketMessage(
-                    type="agent_message",
-                    data=message_payload,
-                    connection_id=self.connection_id,
-                )
-                self.send_message_function(socket_msg.dict())
-
-    async def a_process_message(
-        self,
-        sender: autogen.Agent,
-        receiver: autogen.Agent,
-        message: Dict,
-        request_reply: bool = False,
-        silent: bool = False,
-        sender_type: str = "agent",
-    ) -> None:
-        """
-        Asynchronously processes the message and adds it to the agent history.
-
-        Args:
-
-            sender: The sender of the message.
-            receiver: The receiver of the message.
-            message: The message content.
-            request_reply: If set to True, the message will be added to agent history.
-            silent: determining verbosity.
-            sender_type: The type of the sender of the message.
-        """
-
-        message = message if isinstance(message, dict) else {"content": message, "role": "user"}
-        message_payload = {
-            "recipient": receiver.name,
-            "sender": sender.name,
-            "message": message,
-            "timestamp": datetime.now().isoformat(),
-            "sender_type": sender_type,
-            "connection_id": self.connection_id,
-            "message_type": "agent_message",
-        }
-        # if the agent will respond to the message, or the message is sent by a groupchat agent.
-        # This avoids adding groupchat broadcast messages to the history (which are sent with request_reply=False),
-        # or when agent populated from history
-        if request_reply is not False or sender_type == "groupchat":
-            self.agent_history.append(message_payload)  # add to history
-            socket_msg = SocketMessage(
-                type="agent_message",
-                data=message_payload,
-                connection_id=self.connection_id,
-            )
-            if self.a_send_message_function:  # send over the message queue
-                await self.a_send_message_function(socket_msg.dict())
-            elif self.send_message_function:  # send over the message queue
-                self.send_message_function(socket_msg.dict())
-
-    def _populate_history(self, history: List[Message]) -> None:
-        """
-        Populates the agent message history from the provided list of messages.
-
-        Args:
-            history: A list of messages to populate the agents' history.
-        """
-        for msg in history:
-            if isinstance(msg, dict):
-                msg = Message(**msg)
-            if msg.role == "user":
-                self.sender.send(
-                    msg.content,
-                    self.receiver,
-                    request_reply=False,
-                    silent=True,
-                )
-            elif msg.role == "assistant":
-                self.receiver.send(
-                    msg.content,
-                    self.sender,
-                    request_reply=False,
-                    silent=True,
-                )
-
-    def sanitize_agent(self, agent: Dict) -> Agent:
-        """ """
-
-        skills = agent.get("skills", [])
-
-        # When human input mode is not NEVER and no model is attached, the ui is passing bogus llm_config.
-        configured_models = agent.get("models")
-        if not configured_models or len(configured_models) == 0:
-            agent["config"]["llm_config"] = False
-
-        agent = Agent.model_validate(agent)
-        agent.config.is_termination_msg = agent.config.is_termination_msg or (
-            lambda x: "TERMINATE" in x.get("content", "").rstrip()[-20:]
-        )
-
-        def get_default_system_message(agent_type: str) -> str:
-            if agent_type == "assistant":
-                return autogen.AssistantAgent.DEFAULT_SYSTEM_MESSAGE
-            else:
-                return "You are a helpful AI Assistant."
-
-        if agent.config.llm_config is not False:
-            config_list = []
-            for llm in agent.config.llm_config.config_list:
-                # check if api_key is present either in llm or env variable
-                if "api_key" not in llm and "OPENAI_API_KEY" not in os.environ:
-                    error_message = f"api_key is not present in llm_config or OPENAI_API_KEY env variable for agent ** {agent.config.name}**. Update your workflow to provide an api_key to use the LLM."
-                    raise ValueError(error_message)
-
-                # only add key if value is not None
-                sanitized_llm = sanitize_model(llm)
-                config_list.append(sanitized_llm)
-            agent.config.llm_config.config_list = config_list
-
-        agent.config.code_execution_config = self.code_executor_pool.get(agent.config.code_execution_config, False)
-
-        if skills:
-            for skill in skills:
-                self.workflow_skills.append(skill)
-            skills_prompt = ""
-            skills_prompt = get_skills_prompt(skills, self.work_dir)
-            if agent.config.system_message:
-                agent.config.system_message = agent.config.system_message + "\n\n" + skills_prompt
-            else:
-                agent.config.system_message = get_default_system_message(agent.type) + "\n\n" + skills_prompt
-        return agent
-
-    def load(self, agent: Any) -> autogen.Agent:
-        """
-        Loads an agent based on the provided agent specification.
-
-        Args:
-            agent_spec: The specification of the agent to be loaded.
-
-        Returns:
-            An instance of the loaded agent.
-        """
-        if not agent:
-            raise ValueError(
-                "An agent configuration in this workflow is empty. Please provide a valid agent configuration."
-            )
-
-        linked_agents = agent.get("agents", [])
-        agent = self.sanitize_agent(agent)
-        if agent.type == "groupchat":
-            groupchat_agents = [self.load(agent) for agent in linked_agents]
-            group_chat_config = self._serialize_agent(agent)
-            group_chat_config["agents"] = groupchat_agents
-            groupchat = autogen.GroupChat(**group_chat_config)
-            agent = ExtendedGroupChatManager(
-                groupchat=groupchat,
-                message_processor=self.process_message,
-                a_message_processor=self.a_process_message,
-                a_human_input_function=self.a_human_input_function,
-                a_human_input_timeout=self.a_human_input_timeout,
-                connection_id=self.connection_id,
-                llm_config=agent.config.llm_config.model_dump(),
-            )
-            return agent
-
-        else:
-            if agent.type == "assistant":
-                agent = ExtendedConversableAgent(
-                    **self._serialize_agent(agent),
-                    message_processor=self.process_message,
-                    a_message_processor=self.a_process_message,
-                    a_human_input_function=self.a_human_input_function,
-                    a_human_input_timeout=self.a_human_input_timeout,
-                    connection_id=self.connection_id,
-                )
-            elif agent.type == "userproxy":
-                agent = ExtendedConversableAgent(
-                    **self._serialize_agent(agent),
-                    message_processor=self.process_message,
-                    a_message_processor=self.a_process_message,
-                    a_human_input_function=self.a_human_input_function,
-                    a_human_input_timeout=self.a_human_input_timeout,
-                    connection_id=self.connection_id,
-                )
-            else:
-                raise ValueError(f"Unknown agent type: {agent.type}")
-            return agent
-
-    def _generate_output(
-        self,
-        message_text: str,
-        summary_method: str,
-    ) -> str:
-        """
-        Generates the output response based on the workflow configuration and agent history.
-
-        :param message_text: The text of the incoming message.
-        :param flow: An instance of `WorkflowManager`.
-        :param flow_config: An instance of `AgentWorkFlowConfig`.
-        :return: The output response as a string.
-        """
-
-        output = ""
-        if summary_method == WorkFlowSummaryMethod.last:
-            (self.agent_history)
-            last_message = self.agent_history[-1]["message"]["content"] if self.agent_history else ""
-            output = last_message
-        elif summary_method == WorkFlowSummaryMethod.llm:
-            client = self.receiver.client
-            if self.connection_id:
-                status_message = SocketMessage(
-                    type="agent_status",
-                    data={
-                        "status": "summarizing",
-                        "message": "Summarizing agent dialogue",
-                    },
-                    connection_id=self.connection_id,
-                )
-                self.send_message_function(status_message.model_dump(mode="json"))
-            output = summarize_chat_history(
-                task=message_text,
-                messages=self.agent_history,
-                client=client,
-            )
-
-        elif summary_method == "none":
-            output = ""
-        return output
-
-    def _get_agent_usage(self, agent: autogen.Agent):
-        final_usage = []
-        default_usage = {"total_cost": 0, "total_tokens": 0}
-        agent_usage = agent.client.total_usage_summary if agent.client else default_usage
-        agent_usage = {
-            "agent": agent.name,
-            "total_cost": find_key_value(agent_usage, "total_cost") or 0,
-            "total_tokens": find_key_value(agent_usage, "total_tokens") or 0,
-        }
-        final_usage.append(agent_usage)
-
-        if type(agent) == ExtendedGroupChatManager:
-            print("groupchat found, processing", len(agent.groupchat.agents))
-            for agent in agent.groupchat.agents:
-                agent_usage = agent.client.total_usage_summary if agent.client else default_usage or default_usage
-                agent_usage = {
-                    "agent": agent.name,
-                    "total_cost": find_key_value(agent_usage, "total_cost") or 0,
-                    "total_tokens": find_key_value(agent_usage, "total_tokens") or 0,
-                }
-                final_usage.append(agent_usage)
-        return final_usage
-
-    def _get_usage_summary(self):
-        sender_usage = self._get_agent_usage(self.sender)
-        receiver_usage = self._get_agent_usage(self.receiver)
-
-        all_usage = []
-        all_usage.extend(sender_usage)
-        all_usage.extend(receiver_usage)
-        # all_usage = [sender_usage, receiver_usage]
-        return all_usage
-
-    def run(self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False) -> Message:
-        """
-        Initiates a chat between the sender and receiver agents with an initial message
-        and an option to clear the history.
-
-        Args:
-            message: The initial message to start the chat.
-            clear_history: If set to True, clears the chat history before initiating.
-        """
-
-        start_time = time.time()
-        self._run_workflow(message=message, history=history, clear_history=clear_history)
-        end_time = time.time()
-
-        output = self._generate_output(message, self.workflow.get("summary_method", "last"))
-
-        usage = self._get_usage_summary()
-        # print("usage", usage)
-
-        result_message = Message(
-            content=output,
-            role="assistant",
-            meta={
-                "messages": self.agent_history,
-                "summary_method": self.workflow.get("summary_method", "last"),
-                "time": end_time - start_time,
-                "files": get_modified_files(start_time, end_time, source_dir=self.work_dir),
-                "usage": usage,
-            },
-        )
-        return result_message
-
-    async def a_run(
-        self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False
-    ) -> Message:
-        """
-        Asynchronously initiates a chat between the sender and receiver agents with an initial message
-        and an option to clear the history.
-
-        Args:
-            message: The initial message to start the chat.
-            clear_history: If set to True, clears the chat history before initiating.
-        """
-
-        start_time = time.time()
-        await self._a_run_workflow(message=message, history=history, clear_history=clear_history)
-        end_time = time.time()
-
-        output = self._generate_output(message, self.workflow.get("summary_method", "last"))
-
-        usage = self._get_usage_summary()
-        # print("usage", usage)
-
-        result_message = Message(
-            content=output,
-            role="assistant",
-            meta={
-                "messages": self.agent_history,
-                "summary_method": self.workflow.get("summary_method", "last"),
-                "time": end_time - start_time,
-                "files": get_modified_files(start_time, end_time, source_dir=self.work_dir),
-                "usage": usage,
-            },
-        )
-        return result_message
-
-
-class SequentialWorkflowManager:
-    """
-    WorkflowManager class to load agents from a provided configuration and run a chat between them sequentially.
-    """
-
-    def __init__(
-        self,
-        workflow: Union[Dict, str],
-        history: Optional[List[Message]] = None,
-        work_dir: str = None,
-        clear_work_dir: bool = True,
-        send_message_function: Optional[callable] = None,
-        a_send_message_function: Optional[Coroutine] = None,
-        a_human_input_function: Optional[callable] = None,
-        a_human_input_timeout: Optional[int] = 60,
-        connection_id: Optional[str] = None,
-    ) -> None:
-        """
-        Initializes the WorkflowManager with agents specified in the config and optional message history.
-
-        Args:
-            workflow (Union[Dict, str]): The workflow configuration. This can be a dictionary or a string which is a path to a JSON file.
-            history (Optional[List[Message]]): The message history.
-            work_dir (str): The working directory.
-            clear_work_dir (bool): If set to True, clears the working directory.
-            send_message_function (Optional[callable]): The function to send messages.
-            a_send_message_function (Optional[Coroutine]): Async coroutine to send messages.
-            a_human_input_function (Optional[callable]): Async coroutine to prompt for human input.
-            a_human_input_timeout (Optional[int]): A time (in seconds) to wait for user input.  After this time, the a_human_input_function will timeout and end the conversation.
-            connection_id (Optional[str]): The connection identifier.
-        """
-        if isinstance(workflow, str):
-            if os.path.isfile(workflow):
-                with open(workflow, "r") as file:
-                    self.workflow = json.load(file)
-            else:
-                raise FileNotFoundError(f"The file {workflow} does not exist.")
-        elif isinstance(workflow, dict):
-            self.workflow = workflow
-        else:
-            raise ValueError("The 'workflow' parameter should be either a dictionary or a valid JSON file path")
-
-        # TODO - improved typing for workflow
-        self.send_message_function = send_message_function
-        self.a_send_message_function = a_send_message_function
-        self.a_human_input_function = a_human_input_function
-        self.a_human_input_timeout = a_human_input_timeout
-        self.connection_id = connection_id
-        self.work_dir = work_dir or "work_dir"
-        if clear_work_dir:
-            clear_folder(self.work_dir)
-        self.agent_history = []
-        self.history = history or []
-        self.sender = None
-        self.receiver = None
-        self.model_client = None
-
-    def _run_workflow(self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False) -> None:
-        """
-        Runs the workflow based on the provided configuration.
-
-        Args:
-            message: The initial message to start the chat.
-            history: A list of messages to populate the agents' history.
-            clear_history: If set to True, clears the chat history before initiating.
-
-        """
-        user_proxy = {
-            "config": {
-                "name": "user_proxy",
-                "human_input_mode": "NEVER",
-                "max_consecutive_auto_reply": 25,
-                "code_execution_config": "local",
-                "default_auto_reply": "TERMINATE",
-                "description": "User Proxy Agent Configuration",
-                "llm_config": False,
-                "type": "userproxy",
-            }
-        }
-        sequential_history = []
-        for i, agent in enumerate(self.workflow.get("agents", [])):
-            workflow = Workflow(
-                name="agent workflow", type=WorkFlowType.autonomous, summary_method=WorkFlowSummaryMethod.llm
-            )
-            workflow = workflow.model_dump(mode="json")
-            agent = agent.get("agent")
-            workflow["agents"] = [
-                {"agent": user_proxy, "link": {"agent_type": "sender"}},
-                {"agent": agent, "link": {"agent_type": "receiver"}},
-            ]
-
-            auto_workflow = AutoWorkflowManager(
-                workflow=workflow,
-                history=history,
-                work_dir=self.work_dir,
-                clear_work_dir=True,
-                send_message_function=self.send_message_function,
-                a_send_message_function=self.a_send_message_function,
-                a_human_input_timeout=self.a_human_input_timeout,
-                connection_id=self.connection_id,
-            )
-            task_prompt = (
-                f"""
-            Your primary instructions are as follows:
-            {agent.get("task_instruction")}
-            Context for addressing your task is below:
-            =======
-            {str(sequential_history)}
-            =======
-            Now address your task:
-            """
-                if i > 0
-                else message
-            )
-            result = auto_workflow.run(message=task_prompt, clear_history=clear_history)
-            sequential_history.append(result.content)
-            self.model_client = auto_workflow.receiver.client
-            print(f"======== end of sequence === {i}============")
-            self.agent_history.extend(result.meta.get("messages", []))
-
-    async def _a_run_workflow(
-        self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False
-    ) -> None:
-        """
-        Asynchronously runs the workflow based on the provided configuration.
-
-        Args:
-            message: The initial message to start the chat.
-            history: A list of messages to populate the agents' history.
-            clear_history: If set to True, clears the chat history before initiating.
-
-        """
-        user_proxy = {
-            "config": {
-                "name": "user_proxy",
-                "human_input_mode": "NEVER",
-                "max_consecutive_auto_reply": 25,
-                "code_execution_config": "local",
-                "default_auto_reply": "TERMINATE",
-                "description": "User Proxy Agent Configuration",
-                "llm_config": False,
-                "type": "userproxy",
-            }
-        }
-        sequential_history = []
-        for i, agent in enumerate(self.workflow.get("agents", [])):
-            workflow = Workflow(
-                name="agent workflow", type=WorkFlowType.autonomous, summary_method=WorkFlowSummaryMethod.llm
-            )
-            workflow = workflow.model_dump(mode="json")
-            agent = agent.get("agent")
-            workflow["agents"] = [
-                {"agent": user_proxy, "link": {"agent_type": "sender"}},
-                {"agent": agent, "link": {"agent_type": "receiver"}},
-            ]
-
-            auto_workflow = AutoWorkflowManager(
-                workflow=workflow,
-                history=history,
-                work_dir=self.work_dir,
-                clear_work_dir=True,
-                send_message_function=self.send_message_function,
-                a_send_message_function=self.a_send_message_function,
-                a_human_input_function=self.a_human_input_function,
-                a_human_input_timeout=self.a_human_input_timeout,
-                connection_id=self.connection_id,
-            )
-            task_prompt = (
-                f"""
-            Your primary instructions are as follows:
-            {agent.get("task_instruction")}
-            Context for addressing your task is below:
-            =======
-            {str(sequential_history)}
-            =======
-            Now address your task:
-            """
-                if i > 0
-                else message
-            )
-            result = await auto_workflow.a_run(message=task_prompt, clear_history=clear_history)
-            sequential_history.append(result.content)
-            self.model_client = auto_workflow.receiver.client
-            print(f"======== end of sequence === {i}============")
-            self.agent_history.extend(result.meta.get("messages", []))
-
-    def _generate_output(
-        self,
-        message_text: str,
-        summary_method: str,
-    ) -> str:
-        """
-        Generates the output response based on the workflow configuration and agent history.
-
-        :param message_text: The text of the incoming message.
-        :param flow: An instance of `WorkflowManager`.
-        :param flow_config: An instance of `AgentWorkFlowConfig`.
-        :return: The output response as a string.
-        """
-
-        output = ""
-        if summary_method == WorkFlowSummaryMethod.last:
-            (self.agent_history)
-            last_message = self.agent_history[-1]["message"]["content"] if self.agent_history else ""
-            output = last_message
-        elif summary_method == WorkFlowSummaryMethod.llm:
-            if self.connection_id:
-                status_message = SocketMessage(
-                    type="agent_status",
-                    data={
-                        "status": "summarizing",
-                        "message": "Summarizing agent dialogue",
-                    },
-                    connection_id=self.connection_id,
-                )
-                self.send_message_function(status_message.model_dump(mode="json"))
-            output = summarize_chat_history(
-                task=message_text,
-                messages=self.agent_history,
-                client=self.model_client,
-            )
-
-        elif summary_method == "none":
-            output = ""
-        return output
-
-    def run(self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False) -> Message:
-        """
-        Initiates a chat between the sender and receiver agents with an initial message
-        and an option to clear the history.
-
-        Args:
-            message: The initial message to start the chat.
-            clear_history: If set to True, clears the chat history before initiating.
-        """
-
-        start_time = time.time()
-        self._run_workflow(message=message, history=history, clear_history=clear_history)
-        end_time = time.time()
-        output = self._generate_output(message, self.workflow.get("summary_method", "last"))
-
-        result_message = Message(
-            content=output,
-            role="assistant",
-            meta={
-                "messages": self.agent_history,
-                "summary_method": self.workflow.get("summary_method", "last"),
-                "time": end_time - start_time,
-                "files": get_modified_files(start_time, end_time, source_dir=self.work_dir),
-                "task": message,
-            },
-        )
-        return result_message
-
-    async def a_run(
-        self, message: str, history: Optional[List[Message]] = None, clear_history: bool = False
-    ) -> Message:
-        """
-        Asynchronously initiates a chat between the sender and receiver agents with an initial message
-        and an option to clear the history.
-
-        Args:
-            message: The initial message to start the chat.
-            clear_history: If set to True, clears the chat history before initiating.
-        """
-
-        start_time = time.time()
-        await self._a_run_workflow(message=message, history=history, clear_history=clear_history)
-        end_time = time.time()
-        output = self._generate_output(message, self.workflow.get("summary_method", "last"))
-
-        result_message = Message(
-            content=output,
-            role="assistant",
-            meta={
-                "messages": self.agent_history,
-                "summary_method": self.workflow.get("summary_method", "last"),
-                "time": end_time - start_time,
-                "files": get_modified_files(start_time, end_time, source_dir=self.work_dir),
-                "task": message,
-            },
-        )
-        return result_message
-
-
-class WorkflowManager:
-    """
-    WorkflowManager class to load agents from a provided configuration and run a chat between them.
-    """
-
-    def __new__(
-        self,
-        workflow: Union[Dict, str],
-        history: Optional[List[Message]] = None,
-        work_dir: str = None,
-        clear_work_dir: bool = True,
-        send_message_function: Optional[callable] = None,
-        a_send_message_function: Optional[Coroutine] = None,
-        a_human_input_function: Optional[callable] = None,
-        a_human_input_timeout: Optional[int] = 60,
-        connection_id: Optional[str] = None,
-    ) -> None:
-        """
-        Initializes the WorkflowManager with agents specified in the config and optional message history.
-
-        Args:
-            workflow (Union[Dict, str]): The workflow configuration. This can be a dictionary or a string which is a path to a JSON file.
-            history (Optional[List[Message]]): The message history.
-            work_dir (str): The working directory.
-            clear_work_dir (bool): If set to True, clears the working directory.
-            send_message_function (Optional[callable]): The function to send messages.
-            a_send_message_function (Optional[Coroutine]): Async coroutine to send messages.
-            a_human_input_function (Optional[callable]): Async coroutine to prompt for user input.
-            a_human_input_timeout (Optional[int]): A time (in seconds) to wait for user input.  After this time, the a_human_input_function will timeout and end the conversation.
-            connection_id (Optional[str]): The connection identifier.
-        """
-        if isinstance(workflow, str):
-            if os.path.isfile(workflow):
-                with open(workflow, "r") as file:
-                    self.workflow = json.load(file)
-            else:
-                raise FileNotFoundError(f"The file {workflow} does not exist.")
-        elif isinstance(workflow, dict):
-            self.workflow = workflow
-        else:
-            raise ValueError("The 'workflow' parameter should be either a dictionary or a valid JSON file path")
-
-        if self.workflow.get("type") == WorkFlowType.autonomous.value:
-            return AutoWorkflowManager(
-                workflow=workflow,
-                history=history,
-                work_dir=work_dir,
-                clear_work_dir=clear_work_dir,
-                send_message_function=send_message_function,
-                a_send_message_function=a_send_message_function,
-                a_human_input_function=a_human_input_function,
-                a_human_input_timeout=a_human_input_timeout,
-                connection_id=connection_id,
-            )
-        elif self.workflow.get("type") == WorkFlowType.sequential.value:
-            return SequentialWorkflowManager(
-                workflow=workflow,
-                history=history,
-                work_dir=work_dir,
-                clear_work_dir=clear_work_dir,
-                send_message_function=send_message_function,
-                a_send_message_function=a_send_message_function,
-                a_human_input_function=a_human_input_function,
-                a_human_input_timeout=a_human_input_timeout,
-                connection_id=connection_id,
-            )
-
-
-class ExtendedConversableAgent(autogen.ConversableAgent):
-    def __init__(
-        self,
-        message_processor=None,
-        a_message_processor=None,
-        a_human_input_function=None,
-        a_human_input_timeout: Optional[int] = 60,
-        connection_id=None,
-        *args,
-        **kwargs,
-    ):
-
-        super().__init__(*args, **kwargs)
-        self.message_processor = message_processor
-        self.a_message_processor = a_message_processor
-        self.a_human_input_function = a_human_input_function
-        self.a_human_input_response = None
-        self.a_human_input_timeout = a_human_input_timeout
-        self.connection_id = connection_id
-
-    def receive(
-        self,
-        message: Union[Dict, str],
-        sender: autogen.Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
-    ):
-        if self.message_processor:
-            self.message_processor(sender, self, message, request_reply, silent, sender_type="agent")
-        super().receive(message, sender, request_reply, silent)
-
-    async def a_receive(
-        self,
-        message: Union[Dict, str],
-        sender: autogen.Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
-    ) -> None:
-        if self.a_message_processor:
-            await self.a_message_processor(sender, self, message, request_reply, silent, sender_type="agent")
-        elif self.message_processor:
-            self.message_processor(sender, self, message, request_reply, silent, sender_type="agent")
-        await super().a_receive(message, sender, request_reply, silent)
-
-    # Strangely, when the response from a_get_human_input == "" (empty string) the libs call into the
-    # sync version.  I guess that's "just in case", but it's odd because replying with an empty string
-    # is the intended way for the user to signal the underlying libs that they want to system to go forward
-    # with whatever function call, tool call or AI generated response the request calls for.  Oh well,
-    # Que Sera Sera.
-    def get_human_input(self, prompt: str) -> str:
-        if self.a_human_input_response is None:
-            return super().get_human_input(prompt)
-        else:
-            response = self.a_human_input_response
-            self.a_human_input_response = None
-            return response
-
-    async def a_get_human_input(self, prompt: str) -> str:
-        if self.message_processor and self.a_human_input_function:
-            message_dict = {"content": prompt, "role": "system", "type": "user-input-request"}
-
-            message_payload = {
-                "recipient": self.name,
-                "sender": "system",
-                "message": message_dict,
-                "timestamp": datetime.now().isoformat(),
-                "sender_type": "system",
-                "connection_id": self.connection_id,
-                "message_type": "agent_message",
-            }
-
-            socket_msg = SocketMessage(
-                type="user_input_request",
-                data=message_payload,
-                connection_id=self.connection_id,
-            )
-            self.a_human_input_response = await self.a_human_input_function(
-                socket_msg.dict(), self.a_human_input_timeout
-            )
-            return self.a_human_input_response
-
-        else:
-            result = await super().a_get_human_input(prompt)
-            return result
-
-
-class ExtendedGroupChatManager(autogen.GroupChatManager):
-    def __init__(
-        self,
-        message_processor=None,
-        a_message_processor=None,
-        a_human_input_function=None,
-        a_human_input_timeout: Optional[int] = 60,
-        connection_id=None,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-        self.message_processor = message_processor
-        self.a_message_processor = a_message_processor
-        self.a_human_input_function = a_human_input_function
-        self.a_human_input_response = None
-        self.a_human_input_timeout = a_human_input_timeout
-        self.connection_id = connection_id
-
-    def receive(
-        self,
-        message: Union[Dict, str],
-        sender: autogen.Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
-    ):
-        if self.message_processor:
-            self.message_processor(sender, self, message, request_reply, silent, sender_type="groupchat")
-        super().receive(message, sender, request_reply, silent)
-
-    async def a_receive(
-        self,
-        message: Union[Dict, str],
-        sender: autogen.Agent,
-        request_reply: Optional[bool] = None,
-        silent: Optional[bool] = False,
-    ) -> None:
-        if self.a_message_processor:
-            await self.a_message_processor(sender, self, message, request_reply, silent, sender_type="agent")
-        elif self.message_processor:
-            self.message_processor(sender, self, message, request_reply, silent, sender_type="agent")
-        await super().a_receive(message, sender, request_reply, silent)
-
-    def get_human_input(self, prompt: str) -> str:
-        if self.a_human_input_response is None:
-            return super().get_human_input(prompt)
-        else:
-            response = self.a_human_input_response
-            self.a_human_input_response = None
-            return response
-
-    async def a_get_human_input(self, prompt: str) -> str:
-        if self.message_processor and self.a_human_input_function:
-            message_dict = {"content": prompt, "role": "system", "type": "user-input-request"}
-
-            message_payload = {
-                "recipient": self.name,
-                "sender": "system",
-                "message": message_dict,
-                "timestamp": datetime.now().isoformat(),
-                "sender_type": "system",
-                "connection_id": self.connection_id,
-                "message_type": "agent_message",
-            }
-            socket_msg = SocketMessage(
-                type="user_input_request",
-                data=message_payload,
-                connection_id=self.connection_id,
-            )
-            result = await self.a_human_input_function(socket_msg.dict(), self.a_human_input_timeout)
-            return result
-
-        else:
-            result = await super().a_get_human_input(prompt)
-            return result
diff --git a/python/packages/autogen-studio/frontend/.env.default b/python/packages/autogen-studio/frontend/.env.default
index 7f0839b275d2..9bd224b3320c 100644
--- a/python/packages/autogen-studio/frontend/.env.default
+++ b/python/packages/autogen-studio/frontend/.env.default
@@ -1 +1 @@
-GATSBY_API_URL=http://127.0.0.1:8081/api
+GATSBY_API_URL=http://127.0.0.1:8081/api 
\ No newline at end of file
diff --git a/python/packages/autogen-studio/frontend/.gitignore b/python/packages/autogen-studio/frontend/.gitignore
index 8a0ea868f24b..f48f83a425b5 100644
--- a/python/packages/autogen-studio/frontend/.gitignore
+++ b/python/packages/autogen-studio/frontend/.gitignore
@@ -1,8 +1,6 @@
 node_modules/
 .cache/
-public/
-
+public
+src/gatsby-types.d.ts
 .env.development
-.env.production
-
-yarn.lock
+.env.production
\ No newline at end of file
diff --git a/python/packages/autogen-studio/frontend/LICENSE b/python/packages/autogen-studio/frontend/LICENSE
deleted file mode 100644
index 16ab6489c8ed..000000000000
--- a/python/packages/autogen-studio/frontend/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Victor Dibia
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/python/packages/autogen-studio/frontend/README.md b/python/packages/autogen-studio/frontend/README.md
index b707495cf42a..768541b0d06a 100644
--- a/python/packages/autogen-studio/frontend/README.md
+++ b/python/packages/autogen-studio/frontend/README.md
@@ -2,8 +2,8 @@
 
 Run the UI in dev mode (make changes and see them reflected in the browser with hotreloading):
 
-- npm install
-- npm run start
+- yarn install
+- yarn start
 
 This should start the server on port 8000.
 
diff --git a/python/packages/autogen-studio/frontend/gatsby-config.ts b/python/packages/autogen-studio/frontend/gatsby-config.ts
index f66761c24be8..6497a72fe558 100644
--- a/python/packages/autogen-studio/frontend/gatsby-config.ts
+++ b/python/packages/autogen-studio/frontend/gatsby-config.ts
@@ -14,22 +14,20 @@ require("dotenv").config({
 });
 
 const config: GatsbyConfig = {
-  pathPrefix: process.env.PREFIX_PATH_VALUE || '',
+  pathPrefix: process.env.PREFIX_PATH_VALUE || "",
   siteMetadata: {
     title: `AutoGen Studio [Beta]`,
     description: `Build Multi-Agent Apps`,
     siteUrl: `http://tbd.place`,
   },
-  flags: {
-    LAZY_IMAGES: true,
-    FAST_DEV: true,
-    DEV_SSR: false,
-  },
+  // More easily incorporate content into your pages through automatic TypeScript type generation and better GraphQL IntelliSense.
+  // If you use VSCode you can also use the GraphQL plugin
+  // Learn more at: https://gatsby.dev/graphql-typegen
+  graphqlTypegen: true,
   plugins: [
-    "gatsby-plugin-sass",
+    "gatsby-plugin-postcss",
     "gatsby-plugin-image",
     "gatsby-plugin-sitemap",
-    "gatsby-plugin-postcss",
     {
       resolve: "gatsby-plugin-manifest",
       options: {
diff --git a/python/packages/autogen-studio/frontend/package.json b/python/packages/autogen-studio/frontend/package.json
index 7a06f09dac03..24ba03e190f3 100644
--- a/python/packages/autogen-studio/frontend/package.json
+++ b/python/packages/autogen-studio/frontend/package.json
@@ -1,9 +1,9 @@
 {
-  "name": "AutoGen_Studio",
+  "name": "autogentstudio",
   "version": "1.0.0",
   "private": true,
   "description": "AutoGen Studio - Build LLM Enabled Agents",
-  "author": "SPIRAL Team",
+  "author": "Microsoft",
   "keywords": [
     "gatsby"
   ],
@@ -17,55 +17,41 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ant-design/charts": "^1.3.6",
+    "@ant-design/charts": "^2.2.1",
     "@ant-design/plots": "^2.2.2",
     "@headlessui/react": "^1.7.16",
     "@heroicons/react": "^2.0.18",
-    "@mdx-js/mdx": "^1.6.22",
-    "@mdx-js/react": "^1.6.22",
+    "@mdx-js/react": "^3.1.0",
     "@monaco-editor/react": "^4.6.0",
-    "@tailwindcss/line-clamp": "^0.4.0",
     "@tailwindcss/typography": "^0.5.9",
-    "@types/lodash.debounce": "^4.0.9",
-    "@types/react-syntax-highlighter": "^15.5.10",
     "antd": "^5.1.0",
-    "autoprefixer": "^10.4.7",
-    "gatsby": "^4.14.0",
-    "gatsby-plugin-image": "^2.14.1",
-    "gatsby-plugin-manifest": "^4.14.0",
-    "gatsby-plugin-mdx": "^3.14.0",
-    "gatsby-plugin-postcss": "^5.14.0",
-    "gatsby-plugin-sass": "^5.14.0",
-    "gatsby-plugin-sharp": "^4.14.1",
-    "gatsby-plugin-sitemap": "^5.14.0",
-    "gatsby-source-filesystem": "^4.14.0",
-    "gatsby-transformer-sharp": "^4.14.0",
-    "jszip": "^3.10.1",
-    "lodash.debounce": "^4.0.8",
-    "papaparse": "^5.4.1",
-    "postcss": "^8.4.13",
+    "autoprefixer": "^10.4.20",
+    "gatsby": "^5.13.7",
+    "gatsby-plugin-image": "^3.13.1",
+    "gatsby-plugin-manifest": "^5.13.1",
+    "gatsby-plugin-mdx": "^5.13.1",
+    "gatsby-plugin-postcss": "^6.13.1",
+    "gatsby-plugin-sharp": "^5.13.1",
+    "gatsby-plugin-sitemap": "^6.13.1",
+    "gatsby-source-filesystem": "^5.13.1",
+    "gatsby-transformer-sharp": "^5.13.1",
+    "install": "^0.13.0",
+    "lucide-react": "^0.454.0",
+    "postcss": "^8.4.47",
     "react": "^18.2.0",
-    "react-contenteditable": "^3.3.6",
     "react-dom": "^18.2.0",
-    "react-inner-image-zoom": "^3.0.2",
-    "react-markdown": "^8.0.7",
-    "react-resizable": "^3.0.5",
-    "react-router-dom": "^6.3.0",
-    "react-syntax-highlighter": "^15.5.0",
-    "remark-gfm": "^3.0.1",
-    "sass": "^1.51.0",
-    "tailwindcss": "^3.0.24",
-    "uuid": "^9.0.1",
-    "zustand": "^4.4.6"
+    "react-markdown": "^9.0.1",
+    "tailwindcss": "^3.4.14",
+    "yarn": "^1.22.22",
+    "zustand": "^5.0.1"
   },
   "devDependencies": {
-    "@types/node": "^18.7.13",
-    "@types/papaparse": "^5.3.14",
-    "@types/react": "^18.2.48",
-    "@types/react-dom": "^18.2.15",
-    "@types/react-inner-image-zoom": "^3.0.0",
-    "@types/react-resizable": "^3.0.2",
-    "@types/uuid": "^9.0.8",
-    "typescript": "^4.6.4"
+    "@types/lodash.debounce": "^4.0.9",
+    "@types/node": "^20.11.19",
+    "@types/react": "^18.2.55",
+    "@types/react-dom": "^18.2.19",
+    "@types/react-syntax-highlighter": "^15.5.10",
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.3.3"
   }
 }
diff --git a/python/packages/autogen-studio/frontend/postcss.config.js b/python/packages/autogen-studio/frontend/postcss.config.js
index e8351e2a4d51..33ad091d26d8 100644
--- a/python/packages/autogen-studio/frontend/postcss.config.js
+++ b/python/packages/autogen-studio/frontend/postcss.config.js
@@ -1,4 +1,6 @@
-
-module.exports = () => ({
-  plugins: [require("tailwindcss")],
-})
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
diff --git a/python/packages/autogen-studio/frontend/src/components/atoms.tsx b/python/packages/autogen-studio/frontend/src/components/atoms.tsx
deleted file mode 100644
index 8f52e60281b7..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/atoms.tsx
+++ /dev/null
@@ -1,873 +0,0 @@
-import {
-  ChevronDownIcon,
-  ChevronUpIcon,
-  Cog8ToothIcon,
-  XMarkIcon,
-  ClipboardIcon,
-  InformationCircleIcon,
-} from "@heroicons/react/24/outline";
-import React, { ReactNode, useEffect, useRef, useState } from "react";
-import Icon from "./icons";
-import { Modal, Table, Tooltip, theme } from "antd";
-import Editor from "@monaco-editor/react";
-import Papa from "papaparse";
-import remarkGfm from "remark-gfm";
-import ReactMarkdown from "react-markdown";
-import { atomDark } from "react-syntax-highlighter/dist/esm/styles/prism";
-import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
-import { truncateText } from "./utils";
-
-const { useToken } = theme;
-interface CodeProps {
-  node?: any;
-  inline?: any;
-  className?: any;
-  children?: React.ReactNode;
-}
-
-interface IProps {
-  children?: ReactNode;
-  title?: string | ReactNode;
-  subtitle?: string | ReactNode;
-  count?: number;
-  active?: boolean;
-  cursor?: string;
-  icon?: ReactNode;
-  padding?: string;
-  className?: string;
-  open?: boolean;
-  hoverable?: boolean;
-  onClick?: () => void;
-  loading?: boolean;
-}
-
-export const SectionHeader = ({
-  children,
-  title,
-  subtitle,
-  count,
-  icon,
-}: IProps) => {
-  return (
-    

-      

-        {/* {count !== null && {count}} */}
-        {icon && <>{icon}}
-        {title}
-        {count !== null && (
-          {count}
-        )}
-      

-      {subtitle && {subtitle}}
-      {children}
-    

-  );
-};
-
-export const IconButton = ({
-  onClick,
-  icon,
-  className,
-  active = false,
-}: IProps) => {
-  return (
-    
-      {icon}
-    
-  );
-};
-
-export const LaunchButton = ({
-  children,
-  onClick,
-  className = "p-3 px-5 ",
-}: any) => {
-  return (
-    
-  );
-};
-
-export const SecondaryButton = ({ children, onClick, className }: any) => {
-  return (
-    
-  );
-};
-
-export const Card = ({
-  children,
-  title,
-  subtitle,
-  hoverable = true,
-  active,
-  cursor = "cursor-pointer",
-  className = "p-3",
-  onClick,
-}: IProps) => {
-  let border = active
-    ? "border-accent"
-    : "border-secondary hover:border-accent ";
-  border = hoverable ? border : "border-secondary";
-
-  return (
-    
-  );
-};
-
-export const CollapseBox = ({
-  title,
-  subtitle,
-  children,
-  className = " p-3",
-  open = false,
-}: IProps) => {
-  const [isOpen, setIsOpen] = React.useState(open);
-  const chevronClass = "h-4 cursor-pointer inline-block mr-1";
-  return (
-    
 {
-        if (e.detail > 1) {
-          e.preventDefault();
-        }
-      }}
-      className="bordper border-secondary rounded"
-    >
-      
 {
-          setIsOpen(!isOpen);
-        }}
-        className={`cursor-pointer bg-secondary p-2 rounded ${
-          isOpen ? "rounded-b-none " : " "
-        }"}`}
-      >
-        {isOpen && }
-        {!isOpen && }
-
-        
-          {" "}
-          {/* {isOpen ? "hide" : "show"} section |  */}
-          {title}
-        
-      

-
-      {isOpen && (
-        

-          {children}
-        

-      )}
-    

-  );
-};
-
-export const HighLight = ({ children }: IProps) => {
-  return {children};
-};
-
-export const LoadBox = ({
-  subtitle,
-  className = "my-2 text-accent ",
-}: IProps) => {
-  return (
-    

-      
-        {" "}
-        
-      {" "}
-      {subtitle}
-    

-  );
-};
-
-export const LoadingBar = ({ children }: IProps) => {
-  return (
-    <>
-      

-        
-          
-          
-        
-        {children}
-      

-      

-        

-      

-    
-  );
-};
-
-export const MessageBox = ({ title, children, className }: IProps) => {
-  const messageBox = useRef(null);
-
-  const closeMessage = () => {
-    if (messageBox.current) {
-      messageBox.current.remove();
-    }
-  };
-
-  return (
-    

-      {" "}
-      

-        

-          {/* 
-            
-          {" "} */}
-          {title}
-        

-        

-           {
-              closeMessage();
-            }}
-            className=" border border-secondary bg-secondary brightness-125 hover:brightness-100 cursor-pointer transition duration-200   inline-block px-1 pb-1 rounded text-primary"
-          >
-            
-          
-        

-      

-      {children}
-    

-  );
-};
-
-export const GroupView = ({
-  children,
-  title,
-  className = "text-primary bg-primary ",
-}: any) => {
-  return (
-    

-      

-        

-          {title}
-        

-        
 {children}

-      

-    

-  );
-};
-
-export const ExpandView = ({
-  children,
-  icon = null,
-  className = "",
-  title = "Detail View",
-}: any) => {
-  const [isOpen, setIsOpen] = React.useState(false);
-  let windowAspect = 1;
-  if (typeof window !== "undefined") {
-    windowAspect = window.innerWidth / window.innerHeight;
-  }
-  const minImageWidth = 400;
-  return (
-    

-      
 {
-          setIsOpen(true);
-        }}
-        className="text-xs mb-2 h-full w-full break-words"
-      >
-        {icon ? icon : children}
-      

-      {isOpen && (
-         setIsOpen(false)}
-          footer={null}
-        >
-          {/* resize}
-            lockAspectRatio={false}
-            handle={
-              

-                
-              

-            }
-            width={800}
-            height={minImageWidth * windowAspect}
-            minConstraints={[minImageWidth, minImageWidth * windowAspect]}
-            maxConstraints={[900, 900 * windowAspect]}
-            className="overflow-auto w-full rounded select-none "
-          > */}
-          {children}
-          {/*  */}
-        
-      )}
-    

-  );
-};
-
-export const LoadingOverlay = ({ children, loading }: IProps) => {
-  return (
-    <>
-      {loading && (
-        <>
-          

-            {/* Overlay background */}
-          

-          

-            {/* Center BounceLoader without inheriting the opacity */}
-            
-          

-        
-      )}
-      
{children}

-    
-  );
-};
-
-export const MarkdownView = ({
-  data,
-  className = "",
-  showCode = true,
-}: {
-  data: string;
-  className?: string;
-  showCode?: boolean;
-}) => {
-  function processString(inputString: string): string {
-    // TODO: Had to add this temp measure while debugging.  Why is it null?
-    if (!inputString) {
-        console.log("inputString is null!")
-    }
-    inputString = inputString && inputString.replace(/\n/g, "  \n");
-    const markdownPattern = /```markdown\s+([\s\S]*?)\s+```/g;
-    return inputString?.replace(markdownPattern, (match, content) => content);
-  }
-  const [showCopied, setShowCopied] = React.useState(false);
-
-  const CodeView = ({ props, children, language }: any) => {
-    const [codeVisible, setCodeVisible] = React.useState(showCode);
-    return (
-      

-        

-          
 {
-              setCodeVisible(!codeVisible);
-            }}
-            className="  flex-1 mr-4  "
-          >
-            {!codeVisible && (
-              

-                
-                 show
-              

-            )}
-
-            {codeVisible && (
-              

-                {" "}
-                
-                 hide
-              

-            )}
-          

-          {/* 
 */}
-          

-            {showCopied && (
-              

-                {" "}
-                🎉 Copied!{" "}
-              

-            )}
-             {
-                navigator.clipboard.writeText(data);
-                // message.success("Code copied to clipboard");
-                setShowCopied(true);
-                setTimeout(() => {
-                  setShowCopied(false);
-                }, 3000);
-              }}
-              className=" inline-block duration-300 text-white hover:text-accent w-5 h-5"
-            />
-          

-        

-        {codeVisible && (
-          
-            {String(children).replace(/\n$/, "")}
-          
-        )}
-      

-    );
-  };
-
-  return (
-    

-      
-            ) : (
-              
-                {children}
-              
-            );
-          },
-        }}
-      >
-        {processString(data)}
-      
-    

-  );
-};
-
-interface ICodeProps {
-  code: string;
-  language: string;
-  title?: string;
-  showLineNumbers?: boolean;
-  className?: string | undefined;
-  wrapLines?: boolean;
-  maxWidth?: string;
-  maxHeight?: string;
-  minHeight?: string;
-}
-
-export const CodeBlock = ({
-  code,
-  language = "python",
-  showLineNumbers = false,
-  className = " ",
-  wrapLines = false,
-  maxHeight = "400px",
-  minHeight = "auto",
-}: ICodeProps) => {
-  const codeString = code;
-
-  const [showCopied, setShowCopied] = React.useState(false);
-  return (
-    

-      

-        

-          

-          

-            {showCopied && (
-              

-                {" "}
-                🎉 Copied!{" "}
-              

-            )}
-             {
-                navigator.clipboard.writeText(codeString);
-                // message.success("Code copied to clipboard");
-                setShowCopied(true);
-                setTimeout(() => {
-                  setShowCopied(false);
-                }, 6000);
-              }}
-              className="m-2  inline-block duration-300 text-white hover:text-accent w-5 h-5"
-            />
-          

-        

-      

-      

-        
-          {codeString}
-        
-      

-    

-  );
-};
-
-// Controls Row
-export const ControlRowView = ({
-  title,
-  description,
-  value,
-  control,
-  className,
-  truncateLength = 20,
-}: {
-  title: string;
-  description: string;
-  value: string | number | boolean;
-  control: any;
-  className?: string;
-  truncateLength?: number;
-}) => {
-  return (
-    

-      

-        {title} 
-        
-          {truncateText(value + "", truncateLength)}
-        {" "}
-        
-          
-        
-      

-      {control}
-      

-    

-  );
-};
-
-export const BounceLoader = ({
-  className,
-  title = "",
-}: {
-  className?: string;
-  title?: string;
-}) => {
-  return (
-    

-      

-        
-        
-        
-      

-      {title}
-    

-  );
-};
-
-export const ImageLoader = ({
-  src,
-  className = "",
-}: {
-  src: string;
-  className?: string;
-}) => {
-  const [isLoading, setIsLoading] = useState(true);
-
-  return (
-    

-      {isLoading && (
-        

-          
-        

-      )}
-      Dynamic content setIsLoading(false)}
-      />
-    

-  );
-};
-
-type DataRow = { [key: string]: any };
-export const CsvLoader = ({
-  csvUrl,
-  className,
-}: {
-  csvUrl: string;
-  className?: string;
-}) => {
-  const [data, setData] = useState([]);
-  const [columns, setColumns] = useState([]);
-  const [isLoading, setIsLoading] = useState(true);
-  const [pageSize, setPageSize] = useState(50);
-
-  useEffect(() => {
-    const fetchData = async () => {
-      try {
-        const response = await fetch(csvUrl);
-        const csvString = await response.text();
-        const parsedData = Papa.parse(csvString, {
-          header: true,
-          dynamicTyping: true,
-          skipEmptyLines: true,
-        });
-        setData(parsedData.data as DataRow[]);
-
-        // Use the keys of the first object for column headers
-        const firstRow = parsedData.data[0] as DataRow; // Type assertion
-        const columnHeaders: any[] = Object.keys(firstRow).map((key) => {
-          const val = {
-            title: key.charAt(0).toUpperCase() + key.slice(1), // Capitalize the key for the title
-            dataIndex: key,
-            key: key,
-          };
-          if (typeof firstRow[key] === "number") {
-            return {
-              ...val,
-              sorter: (a: DataRow, b: DataRow) => a[key] - b[key],
-            };
-          }
-          return val;
-        });
-        setColumns(columnHeaders);
-        setIsLoading(false);
-      } catch (error) {
-        console.error("Error fetching CSV data:", error);
-        setIsLoading(false);
-      }
-    };
-
-    fetchData();
-  }, [csvUrl]);
-
-  // calculate x scroll, based on number of columns
-  const scrollX = columns.length * 150;
-
-  return (
-    

-       {
-          setPageSize(pagination.pageSize || 50);
-        }}
-      />
-    
-  );
-};
-
-export const CodeLoader = ({
-  url,
-  className,
-}: {
-  url: string;
-  className?: string;
-}) => {
-  const [isLoading, setIsLoading] = useState(true);
-  const [code, setCode] = useState(null);
-
-  React.useEffect(() => {
-    fetch(url)
-      .then((response) => response.text())
-      .then((data) => {
-        setCode(data);
-        setIsLoading(false);
-      });
-  }, [url]);
-
-  return (
-    

-      {isLoading && (
-        

-          
-        

-      )}
-
-      {!isLoading && }
-    

-  );
-};
-
-export const PdfViewer = ({ url }: { url: string }) => {
-  const [loading, setLoading] = useState(true);
-
-  React.useEffect(() => {
-    // Assuming the URL is directly usable as the source for the  tag
-    setLoading(false);
-    // Note: No need to handle the creation and cleanup of a blob URL or converting file content as it's not provided anymore.
-  }, [url]);
-
-  // Render the PDF viewer
-  return (
-    

-      {loading && 
Loading PDF...
}
-      {!loading && (
-        
-          
PDF cannot be displayed.

-        
-      )}
-    

-  );
-};
-
-export const MonacoEditor = ({
-  value,
-  editorRef,
-  language,
-  onChange,
-  minimap = true,
-}: {
-  value: string;
-  onChange?: (value: string) => void;
-  editorRef: any;
-  language: string;
-  minimap?: boolean;
-}) => {
-  const [isEditorReady, setIsEditorReady] = useState(false);
-  const onEditorDidMount = (editor: any, monaco: any) => {
-    editorRef.current = editor;
-    setIsEditorReady(true);
-  };
-  return (
-    

-       {
-          if (onChange && value) {
-            onChange(value);
-          }
-        }}
-        onMount={onEditorDidMount}
-        theme="vs-dark"
-        options={{
-          wordWrap: "on",
-          wrappingIndent: "indent",
-          wrappingStrategy: "advanced",
-          minimap: {
-            enabled: minimap,
-          },
-        }}
-      />
-    

-  );
-};
-
-export const CardHoverBar = ({
-  items,
-}: {
-  items: {
-    title: string;
-    icon: any;
-    hoverText: string;
-    onClick: (e: any) => void;
-  }[];
-}) => {
-  const itemRows = items.map((item, i) => {
-    return (
-      

-        
-          
-        
-      

-    );
-  });
-  return (
-    
 {
-        e.stopPropagation();
-      }}
-      className=" mt-2 text-right opacity-0 group-hover:opacity-100 "
-    >
-      {itemRows}
-    

-  );
-};
-
-export const AgentRow = ({ message }: { message: any }) => {
-  return (
-    
-          {message.sender} ( to{" "}
-          {message.recipient} )
-        
-      }
-      className="m"
-    >
-      
-    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/contentheader.tsx b/python/packages/autogen-studio/frontend/src/components/contentheader.tsx
new file mode 100644
index 000000000000..b66bc0d7da27
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/contentheader.tsx
@@ -0,0 +1,157 @@
+import React from "react";
+import { Menu } from "@headlessui/react";
+import {
+  BellIcon,
+  MoonIcon,
+  SunIcon,
+  MagnifyingGlassIcon,
+} from "@heroicons/react/24/outline";
+import {
+  ChevronDown,
+  PanelLeftClose,
+  PanelLeftOpen,
+  Menu as MenuIcon,
+} from "lucide-react";
+import { Tooltip } from "antd";
+import { appContext } from "../hooks/provider";
+import { useConfigStore } from "../hooks/store";
+
+type ContentHeaderProps = {
+  title?: string;
+  onMobileMenuToggle: () => void;
+  isMobileMenuOpen: boolean;
+};
+
+const classNames = (...classes: (string | undefined | boolean)[]) => {
+  return classes.filter(Boolean).join(" ");
+};
+
+const ContentHeader = ({
+  title,
+  onMobileMenuToggle,
+  isMobileMenuOpen,
+}: ContentHeaderProps) => {
+  const { darkMode, setDarkMode, user, logout } = React.useContext(appContext);
+  const { sidebar, setSidebarState } = useConfigStore();
+  const { isExpanded } = sidebar;
+
+  return (
+    

+      

+        {/* Mobile Menu Button */}
+        
+
+        {/* Desktop Sidebar Toggle - Hidden on Mobile */}
+        

+          
+            
+          
+        

+
+        

+          {/* Search */}
+          

+            

+              
+              
+              
+            
+          

+
+          {/* Right side header items */}
+          

+            {/* Dark Mode Toggle */}
+            
+
+            {/* Notifications */}
+            
+
+            {/* Separator */}
+            

+
+            {/* User Menu */}
+            {user && (
+              
+                
+                  {user.avatar_url ? (
+                    {user.name}
+                  ) : (
+                    

+                      {user.name?.[0]}
+                    

+                  )}
+                  
+                    
+                      {user.name}
+                    
+                    
+                  
+                
+                
+                  
+                    {({ active }) => (
+                       logout()}
+                        className={`${
+                          active ? "bg-secondary" : ""
+                        } block px-4 py-2 text-sm text-primary`}
+                      >
+                        Sign out
+                      
+                    )}
+                  
+                
+              
+            )}
+          

+        

+      

+    

+  );
+};
+
+export default ContentHeader;
diff --git a/python/packages/autogen-studio/frontend/src/components/footer.tsx b/python/packages/autogen-studio/frontend/src/components/footer.tsx
index 104547b443d3..6a8828d5ea28 100644
--- a/python/packages/autogen-studio/frontend/src/components/footer.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/footer.tsx
@@ -17,7 +17,7 @@ const Footer = () => {
     }
   }, []);
   return (
-    

+    

       

         Maintained by the AutoGen{" "}
          {
         className={` ${sizeClass} inline-block  `}
         xmlns="http://www.w3.org/2000/svg"
         fill="currentColor"
-        viewBox="0 0 93 90"
+        viewBox="0 0 290 264"
       >
         
         
         
+        
+          
+            
+            
+            
+          
+          
+            
+            
+            
+            
+          
+          
+            
+            
+            
+            
+            
+            
+          
+        
       
     );
   }
diff --git a/python/packages/autogen-studio/frontend/src/components/layout.tsx b/python/packages/autogen-studio/frontend/src/components/layout.tsx
index 9142470534eb..42182b07684f 100644
--- a/python/packages/autogen-studio/frontend/src/components/layout.tsx
+++ b/python/packages/autogen-studio/frontend/src/components/layout.tsx
@@ -1,10 +1,16 @@
 import * as React from "react";
-import Header from "./header";
+import { Dialog } from "@headlessui/react";
+import { X } from "lucide-react";
 import { appContext } from "../hooks/provider";
+import { useConfigStore } from "../hooks/store";
 import Footer from "./footer";
-
-/// import ant css
 import "antd/dist/reset.css";
+import SideBar from "./sidebar";
+import ContentHeader from "./contentheader";
+
+const classNames = (...classes: (string | undefined | boolean)[]) => {
+  return classes.filter(Boolean).join(" ");
+};
 
 type Props = {
   title: string;
@@ -23,38 +29,96 @@ const Layout = ({
   showHeader = true,
   restricted = false,
 }: Props) => {
-  const layoutContent = (
-    

-      {showHeader && 
}
-      

-        {meta?.title + " | " + title}
-        
{children}

-      

-      

-    

-  );
-
   const { darkMode } = React.useContext(appContext);
+  const { sidebar } = useConfigStore();
+  const { isExpanded } = sidebar;
+  const [isMobileMenuOpen, setIsMobileMenuOpen] = React.useState(false);
+
+  // Close mobile menu on route change
+  React.useEffect(() => {
+    setIsMobileMenuOpen(false);
+  }, [link]);
+
   React.useEffect(() => {
     document.getElementsByTagName("html")[0].className = `${
       darkMode === "dark" ? "dark bg-primary" : "light bg-primary"
-    } `;
+    }`;
   }, [darkMode]);
 
-  return (
-    
-      {(context: any) => {
-        if (restricted) {
-          return 
{context.user && layoutContent}
;
-        } else {
-          return layoutContent;
-        }
-      }}
-    
+  const layoutContent = (
+    

+      {/* Mobile menu */}
+       setIsMobileMenuOpen(false)}
+        className="relative z-50 md:hidden"
+      >
+        {/* Backdrop */}
+        
+
+      {/* Desktop sidebar */}
+      

+        
+      

+
+      {/* Content area */}
+      

+        {showHeader && (
+           setIsMobileMenuOpen(!isMobileMenuOpen)}
+          />
+        )}
+
+        
{children}

+
+        

+      

+    

   );
+
+  // Handle restricted content
+  if (restricted) {
+    return (
+      
+        {(context: any) => {
+          if (context.user) {
+            return layoutContent;
+          }
+          return null;
+        }}
+      
+    );
+  }
+
+  return layoutContent;
 };
 
 export default Layout;
diff --git a/python/packages/autogen-studio/frontend/src/components/sidebar.tsx b/python/packages/autogen-studio/frontend/src/components/sidebar.tsx
new file mode 100644
index 000000000000..b9decb10170d
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/sidebar.tsx
@@ -0,0 +1,148 @@
+import React from "react";
+import { Link } from "gatsby";
+import { useConfigStore } from "../hooks/store";
+import { Tooltip } from "antd";
+import { Blocks, Settings, MessagesSquare } from "lucide-react";
+import Icon from "./icons";
+
+const navigation = [
+  // { name: "Build", href: "/build", icon: Blocks },
+  { name: "Playground", href: "/", icon: MessagesSquare },
+];
+
+const classNames = (...classes: (string | undefined | boolean)[]) => {
+  return classes.filter(Boolean).join(" ");
+};
+
+type SidebarProps = {
+  link: string;
+  meta?: {
+    title: string;
+    description: string;
+  };
+  isMobile: boolean;
+};
+
+const Sidebar = ({ link, meta, isMobile }: SidebarProps) => {
+  const { sidebar } = useConfigStore();
+  const { isExpanded } = sidebar;
+
+  // Always show full sidebar in mobile view
+  const showFull = isMobile || isExpanded;
+
+  return (
+    

+      {/* App Logo/Title */}
+      

+        

+          
+        

+        {showFull && (
+          

+            
+              {meta?.title}
+            
+            {meta?.description}
+          

+        )}
+      

+
+      {/* Navigation */}
+      
+    

+  );
+};
+
+export default Sidebar;
diff --git a/python/packages/autogen-studio/frontend/src/components/types.ts b/python/packages/autogen-studio/frontend/src/components/types.ts
deleted file mode 100644
index ca51003e7ed0..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/types.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-export type NotificationType = "success" | "info" | "warning" | "error";
-
-export interface IMessage {
-  user_id: string;
-  role: string;
-  content: string;
-  created_at?: string;
-  updated_at?: string;
-  session_id?: number;
-  connection_id?: string;
-  workflow_id?: number;
-  meta?: any;
-  id?: number;
-}
-
-export interface IStatus {
-  message: string;
-  status: boolean;
-  data?: any;
-}
-
-export interface IChatMessage {
-  text: string;
-  sender: "user" | "bot";
-  meta?: any;
-  id?: number;
-}
-
-export interface ILLMConfig {
-  config_list: Array;
-  timeout?: number;
-  cache_seed?: number | null;
-  temperature: number;
-  max_tokens: number;
-}
-
-export interface IAgentConfig {
-  name: string;
-  llm_config?: ILLMConfig | false;
-  human_input_mode: string;
-  max_consecutive_auto_reply: number;
-  system_message: string | "";
-  is_termination_msg?: boolean | string;
-  default_auto_reply?: string | null;
-  code_execution_config?: "none" | "local" | "docker";
-  description?: string;
-
-  admin_name?: string;
-  messages?: Array;
-  max_round?: number;
-  speaker_selection_method?: string;
-  allow_repeat_speaker?: boolean;
-}
-
-export interface IAgent {
-  type?: "assistant" | "userproxy" | "groupchat";
-  config: IAgentConfig;
-  created_at?: string;
-  updated_at?: string;
-  id?: number;
-  skills?: Array;
-  user_id?: string;
-}
-
-export interface IWorkflow {
-  name: string;
-  description: string;
-  sender?: IAgent;
-  receiver?: IAgent;
-  type?: "autonomous" | "sequential";
-  created_at?: string;
-  updated_at?: string;
-  summary_method?: "none" | "last" | "llm";
-  id?: number;
-  user_id?: string;
-}
-
-export interface IModelConfig {
-  model: string;
-  api_key?: string;
-  api_version?: string;
-  base_url?: string;
-  api_type?: "open_ai" | "azure" | "google" | "anthropic" | "mistral";
-  user_id?: string;
-  created_at?: string;
-  updated_at?: string;
-  description?: string;
-  id?: number;
-}
-
-export interface IMetadataFile {
-  name: string;
-  path: string;
-  extension: string;
-  content: string;
-  type: string;
-}
-
-export interface IChatSession {
-  id?: number;
-  user_id: string;
-  workflow_id?: number;
-  created_at?: string;
-  updated_at?: string;
-  name: string;
-}
-
-export interface IGalleryItem {
-  id: number;
-  messages: Array;
-  session: IChatSession;
-  tags: Array;
-  created_at: string;
-  updated_at: string;
-}
-
-export interface ISkill {
-  name: string;
-  content: string;
-  secrets?: any[];
-  libraries?: string[];
-  id?: number;
-  description?: string;
-  user_id?: string;
-  created_at?: string;
-  updated_at?: string;
-}
diff --git a/python/packages/autogen-studio/frontend/src/components/types/app.ts b/python/packages/autogen-studio/frontend/src/components/types/app.ts
new file mode 100644
index 000000000000..e71635902323
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/types/app.ts
@@ -0,0 +1,5 @@
+export interface IStatus {
+  message: string;
+  status: boolean;
+  data?: any;
+}
diff --git a/python/packages/autogen-studio/frontend/src/components/types/datamodel.ts b/python/packages/autogen-studio/frontend/src/components/types/datamodel.ts
new file mode 100644
index 000000000000..da4999d376a2
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/types/datamodel.ts
@@ -0,0 +1,86 @@
+export interface RequestUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+}
+
+export interface MessageConfig {
+  source: string;
+  content: string;
+  models_usage?: RequestUsage;
+}
+
+export interface DBModel {
+  id?: number;
+  user_id?: string;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface Message extends DBModel {
+  config: MessageConfig;
+  session_id: number;
+  run_id: string;
+}
+
+export interface Session extends DBModel {
+  name: string;
+  team_id?: string;
+}
+
+export interface TeamConfig {
+  name: string;
+  participants: AgentConfig[];
+  team_type: TeamTypes;
+  model_client?: ModelConfig;
+  termination_condition?: TerminationConfig;
+}
+
+export interface Team extends DBModel {
+  config: TeamConfig;
+}
+
+export type ModelTypes = "OpenAIChatCompletionClient";
+
+export type AgentTypes = "AssistantAgent" | "CodingAssistantAgent";
+
+export type TeamTypes = "RoundRobinGroupChat" | "SelectorGroupChat";
+
+export type TerminationTypes =
+  | "MaxMessageTermination"
+  | "StopMessageTermination"
+  | "TextMentionTermination";
+
+export interface ModelConfig {
+  model: string;
+  model_type: ModelTypes;
+  api_key?: string;
+  base_url?: string;
+}
+
+export interface ToolConfig {
+  name: string;
+  description: string;
+  content: string;
+}
+
+export interface AgentConfig {
+  name: string;
+  agent_type: AgentTypes;
+  system_message?: string;
+  model_client?: ModelConfig;
+  tools?: ToolConfig[];
+  description?: string;
+}
+
+export interface TerminationConfig {
+  termination_type: TerminationTypes;
+  max_messages?: number;
+  text?: string;
+}
+
+export interface TaskResult {
+  messages: MessageConfig[];
+  usage: string;
+  duration: number;
+  stop_reason?: string;
+}
diff --git a/python/packages/autogen-studio/frontend/src/components/utils.ts b/python/packages/autogen-studio/frontend/src/components/utils.ts
index e70590153a88..2f3d21230da7 100644
--- a/python/packages/autogen-studio/frontend/src/components/utils.ts
+++ b/python/packages/autogen-studio/frontend/src/components/utils.ts
@@ -1,12 +1,4 @@
-import {
-  IAgent,
-  IAgentConfig,
-  ILLMConfig,
-  IModelConfig,
-  ISkill,
-  IStatus,
-  IWorkflow,
-} from "./types";
+import { IStatus } from "./types";
 
 export const getServerUrl = () => {
   return process.env.GATSBY_API_URL || "/api";
@@ -100,10 +92,6 @@ export function fetchJSON(
       onFinal();
     });
 }
-export const capitalize = (s: string) => {
-  if (typeof s !== "string") return "";
-  return s.charAt(0).toUpperCase() + s.slice(1);
-};
 
 export function eraseCookie(name: string) {
   document.cookie = name + "=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;";
@@ -116,435 +104,6 @@ export function truncateText(text: string, length = 50) {
   return text;
 }
 
-export const getCaretCoordinates = () => {
-  let caretX, caretY;
-  const selection = window.getSelection();
-  if (selection && selection?.rangeCount !== 0) {
-    const range = selection.getRangeAt(0).cloneRange();
-    range.collapse(false);
-    const rect = range.getClientRects()[0];
-    if (rect) {
-      caretX = rect.left;
-      caretY = rect.top;
-    }
-  }
-  return { caretX, caretY };
-};
-
-export const getPrefixSuffix = (container: any) => {
-  let prefix = "";
-  let suffix = "";
-  if (window.getSelection) {
-    const sel = window.getSelection();
-    if (sel && sel.rangeCount > 0) {
-      let range = sel.getRangeAt(0).cloneRange();
-      range.collapse(true);
-      range.setStart(container!, 0);
-      prefix = range.toString();
-
-      range = sel.getRangeAt(0).cloneRange();
-      range.collapse(true);
-      range.setEnd(container, container.childNodes.length);
-
-      suffix = range.toString();
-      console.log("prefix", prefix);
-      console.log("suffix", suffix);
-    }
-  }
-  return { prefix, suffix };
-};
-
-export const uid = () => {
-  return Date.now().toString(36) + Math.random().toString(36).substr(2);
-};
-
-export const setCaretToEnd = (element: HTMLElement) => {
-  const range = document.createRange();
-  const selection = window.getSelection();
-  range.selectNodeContents(element);
-  range.collapse(false);
-  selection?.removeAllRanges();
-  selection?.addRange(range);
-  element.focus();
-};
-
-// return a color between a start and end color using a percentage
-export const ColorTween = (
-  startColor: string,
-  endColor: string,
-  percent: number
-) => {
-  // example startColor = "#ff0000" endColor = "#0000ff" percent = 0.5
-  const start = {
-    r: parseInt(startColor.substring(1, 3), 16),
-    g: parseInt(startColor.substring(3, 5), 16),
-    b: parseInt(startColor.substring(5, 7), 16),
-  };
-  const end = {
-    r: parseInt(endColor.substring(1, 3), 16),
-    g: parseInt(endColor.substring(3, 5), 16),
-    b: parseInt(endColor.substring(5, 7), 16),
-  };
-  const r = Math.floor(start.r + (end.r - start.r) * percent);
-  const g = Math.floor(start.g + (end.g - start.g) * percent);
-  const b = Math.floor(start.b + (end.b - start.b) * percent);
-  return `rgb(${r}, ${g}, ${b})`;
-};
-
-export const guid = () => {
-  var w = () => {
-    return Math.floor((1 + Math.random()) * 0x10000)
-      .toString(16)
-      .substring(1);
-  };
-  return `${w()}${w()}-${w()}-${w()}-${w()}-${w()}${w()}${w()}`;
-};
-
-/**
- * Takes a string and returns the first n characters followed by asterisks.
- * @param {string} str - The string to obscure
- * @param {number} n - Number of characters to show before obscuring
- * @returns {string} The obscured string with first n characters in clear text
- */
-export const obscureString = (str: string, n: number = 3) => {
-  if (n < 0 || n > str.length) {
-    console.log("n cannot be less than 0 or greater than the string length.");
-    return str;
-  }
-  // First n characters in clear text
-  var clearText = str.substring(0, n);
-  // Remaining characters replaced with asterisks
-  var obscured = clearText + "*".repeat(str.length - n);
-
-  return obscured;
-};
-
-/**
- * Converts a number of seconds into a human-readable string representing the duration in days, hours, minutes, and seconds.
- * @param {number} seconds - The number of seconds to convert.
- * @returns {string} A well-formatted duration string.
- */
-export const formatDuration = (seconds: number) => {
-  const units = [
-    { label: " day", seconds: 86400 },
-    { label: " hr", seconds: 3600 },
-    { label: " min", seconds: 60 },
-    { label: " sec", seconds: 1 },
-  ];
-
-  let remainingSeconds = seconds;
-  const parts = [];
-
-  for (const { label, seconds: unitSeconds } of units) {
-    const count = Math.floor(remainingSeconds / unitSeconds);
-    if (count > 0) {
-      parts.push(count + (count > 1 ? label + "s" : label));
-      remainingSeconds -= count * unitSeconds;
-    }
-  }
-
-  return parts.length > 0 ? parts.join(" ") : "0 sec";
-};
-
-export const sampleModelConfig = (modelType: string = "open_ai") => {
-  const openaiConfig: IModelConfig = {
-    model: "gpt-4-1106-preview",
-    api_type: "open_ai",
-    description: "OpenAI GPT-4 model",
-  };
-  const azureConfig: IModelConfig = {
-    model: "gpt-4",
-    api_type: "azure",
-    api_version: "v1",
-    base_url: "https://youazureendpoint.azure.com/",
-    description: "Azure model",
-  };
-
-  const googleConfig: IModelConfig = {
-    model: "gemini-1.0-pro",
-    api_type: "google",
-    description: "Google Gemini Model model",
-  };
-
-  const anthropicConfig: IModelConfig = {
-    model: "claude-3-5-sonnet-20240620",
-    api_type: "anthropic",
-    description: "Claude 3.5 Sonnet model",
-  };
-
-  const mistralConfig: IModelConfig = {
-    model: "mistral",
-    api_type: "mistral",
-    description: "Mistral model",
-  };
-
-  switch (modelType) {
-    case "open_ai":
-      return openaiConfig;
-    case "azure":
-      return azureConfig;
-    case "google":
-      return googleConfig;
-    case "anthropic":
-      return anthropicConfig;
-    case "mistral":
-      return mistralConfig;
-    default:
-      return openaiConfig;
-  }
-};
-
-export const getRandomIntFromDateAndSalt = (salt: number = 43444) => {
-  const currentDate = new Date();
-  const seed = currentDate.getTime() + salt;
-  const randomValue = Math.sin(seed) * 10000;
-  const randomInt = Math.floor(randomValue) % 100;
-  return randomInt;
-};
-
-export const getSampleWorkflow = (workflow_type: string = "autonomous") => {
-  const autonomousWorkflow: IWorkflow = {
-    name: "Default Chat Workflow",
-    description: "Autonomous Workflow",
-    type: "autonomous",
-    summary_method: "llm",
-  };
-  const sequentialWorkflow: IWorkflow = {
-    name: "Default Sequential Workflow",
-    description: "Sequential Workflow",
-    type: "sequential",
-    summary_method: "llm",
-  };
-
-  if (workflow_type === "autonomous") {
-    return autonomousWorkflow;
-  } else if (workflow_type === "sequential") {
-    return sequentialWorkflow;
-  } else {
-    return autonomousWorkflow;
-  }
-};
-
-export const sampleAgentConfig = (agent_type: string = "assistant") => {
-  const llm_config: ILLMConfig = {
-    config_list: [],
-    temperature: 0.1,
-    timeout: 600,
-    cache_seed: null,
-    max_tokens: 4000,
-  };
-
-  const userProxyConfig: IAgentConfig = {
-    name: "userproxy",
-    human_input_mode: "NEVER",
-    description: "User Proxy",
-    max_consecutive_auto_reply: 25,
-    system_message: "You are a helpful assistant.",
-    default_auto_reply: "TERMINATE",
-    llm_config: false,
-    code_execution_config: "local",
-  };
-  const userProxyFlowSpec: IAgent = {
-    type: "userproxy",
-    config: userProxyConfig,
-  };
-
-  const assistantConfig: IAgentConfig = {
-    name: "primary_assistant",
-    description: "Primary Assistant",
-    llm_config: llm_config,
-    human_input_mode: "NEVER",
-    max_consecutive_auto_reply: 25,
-    code_execution_config: "none",
-    system_message:
-      "You are a helpful AI assistant. Solve tasks using your coding and language skills. In the following cases, suggest python code (in a python coding block) or shell script (in a sh coding block) for the user to execute. 1. When you need to collect info, use the code to output the info you need, for example, browse or search the web, download/read a file, print the content of a webpage or a file, get the current date/time, check the operating system. After sufficient info is printed and the task is ready to be solved based on your language skill, you can solve the task by yourself. 2. When you need to perform some task with code, use the code to perform the task and output the result. Finish the task smartly. Solve the task step by step if you need to. If a plan is not provided, explain your plan first. Be clear which step uses code, and which step uses your language skill. When using code, you must indicate the script type in the code block. The user cannot provide any other feedback or perform any other action beyond executing the code you suggest. The user can't modify your code. So do not suggest incomplete code which requires users to modify. Don't use a code block if it's not intended to be executed by the user. If you want the user to save the code in a file before executing it, put # filename:  inside the code block as the first line. Don't include multiple code blocks in one response. Do not ask users to copy and paste the result. Instead, use 'print' function for the output when relevant. Check the execution result returned by the user. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. When you find an answer, verify the answer carefully. Include verifiable evidence in your response if possible. Reply 'TERMINATE' in the end when everything is done.",
-  };
-
-  const assistantFlowSpec: IAgent = {
-    type: "assistant",
-    config: assistantConfig,
-  };
-
-  const groupChatAssistantConfig = Object.assign(
-    {
-      admin_name: "groupchat_assistant",
-      messages: [],
-      max_round: 10,
-      speaker_selection_method: "auto",
-      allow_repeat_speaker: false,
-    },
-    assistantConfig
-  );
-  groupChatAssistantConfig.name = "groupchat_assistant";
-  groupChatAssistantConfig.system_message =
-    "You are a helpful assistant skilled at cordinating a group of other assistants to solve a task. ";
-  groupChatAssistantConfig.description = "Group Chat Assistant";
-
-  const groupChatFlowSpec: IAgent = {
-    type: "groupchat",
-    config: groupChatAssistantConfig,
-  };
-
-  if (agent_type === "userproxy") {
-    return userProxyFlowSpec;
-  } else if (agent_type === "assistant") {
-    return assistantFlowSpec;
-  } else if (agent_type === "groupchat") {
-    return groupChatFlowSpec;
-  } else {
-    return assistantFlowSpec;
-  }
-};
-
-export const getSampleSkill = () => {
-  const content = `
-from typing import List
-import uuid
-import requests  # to perform HTTP requests
-from pathlib import Path
-
-from openai import OpenAI
-
-
-def generate_and_save_images(query: str, image_size: str = "1024x1024") -> List[str]:
-    """
-    Function to paint, draw or illustrate images based on the users query or request. Generates images from a given query using OpenAI's DALL-E model and saves them to disk.  Use the code below anytime there is a request to create an image.
-
-    :param query: A natural language description of the image to be generated.
-    :param image_size: The size of the image to be generated. (default is "1024x1024")
-    :return: A list of filenames for the saved images.
-    """
-
-    client = OpenAI()  # Initialize the OpenAI client
-    response = client.images.generate(model="dall-e-3", prompt=query, n=1, size=image_size)  # Generate images
-
-    # List to store the file names of saved images
-    saved_files = []
-
-    # Check if the response is successful
-    if response.data:
-        for image_data in response.data:
-            # Generate a random UUID as the file name
-            file_name = str(uuid.uuid4()) + ".png"  # Assuming the image is a PNG
-            file_path = Path(file_name)
-
-            img_url = image_data.url
-            img_response = requests.get(img_url)
-            if img_response.status_code == 200:
-                # Write the binary content to a file
-                with open(file_path, "wb") as img_file:
-                    img_file.write(img_response.content)
-                    print(f"Image saved to {file_path}")
-                    saved_files.append(str(file_path))
-            else:
-                print(f"Failed to download the image from {img_url}")
-    else:
-        print("No image data found in the response!")
-
-    # Return the list of saved files
-    return saved_files
-
-
-# Example usage of the function:
-# generate_and_save_images("A cute baby sea otter")
-  `;
-
-  const skill: ISkill = {
-    name: "generate_and_save_images",
-    description: "Generate and save images based on a user's query.",
-    content: content,
-  };
-
-  return skill;
-};
-
-export const timeAgo = (
-  dateString: string,
-  returnFormatted: boolean = false
-): string => {
-  // if dateStr is empty, return empty string
-  if (!dateString) {
-    return "";
-  }
-  // Parse the date string into a Date object
-  const timestamp = new Date(dateString);
-
-  // Check for invalid date
-  if (isNaN(timestamp.getTime())) {
-    throw new Error("Invalid date string provided.");
-  }
-
-  // Get the current time
-  const now = new Date();
-
-  // Calculate the difference in milliseconds
-  const timeDifference = now.getTime() - timestamp.getTime();
-
-  // Convert time difference to minutes and hours
-  const minutesAgo = Math.floor(timeDifference / (1000 * 60));
-  const hoursAgo = Math.floor(minutesAgo / 60);
-
-  // Format the date into a readable format e.g. "November 27, 2021, 3:45 PM"
-  const options: Intl.DateTimeFormatOptions = {
-    month: "long",
-    day: "numeric",
-    year: "numeric",
-    hour: "numeric",
-    minute: "numeric",
-  };
-  const formattedDate = timestamp.toLocaleDateString(undefined, options);
-
-  if (returnFormatted) {
-    return formattedDate;
-  }
-
-  // Determine the time difference string
-  let timeAgoStr: string;
-  if (minutesAgo < 1) {
-    timeAgoStr = "just now";
-  } else if (minutesAgo < 60) {
-    // Less than an hour ago, display minutes
-    timeAgoStr = `${minutesAgo} ${minutesAgo === 1 ? "minute" : "minutes"} ago`;
-  } else if (hoursAgo < 24) {
-    // Less than a day ago, display hours
-    timeAgoStr = `${hoursAgo} ${hoursAgo === 1 ? "hour" : "hours"} ago`;
-  } else {
-    // More than a day ago, display the formatted date
-    timeAgoStr = formattedDate;
-  }
-
-  // Return the final readable string
-  return timeAgoStr;
-};
-
-export const examplePrompts = [
-  {
-    title: "Stock Price",
-    prompt:
-      "Plot a chart of NVDA and TESLA stock price for 2023. Save the result to a file named nvda_tesla.png",
-  },
-  {
-    title: "Sine Wave",
-    prompt:
-      "Write a python script to plot a sine wave and save it to disc as a png file sine_wave.png",
-  },
-  {
-    title: "Markdown",
-    prompt:
-      "List out the top 5 rivers in africa and their length and return that as a markdown table. Do not try to write any code, just write the table",
-  },
-  {
-    title: "Paint",
-    prompt:
-      "paint a picture of a glass of ethiopian coffee, freshly brewed in a tall glass cup, on a table right in front of a lush green forest scenery",
-  },
-  {
-    title: "Travel",
-    prompt:
-      "Plan a 2 day trip to hawaii. Limit to 3 activities per day, be as brief as possible!",
-  },
-];
-
 export const fetchVersion = () => {
   const versionUrl = getServerUrl() + "/version";
   return fetch(versionUrl)
@@ -557,128 +116,3 @@ export const fetchVersion = () => {
       return null;
     });
 };
-
-/**
- * Recursively sanitizes JSON objects by replacing specific keys with a given value.
- * @param {JsonValue} data - The JSON data to be sanitized.
- * @param {string[]} keys - An array of keys to be replaced in the JSON object.
- * @param {string} replacement - The value to use as replacement for the specified keys.
- * @returns {JsonValue} - The sanitized JSON data.
- */
-export const sanitizeConfig = (
-  data: any,
-  keys: string[] = ["api_key", "id", "created_at", "updated_at", "secrets"]
-): any => {
-  if (Array.isArray(data)) {
-    return data.map((item) => sanitizeConfig(item, keys));
-  } else if (typeof data === "object" && data !== null) {
-    Object.keys(data).forEach((key) => {
-      if (keys.includes(key)) {
-        delete data[key];
-      } else {
-        data[key] = sanitizeConfig(data[key], keys);
-      }
-    });
-  }
-  return data;
-};
-
-/**
- * Checks the input text against the regex '^[a-zA-Z0-9_-]{1,64}$' and returns an object with
- * status, message, and sanitizedText. Status is boolean indicating whether input text is valid,
- * message provides information about the outcome, and sanitizedText contains a valid version
- * of the input text or the original text if it was already valid.
- *
- * @param text - The input string to be checked and sanitized.
- * @returns An object containing a status, a message, and sanitizedText.
- */
-export const checkAndSanitizeInput = (
-  text: string
-): { status: boolean; message: string; sanitizedText: string } => {
-  // Create a regular expression pattern to match valid characters
-  const regexPattern: RegExp = /^[a-zA-Z0-9_-]{1,64}$/;
-  let status: boolean = true;
-  let message: string;
-  let sanitizedText: string;
-
-  // Check if the input text matches the pattern
-  if (regexPattern.test(text)) {
-    // Text already adheres to the pattern
-    message = `The text '${text}' is valid.`;
-    sanitizedText = text;
-  } else {
-    // The text does not match; sanitize the input
-    status = false;
-    sanitizedText = text.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
-    message = `'${text}' is invalid. Consider using '${sanitizedText}' instead.`;
-  }
-
-  return { status, message, sanitizedText };
-};
-
-export const isValidConfig = (
-  jsonObj: any,
-  templateObj: any,
-  diffThreshold: number = 4
-): {
-  status: boolean;
-  message: string;
-} => {
-  // Check if both parameters are indeed objects and not null
-  if (
-    typeof jsonObj !== "object" ||
-    jsonObj === null ||
-    Array.isArray(jsonObj) ||
-    typeof templateObj !== "object" ||
-    templateObj === null ||
-    Array.isArray(templateObj)
-  ) {
-    return {
-      status: false,
-      message:
-        "Invalid input: One or both parameters are not objects, or are null or arrays.",
-    };
-  }
-
-  const jsonKeys = new Set(Object.keys(jsonObj));
-  const templateKeys = new Set(Object.keys(templateObj));
-
-  if (jsonKeys.size !== templateKeys.size) {
-    if (Math.abs(jsonKeys.size - templateKeys.size) > diffThreshold) {
-      return {
-        status: false,
-        message:
-          "Configuration does not match template: Number of keys differ.",
-      };
-    }
-  }
-
-  for (const key of templateKeys) {
-    if (!jsonKeys.has(key)) {
-      return {
-        status: false,
-        message: `Configuration does not match template: Missing key '${key}' in configuration.`,
-      };
-    }
-
-    // If the value is an object, recursively validate
-    if (
-      typeof templateObj[key] === "object" &&
-      templateObj[key] !== null &&
-      !Array.isArray(templateObj[key])
-    ) {
-      const result = isValidConfig(jsonObj[key], templateObj[key]);
-      if (!result.status) {
-        return {
-          status: false,
-          message: `Configuration error in nested key '${key}': ${result.message}`,
-        };
-      }
-    }
-  }
-
-  return {
-    status: true,
-    message: "Configuration is valid.",
-  };
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/agents.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/agents.tsx
deleted file mode 100644
index 6fcb505cc7e6..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/agents.tsx
+++ /dev/null
@@ -1,385 +0,0 @@
-import {
-  ArrowDownTrayIcon,
-  ArrowUpTrayIcon,
-  DocumentDuplicateIcon,
-  InformationCircleIcon,
-  PlusIcon,
-  TrashIcon,
-} from "@heroicons/react/24/outline";
-import { Dropdown, MenuProps, Modal, message } from "antd";
-import * as React from "react";
-import { IAgent, IStatus } from "../../types";
-import { appContext } from "../../../hooks/provider";
-import {
-  fetchJSON,
-  getServerUrl,
-  sanitizeConfig,
-  timeAgo,
-  truncateText,
-} from "../../utils";
-import { BounceLoader, Card, CardHoverBar, LoadingOverlay } from "../../atoms";
-import { AgentViewer } from "./utils/agentconfig";
-
-const AgentsView = ({}: any) => {
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState({
-    status: true,
-    message: "All good",
-  });
-
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const listAgentsUrl = `${serverUrl}/agents?user_id=${user?.email}`;
-
-  const [agents, setAgents] = React.useState([]);
-  const [selectedAgent, setSelectedAgent] = React.useState(null);
-
-  const [showNewAgentModal, setShowNewAgentModal] = React.useState(false);
-
-  const [showAgentModal, setShowAgentModal] = React.useState(false);
-
-  const sampleAgent = {
-    config: {
-      name: "sample_agent",
-      description: "Sample agent description",
-      human_input_mode: "NEVER",
-      max_consecutive_auto_reply: 3,
-      system_message: "",
-    },
-  };
-  const [newAgent, setNewAgent] = React.useState(sampleAgent);
-
-  const deleteAgent = (agent: IAgent) => {
-    setError(null);
-    setLoading(true);
-
-    const deleteAgentUrl = `${serverUrl}/agents/delete?user_id=${user?.email}&agent_id=${agent.id}`;
-    // const fetch;
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        user_id: user?.email,
-        agent: agent,
-      }),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchAgents();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(deleteAgentUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchAgents = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setAgents(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listAgentsUrl, payLoad, onSuccess, onError);
-  };
-
-  React.useEffect(() => {
-    if (user) {
-      // console.log("fetching messages", messages);
-      fetchAgents();
-    }
-  }, []);
-
-  const agentRows = (agents || []).map((agent: IAgent, i: number) => {
-    const cardItems = [
-      {
-        title: "Download",
-        icon: ArrowDownTrayIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          // download workflow as workflow.name.json
-          const element = document.createElement("a");
-          const sanitizedAgent = sanitizeConfig(agent);
-          const file = new Blob([JSON.stringify(sanitizedAgent)], {
-            type: "application/json",
-          });
-          element.href = URL.createObjectURL(file);
-          element.download = `agent_${agent.config.name}.json`;
-          document.body.appendChild(element); // Required for this to work in FireFox
-          element.click();
-        },
-        hoverText: "Download",
-      },
-      {
-        title: "Make a Copy",
-        icon: DocumentDuplicateIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          let newAgent = { ...sanitizeConfig(agent) };
-          newAgent.config.name = `${agent.config.name}_copy`;
-          console.log("newAgent", newAgent);
-          setNewAgent(newAgent);
-          setShowNewAgentModal(true);
-        },
-        hoverText: "Make a Copy",
-      },
-      {
-        title: "Delete",
-        icon: TrashIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          deleteAgent(agent);
-        },
-        hoverText: "Delete",
-      },
-    ];
-    return (
-      
  • 
-        
-              {truncateText(agent.config.name || "", 25)}
-            
    • 
-          }
-          onClick={() => {
-            setSelectedAgent(agent);
-            setShowAgentModal(true);
-          }}
-        >
-          
-          
    
-            {timeAgo(agent.updated_at || "")}
-          
    
-          
-        
-      
-    );
-  });
-
-  const AgentModal = ({
-    agent,
-    setAgent,
-    showAgentModal,
-    setShowAgentModal,
-    handler,
-  }: {
-    agent: IAgent | null;
-    setAgent: (agent: IAgent | null) => void;
-    showAgentModal: boolean;
-    setShowAgentModal: (show: boolean) => void;
-    handler?: (agent: IAgent | null) => void;
-  }) => {
-    const [localAgent, setLocalAgent] = React.useState(agent);
-
-    const closeModal = () => {
-      setShowAgentModal(false);
-      if (handler) {
-        handler(localAgent);
-      }
-    };
-
-    return (
-      Agent Configuration}
-        width={800}
-        open={showAgentModal}
-        onOk={() => {
-          closeModal();
-        }}
-        onCancel={() => {
-          closeModal();
-        }}
-        footer={[]}
-      >
-        {agent && (
-          
-        )}
-        {/* {JSON.stringify(localAgent)} */}
-      
-    );
-  };
-
-  const uploadAgent = () => {
-    const input = document.createElement("input");
-    input.type = "file";
-    input.accept = ".json";
-    input.onchange = (e: any) => {
-      const file = e.target.files[0];
-      const reader = new FileReader();
-      reader.onload = (e: any) => {
-        const contents = e.target.result;
-        if (contents) {
-          try {
-            const agent = JSON.parse(contents);
-            // TBD validate that it is a valid agent
-            if (!agent.config) {
-              throw new Error(
-                "Invalid agent file. An agent must have a config"
-              );
-            }
-            setNewAgent(agent);
-            setShowNewAgentModal(true);
-          } catch (err) {
-            message.error(
-              "Invalid agent file. Please upload a valid agent file."
-            );
-          }
-        }
-      };
-      reader.readAsText(file);
-    };
-    input.click();
-  };
-
-  const agentsMenuItems: MenuProps["items"] = [
-    // {
-    //   type: "divider",
-    // },
-    {
-      key: "uploadagent",
-      label: (
-        
    
-          
-          Upload Agent
-        
    
-      ),
-    },
-  ];
-
-  const agentsMenuItemOnClick: MenuProps["onClick"] = ({ key }) => {
-    if (key === "uploadagent") {
-      uploadAgent();
-      return;
-    }
-  };
-
-  return (
-    
    
-       {
-          fetchAgents();
-        }}
-      />
-
-       {
-          fetchAgents();
-        }}
-      />
-
-      
    
-        
    
-          
    
-            
    
-              {" "}
-              Agents ({agentRows.length}){" "}
-            
    
-            
    
-               {
-                  setShowNewAgentModal(true);
-                }}
-              >
-                
-                New Agent
-              
-            
    
-          
    
-
-          
    
-            {" "}
-            Configure an agent that can reused in your agent workflow .
-            
    
-              Tip: You can also create a Group of Agents ( New Agent -
-              GroupChat) which can have multiple agents in it.
-            
    
-          
    
-          {agents && agents.length > 0 && (
-            
    
-              
-              
      {agentRows}
    
-            
    
-          )}
-
-          {agents && agents.length === 0 && !loading && (
-            
    
-              
-              No agents found. Please create a new agent.
-            
    
-          )}
-
-          {loading && (
-            
    
-              {" "}
-              {" "}
-               loading .. 
-            
    
-          )}
-        
    
-      
    
-    
    
-  );
-};
-
-export default AgentsView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/build.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/build.tsx
deleted file mode 100644
index bf8128fe0f9c..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/build.tsx
+++ /dev/null
@@ -1,81 +0,0 @@
-import * as React from "react";
-import SkillsView from "./skills";
-import AgentsView from "./agents";
-import WorkflowView from "./workflow";
-import { Tabs } from "antd";
-import {
-  BugAntIcon,
-  CpuChipIcon,
-  Square2StackIcon,
-  Square3Stack3DIcon,
-} from "@heroicons/react/24/outline";
-import ModelsView from "./models";
-
-const BuildView = () => {
-  return (
-    
    
-      {/* 
    Build 
     */}
-      
    
-        {" "}
-        Create skills, agents and workflows for building multiagent capabilities{" "}
-      
    
-
-      
    
-        {" "}
-        
-                  {" "}
-                  
-                  Skills
-                
    
-              ),
-              key: "1",
-              children: ,
-            },
-            {
-              label: (
-                
    
-                  {" "}
-                  
-                  Models
-                
    
-              ),
-              key: "2",
-              children: ,
-            },
-            {
-              label: (
-                <>
-                  
-                  Agents
-                
-              ),
-              key: "3",
-              children: ,
-            },
-            {
-              label: (
-                <>
-                  
-                  Workflows
-                
-              ),
-              key: "4",
-              children: ,
-            },
-          ]}
-        />
-      
    
-
-      
    
-    
    
-  );
-};
-
-export default BuildView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/models.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/models.tsx
deleted file mode 100644
index 87ae739b62e7..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/models.tsx
+++ /dev/null
@@ -1,403 +0,0 @@
-import {
-  ArrowDownTrayIcon,
-  ArrowUpTrayIcon,
-  DocumentDuplicateIcon,
-  InformationCircleIcon,
-  PlusIcon,
-  TrashIcon,
-} from "@heroicons/react/24/outline";
-import { Dropdown, MenuProps, Modal, message } from "antd";
-import * as React from "react";
-import { IModelConfig, IStatus } from "../../types";
-import { appContext } from "../../../hooks/provider";
-import {
-  fetchJSON,
-  getServerUrl,
-  sanitizeConfig,
-  timeAgo,
-  truncateText,
-} from "../../utils";
-import { BounceLoader, Card, CardHoverBar, LoadingOverlay } from "../../atoms";
-import { ModelConfigView } from "./utils/modelconfig";
-
-const ModelsView = ({}: any) => {
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState({
-    status: true,
-    message: "All good",
-  });
-
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const listModelsUrl = `${serverUrl}/models?user_id=${user?.email}`;
-  const createModelUrl = `${serverUrl}/models`;
-  const testModelUrl = `${serverUrl}/models/test`;
-
-  const defaultModel: IModelConfig = {
-    model: "gpt-4-1106-preview",
-    description: "Sample OpenAI GPT-4 model",
-    user_id: user?.email,
-  };
-
-  const [models, setModels] = React.useState([]);
-  const [selectedModel, setSelectedModel] = React.useState(
-    null
-  );
-  const [newModel, setNewModel] = React.useState(
-    defaultModel
-  );
-
-  const [showNewModelModal, setShowNewModelModal] = React.useState(false);
-  const [showModelModal, setShowModelModal] = React.useState(false);
-
-  const deleteModel = (model: IModelConfig) => {
-    setError(null);
-    setLoading(true);
-    const deleteModelUrl = `${serverUrl}/models/delete?user_id=${user?.email}&model_id=${model.id}`;
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchModels();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(deleteModelUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchModels = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setModels(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listModelsUrl, payLoad, onSuccess, onError);
-  };
-
-  const createModel = (model: IModelConfig) => {
-    setError(null);
-    setLoading(true);
-    model.user_id = user?.email;
-
-    const payLoad = {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(model),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        const updatedModels = [data.data].concat(models || []);
-        setModels(updatedModels);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(createModelUrl, payLoad, onSuccess, onError);
-  };
-
-  React.useEffect(() => {
-    if (user) {
-      // console.log("fetching messages", messages);
-      fetchModels();
-    }
-  }, []);
-
-  const modelRows = (models || []).map((model: IModelConfig, i: number) => {
-    const cardItems = [
-      {
-        title: "Download",
-        icon: ArrowDownTrayIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          // download workflow as workflow.name.json
-          const element = document.createElement("a");
-          const sanitizedSkill = sanitizeConfig(model);
-          const file = new Blob([JSON.stringify(sanitizedSkill)], {
-            type: "application/json",
-          });
-          element.href = URL.createObjectURL(file);
-          element.download = `model_${model.model}.json`;
-          document.body.appendChild(element); // Required for this to work in FireFox
-          element.click();
-        },
-        hoverText: "Download",
-      },
-      {
-        title: "Make a Copy",
-        icon: DocumentDuplicateIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          let newModel = { ...sanitizeConfig(model) };
-          newModel.model = `${model.model}_copy`;
-          setNewModel(newModel);
-          setShowNewModelModal(true);
-        },
-        hoverText: "Make a Copy",
-      },
-      {
-        title: "Delete",
-        icon: TrashIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          deleteModel(model);
-        },
-        hoverText: "Delete",
-      },
-    ];
-    return (
-      
  • 
-        {truncateText(model.model || "", 20)}
    • 
-          }
-          onClick={() => {
-            setSelectedModel(model);
-            setShowModelModal(true);
-          }}
-        >
-          
    
-            {" "}
-            {truncateText(model.description || model.model || "", 70)}
-          
    
-          
    
-            {timeAgo(model.updated_at || "")}
-          
    
-          
-        
-      
-    );
-  });
-
-  const ModelModal = ({
-    model,
-    setModel,
-    showModelModal,
-    setShowModelModal,
-    handler,
-  }: {
-    model: IModelConfig;
-    setModel: (model: IModelConfig | null) => void;
-    showModelModal: boolean;
-    setShowModelModal: (show: boolean) => void;
-    handler?: (agent: IModelConfig) => void;
-  }) => {
-    const [localModel, setLocalModel] = React.useState(model);
-
-    const closeModal = () => {
-      setModel(null);
-      setShowModelModal(false);
-      if (handler) {
-        handler(model);
-      }
-    };
-
-    return (
-      
-            Model Specification{" "}
-            {model?.model}{" "}
-          
-        }
-        width={800}
-        open={showModelModal}
-        footer={[]}
-        onOk={() => {
-          closeModal();
-        }}
-        onCancel={() => {
-          closeModal();
-        }}
-      >
-        {model && (
-          
-        )}
-      
-    );
-  };
-
-  const uploadModel = () => {
-    const input = document.createElement("input");
-    input.type = "file";
-    input.accept = ".json";
-    input.onchange = (e: any) => {
-      const file = e.target.files[0];
-      const reader = new FileReader();
-      reader.onload = (e: any) => {
-        const contents = e.target.result;
-        if (contents) {
-          try {
-            const model = JSON.parse(contents);
-            if (model) {
-              setNewModel(model);
-              setShowNewModelModal(true);
-            }
-          } catch (e) {
-            message.error("Invalid model file");
-          }
-        }
-      };
-      reader.readAsText(file);
-    };
-    input.click();
-  };
-
-  const modelsMenuItems: MenuProps["items"] = [
-    // {
-    //   type: "divider",
-    // },
-    {
-      key: "uploadmodel",
-      label: (
-        
    
-          
-          Upload Model
-        
    
-      ),
-    },
-  ];
-
-  const modelsMenuItemOnClick: MenuProps["onClick"] = ({ key }) => {
-    if (key === "uploadmodel") {
-      uploadModel();
-      return;
-    }
-  };
-
-  return (
-    
    
-      {selectedModel && (
-         {
-            fetchModels();
-          }}
-        />
-      )}
-       {
-          fetchModels();
-        }}
-      />
-
-      
    
-        
    
-          
    
-            
    
-              {" "}
-              Models ({modelRows.length}){" "}
-            
    
-            
    
-               {
-                  setShowNewModelModal(true);
-                }}
-              >
-                
-                New Model
-              
-            
    
-          
    
-
-          
    
-            {" "}
-            Create model configurations that can be reused in your agents and
-            workflows. {selectedModel?.model}
-          
    
-          {models && models.length > 0 && (
-            
    
-              
-              
      {modelRows}
    
-            
    
-          )}
-
-          {models && models.length === 0 && !loading && (
-            
    
-              
-              No models found. Please create a new model which can be reused
-              with agents.
-            
    
-          )}
-
-          {loading && (
-            
    
-              {" "}
-              {" "}
-               loading .. 
-            
    
-          )}
-        
    
-      
    
-    
    
-  );
-};
-
-export default ModelsView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/skills.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/skills.tsx
deleted file mode 100644
index 7d3dfe75611f..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/skills.tsx
+++ /dev/null
@@ -1,380 +0,0 @@
-import {
-  ArrowDownTrayIcon,
-  ArrowUpTrayIcon,
-  CodeBracketIcon,
-  CodeBracketSquareIcon,
-  DocumentDuplicateIcon,
-  InformationCircleIcon,
-  KeyIcon,
-  PlusIcon,
-  TrashIcon,
-} from "@heroicons/react/24/outline";
-import { Button, Input, Modal, message, MenuProps, Dropdown, Tabs } from "antd";
-import * as React from "react";
-import { ISkill, IStatus } from "../../types";
-import { appContext } from "../../../hooks/provider";
-import {
-  fetchJSON,
-  getSampleSkill,
-  getServerUrl,
-  sanitizeConfig,
-  timeAgo,
-  truncateText,
-} from "../../utils";
-import {
-  BounceLoader,
-  Card,
-  CardHoverBar,
-  LoadingOverlay,
-  MonacoEditor,
-} from "../../atoms";
-import { SkillSelector } from "./utils/selectors";
-import { SkillConfigView } from "./utils/skillconfig";
-
-const SkillsView = ({}: any) => {
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState({
-    status: true,
-    message: "All good",
-  });
-
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const listSkillsUrl = `${serverUrl}/skills?user_id=${user?.email}`;
-  const saveSkillsUrl = `${serverUrl}/skills`;
-
-  const [skills, setSkills] = React.useState([]);
-  const [selectedSkill, setSelectedSkill] = React.useState(null);
-
-  const [showSkillModal, setShowSkillModal] = React.useState(false);
-  const [showNewSkillModal, setShowNewSkillModal] = React.useState(false);
-
-  const sampleSkill = getSampleSkill();
-  const [newSkill, setNewSkill] = React.useState(sampleSkill);
-
-  const deleteSkill = (skill: ISkill) => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const deleteSkillUrl = `${serverUrl}/skills/delete?user_id=${user?.email}&skill_id=${skill.id}`;
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        user_id: user?.email,
-        skill: skill,
-      }),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchSkills();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(deleteSkillUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchSkills = () => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        // message.success(data.message);
-        console.log("skills", data.data);
-        setSkills(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listSkillsUrl, payLoad, onSuccess, onError);
-  };
-
-  React.useEffect(() => {
-    if (user) {
-      // console.log("fetching messages", messages);
-      fetchSkills();
-    }
-  }, []);
-
-  const skillRows = (skills || []).map((skill: ISkill, i: number) => {
-    const cardItems = [
-      {
-        title: "Download",
-        icon: ArrowDownTrayIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          // download workflow as workflow.name.json
-          const element = document.createElement("a");
-          const sanitizedSkill = sanitizeConfig(skill);
-          const file = new Blob([JSON.stringify(sanitizedSkill)], {
-            type: "application/json",
-          });
-          element.href = URL.createObjectURL(file);
-          element.download = `skill_${skill.name}.json`;
-          document.body.appendChild(element); // Required for this to work in FireFox
-          element.click();
-        },
-        hoverText: "Download",
-      },
-      {
-        title: "Make a Copy",
-        icon: DocumentDuplicateIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          let newSkill = { ...sanitizeConfig(skill) };
-          newSkill.name = `${skill.name}_copy`;
-          setNewSkill(newSkill);
-          setShowNewSkillModal(true);
-        },
-        hoverText: "Make a Copy",
-      },
-      {
-        title: "Delete",
-        icon: TrashIcon,
-        onClick: (e: any) => {
-          e.stopPropagation();
-          deleteSkill(skill);
-        },
-        hoverText: "Delete",
-      },
-    ];
-    return (
-      
  • 
-        
    
-          {" "}
-           {
-              setSelectedSkill(skill);
-              setShowSkillModal(true);
-            }}
-          >
-            
-            
    
-              {timeAgo(skill.updated_at || "")}
-            
    
-            
-              
-          
    
-        
    
-      
    • 
-    );
-  });
-
-  const SkillModal = ({
-    skill,
-    setSkill,
-    showSkillModal,
-    setShowSkillModal,
-    handler,
-  }: {
-    skill: ISkill | null;
-    setSkill: any;
-    showSkillModal: boolean;
-    setShowSkillModal: any;
-    handler: any;
-  }) => {
-    const editorRef = React.useRef(null);
-    const [localSkill, setLocalSkill] = React.useState(skill);
-
-    const closeModal = () => {
-      setSkill(null);
-      setShowSkillModal(false);
-      if (handler) {
-        handler(skill);
-      }
-    };
-
-    return (
-      
-            Skill Specification{" "}
-            {localSkill?.name}{" "}
-          
-        }
-        width={800}
-        open={showSkillModal}
-        onCancel={() => {
-          setShowSkillModal(false);
-        }}
-        footer={[]}
-      >
-        {localSkill && (
-          
-        )}
-      
-    );
-  };
-
-  const uploadSkill = () => {
-    const fileInput = document.createElement("input");
-    fileInput.type = "file";
-    fileInput.accept = ".json";
-    fileInput.onchange = (e: any) => {
-      const file = e.target.files[0];
-      const reader = new FileReader();
-      reader.onload = (e) => {
-        const content = e.target?.result;
-        if (content) {
-          try {
-            const skill = JSON.parse(content as string);
-            if (skill) {
-              setNewSkill(skill);
-              setShowNewSkillModal(true);
-            }
-          } catch (e) {
-            message.error("Invalid skill file");
-          }
-        }
-      };
-      reader.readAsText(file);
-    };
-    fileInput.click();
-  };
-
-  const skillsMenuItems: MenuProps["items"] = [
-    // {
-    //   type: "divider",
-    // },
-    {
-      key: "uploadskill",
-      label: (
-        
    
-          
-          Upload Skill
-        
    
-      ),
-    },
-  ];
-
-  const skillsMenuItemOnClick: MenuProps["onClick"] = ({ key }) => {
-    if (key === "uploadskill") {
-      uploadSkill();
-      return;
-    }
-  };
-
-  return (
-    
    
-       {
-          fetchSkills();
-        }}
-      />
-
-       {
-          fetchSkills();
-        }}
-      />
-
-      
    
-        
    
-          
    
-            
      
-              {" "}
-              Skills ({skillRows.length}){" "}
-            
    
-            
    
-               {
-                  setShowNewSkillModal(true);
-                }}
-              >
-                
-                New Skill
-              
-            
    
-          
    
-          
    
-            {" "}
-            Skills are python functions that agents can use to solve tasks.{" "}
-          
    
-          {skills && skills.length > 0 && (
-            
    
-              
-              
    {skillRows}
    
-            
    
-          )}
-
-          {skills && skills.length === 0 && !loading && (
-            
    
-              
-              No skills found. Please create a new skill.
-            
    
-          )}
-          {loading && (
-            
    
-              {" "}
-              {" "}
-               loading .. 
-            
    
-          )}
-        
    
-      
    
-    
    
-  );
-};
-
-export default SkillsView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/agentconfig.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/agentconfig.tsx
deleted file mode 100644
index a62e6fc6ef14..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/agentconfig.tsx
+++ /dev/null
@@ -1,517 +0,0 @@
-import React from "react";
-import { CollapseBox, ControlRowView } from "../../../atoms";
-import { checkAndSanitizeInput, fetchJSON, getServerUrl } from "../../../utils";
-import {
-  Button,
-  Form,
-  Input,
-  Select,
-  Slider,
-  Tabs,
-  message,
-  theme,
-} from "antd";
-import {
-  BugAntIcon,
-  CpuChipIcon,
-  UserGroupIcon,
-} from "@heroicons/react/24/outline";
-import { appContext } from "../../../../hooks/provider";
-import {
-  AgentSelector,
-  AgentTypeSelector,
-  ModelSelector,
-  SkillSelector,
-} from "./selectors";
-import { IAgent, ILLMConfig } from "../../../types";
-import TextArea from "antd/es/input/TextArea";
-
-const { useToken } = theme;
-
-export const AgentConfigView = ({
-  agent,
-  setAgent,
-  close,
-}: {
-  agent: IAgent;
-  setAgent: (agent: IAgent) => void;
-  close: () => void;
-}) => {
-  const nameValidation = checkAndSanitizeInput(agent?.config?.name);
-  const [error, setError] = React.useState(null);
-  const [loading, setLoading] = React.useState(false);
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const createAgentUrl = `${serverUrl}/agents`;
-  const [controlChanged, setControlChanged] = React.useState(false);
-
-  const onControlChange = (value: any, key: string) => {
-    // if (key === "llm_config") {
-    //   if (value.config_list.length === 0) {
-    //     value = false;
-    //   }
-    // }
-    const updatedAgent = {
-      ...agent,
-      config: { ...agent.config, [key]: value },
-    };
-
-    setAgent(updatedAgent);
-    setControlChanged(true);
-  };
-
-  const llm_config: ILLMConfig = agent?.config?.llm_config || {
-    config_list: [],
-    temperature: 0.1,
-    max_tokens: 4000,
-  };
-
-  const createAgent = (agent: IAgent) => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-
-    console.log("agent", agent);
-    agent.user_id = user?.email;
-    const payLoad = {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(agent),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        console.log("agents", data.data);
-        const newAgent = data.data;
-        setAgent(newAgent);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-      // setNewAgent(sampleAgent);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    const onFinal = () => {
-      setLoading(false);
-      setControlChanged(false);
-    };
-
-    fetchJSON(createAgentUrl, payLoad, onSuccess, onError, onFinal);
-  };
-
-  const hasChanged =
-    (!controlChanged || !nameValidation.status) && agent?.id !== undefined;
-
-  return (
-    
    
-      
    
-        
    
-          
    
-            
-                   {
-                      onControlChange(e.target.value, "name");
-                    }}
-                  />
-                  {!nameValidation.status && (
-                    
    
-                      {nameValidation.message}
-                    
    
-                  )}
-                
-              }
-            />
-
-             {
-                    onControlChange(e.target.value, "description");
-                  }}
-                />
-              }
-            />
-
-             {
-                    onControlChange(value, "max_consecutive_auto_reply");
-                  }}
-                />
-              }
-            />
-
-             {
-                    onControlChange(value, "human_input_mode");
-                  }}
-                  options={
-                    [
-                      { label: "NEVER", value: "NEVER" },
-                      { label: "TERMINATE", value: "TERMINATE" },
-                      { label: "ALWAYS", value: "ALWAYS" },
-                    ] as any
-                  }
-                />
-              }
-            />
-
-             {
-                    onControlChange(e.target.value, "system_message");
-                  }}
-                />
-              }
-            />
-
-            
    
-              {" "}
-              
-                 {
-                        const llm_config = {
-                          ...agent.config.llm_config,
-                          temperature: value,
-                        };
-                        onControlChange(llm_config, "llm_config");
-                      }}
-                    />
-                  }
-                />
-
-                 {
-                        onControlChange(e.target.value, "default_auto_reply");
-                      }}
-                    />
-                  }
-                />
-
-                 {
-                        const llm_config = {
-                          ...agent.config.llm_config,
-                          max_tokens: value,
-                        };
-                        onControlChange(llm_config, "llm_config");
-                      }}
-                    />
-                  }
-                />
-                 {
-                        onControlChange(value, "code_execution_config");
-                      }}
-                      options={
-                        [
-                          { label: "None", value: "none" },
-                          { label: "Local", value: "local" },
-                          { label: "Docker", value: "docker" },
-                        ] as any
-                      }
-                    />
-                  }
-                />
-              
-            
    
-          
    
-          {/* ====================== Group Chat Config ======================= */}
-          {agent.type === "groupchat" && (
-            
    
-               {
-                      if (agent?.config) {
-                        onControlChange(value, "speaker_selection_method");
-                      }
-                    }}
-                    options={
-                      [
-                        { label: "Auto", value: "auto" },
-                        { label: "Round Robin", value: "round_robin" },
-                        { label: "Random", value: "random" },
-                      ] as any
-                    }
-                  />
-                }
-              />
-
-               {
-                      onControlChange(e.target.value, "admin_name");
-                    }}
-                  />
-                }
-              />
-
-               {
-                      onControlChange(value, "max_round");
-                    }}
-                  />
-                }
-              />
-
-               {
-                      onControlChange(value, "allow_repeat_speaker");
-                    }}
-                    options={
-                      [
-                        { label: "True", value: true },
-                        { label: "False", value: false },
-                      ] as any
-                    }
-                  />
-                }
-              />
-            
    
-          )}
-        
    
-      
-
-      
    
-        {" "}
-        {!hasChanged && (
-          
-        )}
-        
-      
    
-    
    
-  );
-};
-
-export const AgentViewer = ({
-  agent,
-  setAgent,
-  close,
-}: {
-  agent: IAgent | null;
-  setAgent: (newAgent: IAgent) => void;
-  close: () => void;
-}) => {
-  let items = [
-    {
-      label: (
-        
    
-          {" "}
-          
-          Agent Configuration
-        
    
-      ),
-      key: "1",
-      children: (
-        
    
-          {!agent?.type && (
-            
-          )}
-
-          {agent?.type && agent && (
-            
-          )}
-        
    
-      ),
-    },
-  ];
-  if (agent) {
-    if (agent?.id) {
-      if (agent.type && agent.type === "groupchat") {
-        items.push({
-          label: (
-            
    
-              {" "}
-              
-              Agents
-            
    
-          ),
-          key: "2",
-          children: ,
-        });
-      }
-
-      items.push({
-        label: (
-          
    
-            {" "}
-            
-            Models
-          
    
-        ),
-        key: "3",
-        children: ,
-      });
-
-      items.push({
-        label: (
-          <>
-            
-            Skills
-          
-        ),
-        key: "4",
-        children: ,
-      });
-    }
-  }
-
-  return (
-    
    
-      {/*  */}
-      
-    
    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/export.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/export.tsx
deleted file mode 100644
index bb74bd0e2e37..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/export.tsx
+++ /dev/null
@@ -1,207 +0,0 @@
-import { Button, Modal, message } from "antd";
-import * as React from "react";
-import { IWorkflow } from "../../../types";
-import { ArrowDownTrayIcon } from "@heroicons/react/24/outline";
-import {
-  checkAndSanitizeInput,
-  fetchJSON,
-  getServerUrl,
-  sanitizeConfig,
-} from "../../../utils";
-import { appContext } from "../../../../hooks/provider";
-import { CodeBlock } from "../../../atoms";
-
-export const ExportWorkflowModal = ({
-  workflow,
-  show,
-  setShow,
-}: {
-  workflow: IWorkflow | null;
-  show: boolean;
-  setShow: (show: boolean) => void;
-}) => {
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-
-  const [error, setError] = React.useState(null);
-  const [loading, setLoading] = React.useState(false);
-  const [workflowDetails, setWorkflowDetails] = React.useState(null);
-
-  const getWorkflowCode = (workflow: IWorkflow) => {
-    const workflowCode = `from autogenstudio import WorkflowManager
-# load workflow from exported json workflow file.
-workflow_manager = WorkflowManager(workflow="path/to/your/workflow_.json")
-
-# run the workflow on a task
-task_query = "What is the height of the Eiffel Tower?. Dont write code, just respond to the question."
-workflow_manager.run(message=task_query)`;
-    return workflowCode;
-  };
-
-  const getCliWorkflowCode = (workflow: IWorkflow) => {
-    const workflowCode = `autogenstudio serve --workflow=workflow.json --port=5000
-    `;
-    return workflowCode;
-  };
-
-  const getGunicornWorkflowCode = (workflow: IWorkflow) => {
-    const workflowCode = `gunicorn -w $((2 * $(getconf _NPROCESSORS_ONLN) + 1)) --timeout 12600 -k uvicorn.workers.UvicornWorker autogenstudio.web.app:app --bind `;
-
-    return workflowCode;
-  };
-
-  const fetchWorkFlow = (workflow: IWorkflow) => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const downloadWorkflowUrl = `${serverUrl}/workflows/export/${workflow.id}?user_id=${user?.email}`;
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setWorkflowDetails(data.data);
-        console.log("workflow details", data.data);
-
-        const sanitized_name =
-          checkAndSanitizeInput(workflow.name).sanitizedText || workflow.name;
-        const file_name = `workflow_${sanitized_name}.json`;
-        const workflowData = sanitizeConfig(data.data);
-        const file = new Blob([JSON.stringify(workflowData)], {
-          type: "application/json",
-        });
-        const downloadUrl = URL.createObjectURL(file);
-        const a = document.createElement("a");
-        a.href = downloadUrl;
-        a.download = file_name;
-        a.click();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(downloadWorkflowUrl, payLoad, onSuccess, onError);
-  };
-
-  React.useEffect(() => {
-    if (workflow && workflow.id && show) {
-      // fetchWorkFlow(workflow.id);
-      console.log("workflow modal ... component loaded", workflow);
-    }
-  }, [show]);
-
-  return (
-    
-          Export Workflow
-          
-            {workflow?.name}
-          {" "}
-        
-      }
-      width={800}
-      open={show}
-      onOk={() => {
-        setShow(false);
-      }}
-      onCancel={() => {
-        setShow(false);
-      }}
-      footer={[]}
-    >
-      
    
-        
    
-          {" "}
-          You can use the following steps to start integrating your workflow
-          into your application.{" "}
-        
    
-        {workflow && workflow.id && (
-          <>
-            
    
-              
    
-                
    Step 1
    
-                
    
-                  Download your workflow as a JSON file by clicking the button
-                  below.
-                
    
-
-                
    
-                  
-                
    
-              
    
-
-              
    
-                
    Step 2
    
-                
    
-                  Copy the following code snippet and paste it into your
-                  application to run your workflow on a task.
-                
    
-                
    
-                  
-                
    
-              
    
-            
    
-
-            
    
-              
    
-                Step 3 (Deploy)
-              
    
-              
    
-                You can also deploy your workflow as an API endpoint using the
-                autogenstudio python CLI.
-              
    
-
-              
    
-                
-
-                
    
-                  Note: this will start a endpoint on port 5000. You can change
-                  the port by changing the port number. You can also scale this
-                  using multiple workers (e.g., via an application server like
-                  gunicorn) or wrap it in a docker container and deploy on a
-                  cloud provider like Azure.
-                
    
-
-                
-              
    
-            
    
-          
-        )}
-      
    
-        
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/modelconfig.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/modelconfig.tsx
deleted file mode 100644
index c4a39956ba0f..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/modelconfig.tsx
+++ /dev/null
@@ -1,388 +0,0 @@
-import React from "react";
-import { fetchJSON, getServerUrl, sampleModelConfig } from "../../../utils";
-import { Button, Input, message, theme } from "antd";
-import {
-  CpuChipIcon,
-  InformationCircleIcon,
-} from "@heroicons/react/24/outline";
-import { IModelConfig, IStatus } from "../../../types";
-import { Card, ControlRowView } from "../../../atoms";
-import TextArea from "antd/es/input/TextArea";
-import { appContext } from "../../../../hooks/provider";
-
-const ModelTypeSelector = ({
-  model,
-  setModel,
-}: {
-  model: IModelConfig;
-  setModel: (newModel: IModelConfig) => void;
-}) => {
-  const modelTypes = [
-    {
-      label: "OpenAI",
-      value: "open_ai",
-      description: "OpenAI or other endpoints that implement the OpenAI API",
-      icon: ,
-      hint: "In addition to OpenAI models, You can also use OSS models via tools like Ollama, vLLM, LMStudio etc. that provide OpenAI compatible endpoint.",
-    },
-    {
-      label: "Azure OpenAI",
-      value: "azure",
-      description: "Azure OpenAI endpoint",
-      icon: ,
-      hint: "Azure OpenAI endpoint",
-    },
-    {
-      label: "Gemini",
-      value: "google",
-      description: "Gemini",
-      icon: ,
-      hint: "Gemini",
-    },
-    {
-      label: "Claude",
-      value: "anthropic",
-      description: "Anthropic Claude",
-      icon: ,
-      hint: "Anthropic Claude models",
-    },
-    {
-      label: "Mistral",
-      value: "mistral",
-      description: "Mistral",
-      icon: ,
-      hint: "Mistral models",
-    },
-  ];
-
-  const [selectedType, setSelectedType] = React.useState(
-    model?.api_type
-  );
-
-  const modelTypeRows = modelTypes.map((modelType: any, i: number) => {
-    return (
-      
  •  {
-          setSelectedHint(modelType.hint);
-        }}
-        role="listitem"
-        key={"modeltype" + i}
-        className="w-36"
-      >
-        {modelType.label}
    • }
-          onClick={() => {
-            setSelectedType(modelType.value);
-            if (model) {
-              const sampleModel = sampleModelConfig(modelType.value);
-              setModel(sampleModel);
-              //   setAgent(sampleAgent);
-            }
-          }}
-        >
-          
    
-            {" "}
-            
    {modelType.icon}
    
-            
-              {" "}
-              {modelType.description}
-            
-          
    
-        
-      
-    );
-  });
-
-  const [selectedHint, setSelectedHint] = React.useState("open_ai");
-
-  return (
-    <>
-      
    Select Model Type
    
-      
      {modelTypeRows}
    
-
-      
    
-        
-        {selectedHint}
-      
    
-    
-  );
-};
-
-const ModelConfigMainView = ({
-  model,
-  setModel,
-  close,
-}: {
-  model: IModelConfig;
-  setModel: (newModel: IModelConfig) => void;
-  close: () => void;
-}) => {
-  const [loading, setLoading] = React.useState(false);
-  const [modelStatus, setModelStatus] = React.useState(null);
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-  const testModelUrl = `${serverUrl}/models/test`;
-  const createModelUrl = `${serverUrl}/models`;
-
-  //   const [model, setmodel] = React.useState(
-  //     model
-  //   );
-  const testModel = (model: IModelConfig) => {
-    setModelStatus(null);
-    setLoading(true);
-    model.user_id = user?.email;
-    const payLoad = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(model),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        setModelStatus(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-      setModelStatus(data);
-    };
-    const onError = (err: any) => {
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(testModelUrl, payLoad, onSuccess, onError);
-  };
-  const createModel = (model: IModelConfig) => {
-    setLoading(true);
-    model.user_id = user?.email;
-    const payLoad = {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(model),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        setModel(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      message.error(err.message);
-      setLoading(false);
-    };
-    const onFinal = () => {
-      setLoading(false);
-      setControlChanged(false);
-    };
-    fetchJSON(createModelUrl, payLoad, onSuccess, onError, onFinal);
-  };
-
-  const [controlChanged, setControlChanged] = React.useState(false);
-
-  const updateModelConfig = (key: string, value: string) => {
-    if (model) {
-      const updatedModelConfig = { ...model, [key]: value };
-      //   setmodel(updatedModelConfig);
-      setModel(updatedModelConfig);
-    }
-    setControlChanged(true);
-  };
-
-  const hasChanged = !controlChanged && model.id !== undefined;
-
-  return (
-    
    
-      
    
-        Enter parameters for your{" "}
-        {model.api_type} model.
-      
    
-      
    
-        
    
-           {
-                  updateModelConfig("model", e.target.value);
-                }}
-              />
-            }
-          />
-
-           {
-                  updateModelConfig("base_url", e.target.value);
-                }}
-              />
-            }
-          />
-        
    
-        
    
-           {
-                  updateModelConfig("api_key", e.target.value);
-                }}
-              />
-            }
-          />
-          {model?.api_type == "azure" && (
-             {
-                    updateModelConfig("api_version", e.target.value);
-                  }}
-                />
-              }
-            />
-          )}
-        
    
-      
    
-
-       {
-              updateModelConfig("description", e.target.value);
-            }}
-          />
-        }
-      />
-
-      {model?.api_type === "azure" && (
-        
    
-          Note: For Azure OAI models, you will need to specify all fields.
-        
    
-      )}
-
-      {modelStatus && (
-        
    
-          
-          {modelStatus.message}
-
-          {/*  Note  */}
-        
    
-      )}
-
-      
    
-        
-
-        {!hasChanged && (
-          
-        )}
-
-        
-      
    
-    
    
-  );
-};
-
-export const ModelConfigView = ({
-  model,
-  setModel,
-  close,
-}: {
-  model: IModelConfig;
-  setModel: (newModel: IModelConfig) => void;
-  close: () => void;
-}) => {
-  return (
-    
    
-      
    
-        {!model?.api_type && (
-          
-        )}
-
-        {model?.api_type && model && (
-          
-        )}
-      
    
-    
    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/selectors.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/selectors.tsx
deleted file mode 100644
index 79275fe4ba2f..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/selectors.tsx
+++ /dev/null
@@ -1,1359 +0,0 @@
-import React, { useEffect, useState } from "react";
-import { IAgent, IModelConfig, ISkill, IWorkflow } from "../../../types";
-import { Card } from "../../../atoms";
-import {
-  fetchJSON,
-  getSampleWorkflow,
-  getServerUrl,
-  obscureString,
-  sampleAgentConfig,
-  truncateText,
-} from "../../../utils";
-import {
-  Divider,
-  Dropdown,
-  MenuProps,
-  Space,
-  Tooltip,
-  message,
-  theme,
-} from "antd";
-import {
-  ArrowLongRightIcon,
-  ChatBubbleLeftRightIcon,
-  CodeBracketSquareIcon,
-  ExclamationTriangleIcon,
-  InformationCircleIcon,
-  PlusIcon,
-  RectangleGroupIcon,
-  UserCircleIcon,
-  XMarkIcon,
-} from "@heroicons/react/24/outline";
-import { appContext } from "../../../../hooks/provider";
-
-const { useToken } = theme;
-
-export const SkillSelector = ({ agentId }: { agentId: number }) => {
-  const [error, setError] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [skills, setSkills] = useState([]);
-  const [agentSkills, setAgentSkills] = useState([]);
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-  const listSkillsUrl = `${serverUrl}/skills?user_id=${user?.email}`;
-  const listAgentSkillsUrl = `${serverUrl}/agents/link/skill/${agentId}`;
-
-  const fetchSkills = () => {
-    setError(null);
-    setLoading(true);
-
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setSkills(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(listSkillsUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchAgentSkills = () => {
-    setError(null);
-    setLoading(true);
-
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setAgentSkills(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(listAgentSkillsUrl, payLoad, onSuccess, onError);
-  };
-
-  const linkAgentSkill = (agentId: number, skillId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkSkillUrl = `${serverUrl}/agents/link/skill/${agentId}/${skillId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchAgentSkills();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(linkSkillUrl, payLoad, onSuccess, onError);
-  };
-
-  const unLinkAgentSkill = (agentId: number, skillId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkSkillUrl = `${serverUrl}/agents/link/skill/${agentId}/${skillId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchAgentSkills();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(linkSkillUrl, payLoad, onSuccess, onError);
-  };
-
-  useEffect(() => {
-    fetchSkills();
-    fetchAgentSkills();
-  }, [agentId]);
-
-  const skillItems: MenuProps["items"] = skills.map((skill, index) => ({
-    key: index,
-    label: (
-      <>
-        
    {skill.name}
    
-        
    
-          {truncateText(skill.description || "", 20)}
-        
    
-      
-    ),
-    value: index,
-  }));
-
-  const skillOnClick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedSkill = skills[selectedIndex];
-
-    if (selectedSkill && selectedSkill.id) {
-      linkAgentSkill(agentId, selectedSkill.id);
-    }
-  };
-
-  const { token } = useToken();
-  const contentStyle: React.CSSProperties = {
-    backgroundColor: token.colorBgElevated,
-    borderRadius: token.borderRadiusLG,
-    boxShadow: token.boxShadowSecondary,
-  };
-
-  const handleRemoveSkill = (index: number) => {
-    const skill = agentSkills[index];
-    if (skill && skill.id) {
-      unLinkAgentSkill(agentId, skill.id);
-    }
-  };
-
-  const AddSkillsDropDown = () => {
-    return (
-       (
-          
    
-            {React.cloneElement(menu as React.ReactElement, {
-              style: { boxShadow: "none" },
-            })}
-            {skills.length === 0 && (
-              <>
-                
-                
-                
    
-                  {" "}
-                  
-                    {" "}
-                    Please create skills in the Skills tab
-                  
-                
    
-              
-            )}
-          
    
-        )}
-      >
-        
    
-          add 
-        
    
-          
-    );
-  };
-
-  const agentSkillButtons = agentSkills.map((skill, i) => {
-    const tooltipText = (
-      <>
-        
    {skill.name}
    
-        
    
-          {truncateText(skill.description || "", 90)}
-        
    
-      
-    );
-    return (
-      
     showModal(config, i)}
-      >
-        
    
-          {" "}
-          
-            
    {skill.name}
    {" "}
-              
-          
     {
-              e.stopPropagation(); // Prevent opening the modal to edit
-              handleRemoveSkill(i);
-            }}
-            className="ml-1 text-primary hover:text-accent duration-300"
-          >
-            
-          
    
-        
    
-      
    
-    );
-  });
-
-  return (
-    
    
-      {agentSkills && agentSkills.length > 0 && (
-        
    
-          {agentSkills.length} Skills
-          linked to this agent
-        
    
-      )}
-
-      {(!agentSkills || agentSkills.length === 0) && (
-        
    
-           No skills
-          currently linked to this agent. Please add a skill using the button
-          below.
-        
    
-      )}
-
-      
    
-        {agentSkillButtons}
-        
-      
    
-    
    
-  );
-};
-
-export const AgentTypeSelector = ({
-  agent,
-  setAgent,
-}: {
-  agent: IAgent | null;
-  setAgent: (agent: IAgent) => void;
-}) => {
-  const iconClass = "h-6 w-6 inline-block ";
-  const agentTypes = [
-    {
-      label: "User Proxy Agent",
-      value: "userproxy",
-      description: <>Typically represents the user and executes code. ,
-      icon: ,
-    },
-    {
-      label: "Assistant Agent",
-      value: "assistant",
-      description: <>Plan and generate code to solve user tasks,
-      icon: ,
-    },
-    {
-      label: "GroupChat ",
-      value: "groupchat",
-      description: <>Manage group chat interactions,
-      icon: ,
-    },
-  ];
-  const [selectedAgentType, setSelectedAgentType] = React.useState<
-    string | null
-  >(null);
-
-  const agentTypeRows = agentTypes.map((agentType: any, i: number) => {
-    return (
-      
  • 
-        {agentType.label}}
-          onClick={() => {
-            setSelectedAgentType(agentType.value);
-            if (agent) {
-              const sampleAgent = sampleAgentConfig(agentType.value);
-              setAgent(sampleAgent);
-            }
-          }}
-        >
-          
    
-            {" "}
-            
    {agentType.icon}
    
-            
-              {" "}
-              {agentType.description}
-            
-          
    
-            
-      
    • 
-    );
-  });
-
-  return (
-    <>
-      
    Select Agent Type
    
-      
      {agentTypeRows}
    
-    
-  );
-};
-
-export const WorkflowTypeSelector = ({
-  workflow,
-  setWorkflow,
-}: {
-  workflow: IWorkflow;
-  setWorkflow: (workflow: IWorkflow) => void;
-}) => {
-  const iconClass = "h-6 w-6 inline-block ";
-  const workflowTypes = [
-    {
-      label: "Autonomous (Chat)",
-      value: "autonomous",
-      description:
-        "Includes an initiator and receiver. The initiator is typically a user proxy agent, while the receiver could be any agent type (assistant or groupchat",
-      icon: ,
-    },
-    {
-      label: "Sequential",
-      value: "sequential",
-      description:
-        " Includes a list of agents in a given order. Each agent should have an nstruction and will summarize and pass on the results of their work to the next agent",
-      icon: ,
-    },
-  ];
-  const [seletectedWorkflowType, setSelectedWorkflowType] = React.useState<
-    string | null
-  >(null);
-
-  const workflowTypeRows = workflowTypes.map((workflowType: any, i: number) => {
-    return (
-      
  • 
-        {workflowType.label}}
-          onClick={() => {
-            setSelectedWorkflowType(workflowType.value);
-            if (workflow) {
-              const sampleWorkflow = getSampleWorkflow(workflowType.value);
-              setWorkflow(sampleWorkflow);
-            }
-          }}
-        >
-          
    
-            {" "}
-            
    {workflowType.icon}
    
-            
-              {" "}
-              {truncateText(workflowType.description, 60)}
-            
-          
    
-            
-      
    • 
-    );
-  });
-
-  return (
-    <>
-      
    Select Workflow Type
    
-      
      {workflowTypeRows}
    
-    
-  );
-};
-
-export const AgentSelector = ({ agentId }: { agentId: number }) => {
-  const [error, setError] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [agents, setAgents] = useState([]);
-  const [targetAgents, setTargetAgents] = useState([]);
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-
-  const listAgentsUrl = `${serverUrl}/agents?user_id=${user?.email}`;
-  const listTargetAgentsUrl = `${serverUrl}/agents/link/agent/${agentId}`;
-
-  const fetchAgents = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setAgents(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(listAgentsUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchTargetAgents = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setTargetAgents(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(listTargetAgentsUrl, payLoad, onSuccess, onError);
-  };
-
-  const linkAgentAgent = (agentId: number, targetAgentId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkAgentUrl = `${serverUrl}/agents/link/agent/${agentId}/${targetAgentId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchTargetAgents();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(linkAgentUrl, payLoad, onSuccess, onError);
-  };
-
-  const unLinkAgentAgent = (agentId: number, targetAgentId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkAgentUrl = `${serverUrl}/agents/link/agent/${agentId}/${targetAgentId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchTargetAgents();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(linkAgentUrl, payLoad, onSuccess, onError);
-  };
-
-  useEffect(() => {
-    fetchAgents();
-    fetchTargetAgents();
-  }, []);
-
-  const agentItems: MenuProps["items"] =
-    agents.length > 0
-      ? agents.map((agent, index) => ({
-          key: index,
-          label: (
-            <>
-              
    {agent.config.name}
    
-              
    
-                {truncateText(agent.config.description || "", 20)}
-              
    
-            
-          ),
-          value: index,
-        }))
-      : [
-          {
-            key: -1,
-            label: <>No agents found,
-            value: 0,
-          },
-        ];
-
-  const agentOnClick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedAgent = agents[selectedIndex];
-
-    if (selectedAgent && selectedAgent.id) {
-      linkAgentAgent(agentId, selectedAgent.id);
-    }
-  };
-
-  const handleRemoveAgent = (index: number) => {
-    const agent = targetAgents[index];
-    if (agent && agent.id) {
-      unLinkAgentAgent(agentId, agent.id);
-    }
-  };
-
-  const { token } = useToken();
-  const contentStyle: React.CSSProperties = {
-    backgroundColor: token.colorBgElevated,
-    borderRadius: token.borderRadiusLG,
-    boxShadow: token.boxShadowSecondary,
-  };
-
-  const AddAgentDropDown = () => {
-    return (
-       (
-          
    
-            {React.cloneElement(menu as React.ReactElement, {
-              style: { boxShadow: "none" },
-            })}
-            {agents.length === 0 && (
-              <>
-                
-                
-                
    
-                  {" "}
-                  
-                    {" "}
-                    Please create agents in the Agents tab
-                  
-                
    
-              
-            )}
-          
    
-        )}
-      >
-        
    
-          add 
-        
    
-          
-    );
-  };
-
-  const agentButtons = targetAgents.map((agent, i) => {
-    const tooltipText = (
-      <>
-        
    {agent.config.name}
    
-        
    
-          {truncateText(agent.config.description || "", 90)}
-        
    
-      
-    );
-    return (
-      
    
-        
    
-          {" "}
-          
-            
    {agent.config.name}
    {" "}
-              
-          
     {
-              e.stopPropagation(); // Prevent opening the modal to edit
-              handleRemoveAgent(i);
-            }}
-            className="ml-1 text-primary hover:text-accent duration-300"
-          >
-            
-          
    
-        
    
-      
    
-    );
-  });
-
-  return (
-    
    
-      {targetAgents && targetAgents.length > 0 && (
-        
    
-          {targetAgents.length} Agents
-          linked to this agent
-        
    
-      )}
-
-      {(!targetAgents || targetAgents.length === 0) && (
-        
    
-           No agents
-          currently linked to this agent. Please add an agent using the button
-          below.
-        
    
-      )}
-
-      
    
-        {agentButtons}
-        
-      
    
-    
    
-  );
-};
-
-export const ModelSelector = ({ agentId }: { agentId: number }) => {
-  const [error, setError] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [models, setModels] = useState([]);
-  const [agentModels, setAgentModels] = useState([]);
-  const serverUrl = getServerUrl();
-
-  const { user } = React.useContext(appContext);
-  const listModelsUrl = `${serverUrl}/models?user_id=${user?.email}`;
-  const listAgentModelsUrl = `${serverUrl}/agents/link/model/${agentId}`;
-
-  const fetchModels = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        // message.success(data.message);
-        setModels(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listModelsUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchAgentModels = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        // message.success(data.message);
-        setAgentModels(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listAgentModelsUrl, payLoad, onSuccess, onError);
-  };
-
-  const linkAgentModel = (agentId: number, modelId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkModelUrl = `${serverUrl}/agents/link/model/${agentId}/${modelId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        console.log("linked model", data);
-        fetchAgentModels();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(linkModelUrl, payLoad, onSuccess, onError);
-  };
-
-  const unLinkAgentModel = (agentId: number, modelId: number) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    const linkModelUrl = `${serverUrl}/agents/link/model/${agentId}/${modelId}`;
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        console.log("unlinked model", data);
-        fetchAgentModels();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(linkModelUrl, payLoad, onSuccess, onError);
-  };
-
-  useEffect(() => {
-    fetchModels();
-    fetchAgentModels();
-  }, []);
-
-  const modelItems: MenuProps["items"] =
-    models.length > 0
-      ? models.map((model: IModelConfig, index: number) => ({
-          key: index,
-          label: (
-            <>
-              
    {model.model}
    
-              
    
-                {truncateText(model.description || "", 20)}
-              
    
-            
-          ),
-          value: index,
-        }))
-      : [
-          {
-            key: -1,
-            label: <>No models found,
-            value: 0,
-          },
-        ];
-
-  const modelOnClick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedModel = models[selectedIndex];
-
-    console.log("selected model", selectedModel);
-    if (selectedModel && selectedModel.id) {
-      linkAgentModel(agentId, selectedModel.id);
-    }
-  };
-
-  const menuStyle: React.CSSProperties = {
-    boxShadow: "none",
-  };
-
-  const { token } = useToken();
-  const contentStyle: React.CSSProperties = {
-    backgroundColor: token.colorBgElevated,
-    borderRadius: token.borderRadiusLG,
-    boxShadow: token.boxShadowSecondary,
-  };
-
-  const AddModelsDropDown = () => {
-    return (
-       (
-          
    
-            {React.cloneElement(menu as React.ReactElement, {
-              style: menuStyle,
-            })}
-            {models.length === 0 && (
-              <>
-                
-                
-                
    
-                  
-                    {" "}
-                    {" "}
-                    Please create models in the Model tab
-                  
-                
    
-              
-            )}
-          
    
-        )}
-      >
-        
    
-          add 
-        
    
-          
-    );
-  };
-
-  const handleRemoveModel = (index: number) => {
-    const model = agentModels[index];
-    if (model && model.id) {
-      unLinkAgentModel(agentId, model.id);
-    }
-  };
-
-  const agentModelButtons = agentModels.map((model, i) => {
-    const tooltipText = (
-      <>
-        
    {model.model}
    
-        {model.base_url && 
    {model.base_url}
    }
-        {model.api_key && 
    {obscureString(model.api_key, 3)}
    }
-        
    
-          {truncateText(model.description || "", 90)}
-        
    
-      
-    );
-    return (
-      
     showModal(config, i)}
-      >
-        
    
-          {" "}
-          
-            
    {model.model}
    {" "}
-              
-          
     {
-              e.stopPropagation(); // Prevent opening the modal to edit
-              handleRemoveModel(i);
-            }}
-            className="ml-1 text-primary hover:text-accent duration-300"
-          >
-            
-          
    
-        
    
-      
    
-    );
-  });
-
-  return (
-    
    
-      {agentModels && agentModels.length > 0 && (
-        <>
-          
    
-            {" "}
-            {agentModels.length} Models
-            linked to this agent{" "}
-          
    
-        
-      )}
-
-      {(!agentModels || agentModels.length == 0) && (
-        
    
-          
-          No models currently linked to this agent. Please add a model using the
-          button below.
-        
    
-      )}
-
-      
    
-        {agentModelButtons}
-        
-      
    
-    
    
-  );
-};
-
-export const WorkflowAgentSelector = ({
-  workflow,
-}: {
-  workflow: IWorkflow;
-}) => {
-  const [error, setError] = useState(null);
-  const [loading, setLoading] = useState(false);
-  const [agents, setAgents] = useState([]);
-  const [linkedAgents, setLinkedAgents] = useState([]);
-
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-
-  const listAgentsUrl = `${serverUrl}/agents?user_id=${user?.email}`;
-
-  const fetchAgents = () => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setAgents(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(listAgentsUrl, payLoad, onSuccess, onError);
-  };
-
-  const fetchLinkedAgents = () => {
-    const listTargetAgentsUrl = `${serverUrl}/workflows/link/agent/${workflow.id}`;
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setLinkedAgents(data.data);
-        console.log("linked agents", data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listTargetAgentsUrl, payLoad, onSuccess, onError);
-  };
-
-  const linkWorkflowAgent = (
-    workflowId: number,
-    targetAgentId: number,
-    agentType: string,
-    sequenceId?: number
-  ) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-    let linkAgentUrl;
-    linkAgentUrl = `${serverUrl}/workflows/link/agent/${workflowId}/${targetAgentId}/${agentType}`;
-    if (agentType === "sequential") {
-      linkAgentUrl = `${serverUrl}/workflows/link/agent/${workflowId}/${targetAgentId}/${agentType}/${sequenceId}`;
-    }
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchLinkedAgents();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(linkAgentUrl, payLoad, onSuccess, onError);
-  };
-
-  const unlinkWorkflowAgent = (agent: IAgent, link: any) => {
-    setError(null);
-    setLoading(true);
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    let unlinkAgentUrl;
-    unlinkAgentUrl = `${serverUrl}/workflows/link/agent/${workflow.id}/${agent.id}/${link.agent_type}`;
-    if (link.agent_type === "sequential") {
-      unlinkAgentUrl = `${serverUrl}/workflows/link/agent/${workflow.id}/${agent.id}/${link.agent_type}/${link.sequence_id}`;
-    }
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchLinkedAgents();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-
-    fetchJSON(unlinkAgentUrl, payLoad, onSuccess, onError);
-  };
-
-  useEffect(() => {
-    fetchAgents();
-    fetchLinkedAgents();
-  }, []);
-
-  const agentItems: MenuProps["items"] =
-    agents.length > 0
-      ? agents.map((agent, index) => ({
-          key: index,
-          label: (
-            <>
-              
    {agent.config.name}
    
-              
    
-                {truncateText(agent.config.description || "", 20)}
-              
    
-            
-          ),
-          value: index,
-        }))
-      : [
-          {
-            key: -1,
-            label: <>No agents found,
-            value: 0,
-          },
-        ];
-
-  const receiverOnclick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedAgent = agents[selectedIndex];
-    if (selectedAgent && selectedAgent.id && workflow.id) {
-      linkWorkflowAgent(workflow.id, selectedAgent.id, "receiver");
-    }
-  };
-
-  const sequenceOnclick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedAgent = agents[selectedIndex];
-
-    if (selectedAgent && selectedAgent.id && workflow.id) {
-      const sequenceId =
-        linkedAgents.length > 0
-          ? linkedAgents[linkedAgents.length - 1].link.sequence_id + 1
-          : 0;
-      linkWorkflowAgent(
-        workflow.id,
-        selectedAgent.id,
-        "sequential",
-        sequenceId
-      );
-    }
-  };
-
-  const senderOnClick: MenuProps["onClick"] = ({ key }) => {
-    const selectedIndex = parseInt(key.toString());
-    let selectedAgent = agents[selectedIndex];
-
-    if (selectedAgent && selectedAgent.id && workflow.id) {
-      linkWorkflowAgent(workflow.id, selectedAgent.id, "sender");
-    }
-  };
-
-  const handleRemoveAgent = (agent: IAgent, link: any) => {
-    if (agent && agent.id && workflow.id) {
-      unlinkWorkflowAgent(agent, link);
-    }
-    console.log(link);
-  };
-
-  const { token } = useToken();
-  const contentStyle: React.CSSProperties = {
-    backgroundColor: token.colorBgElevated,
-    borderRadius: token.borderRadiusLG,
-    boxShadow: token.boxShadowSecondary,
-  };
-
-  const AddAgentDropDown = ({
-    title,
-    onClick,
-    agentType,
-  }: {
-    title?: string;
-    onClick: MenuProps["onClick"];
-    agentType: string;
-  }) => {
-    const targetAgents = linkedAgents.filter(
-      (row) => row.link.agent_type === agentType
-    );
-
-    const agentButtons = targetAgents.map(({ agent, link }, i) => {
-      const tooltipText = (
-        <>
-          
    {agent.config.name}
    
-          
    
-            {truncateText(agent.config.description || "", 90)}
-          
    
-        
-      );
-      return (
-        
    
-          
    
-            {" "}
-            
    
-              {" "}
-              
-                
    {agent.config.name}
    {" "}
-                  
-              
     {
-                  e.stopPropagation(); // Prevent opening the modal to edit
-                  handleRemoveAgent(agent, link);
-                }}
-                className="ml-1 text-primary hover:text-accent duration-300"
-              >
-                
-              
    
-            
    
-          
    
-          {link.agent_type === "sequential" &&
-            i !== targetAgents.length - 1 && (
-              
    
-                {" "}
-              
    
-            )}
-        
    
-      );
-    });
-
-    return (
-      
    
-        
    
-          {(!targetAgents || targetAgents.length === 0) && (
-            
    
-               No{" "}
-              {title} agent linked to this workflow.
-            
    
-          )}
-          
    {agentButtons} 
    
-        
    
-
-        {targetAgents && targetAgents.length == 1 && (
-          
    
-             you can
-            remove current agents and add new ones.
-          
    
-        )}
-        {((targetAgents.length < 1 && agentType !== "sequential") ||
-          agentType === "sequential") && (
-           (
-              
    
-                {React.cloneElement(menu as React.ReactElement, {
-                  style: { boxShadow: "none" },
-                })}
-                {agents.length === 0 && (
-                  <>
-                    
-                    
-                    
    
-                      {" "}
-                      
-                        {" "}
-                        Please create agents in the Agents tab
-                      
-                    
    
-                  
-                )}
-              
    
-            )}
-          >
-            
    
-              {" "}
-              
    
-                Add {title} 
-              
    
-            
    
-              
-        )}
-      
    
-    );
-  };
-
-  return (
-    
    
-      {workflow.type === "autonomous" && (
-        
    
-          
    
-            
    
-              Initiator{" "}
-              
-                
-              
-            
    
-            
      
-              
-            
    
-          
    
-          
    
-            
    Receiver
    
-            
      
-              
-            
    
-          
    
-        
    
-      )}
-
-      {workflow.type === "sequential" && (
-        
    
-          
    Agents
    
-          
      
-            
-          
    
-        
    
-      )}
-    
    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/skillconfig.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/skillconfig.tsx
deleted file mode 100644
index 8a7a2f24c7f0..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/skillconfig.tsx
+++ /dev/null
@@ -1,295 +0,0 @@
-import React from "react";
-import { fetchJSON, getServerUrl, sampleModelConfig } from "../../../utils";
-import { Button, Input, message, theme } from "antd";
-import {
-  CpuChipIcon,
-  EyeIcon,
-  EyeSlashIcon,
-  InformationCircleIcon,
-  PlusIcon,
-  TrashIcon,
-} from "@heroicons/react/24/outline";
-import { ISkill, IStatus } from "../../../types";
-import { Card, ControlRowView, MonacoEditor } from "../../../atoms";
-import TextArea from "antd/es/input/TextArea";
-import { appContext } from "../../../../hooks/provider";
-
-const SecretsEditor = ({
-  secrets = [],
-  updateSkillConfig,
-}: {
-  secrets: { secret: string; value: string }[];
-  updateSkillConfig: (key: string, value: any) => void;
-}) => {
-  const [editingIndex, setEditingIndex] = React.useState(null);
-  const [newSecret, setNewSecret] = React.useState("");
-  const [newValue, setNewValue] = React.useState("");
-
-  const toggleEditing = (index: number) => {
-    setEditingIndex(editingIndex === index ? null : index);
-  };
-
-  const handleAddSecret = () => {
-    if (newSecret && newValue) {
-      const updatedSecrets = [
-        ...secrets,
-        { secret: newSecret, value: newValue },
-      ];
-      updateSkillConfig("secrets", updatedSecrets);
-      setNewSecret("");
-      setNewValue("");
-    }
-  };
-
-  const handleRemoveSecret = (index: number) => {
-    const updatedSecrets = secrets.filter((_, i) => i !== index);
-    updateSkillConfig("secrets", updatedSecrets);
-  };
-
-  const handleSecretChange = (index: number, key: string, value: string) => {
-    const updatedSecrets = secrets.map((item, i) =>
-      i === index ? { ...item, [key]: value } : item
-    );
-    updateSkillConfig("secrets", updatedSecrets);
-  };
-
-  return (
-    
    
-      {secrets && (
-        
    
-          {secrets.map((secret, index) => (
-            
    
-              
-                  handleSecretChange(index, "secret", e.target.value)
-                }
-                className="flex-1"
-              />
-              
-                  handleSecretChange(index, "value", e.target.value)
-                }
-                className="flex-1"
-              />
-              
    
-          ))}
-        
    
-      )}
-      
    
-         setNewSecret(e.target.value)}
-          className="flex-1"
-        />
-         setNewValue(e.target.value)}
-          className="flex-1"
-        />
-        
    
-    
    
-  );
-};
-
-export const SkillConfigView = ({
-  skill,
-  setSkill,
-  close,
-}: {
-  skill: ISkill;
-  setSkill: (newModel: ISkill) => void;
-  close: () => void;
-}) => {
-  const [loading, setLoading] = React.useState(false);
-
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-  const testModelUrl = `${serverUrl}/skills/test`;
-  const createSkillUrl = `${serverUrl}/skills`;
-
-  const createSkill = (skill: ISkill) => {
-    setLoading(true);
-    skill.user_id = user?.email;
-    const payLoad = {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(skill),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        setSkill(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      message.error(err.message);
-      setLoading(false);
-    };
-    const onFinal = () => {
-      setLoading(false);
-      setControlChanged(false);
-    };
-    fetchJSON(createSkillUrl, payLoad, onSuccess, onError, onFinal);
-  };
-
-  const [controlChanged, setControlChanged] = React.useState(false);
-
-  const updateSkillConfig = (key: string, value: string) => {
-    if (skill) {
-      const updatedSkill = { ...skill, [key]: value };
-      //   setSkill(updatedModelConfig);
-      setSkill(updatedSkill);
-    }
-    setControlChanged(true);
-  };
-
-  const hasChanged = !controlChanged && skill.id !== undefined;
-  const editorRef = React.useRef(null);
-
-  return (
-    
    
-      {skill && (
-        
    
-          
    
-            
    
-              
    
-                
    
-                   {
-                      updateSkillConfig("content", value);
-                    }}
-                  />
-                
    
-              
    
-            
    
-            
    
-              
    
-                 {
-                        updateSkillConfig("name", e.target.value);
-                      }}
-                    />
-                  }
-                />
-
-                 {
-                        updateSkillConfig("description", e.target.value);
-                      }}
-                    />
-                  }
-                />
-
-                
-                  }
-                />
-              
    
-            
    
-          
    
-        
    
-      )}
-
-      
    
-        {/*  */}
-
-        {!hasChanged && (
-          
-        )}
-
-        
-      
    
-    
    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/workflowconfig.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/utils/workflowconfig.tsx
deleted file mode 100644
index c42c2e9be302..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/utils/workflowconfig.tsx
+++ /dev/null
@@ -1,279 +0,0 @@
-import React from "react";
-import { IWorkflow, IStatus, IChatSession } from "../../../types";
-import { ControlRowView } from "../../../atoms";
-import {
-  fetchJSON,
-  getRandomIntFromDateAndSalt,
-  getServerUrl,
-} from "../../../utils";
-import { Button, Drawer, Input, Select, Tabs, message, theme } from "antd";
-import { appContext } from "../../../../hooks/provider";
-import { BugAntIcon, UserGroupIcon } from "@heroicons/react/24/outline";
-import { WorkflowAgentSelector, WorkflowTypeSelector } from "./selectors";
-import ChatBox from "../../playground/chatbox";
-
-export const WorkflowViewConfig = ({
-  workflow,
-  setWorkflow,
-  close,
-}: {
-  workflow: IWorkflow;
-  setWorkflow: (newFlowConfig: IWorkflow) => void;
-  close: () => void;
-}) => {
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState(null);
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const createWorkflowUrl = `${serverUrl}/workflows`;
-
-  const [controlChanged, setControlChanged] = React.useState(false);
-  const [localWorkflow, setLocalWorkflow] = React.useState(workflow);
-
-  const updateFlowConfig = (key: string, value: string) => {
-    // When an updatedFlowConfig is created using localWorkflow, if the contents of FlowConfigViewer Modal are changed after the Agent Specification Modal is updated, the updated contents of the Agent Specification Modal are not saved. Fixed to localWorkflow->flowConfig. Fixed a bug.
-    const updatedFlowConfig = { ...workflow, [key]: value };
-
-    setLocalWorkflow(updatedFlowConfig);
-    setWorkflow(updatedFlowConfig);
-    setControlChanged(true);
-  };
-
-  const createWorkflow = (workflow: IWorkflow) => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    workflow.user_id = user?.email;
-
-    const payLoad = {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(workflow),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        const newWorkflow = data.data;
-        setWorkflow(newWorkflow);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-      // setNewAgent(sampleAgent);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    const onFinal = () => {
-      setLoading(false);
-      setControlChanged(false);
-    };
-
-    fetchJSON(createWorkflowUrl, payLoad, onSuccess, onError, onFinal);
-  };
-
-  const hasChanged = !controlChanged && workflow.id !== undefined;
-  const [drawerOpen, setDrawerOpen] = React.useState(false);
-
-  const openDrawer = () => {
-    setDrawerOpen(true);
-  };
-
-  const closeDrawer = () => {
-    setDrawerOpen(false);
-  };
-
-  const dummySession: IChatSession = {
-    user_id: user?.email || "test_session_user_id",
-    workflow_id: workflow?.id,
-    name: "test_session",
-  };
-
-  return (
-    <>
-      {/* 
    {flowConfig.name}
     */}
-      
    
-         updateFlowConfig("name", e.target.value)}
-            />
-          }
-        />
-
-         updateFlowConfig("description", e.target.value)}
-            />
-          }
-        />
-
-        
-                updateFlowConfig("summary_method", value)
-              }
-              options={
-                [
-                  { label: "last", value: "last" },
-                  { label: "none", value: "none" },
-                  { label: "llm", value: "llm" },
-                ] as any
-              }
-            />
-          }
-        />
-      
    
-
-      
    
-        {" "}
-        {!hasChanged && (
-          
-        )}
-        {workflow?.id && (
-          
-        )}
-        
-      
    
-
-      {workflow?.name || "Test Workflow"}}
-        size="large"
-        onClose={closeDrawer}
-        open={drawerOpen}
-      >
-        
    
-          {drawerOpen && (
-            
-          )}
-        
    
-          
-    
-  );
-};
-
-export const WorflowViewer = ({
-  workflow,
-  setWorkflow,
-  close,
-}: {
-  workflow: IWorkflow;
-  setWorkflow: (workflow: IWorkflow) => void;
-  close: () => void;
-}) => {
-  let items = [
-    {
-      label: (
-        
    
-          {" "}
-          
-          Workflow Configuration
-        
    
-      ),
-      key: "1",
-      children: (
-        
    
-          {!workflow?.type && (
-            
-          )}
-
-          {workflow?.type && workflow && (
-            
-          )}
-        
    
-      ),
-    },
-  ];
-  if (workflow) {
-    if (workflow?.id) {
-      items.push({
-        label: (
-          
    
-            {" "}
-            
-            Agents
-          
    
-        ),
-        key: "2",
-        children: (
-          <>
-            {" "}
-          
-        ),
-      });
-    }
-  }
-
-  const { user } = React.useContext(appContext);
-
-  return (
-    
    
-      
-    
    
-  );
-};
diff --git a/python/packages/autogen-studio/frontend/src/components/views/builder/workflow.tsx b/python/packages/autogen-studio/frontend/src/components/views/builder/workflow.tsx
deleted file mode 100644
index 025ad77c7dd2..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/builder/workflow.tsx
+++ /dev/null
@@ -1,428 +0,0 @@
-import {
-  ArrowDownTrayIcon,
-  ArrowUpTrayIcon,
-  CodeBracketSquareIcon,
-  DocumentDuplicateIcon,
-  InformationCircleIcon,
-  PlusIcon,
-  TrashIcon,
-  UserGroupIcon,
-  UsersIcon,
-} from "@heroicons/react/24/outline";
-import { Dropdown, MenuProps, Modal, message } from "antd";
-import * as React from "react";
-import { IWorkflow, IStatus } from "../../types";
-import { appContext } from "../../../hooks/provider";
-import {
-  fetchJSON,
-  getServerUrl,
-  sanitizeConfig,
-  timeAgo,
-  truncateText,
-} from "../../utils";
-import { BounceLoader, Card, CardHoverBar, LoadingOverlay } from "../../atoms";
-import { WorflowViewer } from "./utils/workflowconfig";
-import { ExportWorkflowModal } from "./utils/export";
-
-const WorkflowView = ({}: any) => {
-  const [loading, setLoading] = React.useState(false);
-  const [error, setError] = React.useState({
-    status: true,
-    message: "All good",
-  });
-  const { user } = React.useContext(appContext);
-  const serverUrl = getServerUrl();
-  const listWorkflowsUrl = `${serverUrl}/workflows?user_id=${user?.email}`;
-  const saveWorkflowsUrl = `${serverUrl}/workflows`;
-
-  const [workflows, setWorkflows] = React.useState([]);
-  const [selectedWorkflow, setSelectedWorkflow] =
-    React.useState(null);
-  const [selectedExportWorkflow, setSelectedExportWorkflow] =
-    React.useState(null);
-
-  const sampleWorkflow: IWorkflow = {
-    name: "Sample Agent Workflow",
-    description: "Sample Agent Workflow",
-  };
-  const [newWorkflow, setNewWorkflow] = React.useState(
-    sampleWorkflow
-  );
-
-  const [showWorkflowModal, setShowWorkflowModal] = React.useState(false);
-  const [showNewWorkflowModal, setShowNewWorkflowModal] = React.useState(false);
-
-  const fetchWorkFlow = () => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        setWorkflows(data.data);
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(listWorkflowsUrl, payLoad, onSuccess, onError);
-  };
-
-  const deleteWorkFlow = (workflow: IWorkflow) => {
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const deleteWorkflowsUrl = `${serverUrl}/workflows/delete?user_id=${user?.email}&workflow_id=${workflow.id}`;
-    const payLoad = {
-      method: "DELETE",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        user_id: user?.email,
-        workflow: workflow,
-      }),
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        message.success(data.message);
-        fetchWorkFlow();
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(deleteWorkflowsUrl, payLoad, onSuccess, onError);
-  };
-
-  React.useEffect(() => {
-    if (user) {
-      // console.log("fetching messages", messages);
-      fetchWorkFlow();
-    }
-  }, []);
-
-  React.useEffect(() => {
-    if (selectedWorkflow) {
-      setShowWorkflowModal(true);
-    }
-  }, [selectedWorkflow]);
-
-  const [showExportModal, setShowExportModal] = React.useState(false);
-
-  const workflowRows = (workflows || []).map(
-    (workflow: IWorkflow, i: number) => {
-      const cardItems = [
-        {
-          title: "Export",
-          icon: CodeBracketSquareIcon,
-          onClick: (e: any) => {
-            e.stopPropagation();
-            setSelectedExportWorkflow(workflow);
-            setShowExportModal(true);
-          },
-          hoverText: "Export",
-        },
-        {
-          title: "Download",
-          icon: ArrowDownTrayIcon,
-          onClick: (e: any) => {
-            e.stopPropagation();
-            // download workflow as workflow.name.json
-            const element = document.createElement("a");
-            const sanitizedWorkflow = sanitizeConfig(workflow);
-            const file = new Blob([JSON.stringify(sanitizedWorkflow)], {
-              type: "application/json",
-            });
-            element.href = URL.createObjectURL(file);
-            element.download = `workflow_${workflow.name}.json`;
-            document.body.appendChild(element); // Required for this to work in FireFox
-            element.click();
-          },
-          hoverText: "Download",
-        },
-        {
-          title: "Make a Copy",
-          icon: DocumentDuplicateIcon,
-          onClick: (e: any) => {
-            e.stopPropagation();
-            let newWorkflow = { ...sanitizeConfig(workflow) };
-            newWorkflow.name = `${workflow.name}_copy`;
-            setNewWorkflow(newWorkflow);
-            setShowNewWorkflowModal(true);
-          },
-          hoverText: "Make a Copy",
-        },
-        {
-          title: "Delete",
-          icon: TrashIcon,
-          onClick: (e: any) => {
-            e.stopPropagation();
-            deleteWorkFlow(workflow);
-          },
-          hoverText: "Delete",
-        },
-      ];
-      return (
-        
  • 
-          {truncateText(workflow.name, 25)}}
-            onClick={() => {
-              setSelectedWorkflow(workflow);
-            }}
-          >
-            
-            
    
-              {timeAgo(workflow.updated_at || "")}
-            
    
-
-            
-              
-        
    • 
-      );
-    }
-  );
-
-  const WorkflowModal = ({
-    workflow,
-    setWorkflow,
-    showModal,
-    setShowModal,
-    handler,
-  }: {
-    workflow: IWorkflow | null;
-    setWorkflow?: (workflow: IWorkflow | null) => void;
-    showModal: boolean;
-    setShowModal: (show: boolean) => void;
-    handler?: (workflow: IWorkflow) => void;
-  }) => {
-    const [localWorkflow, setLocalWorkflow] = React.useState(
-      workflow
-    );
-
-    const closeModal = () => {
-      setShowModal(false);
-      if (handler) {
-        handler(localWorkflow as IWorkflow);
-      }
-    };
-
-    return (
-      
-            Workflow Specification{" "}
-            
-              {localWorkflow?.name}
-            {" "}
-          
-        }
-        width={800}
-        open={showModal}
-        onOk={() => {
-          closeModal();
-        }}
-        onCancel={() => {
-          closeModal();
-        }}
-        footer={[]}
-      >
-        <>
-          {localWorkflow && (
-            
-          )}
-        
-      
-    );
-  };
-
-  const uploadWorkflow = () => {
-    const input = document.createElement("input");
-    input.type = "file";
-    input.accept = ".json";
-    input.onchange = (e: any) => {
-      const file = e.target.files[0];
-      const reader = new FileReader();
-      reader.onload = (e: any) => {
-        const contents = e.target.result;
-        if (contents) {
-          try {
-            const workflow = JSON.parse(contents);
-            // TBD validate that it is a valid workflow
-            setNewWorkflow(workflow);
-            setShowNewWorkflowModal(true);
-          } catch (err) {
-            message.error("Invalid workflow file");
-          }
-        }
-      };
-      reader.readAsText(file);
-    };
-    input.click();
-  };
-
-  const workflowTypes: MenuProps["items"] = [
-    // {
-    //   key: "twoagents",
-    //   label: (
-    //     
    
-    //       {" "}
-    //       
-    //       Two Agents
-    //     
    
-    //   ),
-    // },
-    // {
-    //   key: "groupchat",
-    //   label: (
-    //     
    
-    //       
-    //       Group Chat
-    //     
    
-    //   ),
-    // },
-    // {
-    //   type: "divider",
-    // },
-    {
-      key: "uploadworkflow",
-      label: (
-        
    
-          
-          Upload Workflow
-        
    
-      ),
-    },
-  ];
-
-  const showWorkflow = (config: IWorkflow) => {
-    setSelectedWorkflow(config);
-    setShowWorkflowModal(true);
-  };
-
-  const workflowTypesOnClick: MenuProps["onClick"] = ({ key }) => {
-    if (key === "uploadworkflow") {
-      uploadWorkflow();
-      return;
-    }
-    showWorkflow(sampleWorkflow);
-  };
-
-  return (
-    
    
-       {
-          fetchWorkFlow();
-        }}
-      />
-
-       {
-          fetchWorkFlow();
-        }}
-      />
-
-      
-
-      
    
-        
    
-          
    
-            
    
-              {" "}
-              Workflows ({workflowRows.length}){" "}
-            
    
-            
    
-               {
-                  showWorkflow(sampleWorkflow);
-                }}
-              >
-                
-                New Workflow
-              
-            
    
-          
    
-          
    
-            {" "}
-            Configure an agent workflow that can be used to handle tasks.
-          
    
-          {workflows && workflows.length > 0 && (
-            
    
-              
-              
      {workflowRows}
    
-            
    
-          )}
-          {workflows && workflows.length === 0 && !loading && (
-            
    
-              
-              No workflows found. Please create a new workflow.
-            
    
-          )}
-          {loading && (
-            
    
-              {" "}
-              {" "}
-               loading .. 
-            
    
-          )}
-        
    
-      
    
-    
    
-  );
-};
-
-export default WorkflowView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/gallery/gallery.tsx b/python/packages/autogen-studio/frontend/src/components/views/gallery/gallery.tsx
deleted file mode 100644
index 53f1be444938..000000000000
--- a/python/packages/autogen-studio/frontend/src/components/views/gallery/gallery.tsx
+++ /dev/null
@@ -1,207 +0,0 @@
-import * as React from "react";
-import { appContext } from "../../../hooks/provider";
-import { fetchJSON, getServerUrl, timeAgo, truncateText } from "../../utils";
-import { IGalleryItem, IStatus } from "../../types";
-import { Button, message } from "antd";
-import { BounceLoader, Card } from "../../atoms";
-import {
-  ChevronLeftIcon,
-  InformationCircleIcon,
-} from "@heroicons/react/24/outline";
-import { navigate } from "gatsby";
-import ChatBox from "../playground/chatbox";
-
-const GalleryView = ({ location }: any) => {
-  const serverUrl = getServerUrl();
-  const { user } = React.useContext(appContext);
-  const [loading, setLoading] = React.useState(false);
-  const [gallery, setGallery] = React.useState(null);
-  const [currentGallery, setCurrentGallery] =
-    React.useState(null);
-  const listGalleryUrl = `${serverUrl}/gallery?user_id=${user?.email}`;
-  const [error, setError] = React.useState({
-    status: true,
-    message: "All good",
-  });
-  const [currentGalleryId, setCurrentGalleryId] = React.useState(
-    null
-  );
-
-  React.useEffect(() => {
-    // get gallery id from url
-    const urlParams = new URLSearchParams(location.search);
-    const galleryId = urlParams.get("id");
-
-    if (galleryId) {
-      // Fetch gallery details using the galleryId
-      fetchGallery(galleryId);
-      setCurrentGalleryId(galleryId);
-    } else {
-      // Redirect to an error page or home page if the id is not found
-      // navigate("/");
-      fetchGallery(null);
-    }
-  }, []);
-
-  const fetchGallery = (galleryId: string | null) => {
-    const fetchGalleryUrl = galleryId
-      ? `${serverUrl}/gallery?gallery_id=${galleryId}`
-      : listGalleryUrl;
-    setError(null);
-    setLoading(true);
-    // const fetch;
-    const payLoad = {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const onSuccess = (data: any) => {
-      if (data && data.status) {
-        // message.success(data.message);
-        console.log("gallery", data);
-        if (galleryId) {
-          // Set the currently viewed gallery item
-          setCurrentGallery(data.data[0]);
-        } else {
-          setGallery(data.data);
-        }
-        // Set the list of gallery items
-      } else {
-        message.error(data.message);
-      }
-      setLoading(false);
-    };
-    const onError = (err: any) => {
-      setError(err);
-      message.error(err.message);
-      setLoading(false);
-    };
-    fetchJSON(fetchGalleryUrl, payLoad, onSuccess, onError);
-  };
-
-  const GalleryContent = ({ item }: { item: IGalleryItem }) => {
-    return (
-      
    
-        
    
-          This session contains {item.messages.length} messages and was created{" "}
-          {timeAgo(item.timestamp)}
-        
    
-        
    
-          
-        
    
-      
    
-    );
-  };
-
-  const TagsView = ({ tags }: { tags: string[] }) => {
-    const tagsView = tags.map((tag: string, index: number) => {
-      return (
-        
    
-          
-            {tag}
-          
-        
    
-      );
-    });
-    return 
    {tagsView}
    ;
-  };
-
-  const galleryRows = gallery?.map((item: IGalleryItem, index: number) => {
-    const isSelected = currentGallery?.id === item.id;
-    return (
-      
    
-         {
-            setCurrentGallery(item);
-            // add to history
-            navigate(`/gallery?id=${item.id}`);
-          }}
-          className="h-full p-2 cursor-pointer"
-          title={truncateText(item.messages[0]?.content || "", 20)}
-        >
-          
    
-            {" "}
-            {truncateText(item.messages[0]?.content || "", 80)}
-          
    
-          
    
-            {" "}
-            {item.messages.length} message{item.messages.length > 1 && "s"}
-          
    
-          
    
-            {" "}
-          
    
-          
    {timeAgo(item.timestamp)}
    
-            
-      
    
-    );
-  });
-
-  return (
-    
    
-      
    Gallery
    
-
-      {/* back to gallery button */}
-
-      {currentGallery && (
-        
    
-          
-        
    
-      )}
-
-      {!currentGallery && (
-        <>
-          
    
-            View a collection of AutoGen agent specifications and sessions{" "}
-          
    
-          
    
-            {galleryRows}
-          
    
-        
-      )}
-
-      {gallery && gallery.length === 0 && (
-        
    
-          
-          No gallery items found. Please create a chat session and publish to
-          gallery.
-        
    
-      )}
-
-      {currentGallery && (
-        
    
-          
-        
    
-      )}
-
-      {loading && (
-        
    
-          
    
-            {" "}
-            
-          
    
-          loading gallery
-        
    
-      )}
-    
    
-  );
-};
-
-export default GalleryView;
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
new file mode 100644
index 000000000000..55a837d52c10
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chat.tsx
@@ -0,0 +1,449 @@
+import * as React from "react";
+import { message } from "antd";
+import { getServerUrl } from "../../../utils";
+import { SessionManager } from "../../shared/session/manager";
+import { IStatus } from "../../../types/app";
+import { Message } from "../../../types/datamodel";
+import { useConfigStore } from "../../../../hooks/store";
+import { appContext } from "../../../../hooks/provider";
+import ChatInput from "./chatinput";
+import { ModelUsage, SocketMessage, ThreadState, ThreadStatus } from "./types";
+import { MessageList } from "./messagelist";
+import TeamManager from "../../shared/team/manager";
+
+const logo = require("../../../../images/landing/welcome.svg").default;
+
+export default function ChatView({
+  initMessages,
+}: {
+  initMessages: Message[];
+}) {
+  const serverUrl = getServerUrl();
+  const [loading, setLoading] = React.useState(false);
+  const [error, setError] = React.useState({
+    status: true,
+    message: "All good",
+  });
+  const [messages, setMessages] = React.useState(initMessages);
+  const [threadMessages, setThreadMessages] = React.useState<
+    Record
+  >({});
+  const chatContainerRef = React.useRef(null);
+
+  const { user } = React.useContext(appContext);
+  const { session, sessions } = useConfigStore();
+  const [activeSockets, setActiveSockets] = React.useState<
+    Record
+  >({});
+
+  React.useEffect(() => {
+    if (chatContainerRef.current) {
+      chatContainerRef.current.scrollTo({
+        top: chatContainerRef.current.scrollHeight,
+        behavior: "smooth",
+      });
+    }
+  }, [messages, threadMessages]);
+
+  React.useEffect(() => {
+    return () => {
+      Object.values(activeSockets).forEach((socket) => socket.close());
+    };
+  }, [activeSockets]);
+
+  const getBaseUrl = (url: string): string => {
+    try {
+      // Remove protocol (http:// or https://)
+      let baseUrl = url.replace(/(^\w+:|^)\/\//, "");
+
+      // Handle both localhost and production cases
+      if (baseUrl.startsWith("localhost")) {
+        // For localhost, keep the port if it exists
+        baseUrl = baseUrl.replace("/api", "");
+      } else if (baseUrl === "/api") {
+        // For production where url is just '/api'
+        baseUrl = window.location.host;
+      } else {
+        // For other cases, remove '/api' and trailing slash
+        baseUrl = baseUrl.replace("/api", "").replace(/\/$/, "");
+      }
+
+      return baseUrl;
+    } catch (error) {
+      console.error("Error processing server URL:", error);
+      throw new Error("Invalid server URL configuration");
+    }
+  };
+
+  const createRun = async (sessionId: number): Promise => {
+    const payload = { session_id: sessionId, user_id: user?.email || "" };
+
+    const response = await fetch(`${serverUrl}/runs`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to create run");
+    }
+
+    const data = await response.json();
+    return data.data.run_id;
+  };
+
+  const startRun = async (runId: string, query: string) => {
+    const messagePayload = {
+      user_id: user?.email,
+      session_id: session?.id,
+      config: {
+        content: query,
+        source: "user",
+      },
+    };
+
+    const response = await fetch(`${serverUrl}/runs/${runId}/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(messagePayload),
+    });
+
+    if (!response.ok) {
+      throw new Error("Failed to start run");
+    }
+
+    return await response.json();
+  };
+
+  interface RequestUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+  }
+
+  const connectWebSocket = (runId: string, query: string) => {
+    const baseUrl = getBaseUrl(serverUrl);
+    // Determine if we should use ws:// or wss:// based on current protocol
+    const wsProtocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${wsProtocol}//${baseUrl}/api/ws/runs/${runId}`;
+
+    console.log("Connecting to WebSocket URL:", wsUrl); // For debugging
+
+    const socket = new WebSocket(wsUrl);
+    let isClosing = false;
+
+    const closeSocket = () => {
+      if (!isClosing && socket.readyState !== WebSocket.CLOSED) {
+        isClosing = true;
+        socket.close();
+        setActiveSockets((prev) => {
+          const newSockets = { ...prev };
+          delete newSockets[runId];
+          return newSockets;
+        });
+      }
+    };
+
+    socket.onopen = async () => {
+      try {
+        setActiveSockets((prev) => ({
+          ...prev,
+          [runId]: socket,
+        }));
+
+        setThreadMessages((prev) => ({
+          ...prev,
+          [runId]: {
+            messages: [],
+            status: "streaming",
+            isExpanded: true,
+          },
+        }));
+
+        setMessages((prev: Message[]) =>
+          prev.map((msg: Message) => {
+            if (msg.run_id === runId && msg.config.source === "bot") {
+              return {
+                ...msg,
+                config: {
+                  ...msg.config,
+                  content: "Starting...",
+                },
+              };
+            }
+            return msg;
+          })
+        );
+
+        // Start the run only after socket is connected
+        await startRun(runId, query);
+      } catch (error) {
+        console.error("Error starting run:", error);
+        message.error("Failed to start run");
+        closeSocket();
+
+        setThreadMessages((prev) => ({
+          ...prev,
+          [runId]: {
+            ...prev[runId],
+            status: "error",
+            isExpanded: true,
+          },
+        }));
+      }
+    };
+
+    socket.onmessage = (event) => {
+      const message: SocketMessage = JSON.parse(event.data);
+
+      switch (message.type) {
+        case "message":
+          setThreadMessages((prev) => {
+            const currentThread = prev[runId] || {
+              messages: [],
+              status: "streaming",
+              isExpanded: true,
+            };
+
+            const models_usage: ModelUsage | undefined = message.data
+              ?.models_usage
+              ? {
+                  prompt_tokens: message.data.models_usage.prompt_tokens,
+                  completion_tokens:
+                    message.data.models_usage.completion_tokens,
+                }
+              : undefined;
+
+            const newMessage = {
+              source: message.data?.source || "",
+              content: message.data?.content || "",
+              models_usage,
+            };
+
+            return {
+              ...prev,
+              [runId]: {
+                ...currentThread,
+                messages: [...currentThread.messages, newMessage],
+                status: "streaming",
+              },
+            };
+          });
+          break;
+
+        case "result":
+        case "completion":
+          setThreadMessages((prev) => {
+            const currentThread = prev[runId];
+            if (!currentThread) return prev;
+
+            const finalMessage = message.data?.task_result?.messages
+              ?.filter((msg: any) => msg.content !== "TERMINATE")
+              .pop();
+
+            const status: ThreadStatus = message.status || "complete";
+            // Capture completion reason from task_result
+            const reason =
+              message.data?.task_result?.stop_reason ||
+              (message.error ? `Error: ${message.error}` : undefined);
+
+            return {
+              ...prev,
+              [runId]: {
+                ...currentThread,
+                status: status,
+                reason: reason,
+                isExpanded: true,
+                finalResult: finalMessage,
+                messages: currentThread.messages,
+              },
+            };
+          });
+          closeSocket();
+          break;
+      }
+    };
+
+    socket.onclose = (event) => {
+      console.log(
+        `WebSocket closed for run ${runId}. Code: ${event.code}, Reason: ${event.reason}`
+      );
+
+      if (!isClosing) {
+        setActiveSockets((prev) => {
+          const newSockets = { ...prev };
+          delete newSockets[runId];
+          return newSockets;
+        });
+
+        setThreadMessages((prev) => {
+          const thread = prev[runId];
+          if (thread && thread.status === "streaming") {
+            return {
+              ...prev,
+              [runId]: {
+                ...thread,
+                status: "complete",
+                reason: event.reason || "Connection closed",
+              },
+            };
+          }
+          return prev;
+        });
+      }
+    };
+
+    socket.onerror = (error) => {
+      console.error("WebSocket error:", error);
+      message.error("WebSocket connection error");
+
+      setThreadMessages((prev) => {
+        const thread = prev[runId];
+        if (!thread) return prev;
+
+        return {
+          ...prev,
+          [runId]: {
+            ...thread,
+            status: "error",
+            reason: "WebSocket connection error occurred",
+            isExpanded: true,
+          },
+        };
+      });
+
+      closeSocket();
+    };
+
+    return socket;
+  };
+
+  const cancelRun = async (runId: string) => {
+    const socket = activeSockets[runId];
+    if (socket && socket.readyState === WebSocket.OPEN) {
+      socket.send(JSON.stringify({ type: "stop" }));
+
+      setThreadMessages((prev) => ({
+        ...prev,
+        [runId]: {
+          ...prev[runId],
+          status: "cancelled",
+          reason: "Cancelled by user",
+          isExpanded: true,
+        },
+      }));
+    }
+  };
+
+  const runTask = async (query: string) => {
+    setError(null);
+    setLoading(true);
+
+    if (!session?.id) {
+      setLoading(false);
+      return;
+    }
+
+    let runId: string | null = null;
+
+    try {
+      runId = (await createRun(session.id)) + "";
+
+      const userMessage: Message = {
+        config: {
+          content: query,
+          source: "user",
+        },
+        session_id: session.id,
+        run_id: runId,
+      };
+
+      const botMessage: Message = {
+        config: {
+          content: "Thinking...",
+          source: "bot",
+        },
+        session_id: session.id,
+        run_id: runId,
+      };
+
+      setMessages((prev) => [...prev, userMessage, botMessage]);
+      connectWebSocket(runId, query); // Now passing query to connectWebSocket
+    } catch (err) {
+      console.error("Error:", err);
+      message.error("Error during request processing");
+
+      if (runId) {
+        if (activeSockets[runId]) {
+          activeSockets[runId].close();
+        }
+
+        setThreadMessages((prev) => ({
+          ...prev,
+          [runId!]: {
+            ...prev[runId!],
+            status: "error",
+            isExpanded: true,
+          },
+        }));
+      }
+
+      setError({
+        status: false,
+        message: err instanceof Error ? err.message : "Unknown error occurred",
+      });
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  React.useEffect(() => {
+    // session changed
+    if (session) {
+      setMessages([]);
+      setThreadMessages({});
+    }
+  }, [session]);
+
+  return (
+    
    
+      
    
+        
    
+          
+        
    
+        
+      
    
+      
    
+        
    
+          
+        
    
+
+        {sessions?.length === 0 ? (
+          
    
+            
    
+              Welcome
+              Welcome! Create a session to get started!
+            
    
+          
    
+        ) : (
+          <>
+            {session && (
+              
    
+                
+              
    
+            )}
+          
+        )}
+      
    
+    
    
+  );
+}
diff --git a/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chatinput.tsx b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chatinput.tsx
new file mode 100644
index 000000000000..b170f4bcc4c8
--- /dev/null
+++ b/python/packages/autogen-studio/frontend/src/components/views/playground/chat/chatinput.tsx
@@ -0,0 +1,128 @@
+"use client";
+
+import {
+  PaperAirplaneIcon,
+  Cog6ToothIcon,
+  ExclamationTriangleIcon,
+} from "@heroicons/react/24/outline";
+import * as React from "react";
+import { IStatus } from "../../../types/app";
+
+interface ChatInputProps {
+  onSubmit: (text: string) => void;
+  loading: boolean;
+  error: IStatus | null;
+}
+export default function ChatInput({
+  onSubmit,
+  loading,
+  error,
+}: ChatInputProps) {
+  const textAreaRef = React.useRef(null);
+  const [previousLoading, setPreviousLoading] = React.useState(loading);
+  const [text, setText] = React.useState("");
+
+  const textAreaDefaultHeight = "64px";
+
+  // Handle textarea auto-resize
+  React.useEffect(() => {
+    if (textAreaRef.current) {
+      textAreaRef.current.style.height = textAreaDefaultHeight;
+      const scrollHeight = textAreaRef.current.scrollHeight;
+      textAreaRef.current.style.height = `${scrollHeight}px`;
+    }
+  }, [text]);
+
+  // Clear input when loading changes from true to false (meaning the response is complete)
+  React.useEffect(() => {
+    if (previousLoading && !loading && !error) {
+      resetInput();
+    }
+    setPreviousLoading(loading);
+  }, [loading, error, previousLoading]);
+
+  const resetInput = () => {
+    if (textAreaRef.current) {
+      textAreaRef.current.value = "";
+      textAreaRef.current.style.height = textAreaDefaultHeight;
+      setText("");
+    }
+  };
+
+  const handleTextChange = (event: React.ChangeEvent) => {
+    setText(event.target.value);
+  };
+
+  const handleSubmit = () => {
+    if (textAreaRef.current?.value && !loading) {
+      const query = textAreaRef.current.value;
+      onSubmit(query);
+      // Don't reset immediately - wait for response to complete
+    }
+  };
+
+  const handleKeyDown = (event: React.KeyboardEvent) => {
+    if (event.key === "Enter" && !event.shiftKey) {
+      event.preventDefault();
+      handleSubmit();
+    }
+  };
+
+  return (
+    
    
+      
    
+        
     {
+            e.preventDefault();
+            handleSubmit();
+          }}
+        >
+