Skip to content

A programming framework for agentic AI

Migrate docs to use BaseAgent.register (#605)

Eric Zhu8ea09318ce89
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/extracting-results-with-an-agent.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/extracting-results-with-an-agent.ipynb
index e858782d9..c386699f0 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/extracting-results-with-an-agent.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/extracting-results-with-an-agent.ipynb
@@ -18,7 +18,7 @@
},
{
"cell_type": "code",
- "execution_count": 36,
+ "execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
@@ -39,7 +39,7 @@
},
{
"cell_type": "code",
- "execution_count": 37,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
@@ -57,7 +57,7 @@
},
{
"cell_type": "code",
- "execution_count": 38,
+ "execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
@@ -77,7 +77,7 @@
},
{
"cell_type": "code",
- "execution_count": 39,
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -94,7 +94,7 @@
},
{
"cell_type": "code",
- "execution_count": 40,
+ "execution_count": 5,
"metadata": {},
"outputs": [
{
@@ -103,16 +103,14 @@
"AgentType(type='output_result')"
]
},
- "execution_count": 40,
+ "execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
- " \"output_result\", lambda: ClosureAgent(\"An output agent\", output_result), lambda: [DefaultSubscription()]\n",
- ")"
+ "await ClosureAgent.register(runtime, \"output_result\", output_result, subscriptions=lambda: [DefaultSubscription()])"
]
},
{
@@ -124,7 +122,7 @@
},
{
"cell_type": "code",
- "execution_count": 41,
+ "execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
@@ -143,7 +141,7 @@
},
{
"cell_type": "code",
- "execution_count": 42,
+ "execution_count": 7,
"metadata": {},
"outputs": [
{
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/langgraph-agent.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/langgraph-agent.ipynb
index d623709c1..5516bdc42 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/langgraph-agent.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/langgraph-agent.ipynb
@@ -39,7 +39,6 @@
"metadata": {},
"outputs": [],
"source": [
- "import os\n",
"from dataclasses import dataclass\n",
"from typing import Any, Callable, List, Literal\n",
"\n",
@@ -103,7 +102,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
@@ -190,12 +189,13 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
+ "await LangGraphToolUseAgent.register(\n",
+ " runtime,\n",
" \"langgraph_tool_use_agent\",\n",
" lambda: LangGraphToolUseAgent(\n",
" \"Tool use agent\",\n",
@@ -227,7 +227,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
@@ -243,14 +243,14 @@
},
{
"cell_type": "code",
- "execution_count": 14,
+ "execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "The weather in San Francisco is currently 60 degrees and foggy.\n"
+ "The current weather in San Francisco is 60 degrees and foggy.\n"
]
}
],
@@ -268,7 +268,7 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/llamaindex-agent.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/llamaindex-agent.ipynb
index dccd2820d..1bd489f6f 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/llamaindex-agent.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/llamaindex-agent.ipynb
@@ -37,7 +37,6 @@
"metadata": {},
"outputs": [],
"source": [
- "import asyncio\n",
"import os\n",
"from dataclasses import dataclass\n",
"from typing import List, Optional\n",
@@ -221,7 +220,8 @@
"outputs": [],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
+ "await LlamaIndexAgent.register(\n",
+ " runtime,\n",
" \"chat_agent\",\n",
" lambda: LlamaIndexAgent(\n",
" description=\"Llama Index Agent\",\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/local-llms-ollama-litellm.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/local-llms-ollama-litellm.ipynb
index bc0e24a1b..a90cb440d 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/local-llms-ollama-litellm.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/local-llms-ollama-litellm.ipynb
@@ -38,15 +38,15 @@
"outputs": [],
"source": [
"from dataclasses import dataclass\n",
- "from typing import List\n",
"\n",
- "from autogen_core.base import MessageContext\n",
- "from autogen_core.components import DefaultTopicId, RoutedAgent, message_handler\n",
- "from autogen_core.components.code_executor import CodeExecutor, extract_markdown_code_blocks\n",
+ "from autogen_core.application import SingleThreadedAgentRuntime\n",
+ "from autogen_core.base import AgentId, MessageContext\n",
+ "from autogen_core.components import DefaultTopicId, RoutedAgent, default_subscription, message_handler\n",
+ "from autogen_core.components.model_context import BufferedChatCompletionContext\n",
"from autogen_core.components.models import (\n",
" AssistantMessage,\n",
" ChatCompletionClient,\n",
- " LLMMessage,\n",
+ " OpenAIChatCompletionClient,\n",
" SystemMessage,\n",
" UserMessage,\n",
")"
@@ -65,9 +65,6 @@
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.components.models import OpenAIChatCompletionClient\n",
- "\n",
- "\n",
"def get_model_client() -> OpenAIChatCompletionClient:\n",
" \"Mimic OpenAI API using Local LLM Server.\"\n",
" return OpenAIChatCompletionClient(\n",
@@ -110,9 +107,7 @@
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.components.model_context import BufferedChatCompletionContext\n",
- "\n",
- "\n",
+ "@default_subscription\n",
"class Assistant(RoutedAgent):\n",
" def __init__(self, name: str, model_client: ChatCompletionClient) -> None:\n",
" super().__init__(\"An assistant agent.\")\n",
@@ -155,22 +150,18 @@
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.application import SingleThreadedAgentRuntime\n",
- "from autogen_core.base import AgentId\n",
- "from autogen_core.components import DefaultSubscription\n",
- "\n",
"runtime = SingleThreadedAgentRuntime()\n",
"\n",
- "cathy = await runtime.register(\n",
+ "cathy = await Assistant.register(\n",
+ " runtime,\n",
" \"cathy\",\n",
" lambda: Assistant(name=\"Cathy\", model_client=get_model_client()),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")\n",
"\n",
- "joe = await runtime.register(\n",
+ "joe = await Assistant.register(\n",
+ " runtime,\n",
" \"joe\",\n",
" lambda: Assistant(name=\"Joe\", model_client=get_model_client()),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")"
]
},
@@ -224,13 +215,6 @@
")\n",
"await runtime.stop_when_idle()"
]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": []
}
],
"metadata": {
@@ -249,7 +233,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.14"
+ "version": "3.11.9"
}
},
"nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/openai-assistant-agent.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/openai-assistant-agent.ipynb
index 940d6ebd3..6ba9312c6 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/openai-assistant-agent.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/openai-assistant-agent.ipynb
@@ -390,7 +390,8 @@
"from autogen_core.application import SingleThreadedAgentRuntime\n",
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
+ "await OpenAIAssistantAgent.register(\n",
+ " runtime,\n",
" \"assistant\",\n",
" lambda: OpenAIAssistantAgent(\n",
" description=\"OpenAI Assistant Agent\",\n",
@@ -834,7 +835,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.12.4"
+ "version": "3.11.9"
}
},
"nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/cookbook/termination-with-intervention.ipynb b/python/packages/autogen-core/docs/src/user-guide/cookbook/termination-with-intervention.ipynb
index 51f7f1387..bd37a7545 100644
--- a/python/packages/autogen-core/docs/src/user-guide/cookbook/termination-with-intervention.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/cookbook/termination-with-intervention.ipynb
@@ -15,7 +15,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
@@ -25,22 +25,27 @@
"from autogen_core.application import SingleThreadedAgentRuntime\n",
"from autogen_core.base import AgentId, MessageContext\n",
"from autogen_core.base.intervention import DefaultInterventionHandler\n",
- "from autogen_core.components import DefaultSubscription, DefaultTopicId, RoutedAgent, message_handler"
+ "from autogen_core.components import DefaultTopicId, RoutedAgent, default_subscription, message_handler"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "First, we define a dataclass that will be used to signal termination."
+ "First, we define a dataclass for regular message and message that will be used to signal termination."
]
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
+ "@dataclass\n",
+ "class Message:\n",
+ " content: Any\n",
+ "\n",
+ "\n",
"@dataclass\n",
"class Termination:\n",
" reason: str"
@@ -55,17 +60,18 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
+ "@default_subscription\n",
"class AnAgent(RoutedAgent):\n",
" def __init__(self) -> None:\n",
" super().__init__(\"MyAgent\")\n",
" self.received = 0\n",
"\n",
" @message_handler\n",
- " async def on_new_message(self, message: str, ctx: MessageContext) -> None:\n",
+ " async def on_new_message(self, message: Message, ctx: MessageContext) -> None:\n",
" self.received += 1\n",
" if self.received > 3:\n",
" await self.publish_message(Termination(reason=\"Reached maximum number of messages\"), DefaultTopicId())"
@@ -80,7 +86,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
@@ -111,7 +117,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 10,
"metadata": {},
"outputs": [
{
@@ -126,15 +132,15 @@
"termination_handler = TerminationHandler()\n",
"runtime = SingleThreadedAgentRuntime(intervention_handlers=[termination_handler])\n",
"\n",
- "await runtime.register(\"my_agent\", AnAgent, lambda: [DefaultSubscription()])\n",
+ "await AnAgent.register(runtime, \"my_agent\", AnAgent)\n",
"\n",
"runtime.start()\n",
"\n",
"# Publish more than 3 messages to trigger termination.\n",
- "await runtime.publish_message(\"hello\", DefaultTopicId())\n",
- "await runtime.publish_message(\"hello\", DefaultTopicId())\n",
- "await runtime.publish_message(\"hello\", DefaultTopicId())\n",
- "await runtime.publish_message(\"hello\", DefaultTopicId())\n",
+ "await runtime.publish_message(Message(\"hello\"), DefaultTopicId())\n",
+ "await runtime.publish_message(Message(\"hello\"), DefaultTopicId())\n",
+ "await runtime.publish_message(Message(\"hello\"), DefaultTopicId())\n",
+ "await runtime.publish_message(Message(\"hello\"), DefaultTopicId())\n",
"\n",
"# Wait for termination.\n",
"await runtime.stop_when(lambda: termination_handler.has_terminated)\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/agent-and-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/agent-and-agent-runtime.ipynb
index d2a3b5c0d..6bc53cc30 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/agent-and-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/agent-and-agent-runtime.ipynb
@@ -88,15 +88,29 @@
"## Registering Agent Type\n",
"\n",
"To make agents available to the runtime, developers can use the\n",
- "{py:meth}`~autogen_core.base.AgentRuntime.register` method.\n",
- "The process of registration associates an agent type and a factory function\n",
- "that creates an instance of the agent type.\n",
+ "{py:meth}`~autogen_core.base.BaseAgent.register` class method of the\n",
+ "{py:class}`~autogen_core.base.BaseAgent` class.\n",
+ "The process of registration associates an agent type, which is uniquely identified by a string, \n",
+ "and a factory function\n",
+ "that creates an instance of the agent type of the given class.\n",
"The factory function is used to allow automatic creation of agent instances \n",
"when they are needed.\n",
+ "\n",
+ "Agent type ({py:class}`~autogen_core.base.AgentType`) is not the same as the agent class. In this example,\n",
+ "the agent type is `AgentType(\"my_agent\")` and the agent class is the Python class `MyAgent`.\n",
+ "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",
"\n",
- "For example, to register an agent type with the \n",
+ "```{note}\n",
+ "Different agent types can be registered with factory functions that return \n",
+ "the same agent class. For example, in the factory functions, \n",
+ "variations of the constructor parameters\n",
+ "can be used to create different instances of the same agent class.\n",
+ "```\n",
+ "\n",
+ "To register an agent type with the \n",
"{py:class}`~autogen_core.application.SingleThreadedAgentRuntime`,\n",
"the following code can be used:"
]
@@ -121,7 +135,7 @@
"from autogen_core.application import SingleThreadedAgentRuntime\n",
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\"my_agent\", lambda: MyAgent())"
+ "await MyAgent.register(runtime, \"my_agent\", lambda: MyAgent())"
]
},
{
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/distributed-agent-runtime.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/distributed-agent-runtime.ipynb
index 06c5e69ee..fabacded0 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/distributed-agent-runtime.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/distributed-agent-runtime.ipynb
@@ -4,9 +4,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "# Distributed Agent Runtime (Experimental)\n",
+ "# Distributed Agent Runtime\n",
"\n",
- "```{note}\n",
+ "```{attention}\n",
"The distributed agent runtime is an experimental feature. Expect breaking changes\n",
"to the API.\n",
"```\n",
@@ -21,7 +21,7 @@
"It also advertises the agents which they support to the host service,\n",
"so the host service can deliver messages to the correct worker.\n",
"\n",
- "We can start a host service using {py:class}`autogen_core.application.WorkerAgentRuntimeHost`."
+ "We can start a host service using {py:class}`~autogen_core.application.WorkerAgentRuntimeHost`."
]
},
{
@@ -58,7 +58,7 @@
"from dataclasses import dataclass\n",
"\n",
"from autogen_core.base import MessageContext\n",
- "from autogen_core.components import DefaultTopicId, RoutedAgent, message_handler\n",
+ "from autogen_core.components import DefaultTopicId, RoutedAgent, default_subscription, message_handler\n",
"\n",
"\n",
"@dataclass\n",
@@ -66,6 +66,7 @@
" content: str\n",
"\n",
"\n",
+ "@default_subscription\n",
"class MyAgent(RoutedAgent):\n",
" def __init__(self, name: str) -> None:\n",
" super().__init__(\"My agent\")\n",
@@ -87,7 +88,7 @@
"metadata": {},
"source": [
"Now we can set up the worker agent runtimes.\n",
- "We use {py:class}`autogen_core.application.WorkerAgentRuntime`.\n",
+ "We use {py:class}`~autogen_core.application.WorkerAgentRuntime`.\n",
"We set up two worker runtimes. Each runtime hosts one agent.\n",
"All agents publish and subscribe to the default topic, so they can see all\n",
"messages being published.\n",
@@ -121,18 +122,14 @@
"import asyncio\n",
"\n",
"from autogen_core.application import WorkerAgentRuntime\n",
- "from autogen_core.base import AgentId, try_get_known_serializers_for_type\n",
- "from autogen_core.components import DefaultSubscription\n",
"\n",
"worker1 = WorkerAgentRuntime(host_address=\"localhost:50051\")\n",
- "worker1.add_message_serializer(try_get_known_serializers_for_type(MyMessage))\n",
"worker1.start()\n",
- "await worker1.register(\"worker1\", lambda: MyAgent(\"worker1\"), lambda: [DefaultSubscription()])\n",
+ "await MyAgent.register(worker1, \"worker1\", lambda: MyAgent(\"worker1\"))\n",
"\n",
"worker2 = WorkerAgentRuntime(host_address=\"localhost:50051\")\n",
- "worker2.add_message_serializer(try_get_known_serializers_for_type(MyMessage))\n",
"worker2.start()\n",
- "await worker2.register(\"worker2\", lambda: MyAgent(\"worker2\"), lambda: [DefaultSubscription()])\n",
+ "await MyAgent.register(worker2, \"worker2\", lambda: MyAgent(\"worker2\"))\n",
"\n",
"await worker2.publish_message(MyMessage(content=\"Hello!\"), DefaultTopicId())\n",
"\n",
@@ -146,7 +143,7 @@
"source": [
"We can see each agent published exactly 5 messages.\n",
"\n",
- "To stop the worker runtimes, we can call {py:meth}`autogen_core.application.WorkerAgentRuntime.stop`."
+ "To stop the worker runtimes, we can call {py:meth}`~autogen_core.application.WorkerAgentRuntime.stop`."
]
},
{
@@ -166,7 +163,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can call {py:meth}`autogen_core.application.WorkerAgentRuntimeHost.stop`\n",
+ "We can call {py:meth}`~autogen_core.application.WorkerAgentRuntimeHost.stop`\n",
"to stop the host service."
]
},
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/group-chat.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/group-chat.ipynb
index d2f9d53b3..37d4e03cb 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/group-chat.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/group-chat.ipynb
@@ -43,23 +43,20 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
- "from dataclasses import dataclass\n",
- "\n",
"from autogen_core.components import Image\n",
"from autogen_core.components.models import LLMMessage\n",
+ "from pydantic import BaseModel\n",
"\n",
"\n",
- "@dataclass\n",
- "class GroupChatMessage:\n",
+ "class GroupChatMessage(BaseModel):\n",
" body: LLMMessage\n",
"\n",
"\n",
- "@dataclass\n",
- "class RequestToSpeak:\n",
+ "class RequestToSpeak(BaseModel):\n",
" pass"
]
},
@@ -74,19 +71,34 @@
"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`."
+ "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."
]
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"from typing import List\n",
"\n",
"from autogen_core.base import MessageContext\n",
- "from autogen_core.components import DefaultTopicId, RoutedAgent, message_handler\n",
+ "from autogen_core.components import (\n",
+ " DefaultTopicId,\n",
+ " RoutedAgent,\n",
+ " default_subscription,\n",
+ " message_handler,\n",
+ " type_subscription,\n",
+ ")\n",
"from autogen_core.components.models import (\n",
" AssistantMessage,\n",
" ChatCompletionClient,\n",
@@ -96,6 +108,8 @@
")\n",
"\n",
"\n",
+ "@default_subscription\n",
+ "@type_subscription(\"writer\")\n",
"class WriterAgent(RoutedAgent):\n",
" def __init__(\n",
" self,\n",
@@ -124,6 +138,8 @@
" )\n",
"\n",
"\n",
+ "@default_subscription\n",
+ "@type_subscription(\"editor\")\n",
"class EditorAgent(RoutedAgent):\n",
" def __init__(\n",
" self,\n",
@@ -160,7 +176,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
@@ -170,6 +186,8 @@
"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",
@@ -190,7 +208,8 @@
" if match is None:\n",
" print(\"No description found\")\n",
" await self.publish_message(\n",
- " GroupChatMessage(UserMessage(content=\"No description found\", source=\"Illustrator\")), DefaultTopicId()\n",
+ " GroupChatMessage(body=UserMessage(content=\"No description found\", source=\"Illustrator\")),\n",
+ " DefaultTopicId(),\n",
" )\n",
" return\n",
" description = match.group(1)[:500]\n",
@@ -201,7 +220,7 @@
" image = Image.from_base64(response.data[0].b64_json) # type: ignore\n",
" display(image.image) # type: ignore\n",
" await self.publish_message(\n",
- " GroupChatMessage(UserMessage(content=[image], source=\"Illustrator\")), DefaultTopicId()\n",
+ " GroupChatMessage(body=UserMessage(content=[image], source=\"Illustrator\")), DefaultTopicId()\n",
" )"
]
},
@@ -213,23 +232,27 @@
"and selects the next agent to speak in a round-robin fashion.\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",
- "the draft, the group chat manager stops selecting the next speaker, and the group chat ends."
+ "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."
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.base import AgentId\n",
- "\n",
- "\n",
+ "@default_subscription\n",
"class GroupChatManager(RoutedAgent):\n",
- " def __init__(self, participants: List[AgentId]) -> None:\n",
+ " def __init__(self, participant_topic_types: List[str]) -> None:\n",
" super().__init__(\"Group chat manager\")\n",
" self._num_rounds = 0\n",
- " self._participants = participants\n",
+ " self._participant_topic_types = participant_topic_types\n",
" self._chat_history: List[GroupChatMessage] = []\n",
"\n",
" @message_handler\n",
@@ -238,9 +261,9 @@
" assert isinstance(message.body, UserMessage)\n",
" if message.body.source == \"Editor\" and \"APPROVE\" in message.body.content:\n",
" return\n",
- " speaker = self._participants[self._num_rounds % len(self._participants)]\n",
+ " speaker_topic_type = self._participant_topic_types[self._num_rounds % len(self._participant_topic_types)]\n",
" self._num_rounds += 1\n",
- " await self.send_message(RequestToSpeak(), speaker)"
+ " await self.publish_message(RequestToSpeak(), DefaultTopicId(type=speaker_topic_type))"
]
},
{
@@ -256,7 +279,7 @@
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 30,
"metadata": {},
"outputs": [
{
@@ -266,37 +289,35 @@
"\n",
"--------------------------------------------------------------------------------\n",
"Writer:\n",
- "**ILLUSTRATION:**\n",
- "The illustration vividly captures the majestic essence of a dragon, its scales shimmering like a thousand emeralds under the moonlight. The dragon stands atop a rugged cliff, wings unfurled and casting a shadow over the ancient forest below. Its eyes, glowing with an otherworldly light, exude wisdom and power. Tendrils of smoke curl from its nostrils, blending into the mist that envelops the scene. The night sky is dotted with twinkling stars, and a full moon bathes the landscape in a silvery glow, accentuating the dragon's formidable presence. Below, the forest teems with life, unaware of the guardian watching over them from the heights above.\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",
+ "**Poem:**\n",
"\n",
- "In moonlit night, a dragon soared so high,\n",
- "Emerald scales 'neath a starlit sky.\n",
- "Upon a cliff, where whispers of ancients dwell,\n",
- "Its eyes of wisdom, tales untold, foretell.\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, they whisper through the night,\n",
- "A guardian fierce, of forests bathed in light.\n",
- "Smoke tendrils dance, coiling in the mist,\n",
- "A silent sentinel, in nature's tryst.\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",
- "Stars above in silent hush adorn,\n",
- "The ageless dragon, by time unshorn.\n",
- "With power ancient and heart so deep,\n",
- "In moonlit realms, eternal vigil keep.\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",
- ":**\n",
- "The illustration vividly captures the majestic essence of a dragon, its scales shimmering like a thousand emeralds under the moonlight. The dragon stands atop a rugged cliff, wings unfurled and casting a shadow over the ancient forest below. Its eyes, glowing with an otherworldly light, exude wisdom and power. Tendrils of smoke curl from its nostrils, blending into the mist that envelops the scene. The night sky is dotted with twinkling stars, and a full moon bathes the landscape in a silver\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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",
+ "image/jpeg": "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",
+ "image/png": "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",
"text/plain": [
"<PIL.Image.Image image mode=RGB size=256x256>"
]
@@ -317,13 +338,12 @@
],
"source": [
"from autogen_core.application import SingleThreadedAgentRuntime\n",
- "from autogen_core.base import AgentId\n",
- "from autogen_core.components import DefaultSubscription\n",
"from autogen_core.components.models import OpenAIChatCompletionClient\n",
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
"\n",
- "editor_type = await runtime.register(\n",
+ "await EditorAgent.register(\n",
+ " runtime,\n",
" \"editor\",\n",
" lambda: EditorAgent(\n",
" OpenAIChatCompletionClient(\n",
@@ -331,9 +351,9 @@
" # api_key=\"YOUR_API_KEY\",\n",
" )\n",
" ),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")\n",
- "writer_type = await runtime.register(\n",
+ "await WriterAgent.register(\n",
+ " runtime,\n",
" \"writer\",\n",
" lambda: WriterAgent(\n",
" OpenAIChatCompletionClient(\n",
@@ -341,32 +361,29 @@
" # api_key=\"YOUR_API_KEY\",\n",
" )\n",
" ),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")\n",
- "illustrator_type = await runtime.register(\n",
+ "await IllustratorAgent.register(\n",
+ " runtime,\n",
" \"illustrator\",\n",
" lambda: IllustratorAgent(\n",
- " image_client=openai.AsyncClient(\n",
+ " openai.AsyncClient(\n",
" # api_key=\"YOUR_API_KEY\",\n",
" )\n",
" ),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")\n",
- "await runtime.register(\n",
+ "await GroupChatManager.register(\n",
+ " runtime,\n",
" \"group_chat_manager\",\n",
" lambda: GroupChatManager(\n",
- " participants=[\n",
- " AgentId(writer_type, \"default\"),\n",
- " AgentId(illustrator_type, \"default\"),\n",
- " AgentId(editor_type, \"default\"),\n",
- " ],\n",
+ " participant_topic_types=[\"writer\", \"illustrator\", \"editor\"],\n",
" ),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
")\n",
"\n",
"runtime.start()\n",
"await runtime.publish_message(\n",
- " GroupChatMessage(UserMessage(content=\"Please write a short poem about a dragon with illustration.\", source=\"User\")),\n",
+ " GroupChatMessage(\n",
+ " body=UserMessage(content=\"Please write a short poem about a dragon with illustration.\", source=\"User\")\n",
+ " ),\n",
" DefaultTopicId(),\n",
")\n",
"await runtime.stop_when_idle()"
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/message-and-communication.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/message-and-communication.ipynb
index bdbdafa98..40e89bda4 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/message-and-communication.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/message-and-communication.ipynb
@@ -27,7 +27,7 @@
},
{
"cell_type": "code",
- "execution_count": 1,
+ "execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
@@ -86,7 +86,7 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
@@ -114,7 +114,7 @@
},
{
"cell_type": "code",
- "execution_count": 3,
+ "execution_count": 26,
"metadata": {},
"outputs": [
{
@@ -123,14 +123,14 @@
"AgentType(type='my_agent')"
]
},
- "execution_count": 3,
+ "execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\"my_agent\", lambda: MyAgent(\"My Agent\"))"
+ "await MyAgent.register(runtime, \"my_agent\", lambda: MyAgent(\"My Agent\"))"
]
},
{
@@ -142,7 +142,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 27,
"metadata": {},
"outputs": [
{
@@ -162,6 +162,14 @@
"await runtime.stop_when_idle()"
]
},
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The runtime automatically creates an instance of `MyAgent` with the \n",
+ "agent ID `AgentId(\"my_agent\", \"default\")` when delivering the first message."
+ ]
+ },
{
"cell_type": "markdown",
"metadata": {},
@@ -185,7 +193,7 @@
},
{
"cell_type": "code",
- "execution_count": 5,
+ "execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
@@ -216,7 +224,7 @@
},
{
"cell_type": "code",
- "execution_count": 6,
+ "execution_count": 29,
"metadata": {},
"outputs": [
{
@@ -231,7 +239,7 @@
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\"my_agent\", lambda: RoutedBySenderAgent(\"Routed by sender agent\"))\n",
+ "await RoutedBySenderAgent.register(runtime, \"my_agent\", lambda: RoutedBySenderAgent(\"Routed by sender agent\"))\n",
"runtime.start()\n",
"agent_id = AgentId(\"my_agent\", \"default\")\n",
"await runtime.send_message(TextMessage(content=\"Hello, World!\", source=\"user1-test\"), agent_id)\n",
@@ -285,7 +293,7 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
@@ -332,7 +340,7 @@
},
{
"cell_type": "code",
- "execution_count": 8,
+ "execution_count": 31,
"metadata": {},
"outputs": [
{
@@ -346,11 +354,11 @@
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\"inner_agent\", lambda: InnerAgent(\"InnerAgent\"))\n",
- "await runtime.register(\"outer_agent\", lambda: OuterAgent(\"OuterAgent\", \"inner_agent\"))\n",
+ "await InnerAgent.register(runtime, \"inner_agent\", lambda: InnerAgent(\"InnerAgent\"))\n",
+ "await OuterAgent.register(runtime, \"outer_agent\", lambda: OuterAgent(\"OuterAgent\", \"inner_agent\"))\n",
"runtime.start()\n",
- "outer = AgentId(\"outer_agent\", \"default\")\n",
- "await runtime.send_message(Message(content=\"Hello, World!\"), outer)\n",
+ "outer_agent_id = AgentId(\"outer_agent\", \"default\")\n",
+ "await runtime.send_message(Message(content=\"Hello, World!\"), outer_agent_id)\n",
"await runtime.stop_when_idle()"
]
},
@@ -392,47 +400,68 @@
"receive the message it published. This is to prevent infinite loops.\n",
"```\n",
"\n",
- "### Publishing to Topics\n",
+ "### Subscribe and Publish to Topics\n",
+ "\n",
+ "[Type-based subscription](../core-concepts/topic-and-subscription.md#type-based-subscription)\n",
+ "maps messages published to topics of a given topic type to \n",
+ "agents of a given agent type. \n",
+ "To make an agent that subsclasses {py:class}`~autogen_core.components.RoutedAgent`\n",
+ "subscribe to a topic of a given topic type,\n",
+ "you can use the {py:meth}`~autogen_core.components.type_subscription` class decorator.\n",
+ "\n",
+ "The following example shows a `ReceiverAgent` class that subscribes to topics of `\"default\"` topic type\n",
+ "using the {py:meth}`~autogen_core.components.type_subscription` decorator.\n",
+ "and prints the received messages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from autogen_core.components import RoutedAgent, message_handler, type_subscription\n",
+ "\n",
"\n",
+ "@type_subscription(topic_type=\"default\")\n",
+ "class ReceivingAgent(RoutedAgent):\n",
+ " @message_handler\n",
+ " async def on_my_message(self, message: Message, ctx: MessageContext) -> None:\n",
+ " print(f\"Received a message: {message.content}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"To publish a message from an agent's handler,\n",
- "use the {py:meth}`autogen_core.base.BaseAgent.publish_message` method and specify\n",
- "a {py:class}`autogen_core.base.TopicId`.\n",
+ "use the {py:meth}`~autogen_core.base.BaseAgent.publish_message` method and specify\n",
+ "a {py:class}`~autogen_core.base.TopicId`.\n",
"This call must still be awaited to allow the runtime to schedule delivery of \n",
- "the message to all subscribers,\n",
- "but it will always return `None`.\n",
+ "the message to all subscribers, but it will always return `None`.\n",
"If an agent raises an exception while handling a published message,\n",
"this will be logged but will not be propagated back to the publishing agent.\n",
"\n",
- "The following example shows a `BroadcastingAgent` that publishes a message\n",
- "to a topic upon receiving a message. A `ReceivingAgent` subscribes to the topic\n",
- "and prints the message it receives."
+ "The following example shows a `BroadcastingAgent` that \n",
+ "publishes a message to a topic upon receiving a message. "
]
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 33,
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.application import SingleThreadedAgentRuntime\n",
- "from autogen_core.base import MessageContext, TopicId\n",
- "from autogen_core.components import RoutedAgent, message_handler\n",
+ "from autogen_core.base import TopicId\n",
"\n",
"\n",
"class BroadcastingAgent(RoutedAgent):\n",
" @message_handler\n",
" async def on_my_message(self, message: Message, ctx: MessageContext) -> None:\n",
- " # Publish a message to all agents in the same namespace.\n",
" await self.publish_message(\n",
- " Message(f\"Publishing a message: {message.content}!\"),\n",
+ " Message(\"Publishing a message from broadcasting agent!\"),\n",
" topic_id=TopicId(type=\"default\", source=self.id.key),\n",
- " )\n",
- "\n",
- "\n",
- "class ReceivingAgent(RoutedAgent):\n",
- " @message_handler\n",
- " async def on_my_message(self, message: Message, ctx: MessageContext) -> None:\n",
- " print(f\"Received a message: {message.content}\")"
+ " )"
]
},
{
@@ -440,35 +469,31 @@
"metadata": {},
"source": [
"`BroadcastingAgent` publishes message to a topic with type `\"default\"`\n",
- "and source assigned to the agent instance's agent key.\n",
- "\n",
- "Next, we specify the a subscription for this topic so the receiving agent\n",
- "can get message from the broadcasting agent."
+ "and source assigned to the agent instance's agent key."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Registering Subscriptions\n",
- "\n",
"Subscriptions are registered with the agent runtime, either as part of\n",
"agent type's registeration or through a separate API method.\n",
- "\n",
- "Here is how we can register {py:class}`~autogen_core.components.TypeSubscription`\n",
- "for the broadcasting agent and receiving agent."
+ "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."
]
},
{
"cell_type": "code",
- "execution_count": 10,
+ "execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Received a message: Publishing a message: Hello, World! From the runtime!!\n"
+ "Received a message: Hello, World! From the runtime!\n",
+ "Received a message: Publishing a message from broadcasting agent!\n"
]
}
],
@@ -477,23 +502,19 @@
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
"\n",
- "# Registering subscription as part of the `register` method, by providing\n",
- "# a factory function that produces a list of subscriptions.\n",
- "await runtime.register(\n",
- " \"broadcasting_agent\",\n",
- " lambda: BroadcastingAgent(\"Broadcasting Agent\"),\n",
- " subscriptions=lambda: [TypeSubscription(topic_type=\"default\", agent_type=\"broadcasting_agent\")],\n",
- ")\n",
- "\n",
- "await runtime.register(\"receiving_agent\", lambda: ReceivingAgent(\"Receiving Agent\"))\n",
+ "# Option 1: with type_subscription decorator\n",
+ "# The type_subscription class decorator automatically adds a TypeSubscription to\n",
+ "# the runtime when the agent is registered.\n",
+ "await ReceivingAgent.register(runtime, \"receiving_agent\", lambda: ReceivingAgent(\"Receiving Agent\"))\n",
"\n",
- "# Registering subscription directly with the runtime.\n",
- "await runtime.add_subscription(TypeSubscription(topic_type=\"default\", agent_type=\"receiving_agent\"))\n",
+ "# Option 2: with TypeSubscription\n",
+ "await BroadcastingAgent.register(runtime, \"broadcasting_agent\", lambda: BroadcastingAgent(\"Broadcasting Agent\"))\n",
+ "await runtime.add_subscription(TypeSubscription(topic_type=\"default\", agent_type=\"broadcasting_agent\"))\n",
"\n",
- "# Start the runtime and send a message to a broadcasting agent.\n",
+ "# Start the runtime and publish a message.\n",
"runtime.start()\n",
- "await runtime.send_message(\n",
- " Message(\"Hello, World! From the runtime!\"), recipient=AgentId(\"broadcasting_agent\", \"default\")\n",
+ "await runtime.publish_message(\n",
+ " Message(\"Hello, World! From the runtime!\"), topic_id=TopicId(type=\"default\", source=\"default\")\n",
")\n",
"await runtime.stop_when_idle()"
]
@@ -502,8 +523,12 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "From the output, you can see the broadcasting agent published\n",
- "a message, and the message was received by the receiving agent."
+ "As shown in the above example, you can also publish directly to a topic\n",
+ "through the runtime's {py:meth}`~autogen_core.base.AgentRuntime.publish_message` method\n",
+ "without the need to create an agent instance.\n",
+ "\n",
+ "From the output, you can see two messages were received by the receiving agent:\n",
+ "one was published through the runtime, and the other was published by the broadcasting agent."
]
},
{
@@ -519,30 +544,33 @@
"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:class}`~autogen_core.components.DefaultSubscription` to simply our code.\n",
+ "and {py:meth}`~autogen_core.components.default_subscription` to simply 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",
"and the publishing agent's key as the default value for the topic source.\n",
- "We can simplify `BroadcastingAgent` by using \n",
- "{py:class}`~autogen_core.components.DefaultTopicId`."
+ "{py:meth}`~autogen_core.components.default_subscription` is\n",
+ "for creating a type subscription that subscribes to the default topic.\n",
+ "We can simplify `BroadcastingAgent` by using\n",
+ "{py:class}`~autogen_core.components.DefaultTopicId` and {py:meth}`~autogen_core.components.default_subscription`."
]
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
- "from autogen_core.components import DefaultSubscription, DefaultTopicId\n",
+ "from autogen_core.components import DefaultTopicId, default_subscription\n",
"\n",
"\n",
+ "@default_subscription\n",
"class BroadcastingAgentDefaultTopic(RoutedAgent):\n",
" @message_handler\n",
" async def on_my_message(self, message: Message, ctx: MessageContext) -> None:\n",
" # Publish a message to all agents in the same namespace.\n",
" await self.publish_message(\n",
- " Message(f\"Publishing a message: {message.content}!\"),\n",
+ " Message(\"Publishing a message from broadcasting agent!\"),\n",
" topic_id=DefaultTopicId(),\n",
" )"
]
@@ -551,12 +579,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can also simplify subscription using\n",
- "{py:class}`~autogen_core.components.DefaultSubscription`\n",
- "when registering it as part of agent type registration.\n",
- "\n",
- "When the runtime calls {py:class}`~autogen_core.components.DefaultSubscription` in\n",
- "the context of the factory function, \n",
+ "When the runtime calls {py:meth}`~autogen_core.BaseAgent.register` to register the agent type,\n",
"it creates a {py:class}`~autogen_core.components.TypeSubscription`\n",
"whose topic type uses `\"default\"` as the default value and \n",
"agent type uses the same agent type that is being registered in the same context."
@@ -564,29 +587,26 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "Received a message: Publishing a message: Hello, World! From the runtime!!\n"
+ "Received a message: Hello, World! From the runtime!\n",
+ "Received a message: Publishing a message from broadcasting agent!\n"
]
}
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
- " \"broadcasting_agent\",\n",
- " lambda: BroadcastingAgentDefaultTopic(\"Broadcasting Agent\"),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
+ "await BroadcastingAgentDefaultTopic.register(\n",
+ " runtime, \"broadcasting_agent\", lambda: BroadcastingAgentDefaultTopic(\"Broadcasting Agent\")\n",
")\n",
- "await runtime.register(\"receiving_agent\", lambda: ReceivingAgent(\"Receiving Agent\"), lambda: [DefaultSubscription()])\n",
+ "await ReceivingAgent.register(runtime, \"receiving_agent\", lambda: ReceivingAgent(\"Receiving Agent\"))\n",
"runtime.start()\n",
- "await runtime.send_message(\n",
- " Message(\"Hello, World! From the runtime!\"), recipient=AgentId(\"broadcasting_agent\", \"default\")\n",
- ")\n",
+ "await runtime.publish_message(Message(\"Hello, World! From the runtime!\"), topic_id=DefaultTopicId())\n",
"await runtime.stop_when_idle()"
]
},
@@ -597,8 +617,8 @@
"```{note}\n",
"If your scenario allows all agents to publish and subscribe to\n",
"all broadcasted messages, use {py:class}`~autogen_core.components.DefaultTopicId`\n",
- "and {py:class}`~autogen_core.components.DefaultSubscription` without setting its\n",
- "parameters.\n",
+ "and {py:meth}`~autogen_core.components.default_subscription` to decorate your\n",
+ "agent classes.\n",
"```"
]
}
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/model-clients.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/model-clients.ipynb
index e4ed6c0e6..e3a6e2ecf 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/model-clients.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/model-clients.ipynb
@@ -8,7 +8,7 @@
"\n",
"AGNext provides the {py:mod}`autogen_core.components.models` module with a suite of built-in\n",
"model clients for using ChatCompletion API.\n",
- "All model clients implement the {py:class}`autogen_core.components.models.ChatCompletionClient` protocol class."
+ "All model clients implement the {py:class}`~autogen_core.components.models.ChatCompletionClient` protocol class."
]
},
{
@@ -18,8 +18,8 @@
"## 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_core.components.models.OpenAIChatCompletionClient` and\n",
+ "{py:class}`~autogen_core.components.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",
@@ -325,7 +325,8 @@
"from autogen_core.base import AgentId\n",
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
+ "await SimpleAgent.register(\n",
+ " runtime,\n",
" \"simple_agent\",\n",
" lambda: SimpleAgent(\n",
" OpenAIChatCompletionClient(\n",
@@ -458,7 +459,8 @@
],
"source": [
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
+ "await SimpleAgentWithContext.register(\n",
+ " runtime,\n",
" \"simple_agent_context\",\n",
" lambda: SimpleAgentWithContext(\n",
" OpenAIChatCompletionClient(\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/quickstart.ipynb
index a9d42a76a..bfdb8c7b8 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/quickstart.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/quickstart.ipynb
@@ -31,7 +31,7 @@
"from typing import List\n",
"\n",
"from autogen_core.base import MessageContext\n",
- "from autogen_core.components import DefaultTopicId, RoutedAgent, message_handler\n",
+ "from autogen_core.components import DefaultTopicId, RoutedAgent, default_subscription, message_handler\n",
"from autogen_core.components.code_executor import CodeExecutor, extract_markdown_code_blocks\n",
"from autogen_core.components.models import (\n",
" AssistantMessage,\n",
@@ -47,6 +47,7 @@
" content: str\n",
"\n",
"\n",
+ "@default_subscription\n",
"class Assistant(RoutedAgent):\n",
" def __init__(self, model_client: ChatCompletionClient) -> None:\n",
" super().__init__(\"An assistant agent.\")\n",
@@ -67,6 +68,7 @@
" await self.publish_message(Message(content=result.content), DefaultTopicId()) # type: ignore\n",
"\n",
"\n",
+ "@default_subscription\n",
"class Executor(RoutedAgent):\n",
" def __init__(self, code_executor: CodeExecutor) -> None:\n",
" super().__init__(\"An executor agent.\")\n",
@@ -306,7 +308,6 @@
"import tempfile\n",
"\n",
"from autogen_core.application import SingleThreadedAgentRuntime\n",
- "from autogen_core.components import DefaultSubscription\n",
"from autogen_core.components.code_executor import DockerCommandLineCodeExecutor\n",
"from autogen_core.components.models import OpenAIChatCompletionClient\n",
"\n",
@@ -318,7 +319,8 @@
"async with DockerCommandLineCodeExecutor(work_dir=work_dir) as executor: # type: ignore[syntax]\n",
" # Register the assistant and executor agents by providing\n",
" # their agent types, the factory functions for creating instance and subscriptions.\n",
- " await runtime.register(\n",
+ " await Assistant.register(\n",
+ " runtime,\n",
" \"assistant\",\n",
" lambda: Assistant(\n",
" OpenAIChatCompletionClient(\n",
@@ -326,13 +328,8 @@
" # api_key=\"YOUR_API_KEY\"\n",
" )\n",
" ),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
- " )\n",
- " await runtime.register(\n",
- " \"executor\",\n",
- " lambda: Executor(executor),\n",
- " subscriptions=lambda: [DefaultSubscription()],\n",
" )\n",
+ " await Executor.register(runtime, \"executor\", lambda: Executor(executor))\n",
"\n",
" # Start the runtime and publish a message to the assistant.\n",
" runtime.start()\n",
@@ -408,7 +405,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.12.5"
+ "version": "3.11.9"
}
},
"nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/reflection.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/reflection.ipynb
index fdd0b0ea0..6630f30f3 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/reflection.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/reflection.ipynb
@@ -91,7 +91,7 @@
},
{
"cell_type": "code",
- "execution_count": 9,
+ "execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
@@ -101,7 +101,7 @@
"from typing import Dict, List, Union\n",
"\n",
"from autogen_core.base import MessageContext, TopicId\n",
- "from autogen_core.components import RoutedAgent, message_handler\n",
+ "from autogen_core.components import RoutedAgent, default_subscription, message_handler\n",
"from autogen_core.components.models import (\n",
" AssistantMessage,\n",
" ChatCompletionClient,\n",
@@ -123,10 +123,11 @@
},
{
"cell_type": "code",
- "execution_count": 7,
+ "execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
+ "@default_subscription\n",
"class CoderAgent(RoutedAgent):\n",
" \"\"\"An agent that performs code writing tasks.\"\"\"\n",
"\n",
@@ -266,10 +267,11 @@
},
{
"cell_type": "code",
- "execution_count": 19,
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
+ "@default_subscription\n",
"class ReviewerAgent(RoutedAgent):\n",
" \"\"\"An agent that performs code review tasks.\"\"\"\n",
"\n",
@@ -360,7 +362,7 @@
},
{
"cell_type": "code",
- "execution_count": 11,
+ "execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
@@ -376,69 +378,40 @@
"source": [
"## Running the Design Pattern\n",
"\n",
- "Let's test the design pattern with a coding task."
+ "Let's test the design pattern with a coding task.\n",
+ "Since all the agents are decorated with the {py:meth}`~autogen_core.components.default_subscription` class decorator,\n",
+ "the agents when created will automatically subscribe to the default topic.\n",
+ "We publish a `CodeWritingTask` message to the default topic to start the reflection process."
]
},
{
"cell_type": "code",
- "execution_count": 21,
+ "execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
- "INFO:agnext:Publishing message of type CodeWritingTask to all subscribers: {'task': 'Write a function to find the sum of all even numbers in a list.'}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeWritingTask published by Unknown\n",
- "INFO:agnext.events:{\"prompt_tokens\": 101, \"completion_tokens\": 101, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: To find the sum of all even numbers in a list, I will iterate through the list and check if each number is even. If it is, I will add it to a cumulative sum. Finally, I will return this sum. This approach is straightforward and efficient.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n total = 0\\n for number in numbers:\\n if number % 2 == 0:\\n total += number\\n return total\\n```', 'code': 'def sum_of_evens(numbers):\\n total = 0\\n for number in numbers:\\n if number % 2 == 0:\\n total += number\\n return total'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 176, \"completion_tokens\": 191, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly sums all even numbers in the list as intended. There are no logical errors in the implementation.\\nefficiency: The implementation has a time complexity of O(n), where n is the number of elements in the list. This is optimal for this problem since each element has to be examined. However, using a generator expression with the sum function could potentially improve readability.\\nsafety: The function currently does not handle cases where the input 'numbers' is None or not a list. Adding input validation could enhance the safety of the function to prevent runtime errors.\\napproval: REVISE\\nsuggested_changes: Consider adding input validation to check if 'numbers' is a list. Also, you could improve readability and potentially performance by using a generator expression like 'return sum(number for number in numbers if number % 2 == 0)'.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 389, \"completion_tokens\": 97, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: I appreciate the reviewer\\'s feedback on improving the function\\'s safety and readability. I will incorporate input validation to ensure the input is a list, and I will use a generator expression to simplify the summation of even numbers. \\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n return sum(number for number in numbers if number % 2 == 0)\\n```', 'code': 'def sum_of_evens(numbers):\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n return sum(number for number in numbers if number % 2 == 0)'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 357, \"completion_tokens\": 211, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly calculates the sum of all even numbers from the provided list. The logic appears sound and there are no errors in the implementation.\\nefficiency: The time complexity remains O(n), which is optimal for the task at hand since all numbers must be examined to determine if they are even. While using a generator expression improves readability, it does not enhance performance significantly over a list comprehension for this particular case.\\nsafety: The function still raises a ValueError if the input is not a list, which is good. However, it would be beneficial to explicitly handle cases where 'numbers' is None to prevent potential runtime errors. An additional check would enhance its robustness.\\napproval: REVISE\\nsuggested_changes: Consider adding a check at the beginning of the function to handle cases where 'numbers' is None and return a meaningful error or handle it gracefully. An example could be to raise a TypeError or to explicitly check for None before continuing.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 695, \"completion_tokens\": 123, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: I appreciate the continued feedback for enhancing the robustness of the function. I will add an explicit check for `None` at the beginning of the function to raise a `TypeError` if the input is `None`. This will ensure the function is more resilient against unexpected input.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n return sum(number for number in numbers if number % 2 == 0)\\n```', 'code': 'def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n return sum(number for number in numbers if number % 2 == 0)'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 394, \"completion_tokens\": 218, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly computes the sum of all even numbers from the provided list. It raises appropriate errors for incorrect input types, which is a good practice.\\nefficiency: The time complexity of O(n) is optimal for this problem since all elements must be checked to determine if they are even. The use of a generator expression is efficient in terms of memory usage.\\nsafety: The function includes checks for None and enforces input types, which is commendable. However, you should note that if an element within the list is not an integer, it might cause a runtime error when performing the modulus operation. A check to ensure all elements are integers (or can be handled appropriately) would improve safety.\\napproval: REVISE\\nsuggested_changes: Consider adding a check to ensure all elements within the 'numbers' list are integers. If any element is not an integer, raise a ValueError with a suitable message. This will prevent potential runtime errors due to invalid operations on unsupported types.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 1034, \"completion_tokens\": 160, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: Thank you for the constructive feedback. I will add a check to ensure that all elements in the list are integers before attempting to perform the modulus operation. If any element is not an integer, I will raise a `ValueError` with an appropriate message. This will make the function more robust and prevent runtime errors.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n if not all(isinstance(number, int) for number in numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n return sum(number for number in numbers if number % 2 == 0)\\n```', 'code': 'def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n if not all(isinstance(number, int) for number in numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n return sum(number for number in numbers if number % 2 == 0)'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 430, \"completion_tokens\": 249, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly computes the sum of all even numbers from the provided list and raises appropriate errors for incorrect input types, which is a good practice. The checks for None, list type, and integer types are implemented effectively.\\nefficiency: The time complexity of O(n) is optimal, since checking every number in the list is necessary, and the use of a generator expression for summing is both efficient in terms of time and memory.\\nsafety: The function includes checks for None and enforces input types. However, while it checks if all elements are integers, it presumes that this check is sufficient to avoid runtime errors. If the list were to contain non-integer types that can be tested against 'number % 2', the modulus operation could still lead to runtime errors.\\napproval: REVISE\\nsuggested_changes: Consider implementing a specific check to ensure all elements are integers prior to performing the summation, which could raise a ValueError. This could prevent runtime errors if non-integer types somehow bypass the initial check. You could enhance safety by using a try-except block to catch any unexpected types during the modulus operation.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 1441, \"completion_tokens\": 198, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: Thank you for the thorough code review and highlighting the potential issues. I will enhance safety by implementing a try-except block around the modulus operation to catch any errors related to non-integer types during the sum computation. This will ensure that the function handles unexpected types gracefully and avoids runtime errors.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n if not all(isinstance(number, int) for number in numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n \\n total = 0\\n for number in numbers:\\n try:\\n if number % 2 == 0:\\n total += number\\n except TypeError:\\n raise ValueError(f\"Invalid element found: {number}. All elements must be integers.\")\\n \\n return total\\n```', 'code': 'def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n if not all(isinstance(number, int) for number in numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n \\n total = 0\\n for number in numbers:\\n try:\\n if number % 2 == 0:\\n total += number\\n except TypeError:\\n raise ValueError(f\"Invalid element found: {number}. All elements must be integers.\")\\n \\n return total'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 504, \"completion_tokens\": 181, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function still correctly computes the sum of all even numbers and raises appropriate errors for incorrect input types, which maintains a good level of correctness.\\nefficiency: The efficiency remains satisfactory with a time complexity of O(n). The use of a for loop is appropriate for iterating through the list.\\nsafety: While the previous feedback regarding safety was noted, the function doesn't fully mitigate potential runtime errors during the modulus operation. It's still possible for non-integer types to cause issues, which should be handled more effectively.\\napproval: REVISE\\nsuggested_changes: Consider using a try-except block that encapsulates the entire loop or implement an additional step where you filter or validate the elements before processing to ensure that only integers are considered. This will help avoid unexpected runtime errors while performing operations on list elements.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 1818, \"completion_tokens\": 186, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: Thank you for your patience and for highlighting the remaining safety concern. To address the issue of non-integer types causing potential runtime errors, I will refactor the code to filter the input list before attempting any operations. This way, we can ensure that only integers are processed, thus reducing the risk of unexpected errors.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n \\n # Filter the list to ensure only integers are processed.\\n integers = [number for number in numbers if isinstance(number, int)]\\n \\n if len(integers) != len(numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n \\n return sum(number for number in integers if number % 2 == 0)\\n```', 'code': 'def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n \\n # Filter the list to ensure only integers are processed.\\n integers = [number for number in numbers if isinstance(number, int)]\\n \\n if len(integers) != len(numbers):\\n raise ValueError(\"All elements in the list must be integers.\")\\n \\n return sum(number for number in integers if number % 2 == 0)'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 419, \"completion_tokens\": 198, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function still correctly computes the sum of all even numbers and raises appropriate errors for incorrect input types, which maintains a good level of correctness.\\nefficiency: The efficiency remains satisfactory with a time complexity of O(n). The use of list comprehensions for filtering is both clear and efficient for this type of operation.\\nsafety: The function raises errors appropriately for None and non-list inputs, but it doesn't handle scenarios where non-integer types may still exist in the list before the summation. There's still a risk of runtime errors during the modulus operation if non-integers are present.\\napproval: REVISE\\nsuggested_changes: To improve safety, consider filtering the list more robustly by checking types before performing operations. You could also implement a try-except block around the summation operation to catch potential runtime errors, although filtering out non-integers beforehand is a better solution.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 2200, \"completion_tokens\": 187, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: Thank you for your insightful feedback. To make the function more robust against non-integer types, I will use a filtering process to ensure that only integers are included in the summation. Additionally, I will provide a clear error message if non-integer types slip through. This should eliminate runtime errors related to the modulus operation.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n\\n # Filtering to ensure only integers are included\\n integers = []\\n for number in numbers:\\n if isinstance(number, int):\\n integers.append(number)\\n else:\\n raise ValueError(f\"Invalid element found: {number}. All elements must be integers.\")\\n\\n return sum(number for number in integers if number % 2 == 0)\\n```', 'code': 'def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError(\"Input cannot be None.\")\\n if not isinstance(numbers, list):\\n raise ValueError(\"Input must be a list.\")\\n\\n # Filtering to ensure only integers are included\\n integers = []\\n for number in numbers:\\n if isinstance(number, int):\\n integers.append(number)\\n else:\\n raise ValueError(f\"Invalid element found: {number}. All elements must be integers.\")\\n\\n return sum(number for number in integers if number % 2 == 0)'}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 435, \"completion_tokens\": 319, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly handles None and non-list inputs by raising appropriate exceptions. It also accurately computes the sum of even integers in the list, which maintains correctness.\\nefficiency: The time complexity remains O(n) due to the single pass needed to filter integers and another pass for summation. However, it can be slightly optimized by combining both filtering and summation in a single comprehension, which reduces the overall pass through the list.\\nsafety: The function raises errors for invalid input types, but it does not account for cases where non-integer types might appear in the list prior to the sum calculation. This could lead to runtime errors if non-integers are inadvertently included. The error handling can be improved by ensuring that all elements are integers before performing the modulus operation.\\napproval: REVISE\\nsuggested_changes: Consider using a single loop with a generator expression to both filter and sum the even integers in one pass. This would enhance both efficiency and safety by eliminating the risk of runtime errors when performing operations on non-integer values. You can adjust the code as follows:\\n\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError('Input cannot be None.')\\n if not isinstance(numbers, list):\\n raise ValueError('Input must be a list.')\\n\\n return sum(number for number in numbers if isinstance(number, int) and number % 2 == 0)\\n```\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': False}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 2690, \"completion_tokens\": 130, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': \"Thoughts: I appreciate the thorough review and suggestions. By combining filtering and summation into a single iteration using a generator expression, we can enhance both efficiency and safety. This ensures that only integers are considered for summation, which minimizes the risk of runtime errors. I will implement this change.\\n\\nCode:\\n```python\\ndef sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError('Input cannot be None.')\\n if not isinstance(numbers, list):\\n raise ValueError('Input must be a list.')\\n\\n return sum(number for number in numbers if isinstance(number, int) and number % 2 == 0)\\n```\", 'code': \"def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError('Input cannot be None.')\\n if not isinstance(numbers, list):\\n raise ValueError('Input must be a list.')\\n\\n return sum(number for number in numbers if isinstance(number, int) and number % 2 == 0)\"}\n",
- "INFO:agnext:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent\n",
- "INFO:agnext.events:{\"prompt_tokens\": 495, \"completion_tokens\": 253, \"type\": \"LLMCall\"}\n",
- "INFO:agnext:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly implements the requirement of finding the sum of even numbers and raises appropriate exceptions for invalid input. It maintains accuracy in terms of results as it only sums integers that are even.\\nefficiency: While the implementation uses a generator expression to sum even integers efficiently, the previous feedback suggested combining filtering and summation into a single pass. The current approach still iterates through the list only once due to the nature of the generator expression, so it is efficient in its current form, but the suggestion for optimization is valid.\\nsafety: The function checks for None and ensures the input is a list, which increases safety. However, the filter in the generator ensures that only integers are considered for the modulus operation, preventing runtime errors from non-integer types. This aspect has been addressed adequately since the generator will exclude non-integer values.\\napproval: APPROVE\\nsuggested_changes: No further changes are necessary, but a small improvement could be adding a check to handle the situation where the list may contain only non-integers, returning 0 in such cases. Additionally, consider enhancing the documentation with a brief description of the function's behavior on edge cases.\", 'session_id': '633c4a66-2f94-472f-b4a2-09f77c164c17', 'approved': True}\n",
- "INFO:agnext:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent\n",
- "INFO:agnext:Publishing message of type CodeWritingResult to all subscribers: {'task': 'Write a function to find the sum of all even numbers in a list.', 'code': \"def sum_of_evens(numbers):\\n if numbers is None:\\n raise TypeError('Input cannot be None.')\\n if not isinstance(numbers, list):\\n raise ValueError('Input must be a list.')\\n\\n return sum(number for number in numbers if isinstance(number, int) and number % 2 == 0)\", 'review': \"Code review:\\ncorrectness: The function correctly implements the requirement of finding the sum of even numbers and raises appropriate exceptions for invalid input. It maintains accuracy in terms of results as it only sums integers that are even.\\nefficiency: While the implementation uses a generator expression to sum even integers efficiently, the previous feedback suggested combining filtering and summation into a single pass. The current approach still iterates through the list only once due to the nature of the generator expression, so it is efficient in its current form, but the suggestion for optimization is valid.\\nsafety: The function checks for None and ensures the input is a list, which increases safety. However, the filter in the generator ensures that only integers are considered for the modulus operation, preventing runtime errors from non-integer types. This aspect has been addressed adequately since the generator will exclude non-integer values.\\napproval: APPROVE\\nsuggested_changes: No further changes are necessary, but a small improvement could be adding a check to handle the situation where the list may contain only non-integers, returning 0 in such cases. Additionally, consider enhancing the documentation with a brief description of the function's behavior on edge cases.\"}\n"
+ "INFO:autogen_core:Publishing message of type CodeWritingTask to all subscribers: {'task': 'Write a function to find the sum of all even numbers in a list.'}\n",
+ "INFO:autogen_core:Calling message handler for ReviewerAgent with message type CodeWritingTask published by Unknown\n",
+ "INFO:autogen_core:Calling message handler for CoderAgent with message type CodeWritingTask published by Unknown\n",
+ "INFO:autogen_core:Unhandled message: CodeWritingTask(task='Write a function to find the sum of all even numbers in a list.')\n",
+ "INFO:autogen_core.events:{\"prompt_tokens\": 101, \"completion_tokens\": 88, \"type\": \"LLMCall\"}\n",
+ "INFO:autogen_core:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '51db93d5-3e29-4b7f-9f96-77be7bb02a5e', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': 'Thoughts: To find the sum of all even numbers in a list, we can use a list comprehension to filter out the even numbers and then use the `sum()` function to calculate their total. The implementation should handle edge cases like an empty list or a list with no even numbers.\\n\\nCode:\\n```python\\ndef sum_of_even_numbers(numbers):\\n return sum(num for num in numbers if num % 2 == 0)\\n```', 'code': 'def sum_of_even_numbers(numbers):\\n return sum(num for num in numbers if num % 2 == 0)'}\n",
+ "INFO:autogen_core:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent:default\n",
+ "INFO:autogen_core.events:{\"prompt_tokens\": 163, \"completion_tokens\": 235, \"type\": \"LLMCall\"}\n",
+ "INFO:autogen_core:Publishing message of type CodeReviewResult to all subscribers: {'review': \"Code review:\\ncorrectness: The function correctly identifies and sums all even numbers in the provided list. The use of a generator expression ensures that only even numbers are processed, which is correct.\\nefficiency: The function is efficient as it utilizes a generator expression that avoids creating an intermediate list, therefore using less memory. The time complexity is O(n) where n is the number of elements in the input list, which is optimal for this task.\\nsafety: The function does not include checks for input types. If a non-iterable or a list containing non-integer types is passed, it could lead to unexpected behavior or errors. It’s advisable to handle such cases.\\napproval: REVISE\\nsuggested_changes: Consider adding input validation to ensure that 'numbers' is a list and contains only integers. You could raise a ValueError if the input is invalid. Example: 'if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers): raise ValueError('Input must be a list of integers')'. This will make the function more robust.\", 'session_id': '51db93d5-3e29-4b7f-9f96-77be7bb02a5e', 'approved': False}\n",
+ "INFO:autogen_core:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent:default\n",
+ "INFO:autogen_core.events:{\"prompt_tokens\": 421, \"completion_tokens\": 119, \"type\": \"LLMCall\"}\n",
+ "INFO:autogen_core:Publishing message of type CodeReviewTask to all subscribers: {'session_id': '51db93d5-3e29-4b7f-9f96-77be7bb02a5e', 'code_writing_task': 'Write a function to find the sum of all even numbers in a list.', 'code_writing_scratchpad': \"Thoughts: I appreciate the reviewer's feedback on input validation. Adding type checks ensures that the function can handle unexpected inputs gracefully. I will implement the suggested changes and include checks for both the input type and the elements within the list to confirm that they are integers.\\n\\nCode:\\n```python\\ndef sum_of_even_numbers(numbers):\\n if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers):\\n raise ValueError('Input must be a list of integers')\\n \\n return sum(num for num in numbers if num % 2 == 0)\\n```\", 'code': \"def sum_of_even_numbers(numbers):\\n if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers):\\n raise ValueError('Input must be a list of integers')\\n \\n return sum(num for num in numbers if num % 2 == 0)\"}\n",
+ "INFO:autogen_core:Calling message handler for ReviewerAgent with message type CodeReviewTask published by CoderAgent:default\n",
+ "INFO:autogen_core.events:{\"prompt_tokens\": 420, \"completion_tokens\": 153, \"type\": \"LLMCall\"}\n",
+ "INFO:autogen_core:Publishing message of type CodeReviewResult to all subscribers: {'review': 'Code review:\\ncorrectness: The function correctly sums all even numbers in the provided list. It raises a ValueError if the input is not a list of integers, which is a necessary check for correctness.\\nefficiency: The function remains efficient with a time complexity of O(n) due to the use of a generator expression. There are no unnecessary intermediate lists created, so memory usage is optimal.\\nsafety: The function includes input validation, which enhances safety by preventing incorrect input types. It raises a ValueError for invalid inputs, making the function more robust against unexpected data.\\napproval: APPROVE\\nsuggested_changes: No further changes are necessary as the previous feedback has been adequately addressed.', 'session_id': '51db93d5-3e29-4b7f-9f96-77be7bb02a5e', 'approved': True}\n",
+ "INFO:autogen_core:Calling message handler for CoderAgent with message type CodeReviewResult published by ReviewerAgent:default\n",
+ "INFO:autogen_core:Publishing message of type CodeWritingResult to all subscribers: {'task': 'Write a function to find the sum of all even numbers in a list.', 'code': \"def sum_of_even_numbers(numbers):\\n if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers):\\n raise ValueError('Input must be a list of integers')\\n \\n return sum(num for num in numbers if num % 2 == 0)\", 'review': 'Code review:\\ncorrectness: The function correctly sums all even numbers in the provided list. It raises a ValueError if the input is not a list of integers, which is a necessary check for correctness.\\nefficiency: The function remains efficient with a time complexity of O(n) due to the use of a generator expression. There are no unnecessary intermediate lists created, so memory usage is optimal.\\nsafety: The function includes input validation, which enhances safety by preventing incorrect input types. It raises a ValueError for invalid inputs, making the function more robust against unexpected data.\\napproval: APPROVE\\nsuggested_changes: No further changes are necessary as the previous feedback has been adequately addressed.'}\n",
+ "INFO:autogen_core:Calling message handler for ReviewerAgent with message type CodeWritingResult published by CoderAgent:default\n",
+ "INFO:autogen_core:Unhandled message: CodeWritingResult(task='Write a function to find the sum of all even numbers in a list.', code=\"def sum_of_even_numbers(numbers):\\n if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers):\\n raise ValueError('Input must be a list of integers')\\n \\n return sum(num for num in numbers if num % 2 == 0)\", review='Code review:\\ncorrectness: The function correctly sums all even numbers in the provided list. It raises a ValueError if the input is not a list of integers, which is a necessary check for correctness.\\nefficiency: The function remains efficient with a time complexity of O(n) due to the use of a generator expression. There are no unnecessary intermediate lists created, so memory usage is optimal.\\nsafety: The function includes input validation, which enhances safety by preventing incorrect input types. It raises a ValueError for invalid inputs, making the function more robust against unexpected data.\\napproval: APPROVE\\nsuggested_changes: No further changes are necessary as the previous feedback has been adequately addressed.')\n"
]
},
{
@@ -451,45 +424,39 @@
"Write a function to find the sum of all even numbers in a list.\n",
"--------------------------------------------------------------------------------\n",
"Code:\n",
- "def sum_of_evens(numbers):\n",
- " if numbers is None:\n",
- " raise TypeError('Input cannot be None.')\n",
- " if not isinstance(numbers, list):\n",
- " raise ValueError('Input must be a list.')\n",
- "\n",
- " return sum(number for number in numbers if isinstance(number, int) and number % 2 == 0)\n",
+ "def sum_of_even_numbers(numbers):\n",
+ " if not isinstance(numbers, list) or not all(isinstance(num, int) for num in numbers):\n",
+ " raise ValueError('Input must be a list of integers')\n",
+ " \n",
+ " return sum(num for num in numbers if num % 2 == 0)\n",
"--------------------------------------------------------------------------------\n",
"Review:\n",
"Code review:\n",
- "correctness: The function correctly implements the requirement of finding the sum of even numbers and raises appropriate exceptions for invalid input. It maintains accuracy in terms of results as it only sums integers that are even.\n",
- "efficiency: While the implementation uses a generator expression to sum even integers efficiently, the previous feedback suggested combining filtering and summation into a single pass. The current approach still iterates through the list only once due to the nature of the generator expression, so it is efficient in its current form, but the suggestion for optimization is valid.\n",
- "safety: The function checks for None and ensures the input is a list, which increases safety. However, the filter in the generator ensures that only integers are considered for the modulus operation, preventing runtime errors from non-integer types. This aspect has been addressed adequately since the generator will exclude non-integer values.\n",
+ "correctness: The function correctly sums all even numbers in the provided list. It raises a ValueError if the input is not a list of integers, which is a necessary check for correctness.\n",
+ "efficiency: The function remains efficient with a time complexity of O(n) due to the use of a generator expression. There are no unnecessary intermediate lists created, so memory usage is optimal.\n",
+ "safety: The function includes input validation, which enhances safety by preventing incorrect input types. It raises a ValueError for invalid inputs, making the function more robust against unexpected data.\n",
"approval: APPROVE\n",
- "suggested_changes: No further changes are necessary, but a small improvement could be adding a check to handle the situation where the list may contain only non-integers, returning 0 in such cases. Additionally, consider enhancing the documentation with a brief description of the function's behavior on edge cases.\n",
+ "suggested_changes: No further changes are necessary as the previous feedback has been adequately addressed.\n",
"--------------------------------------------------------------------------------\n"
]
}
],
"source": [
"from autogen_core.application import SingleThreadedAgentRuntime\n",
- "from autogen_core.components._type_subscription import TypeSubscription\n",
+ "from autogen_core.components import DefaultTopicId\n",
"from autogen_core.components.models import OpenAIChatCompletionClient\n",
"\n",
"runtime = SingleThreadedAgentRuntime()\n",
- "await runtime.register(\n",
- " \"ReviewerAgent\",\n",
- " lambda: ReviewerAgent(model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\")),\n",
+ "await ReviewerAgent.register(\n",
+ " runtime, \"ReviewerAgent\", lambda: ReviewerAgent(model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"))\n",
")\n",
- "await runtime.add_subscription(TypeSubscription(\"default\", \"CoderAgent\"))\n",
- "await runtime.register(\n",
- " \"CoderAgent\",\n",
- " lambda: CoderAgent(model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\")),\n",
+ "await CoderAgent.register(\n",
+ " runtime, \"CoderAgent\", lambda: CoderAgent(model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"))\n",
")\n",
- "await runtime.add_subscription(TypeSubscription(\"default\", \"ReviewerAgent\"))\n",
"runtime.start()\n",
"await runtime.publish_message(\n",
" message=CodeWritingTask(task=\"Write a function to find the sum of all even numbers in a list.\"),\n",
- " topic_id=TopicId(\"default\", \"default\"),\n",
+ " topic_id=DefaultTopicId(),\n",
")\n",
"\n",
"# Keep processing messages until idle.\n",
diff --git a/python/packages/autogen-core/docs/src/user-guide/guides/tools.ipynb b/python/packages/autogen-core/docs/src/user-guide/guides/tools.ipynb
index 75de39e89..4ac085028 100644
--- a/python/packages/autogen-core/docs/src/user-guide/guides/tools.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/guides/tools.ipynb
@@ -22,7 +22,7 @@
"source": [
"## Built-in Tools\n",
"\n",
- "One of the built-in tools is the {py:class}`autogen_core.components.tools.PythonCodeExecutionTool`,\n",
+ "One of the built-in tools is the {py:class}`~autogen_core.components.tools.PythonCodeExecutionTool`,\n",
"which allows agents to execute Python code snippets.\n",
"\n",
"Here is how you create the tool and use it."
@@ -80,7 +80,7 @@
"\n",
"A tool can also be a simple Python function that performs a specific action.\n",
"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",
+ "and use the {py:class}`~autogen_core.components.tools.FunctionTool` class to wrap it.\n",
"\n",
"For example, a simple tool to obtain the stock price of a company might look like this:"
]
@@ -94,7 +94,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "194.71306528148511\n"
+ "80.44429939059668\n"
]
}
],
@@ -128,7 +128,7 @@
"source": [
"## Tool-Equipped Agent\n",
"\n",
- "To use tools with an agent, you can use {py:class}`autogen_core.components.tool_agent.ToolAgent`,\n",
+ "To use tools with an agent, you can use {py:class}`~autogen_core.components.tool_agent.ToolAgent`,\n",
"by using it in a composition pattern.\n",
"Here is an example tool-use agent that uses {py:class}`~autogen_core.components.tool_agent.ToolAgent`\n",
"as an inner agent for executing tools."
@@ -163,12 +163,12 @@
"\n",
"\n",
"class ToolUseAgent(RoutedAgent):\n",
- " def __init__(self, model_client: ChatCompletionClient, tool_schema: List[ToolSchema], tool_agent: AgentId) -> None:\n",
+ " def __init__(self, model_client: ChatCompletionClient, tool_schema: List[ToolSchema], tool_agent_type: str) -> None:\n",
" super().__init__(\"An agent with tools\")\n",
" self._system_messages: List[LLMMessage] = [SystemMessage(\"You are a helpful AI assistant.\")]\n",
" self._model_client = model_client\n",
" self._tool_schema = tool_schema\n",
- " self._tool_agent = tool_agent\n",
+ " self._tool_agent_id = AgentId(tool_agent_type, self.id.key)\n",
"\n",
" @message_handler\n",
" async def handle_user_message(self, message: Message, ctx: MessageContext) -> Message:\n",
@@ -177,7 +177,7 @@
" # Run the caller loop to handle tool calls.\n",
" messages = await tool_agent_caller_loop(\n",
" self,\n",
- " tool_agent_id=self._tool_agent,\n",
+ " tool_agent_id=self._tool_agent_id,\n",
" model_client=self._model_client,\n",
" input_messages=session,\n",
" tool_schema=self._tool_schema,\n",
@@ -192,7 +192,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "The `ToolUseAgent` class uses a convenience function {py:meth}`autogen_core.components.tool_agent.tool_agent_caller_loop`, \n",
+ "The `ToolUseAgent` class uses a convenience function {py:meth}`~autogen_core.components.tool_agent.tool_agent_caller_loop`, \n",
"to handle the interaction between the model and the tool agent.\n",
"The core idea can be described using a simple control flow graph:\n",
"\n",
@@ -236,19 +236,12 @@
"# Create the tools.\n",
"tools: List[Tool] = [FunctionTool(get_stock_price, description=\"Get the stock price.\")]\n",
"# Register the agents.\n",
- "await runtime.register(\n",
- " \"tool_executor_agent\",\n",
- " lambda: ToolAgent(\n",
- " description=\"Tool Executor Agent\",\n",
- " tools=tools,\n",
- " ),\n",
- ")\n",
- "await runtime.register(\n",
+ "await ToolAgent.register(runtime, \"tool_executor_agent\", lambda: ToolAgent(\"tool executor agent\", tools))\n",
+ "await ToolUseAgent.register(\n",
+ " runtime,\n",
" \"tool_use_agent\",\n",
" lambda: ToolUseAgent(\n",
- " OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n",
- " tool_schema=[tool.schema for tool in tools],\n",
- " tool_agent=AgentId(\"tool_executor_agent\", AgentInstantiationContext.current_agent_id().key),\n",
+ " OpenAIChatCompletionClient(model=\"gpt-4o-mini\"), [tool.schema for tool in tools], \"tool_executor_agent\"\n",
" ),\n",
")"
]
@@ -271,7 +264,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "The stock price of NVIDIA (NVDA) on June 1, 2024, was approximately $148.86.\n"
+ "The stock price of NVDA (NVIDIA Corporation) on June 1, 2024, was approximately $179.46.\n"
]
}
],
@@ -285,16 +278,6 @@
"# Stop processing messages.\n",
"await runtime.stop()"
]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "See [samples](https://github.com/microsoft/autogen_core/tree/main/python/samples#tool-use-examples)\n",
- "for more examples of using tools with agents, including how to use\n",
- "broadcast communication model for tool execution, and how to intercept tool\n",
- "execution for human-in-the-loop approval."
- ]
}
],
"metadata": {