Merge branch 'main' into set-partition-key

Author: yaron2

dapr_agents/agents/agent/agent.py

@@ -201,7 +201,11 @@ async def process_iterations(self, messages: List[Dict[str, Any]]) -> Any:
                 response: LLMChatResponse = self.llm.generate(
                     messages=messages,
                     tools=self.get_llm_tools(),
-                    tool_choice=self.tool_choice,
+                    **(
+                        {"tool_choice": self.tool_choice}
+                        if self.tool_choice is not None
+                        else {}
+                    ),
                 )
                 # Get the first candidate from the response
                 response_message = response.get_message()

dapr_agents/agents/base.py

@@ -27,7 +27,6 @@
 )
 from pydantic import BaseModel, Field, PrivateAttr, model_validator, ConfigDict
 from dapr_agents.llm.chat import ChatClientBase
-from dapr_agents.llm.openai import OpenAIChatClient
 
 logger = logging.getLogger(__name__)
 
@@ -66,8 +65,8 @@ class AgentBase(BaseModel, ABC):
         default=None,
         description="A custom system prompt, overriding name, role, goal, and instructions.",
     )
-    llm: ChatClientBase = Field(
-        default_factory=OpenAIChatClient,
+    llm: Optional[ChatClientBase] = Field(
+        default=None,
         description="Language model client for generating responses.",
     )
     prompt_template: Optional[PromptTemplateBase] = Field(
@@ -136,12 +135,16 @@ def set_name_from_role(cls, values: dict):
     @model_validator(mode="after")
     def validate_llm(cls, values):
         """Validate that LLM is properly configured."""
-        if hasattr(values, "llm") and values.llm:
-            try:
-                # Validate LLM is properly configured by accessing it as this is required to be set.
-                _ = values.llm
-            except Exception as e:
-                raise ValueError(f"Failed to initialize LLM: {e}") from e
+        if hasattr(values, "llm"):
+            if values.llm is None:
+                logger.warning("LLM client is None, some functionality may be limited.")
+            else:
+                try:
+                    # Validate LLM is properly configured by accessing it as this is required to be set.
+                    _ = values.llm
+                except Exception as e:
+                    logger.error(f"Failed to initialize LLM: {e}")
+                    values.llm = None
 
         return values
 
@@ -160,10 +163,15 @@ def model_post_init(self, __context: Any) -> None:
         if self.tool_choice is None:
             self.tool_choice = "auto" if self.tools else None
 
+        # Initialize LLM if not provided
+        if self.llm is None:
+            self.llm = self._create_default_llm()
+
         # Centralize prompt template selection logic
         self.prompt_template = self._initialize_prompt_template()
         # Ensure LLM client and agent both reference the same template
-        self.llm.prompt_template = self.prompt_template
+        if self.llm is not None:
+            self.llm.prompt_template = self.prompt_template
 
         self._validate_prompt_template()
         self.prefill_agent_attributes()
@@ -174,6 +182,21 @@ def model_post_init(self, __context: Any) -> None:
 
         super().model_post_init(__context)
 
+    def _create_default_llm(self) -> Optional[ChatClientBase]:
+        """
+        Creates a default LLM client when none is provided.
+        Returns None if the default LLM cannot be created due to missing configuration.
+        """
+        try:
+            from dapr_agents.llm.openai import OpenAIChatClient
+
+            return OpenAIChatClient()
+        except Exception as e:
+            logger.warning(
+                f"Failed to create default OpenAI client: {e}. LLM will be None."
+            )
+            return None
+
     def _initialize_prompt_template(self) -> PromptTemplateBase:
         """
         Determines which prompt template to use for the agent:
@@ -190,7 +213,11 @@ def _initialize_prompt_template(self) -> PromptTemplateBase:
             return self.prompt_template
 
         # 2) LLM client has one?
-        if self.llm.prompt_template:
+        if (
+            self.llm
+            and hasattr(self.llm, "prompt_template")
+            and self.llm.prompt_template
+        ):
             logger.debug("🔄 Syncing from llm.prompt_template")
             return self.llm.prompt_template
 

dapr_agents/agents/durableagent/agent.py

@@ -379,7 +379,11 @@ async def generate_response(
             response: LLMChatResponse = self.llm.generate(
                 messages=messages,
                 tools=self.get_llm_tools(),
-                tool_choice=self.tool_choice,
+                **(
+                    {"tool_choice": self.tool_choice}
+                    if self.tool_choice is not None
+                    else {}
+                ),
             )
             # Get the first candidate from the response
             response_message = response.get_message()
@@ -418,7 +422,7 @@ async def run_tool(self, tool_call: Dict[str, Any]) -> Dict[str, Any]:
             raise AgentError(f"Invalid JSON in tool args: {e}")
 
         # Run the tool
-        logger.info(f"Executing tool '{fn_name}' with args: {args}")
+        logger.debug(f"Executing tool '{fn_name}' with args: {args}")
         try:
             result = await self.tool_executor.run_tool(fn_name, **args)
         except Exception as e:

dapr_agents/llm/huggingface/chat.py

@@ -162,10 +162,13 @@ def generate(
         else:
             params.update(kwargs)
 
-        # 4) Override model if given
+        # 4) Add the stream parameter explicitly to params
+        params["stream"] = stream
+
+        # 5) Override model if given
         params["model"] = model or self.model
 
-        # 5) Inject tools / response_format via RequestHandler
+        # 6) Inject tools / response_format via RequestHandler
         params = RequestHandler.process_params(
             params,
             llm_provider=self.provider,
@@ -174,11 +177,11 @@ def generate(
             structured_mode=structured_mode,
         )
 
-        # 6) Call HF API + delegate parsing to ResponseHandler
+        # 7) Call HF API + delegate parsing to ResponseHandler
         try:
             logger.info("Calling HF ChatCompletion Inference API...")
             logger.debug(f"HF params: {params}")
-            response = self.client.chat.completions.create(**params, stream=stream)
+            response = self.client.chat.completions.create(**params)
             logger.info("HF ChatCompletion response received.")
 
             # HF-specific error‐code handling
@@ -198,4 +201,4 @@ def generate(
 
         except Exception as e:
             logger.error("Hugging Face ChatCompletion API error", exc_info=True)
-            raise ValueError("Failed to process HF chat completion") from e
+            raise ValueError(f"Failed to process HF chat completion: {e}") from e

dapr_agents/llm/nvidia/chat.py

@@ -168,11 +168,14 @@ def generate(
         else:
             params.update(kwargs)
 
-        # 4) Override model & max_tokens if provided
+        # 4) Add the stream parameter explicitly to params
+        params["stream"] = stream
+
+        # 5) Override model & max_tokens if provided
         params["model"] = model or self.model
         params["max_tokens"] = max_tokens or self.max_tokens
 
-        # 5) Inject tools / response_format / structured_mode
+        # 6) Inject tools / response_format / structured_mode
         params = RequestHandler.process_params(
             params,
             llm_provider=self.provider,
@@ -181,11 +184,11 @@ def generate(
             structured_mode=structured_mode,
         )
 
-        # 6) Call NVIDIA API + dispatch to ResponseHandler
+        # 7) Call NVIDIA API + dispatch to ResponseHandler
         try:
             logger.info("Calling NVIDIA ChatCompletion API.")
             logger.debug(f"Parameters: {params}")
-            resp = self.client.chat.completions.create(**params, stream=stream)
+            resp = self.client.chat.completions.create(**params)
             return ResponseHandler.process_response(
                 response=resp,
                 llm_provider=self.provider,

dapr_agents/llm/openai/chat.py

@@ -194,10 +194,13 @@ def generate(
         else:
             params.update(kwargs)
 
-        # 4) Override model if given
+        # 4) Add the stream parameter explicitly to params
+        params["stream"] = stream
+
+        # 5) Override model if given
         params["model"] = model or self.model
 
-        # 5) Let RequestHandler inject tools / response_format / structured_mode
+        # 6) Let RequestHandler inject tools / response_format / structured_mode
         params = RequestHandler.process_params(
             params,
             llm_provider=self.provider,
@@ -206,13 +209,11 @@ def generate(
             structured_mode=structured_mode,
         )
 
-        # 6) Call API + hand off to ResponseHandler
+        # 7) Call API + hand off to ResponseHandler
         try:
             logger.info("Calling OpenAI ChatCompletion...")
             logger.debug(f"ChatCompletion params: {params}")
-            resp = self.client.chat.completions.create(
-                **params, stream=stream, timeout=self.timeout
-            )
+            resp = self.client.chat.completions.create(**params, timeout=self.timeout)
             logger.info("ChatCompletion response received.")
             return ResponseHandler.process_response(
                 response=resp,

dapr_agents/llm/openai/client/openai.py

@@ -17,7 +17,7 @@ class OpenAIClient:
 
     def __init__(
         self,
-        api_key: str,
+        api_key: Optional[str] = None,
         base_url: Optional[str] = None,
         organization: Optional[str] = None,
         project: Optional[str] = None,
@@ -27,16 +27,16 @@ def __init__(
         Initializes the OpenAI client with API key, base URL, and organization.
 
         Args:
-            api_key: The OpenAI API key.
+            api_key: The OpenAI API key (will fall back to OPENAI_API_KEY env var if not provided).
             base_url: The base URL for OpenAI API (defaults to https://api.openai.com/v1).
             organization: The OpenAI organization (optional).
             project: The OpenAI Project name (optional).
             timeout: Timeout for requests (default is 1500 seconds).
         """
-        self.api_key = api_key  # or inferred from OPENAI_API_KEY env variable.
-        self.base_url = base_url  # or set to "https://api.openai.com/v1" by default.
-        self.organization = organization  # or inferred from OPENAI_ORG_ID env variable.
-        self.project = project  # or inferred from OPENAI_PROJECT_ID env variable.
+        self.api_key = api_key  # Will be None if not provided - OpenAI SDK will handle env var fallback
+        self.base_url = base_url
+        self.organization = organization
+        self.project = project
         self.timeout = HTTPHelper.configure_timeout(timeout)
 
     def get_client(self) -> OpenAI:
@@ -46,13 +46,19 @@ def get_client(self) -> OpenAI:
         Returns:
             OpenAI: The initialized OpenAI client.
         """
-        return OpenAI(
-            api_key=self.api_key,
-            base_url=self.base_url,
-            organization=self.organization,
-            project=self.project,
-            timeout=self.timeout,
-        )
+        # Build kwargs, only including non-None values so SDK can fall back to env vars
+        kwargs = {}
+        if self.api_key is not None:
+            kwargs["api_key"] = self.api_key
+        if self.base_url is not None:
+            kwargs["base_url"] = self.base_url
+        if self.organization is not None:
+            kwargs["organization"] = self.organization
+        if self.project is not None:
+            kwargs["project"] = self.project
+        kwargs["timeout"] = self.timeout
+
+        return OpenAI(**kwargs)
 
     @classmethod
     def from_config(

dapr_agents/observability/__init__.py

@@ -0,0 +1,6 @@
+from .instrumentor import DaprAgentsInstrumentor
+
+
+__all__ = [
+    "DaprAgentsInstrumentor",
+]