A programming framework for agentic AI
Add examples to showcase patterns (#55)
Eric Zhub4ade8b735bc
diff --git a/examples/chess_game.py b/examples/chess_game.pynew file mode 100644index 000000000..119c1abb0--- /dev/null+++ b/examples/chess_game.py@@ -0,0 +1,119 @@+"""This is an example of simulating a chess game with two agents+that play against each other, using tools to reason about the game state+and make moves."""++import argparse+import asyncio+import logging+from typing import Annotated++from agnext.application import SingleThreadedAgentRuntime+from agnext.chat.agents.chat_completion_agent import ChatCompletionAgent+from agnext.chat.patterns.group_chat import GroupChat, GroupChatOutput+from agnext.chat.types import TextMessage+from agnext.components.models import OpenAI, SystemMessage+from agnext.components.tools import FunctionTool+from agnext.core import AgentRuntime+from chess import SQUARE_NAMES, Board, Move+from chess import piece_name as get_piece_name++logging.basicConfig(level=logging.WARNING)+logging.getLogger("agnext").setLevel(logging.DEBUG)+++class ChessGameOutput(GroupChatOutput): # type: ignore+ def on_message_received(self, message: TextMessage) -> None: # type: ignore+ pass++ def get_output(self) -> None:+ pass++ def reset(self) -> None:+ pass+++def chess_game(runtime: AgentRuntime) -> GroupChat: # type: ignore+ """Create agents for a chess game and return the group chat."""++ # Create the board.+ board = Board()++ # Create shared tools.+ def get_legal_moves() -> Annotated[str, "A list of legal moves in UCI format."]:+ return "Possible moves are: " + ", ".join([str(move) for move in board.legal_moves])++ get_legal_moves_tool = FunctionTool(get_legal_moves, description="Get legal moves.")++ def make_move(input: Annotated[str, "A move in UCI format."]) -> Annotated[str, "Result of the move."]:+ move = Move.from_uci(input)+ board.push(move)+ print(board.unicode(borders=True))+ # Get the piece name.+ piece = board.piece_at(move.to_square)+ assert piece is not None+ piece_symbol = piece.unicode_symbol()+ piece_name = get_piece_name(piece.piece_type)+ if piece_symbol.isupper():+ piece_name = piece_name.capitalize()+ return f"Moved {piece_name} ({piece_symbol}) from {SQUARE_NAMES[move.from_square]} to {SQUARE_NAMES[move.to_square]}."++ make_move_tool = FunctionTool(make_move, description="Call this tool to make a move.")++ tools = [get_legal_moves_tool, make_move_tool]++ black = ChatCompletionAgent(+ name="PlayerBlack",+ description="Player playing black.",+ runtime=runtime,+ system_messages=[+ SystemMessage(+ content="You are a chess player and you play as black. "+ "First call get_legal_moves() first, to get list of legal moves. "+ "Then call make_move(move) to make a move."+ ),+ ],+ model_client=OpenAI(model="gpt-4-turbo"),+ tools=tools,+ )+ white = ChatCompletionAgent(+ name="PlayerWhite",+ description="Player playing white.",+ runtime=runtime,+ system_messages=[+ SystemMessage(+ content="You are a chess player and you play as white. "+ "First call get_legal_moves() first, to get list of legal moves. "+ "Then call make_move(move) to make a move."+ ),+ ],+ model_client=OpenAI(model="gpt-4-turbo"),+ tools=tools,+ )+ game_chat = GroupChat(+ name="ChessGame",+ description="A chess game between two agents.",+ runtime=runtime,+ agents=[white, black],+ num_rounds=10,+ output=ChessGameOutput(),+ )+ return game_chat+++async def main(message: str) -> None:+ runtime = SingleThreadedAgentRuntime()+ game_chat = chess_game(runtime)+ future = runtime.send_message(TextMessage(content=message, source="Human"), game_chat)+ while not future.done():+ await runtime.process_next()+++if __name__ == "__main__":+ parser = argparse.ArgumentParser(description="Run a chess game between two agents.")+ parser.add_argument(+ "--initial-message",+ default="Please make a move.",+ help="The initial message to send to the agent playing white.",+ )+ args = parser.parse_args()+ asyncio.run(main(args.initial_message))diff --git a/pyproject.toml b/pyproject.tomlindex 0a6dc535a..e046e6dda 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -31,6 +31,9 @@ dev = ["pytest-xdist","types-Pillow","polars",+ # Dependencies for the examples.+ "chess",+ "tavily-python",]docs = ["sphinx", "furo", "sphinxcontrib-apidoc", "myst-parser"]diff --git a/src/agnext/application/_single_threaded_agent_runtime.py b/src/agnext/application/_single_threaded_agent_runtime.pyindex 4f4260905..2ce46df2e 100644--- a/src/agnext/application/_single_threaded_agent_runtime.py+++ b/src/agnext/application/_single_threaded_agent_runtime.py@@ -10,6 +10,7 @@ from ..core.exceptions import MessageDroppedExceptionfrom ..core.intervention import DropMessage, InterventionHandlerlogger = logging.getLogger("agnext")+event_logger = logging.getLogger("agnext.events")@dataclass(kw_only=True)@@ -67,7 +68,9 @@ class SingleThreadedAgentRuntime(AgentRuntime):return list(self._agents)@property- def unprocessed_messages(self) -> Sequence[PublishMessageEnvelope | SendMessageEnvelope | ResponseMessageEnvelope]:+ def unprocessed_messages(+ self,+ ) -> Sequence[PublishMessageEnvelope | SendMessageEnvelope | ResponseMessageEnvelope]:return self._message_queue# Returns the response of the message@@ -82,6 +85,18 @@ class SingleThreadedAgentRuntime(AgentRuntime):if cancellation_token is None:cancellation_token = CancellationToken()+ logger.info(f"Sending message of type {type(message).__name__} to {recipient.name}: {message.__dict__}")++ # event_logger.info(+ # MessageEvent(+ # payload=message,+ # sender=sender,+ # receiver=recipient,+ # kind=MessageKind.DIRECT,+ # delivery_stage=DeliveryStage.SEND,+ # )+ # )+future = asyncio.get_event_loop().create_future()if recipient not in self._agents:future.set_exception(Exception("Recipient not found"))@@ -108,6 +123,18 @@ class SingleThreadedAgentRuntime(AgentRuntime):if cancellation_token is None:cancellation_token = CancellationToken()+ logger.info(f"Publishing message of type {type(message).__name__} to all subscribers: {message.__dict__}")++ # event_logger.info(+ # MessageEvent(+ # payload=message,+ # sender=sender,+ # receiver=None,+ # kind=MessageKind.PUBLISH,+ # delivery_stage=DeliveryStage.SEND,+ # )+ # )+self._message_queue.append(PublishMessageEnvelope(message=message,@@ -137,8 +164,17 @@ class SingleThreadedAgentRuntime(AgentRuntime):try:sender_name = message_envelope.sender.name if message_envelope.sender is not None else "Unknown"logger.info(- f"Calling message handler for {recipient.name} with message type {type(message_envelope.message).__name__} from {sender_name}"+ f"Calling message handler for {recipient.name} with message type {type(message_envelope.message).__name__} sent by {sender_name}")+ # event_logger.info(+ # MessageEvent(+ # payload=message_envelope.message,+ # sender=message_envelope.sender,+ # receiver=recipient,+ # kind=MessageKind.DIRECT,+ # delivery_stage=DeliveryStage.DELIVER,+ # )+ # )response = await recipient.on_message(message_envelope.message,cancellation_token=message_envelope.cancellation_token,@@ -162,9 +198,19 @@ class SingleThreadedAgentRuntime(AgentRuntime):if message_envelope.sender is not None and agent.name == message_envelope.sender.name:continue+ sender_name = message_envelope.sender.name if message_envelope.sender is not None else "Unknown"logger.info(- f"Calling message handler for {agent.name} with message type {type(message_envelope.message).__name__} published by {message_envelope.sender.name if message_envelope.sender is not None else 'Unknown'}"+ f"Calling message handler for {agent.name} with message type {type(message_envelope.message).__name__} published by {sender_name}")+ # event_logger.info(+ # MessageEvent(+ # payload=message_envelope.message,+ # sender=message_envelope.sender,+ # receiver=agent,+ # kind=MessageKind.PUBLISH,+ # delivery_stage=DeliveryStage.DELIVER,+ # )+ # )future = agent.on_message(message_envelope.message,@@ -182,9 +228,23 @@ class SingleThreadedAgentRuntime(AgentRuntime):async def _process_response(self, message_envelope: ResponseMessageEnvelope) -> None:recipient_name = message_envelope.recipient.name if message_envelope.recipient is not None else "Unknown"+ content = (+ message_envelope.message.__dict__+ if hasattr(message_envelope.message, "__dict__")+ else message_envelope.message+ )logger.info(- f"Resolving response for recipient {recipient_name} from {message_envelope.sender.name} with message type {type(message_envelope.message).__name__}"+ f"Resolving response with message type {type(message_envelope.message).__name__} for recipient {recipient_name} from {message_envelope.sender.name}: {content}")+ # event_logger.info(+ # MessageEvent(+ # payload=message_envelope.message,+ # sender=message_envelope.sender,+ # receiver=message_envelope.recipient,+ # kind=MessageKind.RESPOND,+ # delivery_stage=DeliveryStage.DELIVER,+ # )+ # )message_envelope.future.set_result(message_envelope.message)async def process_next(self) -> None:diff --git a/src/agnext/application/logging/__init__.py b/src/agnext/application/logging/__init__.pyindex e9940925e..1696599c5 100644--- a/src/agnext/application/logging/__init__.py+++ b/src/agnext/application/logging/__init__.py@@ -1,6 +1,13 @@-from ._events import LLMCallEvent+from ._events import DeliveryStage, LLMCallEvent, MessageEvent, MessageKindfrom ._llm_usage import LLMUsageTrackerEVENT_LOGGER_NAME = "agnext.events"-__all__ = ["LLMCallEvent", "EVENT_LOGGER_NAME", "LLMUsageTracker"]+__all__ = [+ "LLMCallEvent",+ "EVENT_LOGGER_NAME",+ "LLMUsageTracker",+ "MessageEvent",+ "MessageKind",+ "DeliveryStage",+]diff --git a/src/agnext/application/logging/_events.py b/src/agnext/application/logging/_events.pyindex ae473b1f2..cec85b43a 100644--- a/src/agnext/application/logging/_events.py+++ b/src/agnext/application/logging/_events.py@@ -1,6 +1,9 @@import json+from enum import Enumfrom typing import Any, cast+from ...core import Agent+class LLMCallEvent:def __init__(self, *, prompt_tokens: int, completion_tokens: int, **kwargs: Any) -> None:@@ -23,6 +26,50 @@ class LLMCallEvent:self.kwargs = kwargsself.kwargs["prompt_tokens"] = prompt_tokensself.kwargs["completion_tokens"] = completion_tokens+ self.kwargs["type"] = "LLMCall"++ @property+ def prompt_tokens(self) -> int:+ return cast(int, self.kwargs["prompt_tokens"])++ @property+ def completion_tokens(self) -> int:+ return cast(int, self.kwargs["completion_tokens"])++ # This must output the event in a json serializable format+ def __str__(self) -> str:+ return json.dumps(self.kwargs)+++class MessageKind(Enum):+ DIRECT = 1+ PUBLISH = 2+ RESPOND = 3+++class DeliveryStage(Enum):+ SEND = 1+ DELIVER = 2+++class MessageEvent:+ def __init__(+ self,+ *,+ payload: Any,+ sender: Agent | None,+ receiver: Agent | None,+ kind: MessageKind,+ delivery_stage: DeliveryStage,+ **kwargs: Any,+ ) -> None:+ self.kwargs = kwargs+ self.kwargs["payload"] = payload+ self.kwargs["sender"] = None if sender is None else sender.name+ self.kwargs["receiver"] = None if receiver is None else receiver.name+ self.kwargs["kind"] = kind+ self.kwargs["delivery_stage"] = delivery_stage+ self.kwargs["type"] = "Message"@propertydef prompt_tokens(self) -> int:diff --git a/src/agnext/chat/agents/chat_completion_agent.py b/src/agnext/chat/agents/chat_completion_agent.pyindex 22ae7c754..c6a1fcda3 100644--- a/src/agnext/chat/agents/chat_completion_agent.py+++ b/src/agnext/chat/agents/chat_completion_agent.py@@ -128,7 +128,10 @@ class ChatCompletionAgent(BaseChatAgent, TypeRoutedAgent):continue# Execute the function.future = self.execute_function(- function_call.name, arguments, function_call.id, cancellation_token=cancellation_token+ function_call.name,+ arguments,+ function_call.id,+ cancellation_token=cancellation_token,)# Append the async result.execution_futures.append(future)@@ -149,24 +152,22 @@ class ChatCompletionAgent(BaseChatAgent, TypeRoutedAgent):return tool_call_result_msgasync def execute_function(- self, name: str, args: Dict[str, Any], call_id: str, cancellation_token: CancellationToken+ self,+ name: str,+ args: Dict[str, Any],+ call_id: str,+ cancellation_token: CancellationToken,) -> Tuple[str, str]:# Find tooltool = next((t for t in self._tools if t.name == name), None)if tool is None:- raise ValueError(f"Tool {name} not found.")+ return (f"Error: tool {name} not found.", call_id)try:result = await tool.run_json(args, cancellation_token)- result_json_or_str = result.model_dump()- if isinstance(result, dict):- result_str = json.dumps(result_json_or_str)- elif isinstance(result_json_or_str, str):- result_str = result_json_or_str- else:- raise ValueError(f"Unexpected result type: {type(result)}")+ result_as_str = tool.return_value_as_string(result)except Exception as e:- result_str = f"Error: {str(e)}"- return (result_str, call_id)+ result_as_str = f"Error: {str(e)}"+ return (result_as_str, call_id)def save_state(self) -> Mapping[str, Any]:return {diff --git a/src/agnext/chat/utils.py b/src/agnext/chat/utils.pyindex 19cba873b..cfee683a7 100644--- a/src/agnext/chat/utils.py+++ b/src/agnext/chat/utils.py@@ -73,17 +73,17 @@ def convert_messages_to_llm_messages(for message in messages:match message:case (- TextMessage(_, source=source)- | MultiModalMessage(_, source=source)- | FunctionCallMessage(_, source=source)+ TextMessage(content=_, source=source)+ | MultiModalMessage(content=_, source=source)+ | FunctionCallMessage(content=_, source=source)) if source == self_name:converted_message_1 = convert_content_message_to_assistant_message(message, handle_unrepresentable)if converted_message_1 is not None:result.append(converted_message_1)case (- TextMessage(_, source=source)- | MultiModalMessage(_, source=source)- | FunctionCallMessage(_, source=source)+ TextMessage(content=_, source=source)+ | MultiModalMessage(content=_, source=source)+ | FunctionCallMessage(content=_, source=source)) if source != self_name:converted_message_2 = convert_content_message_to_user_message(message, handle_unrepresentable)if converted_message_2 is not None:diff --git a/src/agnext/components/_type_routed_agent.py b/src/agnext/components/_type_routed_agent.pyindex 74fc0360c..88bbdb35f 100644--- a/src/agnext/components/_type_routed_agent.py+++ b/src/agnext/components/_type_routed_agent.py@@ -105,18 +105,18 @@ def message_handler(@wraps(func)async def wrapper(self: Any, message: ReceivesT, cancellation_token: CancellationToken) -> ProducesT:- if strict:- if type(message) not in target_types:+ if type(message) not in target_types:+ if strict:raise CantHandleException(f"Message type {type(message)} not in target types {target_types}")else:logger.warning(f"Message type {type(message)} not in target types {target_types}")return_value = await func(self, message, cancellation_token)- if strict:- if return_value is not AnyType and type(return_value) not in return_types:+ if AnyType not in return_types and type(return_value) not in return_types:+ if strict:raise ValueError(f"Return type {type(return_value)} not in return types {return_types}")- elif return_value is not AnyType:+ else:logger.warning(f"Return type {type(return_value)} not in return types {return_types}")return return_value@@ -134,7 +134,10 @@ def message_handler(class TypeRoutedAgent(BaseAgent):def __init__(self, name: str, router: AgentRuntime) -> None:# Self is already bound to the handlers- self._handlers: Dict[Type[Any], Callable[[Any, CancellationToken], Coroutine[Any, Any, Any | None]]] = {}+ self._handlers: Dict[+ Type[Any],+ Callable[[Any, CancellationToken], Coroutine[Any, Any, Any | None]],+ ] = {}for attr in dir(self):if callable(getattr(self, attr, None)):diff --git a/src/agnext/components/models/_openai_client.py b/src/agnext/components/models/_openai_client.pyindex 101aa8bdf..34cd5e933 100644--- a/src/agnext/components/models/_openai_client.py+++ b/src/agnext/components/models/_openai_client.py@@ -1,5 +1,6 @@import inspectimport logging+import reimport warningsfrom typing import (Any,@@ -11,6 +12,7 @@ from typing import (Sequence,Set,Union,+ cast,)from openai import AsyncAzureOpenAI, AsyncOpenAI@@ -27,6 +29,7 @@ from openai.types.chat import (ChatCompletionUserMessageParam,completion_create_params,)+from openai.types.shared_params import FunctionDefinition, FunctionParametersfrom typing_extensions import Unpackfrom ...application.logging import EVENT_LOGGER_NAME, LLMCallEvent@@ -205,15 +208,47 @@ def convert_tools() -> List[ChatCompletionToolParam]:result: List[ChatCompletionToolParam] = []for tool in tools:+ tool_schema = tool.schemaresult.append(- {- "type": "function",- "function": tool.schema, # type: ignore- }+ ChatCompletionToolParam(+ type="function",+ function=FunctionDefinition(+ name=tool_schema["name"],+ description=tool_schema["description"] if "description" in tool_schema else "",+ parameters=cast(FunctionParameters, tool_schema["parameters"])+ if "parameters" in tool_schema+ else {},+ ),+ ))+ # Check if all tools have valid names.+ for tool_param in result:+ assert_valid_name(tool_param["function"]["name"])return result+def normalize_name(name: str) -> str:+ """+ LLMs sometimes ask functions while ignoring their own format requirements, this function should be used to replace invalid characters with "_".++ Prefer _assert_valid_name for validating user configuration or input+ """+ return re.sub(r"[^a-zA-Z0-9_-]", "_", name)[:64]+++def assert_valid_name(name: str) -> str:+ """+ Ensure that configured names are valid, raises ValueError if not.++ For munging LLM responses use _normalize_name to ensure LLM specified names don't break the API.+ """+ if not re.match(r"^[a-zA-Z0-9_-]+$", name):+ raise ValueError(f"Invalid name: {name}. Only letters, numbers, '_' and '-' are allowed.")+ if len(name) > 64:+ raise ValueError(f"Invalid name: {name}. Name must be less than 64 characters.")+ return name++class BaseOpenAI(ChatCompletionClient):def __init__(self,@@ -293,7 +328,10 @@ class BaseOpenAI(ChatCompletionClient):if len(tools) > 0:converted_tools = convert_tools(tools)result = await self._client.chat.completions.create(- messages=oai_messages, stream=False, tools=converted_tools, **create_args+ messages=oai_messages,+ stream=False,+ tools=converted_tools,+ **create_args,)else:result = await self._client.chat.completions.create(messages=oai_messages, stream=False, **create_args)@@ -331,7 +369,11 @@ class BaseOpenAI(ChatCompletionClient):# NOTE: If OAI response type changes, this will need to be updatedcontent = [- FunctionCall(id=x.id, arguments=x.function.arguments, name=x.function.name)+ FunctionCall(+ id=x.id,+ arguments=x.function.arguments,+ name=normalize_name(x.function.name),+ )for x in choice.message.tool_calls]finish_reason = "function_calls"diff --git a/src/agnext/components/tools/_base.py b/src/agnext/components/tools/_base.pyindex ff922c51b..36d7c83c4 100644--- a/src/agnext/components/tools/_base.py+++ b/src/agnext/components/tools/_base.py@@ -1,14 +1,29 @@import jsonfrom abc import ABC, abstractmethod-from typing import Any, Dict, Generic, Mapping, Protocol, Type, TypeVar+from collections.abc import Sequence+from typing import Any, Dict, Generic, Mapping, Protocol, Type, TypedDict, TypeVarfrom pydantic import BaseModel+from typing_extensions import NotRequiredfrom ...core import CancellationToken+from .._function_utils import normalize_annotated_typeT = TypeVar("T", bound=BaseModel, contravariant=True)+class ParametersSchema(TypedDict):+ type: str+ properties: Dict[str, Any]+ required: NotRequired[Sequence[str]]+++class ToolSchema(TypedDict):+ parameters: NotRequired[ParametersSchema]+ name: str+ description: NotRequired[str]++class Tool(Protocol):@propertydef name(self) -> str: ...@@ -17,7 +32,7 @@ class Tool(Protocol):def description(self) -> str: ...@property- def schema(self) -> Mapping[str, Any]: ...+ def schema(self) -> ToolSchema: ...def args_type(self) -> Type[BaseModel]: ...@@ -40,20 +55,36 @@ StateT = TypeVar("StateT", bound=BaseModel)class BaseTool(ABC, Tool, Generic[ArgsT, ReturnT]):- def __init__(self, args_type: Type[ArgsT], return_type: Type[ReturnT], name: str, description: str) -> None:+ def __init__(+ self,+ args_type: Type[ArgsT],+ return_type: Type[ReturnT],+ name: str,+ description: str,+ ) -> None:self._args_type = args_type- self._return_type = return_type+ # Normalize Annotated to the base type.+ self._return_type = normalize_annotated_type(return_type)self._name = nameself._description = description@property- def schema(self) -> Mapping[str, Any]:+ def schema(self) -> ToolSchema:model_schema = self._args_type.model_json_schema()- parameter_schema: Dict[str, Any] = dict()- parameter_schema["parameters"] = model_schema["properties"]- parameter_schema["name"] = self._name- parameter_schema["description"] = self._description- return parameter_schema++ tool_schema = ToolSchema(+ name=self._name,+ description=self._description,+ parameters=ParametersSchema(+ type="object",+ properties=model_schema["properties"],+ ),+ )+ if "required" in model_schema:+ assert "parameters" in tool_schema+ tool_schema["parameters"]["required"] = model_schema["required"]++ return tool_schema@propertydef name(self) -> str:@@ -97,7 +128,12 @@ class BaseTool(ABC, Tool, Generic[ArgsT, ReturnT]):class BaseToolWithState(BaseTool[ArgsT, ReturnT], ABC, Generic[ArgsT, ReturnT, StateT]):def __init__(- self, args_type: Type[ArgsT], return_type: Type[ReturnT], state_type: Type[StateT], name: str, description: str+ self,+ args_type: Type[ArgsT],+ return_type: Type[ReturnT],+ state_type: Type[StateT],+ name: str,+ description: str,) -> None:super().__init__(args_type, return_type, name, description)self._state_type = state_typediff --git a/src/agnext/components/tools/_function_tool.py b/src/agnext/components/tools/_function_tool.pyindex caf4575de..f0536b9bb 100644--- a/src/agnext/components/tools/_function_tool.py+++ b/src/agnext/components/tools/_function_tool.py@@ -32,7 +32,12 @@ class FunctionTool(BaseTool[BaseModel, BaseModel]):else:if self._has_cancellation_support:result = await asyncio.get_event_loop().run_in_executor(- None, functools.partial(self._func, **args.model_dump(), cancellation_token=cancellation_token)+ None,+ functools.partial(+ self._func,+ **args.model_dump(),+ cancellation_token=cancellation_token,+ ),)else:future = asyncio.get_event_loop().run_in_executor(diff --git a/tests/test_tools.py b/tests/test_tools.pyindex 6f7c76309..c5e52f19a 100644--- a/tests/test_tools.py+++ b/tests/test_tools.py@@ -36,9 +36,54 @@ def test_tool_schema_generation() -> None:schema = MyTool().schemaassert schema["name"] == "TestTool"+ assert "description" in schemaassert schema["description"] == "Description of test tool."- assert schema["parameters"]["query"]["description"] == "The description."- assert len(schema["parameters"]) == 1+ assert "parameters" in schema+ assert schema["parameters"]["type"] == "object"+ assert "properties" in schema["parameters"]+ assert schema["parameters"]["properties"]["query"]["description"] == "The description."+ assert schema["parameters"]["properties"]["query"]["type"] == "string"+ assert "required" in schema["parameters"]+ assert schema["parameters"]["required"] == ["query"]+ assert len(schema["parameters"]["properties"]) == 1++def test_func_tool_schema_generation() -> None:+ def my_function(arg: str, other: Annotated[int, "int arg"], nonrequired: int = 5) -> MyResult:+ return MyResult(result="test")+ tool = FunctionTool(my_function, description="Function tool.")+ schema = tool.schema++ assert schema["name"] == "my_function"+ assert "description" in schema+ assert schema["description"] == "Function tool."+ assert "parameters" in schema+ assert schema["parameters"]["type"] == "object"+ assert schema["parameters"]["properties"].keys() == {"arg", "other", "nonrequired"}+ assert schema["parameters"]["properties"]["arg"]["type"] == "string"+ assert schema["parameters"]["properties"]["arg"]["description"] == "arg"+ assert schema["parameters"]["properties"]["other"]["type"] == "integer"+ assert schema["parameters"]["properties"]["other"]["description"] == "int arg"+ assert schema["parameters"]["properties"]["nonrequired"]["type"] == "integer"+ assert schema["parameters"]["properties"]["nonrequired"]["description"] == "nonrequired"+ assert "required" in schema["parameters"]+ assert schema["parameters"]["required"] == ["arg", "other"]+ assert len(schema["parameters"]["properties"]) == 3++def test_func_tool_schema_generation_only_default_arg() -> None:+ def my_function(arg: str = "default") -> MyResult:+ return MyResult(result="test")+ tool = FunctionTool(my_function, description="Function tool.")+ schema = tool.schema++ assert schema["name"] == "my_function"+ assert "description" in schema+ assert schema["description"] == "Function tool."+ assert "parameters" in schema+ assert len(schema["parameters"]["properties"]) == 1+ assert schema["parameters"]["properties"]["arg"]["type"] == "string"+ assert schema["parameters"]["properties"]["arg"]["description"] == "arg"+ assert "required" not in schema["parameters"]+@pytest.mark.asyncioasync def test_tool_run()-> None:@@ -128,7 +173,7 @@ def test_func_tool_return_annotated()-> None:assert tool.name == "my_function"assert tool.description == "Function tool."assert issubclass(tool.args_type(), BaseModel)- assert tool.return_type() == Annotated[str, "test description"]+ assert tool.return_type() == strassert tool.state_type() is Nonedef test_func_tool_no_args()-> None: