Remove assistant related methods from OpenAIAgent (microsoft#6866)

Author: ekzhu

python/packages/autogen-ext/src/autogen_ext/agents/openai/_openai_agent.py

@@ -746,221 +746,6 @@ def _convert_message_to_dict(self, message: OpenAIMessage) -> Dict[str, Any]:
         """Convert an OpenAIMessage to a Dict[str, Any]."""
         return dict(message)
 
-    async def list_assistants(
-        self: "OpenAIAgent",
-        after: Optional[str] = None,
-        before: Optional[str] = None,
-        limit: Optional[int] = 20,
-        order: Optional[str] = "desc",
-    ) -> Dict[str, Any]:  # noqa: D102
-        """
-        List all assistants using the OpenAI API.
-
-        Args:
-            after (Optional[str]): Cursor for pagination (fetch after this assistant ID).
-            before (Optional[str]): Cursor for pagination (fetch before this assistant ID).
-            limit (Optional[int]): Number of assistants to return (1-100, default 20).
-            order (Optional[str]): 'asc' or 'desc' by created_at (default 'desc').
-
-        Returns:
-            Dict[str, Any]: The OpenAI API response containing:
-                    - object: 'list'
-                    - data: List of assistant objects
-                    - first_id: str
-                    - last_id: str
-                    - has_more: bool
-
-        Example:
-            .. code-block:: python
-
-                import asyncio
-                from typing import Dict, Any
-                from autogen_ext.agents.openai import OpenAIAgent
-                from openai import AsyncOpenAI
-                import logging
-
-
-                async def example() -> None:
-                    client = AsyncOpenAI()
-                    agent = OpenAIAgent(
-                        name="test_agent",
-                        description="Test agent",
-                        client=client,
-                        model="gpt-4",
-                        instructions="You are a helpful assistant.",
-                    )
-                    assistants: Dict[str, Any] = await agent.list_assistants(limit=5)
-                    logging.info(assistants)
-
-
-                asyncio.run(example())
-
-        """
-        params = {"limit": limit, "order": order}
-        if after:
-            params["after"] = after
-        if before:
-            params["before"] = before
-        if hasattr(self._client, "assistants"):
-            client_any = cast(Any, self._client)
-            response = await client_any.assistants.list(**params)
-            if hasattr(response, "model_dump"):
-                return cast(Dict[str, Any], response.model_dump())
-            return cast(Dict[str, Any], dict(response))
-        else:
-            raise NotImplementedError("The OpenAI client does not support listing assistants.")
-
-    async def retrieve_assistant(self: "OpenAIAgent", assistant_id: str) -> Dict[str, Any]:  # noqa: D102
-        """
-        Retrieve a single assistant by its ID using the OpenAI API.
-
-        Args:
-            assistant_id (str): The ID of the assistant to retrieve.
-
-        Returns:
-            Dict[str, Any]: The assistant object.
-
-        Example:
-            .. code-block:: python
-
-                import asyncio
-                from typing import Dict, Any
-                from autogen_ext.agents.openai import OpenAIAgent
-                from openai import AsyncOpenAI
-                import logging
-
-
-                async def example() -> None:
-                    client = AsyncOpenAI()
-                    agent = OpenAIAgent(
-                        name="test_agent",
-                        description="Test agent",
-                        client=client,
-                        model="gpt-4",
-                        instructions="You are a helpful assistant.",
-                    )
-                    assistant: Dict[str, Any] = await agent.retrieve_assistant("asst_abc123")
-                    logging.info(assistant)
-
-
-                asyncio.run(example())
-
-        """
-        if hasattr(self._client, "assistants"):
-            client_any = cast(Any, self._client)
-            response = await client_any.assistants.retrieve(assistant_id=assistant_id)
-            if hasattr(response, "model_dump"):
-                return cast(Dict[str, Any], response.model_dump())
-            return cast(Dict[str, Any], dict(response))
-        else:
-            raise NotImplementedError("The OpenAI client does not support retrieving assistants.")
-
-    async def modify_assistant(
-        self: "OpenAIAgent",
-        assistant_id: str,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        instructions: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        model: Optional[str] = None,
-        reasoning_effort: Optional[str] = None,
-        response_format: Optional[str] = None,
-        temperature: Optional[float] = None,
-        tool_resources: Optional[Dict[str, Any]] = None,
-        tools: Optional[List[Any]] = None,
-        top_p: Optional[float] = None,
-        **kwargs: Any,
-    ) -> Dict[str, Any]:  # noqa: D102
-        """
-        Modify (update) an assistant by its ID using the OpenAI API.
-
-        Args:
-            assistant_id (str): The ID of the assistant to update.
-            name (Optional[str]): New name for the assistant.
-            description (Optional[str]): New description.
-            instructions (Optional[str]): New instructions.
-            metadata (Optional[dict]): New metadata.
-            model (Optional[str]): New model.
-            reasoning_effort (Optional[str]): New reasoning effort.
-            response_format (Optional[str]): New response format.
-            temperature (Optional[float]): New temperature.
-            tool_resources (Optional[dict]): New tool resources.
-            tools (Optional[list]): New tools.
-            top_p (Optional[float]): New top_p value.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Dict[str, Any]: The updated assistant object.
-
-        Example:
-            .. code-block:: python
-
-                import asyncio
-                from typing import Dict, Any
-                from autogen_ext.agents.openai import OpenAIAgent
-                from openai import AsyncOpenAI
-                import logging
-
-
-                async def example() -> None:
-                    client = AsyncOpenAI()
-                    agent = OpenAIAgent(
-                        name="test_agent",
-                        description="Test agent",
-                        client=client,
-                        model="gpt-4",
-                        instructions="You are a helpful assistant.",
-                    )
-                    updated: Dict[str, Any] = await agent.modify_assistant(
-                        assistant_id="asst_123",
-                        instructions=(
-                            "You are an HR bot, and you have access to files to answer employee "
-                            "questions about company policies. Always response with info from either "
-                            "of the files."
-                        ),
-                        tools=[{"type": "file_search"}],
-                        tool_resources={"file_search": {"vector_store_ids": []}},
-                    )
-                    logging.info(updated)
-
-
-                asyncio.run(example())
-
-        """
-        params = {k: v for k, v in locals().items() if k not in {"self", "assistant_id", "kwargs"} and v is not None}
-        params.update(kwargs)
-        if hasattr(self._client, "assistants"):
-            client_any = cast(Any, self._client)
-            response = await client_any.assistants.update(assistant_id=assistant_id, **params)
-            if hasattr(response, "model_dump"):
-                return cast(Dict[str, Any], response.model_dump())
-            return cast(Dict[str, Any], dict(response))
-        else:
-            raise NotImplementedError("The OpenAI client does not support modifying assistants.")
-
-    async def delete_assistant(self: "OpenAIAgent", assistant_id: str) -> Dict[str, Any]:  # noqa: D102
-        """
-        Delete an assistant by its ID using the OpenAI API.
-
-        Args:
-            assistant_id (str): The ID of the assistant to delete.
-
-        Returns:
-            Dict[str, Any]: The deletion status object.
-
-        Example:
-
-            {"id": "...", "object": "assistant.deleted", "deleted": true}
-        """
-        if hasattr(self._client, "assistants"):
-            client_any = cast(Any, self._client)
-            response = await client_any.assistants.delete(assistant_id=assistant_id)
-            if hasattr(response, "model_dump"):
-                return cast(Dict[str, Any], response.model_dump())
-            return cast(Dict[str, Any], dict(response))
-        else:
-            raise NotImplementedError("The OpenAI client does not support deleting assistants.")
-
     @property
     def produced_message_types(
         self: "OpenAIAgent",

python/packages/autogen-ext/tests/test_openai_agent.py

@@ -5,7 +5,7 @@
 import pytest
 from autogen_agentchat.base import Response
 from autogen_agentchat.messages import BaseChatMessage, MultiModalMessage, TextMessage
-from autogen_core import CancellationToken, FunctionCall, Image
+from autogen_core import CancellationToken, Image
 from autogen_core.models import UserMessage
 from autogen_core.tools import Tool, ToolSchema
 from autogen_ext.agents.openai import OpenAIAgent
@@ -325,75 +325,6 @@ async def test_tool_schema_conversion(agent: OpenAIAgent) -> None:
     assert "properties" in tool_schema["parameters"]
 
 
-@pytest.mark.asyncio
-async def test_list_assistants(agent: OpenAIAgent) -> Dict[str, Any]:
-    client = cast(Any, agent._client)  # type: ignore
-    client.assistants = MagicMock()
-    client.assistants.list = AsyncMock(
-        return_value=MagicMock(model_dump=lambda: {"object": "list", "data": ["assistant1"]})
-    )
-    result = await agent.list_assistants(limit=1)
-    assert result["object"] == "list"
-    assert "assistant1" in result["data"]
-
-    delattr(client, "assistants")
-    with pytest.raises(NotImplementedError):
-        await agent.list_assistants()
-
-    return result
-
-
-@pytest.mark.asyncio
-async def test_retrieve_assistant(agent: OpenAIAgent) -> Dict[str, Any]:
-    client = cast(Any, agent._client)  # type: ignore
-    client.assistants = MagicMock()
-    client.assistants.retrieve = AsyncMock(return_value=MagicMock(model_dump=lambda: {"id": "asst_abc123"}))
-    result = await agent.retrieve_assistant("asst_abc123")
-    assert result["id"] == "asst_abc123"
-
-    delattr(client, "assistants")
-    with pytest.raises(NotImplementedError):
-        await agent.retrieve_assistant("asst_abc123")
-
-    return result
-
-
-@pytest.mark.asyncio
-async def test_modify_assistant(agent: OpenAIAgent) -> Dict[str, Any]:
-    client = cast(Any, agent._client)  # type: ignore
-    client.assistants = MagicMock()
-    client.assistants.update = AsyncMock(
-        return_value=MagicMock(model_dump=lambda: {"id": "asst_123", "name": "newname"})
-    )
-    result = await agent.modify_assistant("asst_123", name="newname")
-    assert result["id"] == "asst_123"
-    assert result["name"] == "newname"
-
-    delattr(client, "assistants")
-    with pytest.raises(NotImplementedError):
-        await agent.modify_assistant("asst_123", name="newname")
-
-    call = FunctionCall(name="not_a_tool", arguments="{}", id="call1")
-    exec_result = await agent._execute_tool_call(call, CancellationToken())  # type: ignore
-    assert exec_result.is_error
-
-    agent._tool_map["bad_args"] = agent._tool_map["get_weather"]  # type: ignore
-    call = FunctionCall(name="bad_args", arguments="{invalid_json}", id="call2")
-    exec_result = await agent._execute_tool_call(call, CancellationToken())  # type: ignore
-    assert exec_result.is_error and "Invalid JSON" in exec_result.content
-    mock_tool = MagicMock(spec=Tool)
-    mock_tool.name = "fail_tool"
-    mock_tool.run_json = AsyncMock(side_effect=Exception("fail"))
-    mock_tool.return_value_as_string = MagicMock(return_value="error string")
-    agent._tool_map["fail_tool"] = mock_tool  # type: ignore
-
-    call = FunctionCall(name="fail_tool", arguments="{}", id="call3")
-    exec_result = await agent._execute_tool_call(call, CancellationToken())  # type: ignore
-    assert exec_result.is_error and "fail" in exec_result.content
-
-    return result
-
-
 @pytest.mark.asyncio
 async def test_on_messages_inner_messages(agent: OpenAIAgent, cancellation_token: CancellationToken) -> None:
     class DummyMsg(BaseChatMessage):
@@ -449,20 +380,6 @@ async def test_build_api_params(agent: OpenAIAgent) -> None:
     assert params.get("text") == {"type": "json_object"}
 
 
-@pytest.mark.asyncio
-async def test_delete_assistant(agent: OpenAIAgent) -> Dict[str, Any]:
-    client = cast(Any, agent._client)  # type: ignore
-    client.assistants = MagicMock()
-    client.assistants.delete = AsyncMock(return_value=MagicMock(model_dump=lambda: {"id": "asst_123"}))
-    result = await agent.delete_assistant("asst_123")
-    assert result["id"] == "asst_123"
-    delattr(client, "assistants")
-    with pytest.raises(NotImplementedError):
-        await agent.delete_assistant("asst_123")
-
-    return result
-
-
 @pytest.mark.asyncio
 async def test_on_messages_previous_response_id(agent: OpenAIAgent, cancellation_token: CancellationToken) -> None:
     message = TextMessage(source="user", content="hi")