Make OpenAI and Groq and OpenAILike into the new structure

cookbook/models/azure/openai/async/basic.py

@@ -0,0 +1,12 @@
+import asyncio
+
+from agno.agent import Agent
+from agno.models.azure import AzureOpenAI
+
+agent = Agent(
+    model=AzureOpenAI(id="gpt-4o"),
+    description="You help people with their health and fitness goals.",
+    instructions=["Recipes should be under 5 ingredients"],
+)
+# -*- Print a response to the cli
+asyncio.run(agent.aprint_response("Share a breakfast recipe.", markdown=True))

cookbook/models/azure/openai/async/basic_stream.py

@@ -0,0 +1,14 @@
+import asyncio
+
+from agno.agent import Agent
+from agno.models.azure import AzureOpenAI
+
+assistant = Agent(
+    model=AzureOpenAI(id="gpt-4o"),
+    description="You help people with their health and fitness goals.",
+    instructions=["Recipes should be under 5 ingredients"],
+)
+# -*- Print a response to the cli
+asyncio.run(
+    assistant.aprint_response("Share a breakfast recipe.", markdown=True, stream=True)
+)

libs/agno/agno/agent/agent.py

@@ -400,6 +400,7 @@ def __init__(
         # Agent session
         self.agent_session: Optional[AgentSession] = None
 
+        self._tools_for_model: Optional[List[Dict]] = None
         self._functions_for_model: Optional[Dict[str, Function]] = None
 
         self._formatter: Optional[SafeFormatter] = None
@@ -1345,7 +1346,7 @@ def get_tools(self) -> Optional[List[Union[Toolkit, Callable, Function]]]:
     def add_tools_to_model(self, model: Model) -> None:
 
         # Skip if functions_for_model is not None
-        if self._functions_for_model is None:
+        if self._functions_for_model is None or self._tools_for_model is None:
 
             # Get Agent tools
             agent_tools = self.get_tools()
@@ -1356,6 +1357,7 @@ def add_tools_to_model(self, model: Model) -> None:
                 if self.response_model is not None and self.structured_outputs and model.supports_structured_outputs:
                     strict = True
 
+                self._tools_for_model = []
                 self._functions_for_model = {}
 
                 for tool in agent_tools:
@@ -1369,6 +1371,7 @@ def add_tools_to_model(self, model: Model) -> None:
                                 if strict:
                                     func.strict = True
                                 self._functions_for_model[name] = func
+                                self._tools_for_model.append({"type": "function", "function": func.to_dict()})
                                 logger.debug(f"Included function {name} from {tool.name}")
 
                     elif isinstance(tool, Function):
@@ -1378,6 +1381,7 @@ def add_tools_to_model(self, model: Model) -> None:
                             if strict:
                                 tool.strict = True
                             self._functions_for_model[tool.name] = tool
+                            self._tools_for_model.append({"type": "function", "function": tool.to_dict()})
                             logger.debug(f"Included function {tool.name}")
 
                     elif callable(tool):
@@ -1389,10 +1393,13 @@ def add_tools_to_model(self, model: Model) -> None:
                                 if strict:
                                     func.strict = True
                                 self._functions_for_model[func.name] = func
+                                self._tools_for_model.append({"type": "function", "function": func.to_dict()})
                                 logger.debug(f"Included function {func.name}")
                         except Exception as e:
                             logger.warning(f"Could not add function {tool}: {e}")
 
+                # Set tools on the model
+                model.set_tools(tools=self._tools_for_model)
                 # Set functions on the model
                 model.set_functions(functions=self._functions_for_model)
 

libs/agno/agno/memory/db/postgres.py

@@ -9,7 +9,7 @@
     from sqlalchemy.sql.expression import delete, select, text
     from sqlalchemy.types import DateTime, String
 except ImportError:
-    raise ImportError("`sqlalchemy` not installed")
+    raise ImportError("`sqlalchemy` not installed.  Please install using `pip install sqlalchemy 'psycopg[binary]'`")
 
 from agno.memory.db import MemoryDb
 from agno.memory.row import MemoryRow

libs/agno/agno/models/azure/openai_chat.py

@@ -44,7 +44,9 @@ class AzureOpenAI(OpenAILike):
     azure_deployment: Optional[str] = getenv("AZURE_DEPLOYMENT")
     azure_ad_token: Optional[str] = None
     azure_ad_token_provider: Optional[Any] = None
-    openai_client: Optional[AzureOpenAIClient] = None
+
+    client: Optional[AzureOpenAIClient] = None
+    async_client: Optional[AsyncAzureOpenAIClient] = None
 
     def get_client(self) -> AzureOpenAIClient:
         """
@@ -54,12 +56,14 @@ def get_client(self) -> AzureOpenAIClient:
             AzureOpenAIClient: The OpenAI client.
 
         """
-        if self.openai_client:
-            return self.openai_client
+        if self.client is not None:
+            return self.client
 
         _client_params: Dict[str, Any] = self._get_client_params()
 
-        return AzureOpenAIClient(**_client_params)
+        # -*- Create client
+        self.client = AzureOpenAIClient(**_client_params)
+        return self.client
 
     def get_async_client(self) -> AsyncAzureOpenAIClient:
         """
@@ -68,6 +72,8 @@ def get_async_client(self) -> AsyncAzureOpenAIClient:
         Returns:
             AsyncAzureOpenAIClient: An instance of the asynchronous OpenAI client.
         """
+        if self.async_client:
+            return self.async_client
 
         _client_params: Dict[str, Any] = self._get_client_params()
 
@@ -78,7 +84,9 @@ def get_async_client(self) -> AsyncAzureOpenAIClient:
             _client_params["http_client"] = httpx.AsyncClient(
                 limits=httpx.Limits(max_connections=1000, max_keepalive_connections=100)
             )
-        return AsyncAzureOpenAIClient(**_client_params)
+
+        self.async_client = AsyncAzureOpenAIClient(**_client_params)
+        return self.async_client
 
     def _get_client_params(self) -> Dict[str, Any]:
         _client_params: Dict[str, Any] = {}