praisonaiagents 0.0.125__tar.gz → 0.0.127__tar.gz

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.125
+Version: 0.0.127
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/praisonaiagents/agent/agent.py

@@ -1235,7 +1235,8 @@ Your Goal: {self.goal}"""
                     agent_role=self.role,
                     agent_tools=[t.__name__ if hasattr(t, '__name__') else str(t) for t in (tools if tools is not None else self.tools)],
                     execute_tool_fn=self.execute_tool,  # Pass tool execution function
-                    reasoning_steps=reasoning_steps
+                    reasoning_steps=reasoning_steps,
+                    stream=stream  # Pass the stream parameter from chat method
                     )
 
                     self.chat_history.append({"role": "assistant", "content": response_text})

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/praisonaiagents/llm/llm.py

@@ -680,6 +680,7 @@ class LLM:
             max_iterations = 10  # Prevent infinite loops
             iteration_count = 0
             final_response_text = ""
+            stored_reasoning_content = None  # Store reasoning content from tool execution
 
             while iteration_count < max_iterations:
                 try:
@@ -771,7 +772,7 @@ class LLM:
                                         if formatted_tools and self._supports_streaming_tools():
                                             tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
                             
-                            response_text = response_text.strip()
+                            response_text = response_text.strip() if response_text else "" if response_text else "" if response_text else "" if response_text else ""
                             
                             # Create a mock final_response with the captured data
                             final_response = {
@@ -857,8 +858,6 @@ class LLM:
                             iteration_count += 1
                             continue
 
-                        # If we reach here, no more tool calls needed - get final response
-                        # Make one more call to get the final summary response
                         # Special handling for Ollama models that don't automatically process tool results
                         ollama_handled = False
                         ollama_params = self._handle_ollama_model(response_text, tool_results, messages, original_prompt)
@@ -905,7 +904,7 @@ class LLM:
                             
                             # Set flag to indicate Ollama was handled
                             ollama_handled = True
-                            final_response_text = response_text.strip()
+                            final_response_text = response_text.strip() if response_text else ""
                             logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
                             
                             # Display the response if we got one
@@ -918,15 +917,23 @@ class LLM:
                                     console=console
                                 )
                             
-                            # Return the final response after processing Ollama's follow-up
+                            # Update messages and continue the loop instead of returning
                             if final_response_text:
-                                return final_response_text
+                                # Update messages with the response to maintain conversation context
+                                messages.append({
+                                    "role": "assistant",
+                                    "content": final_response_text
+                                })
+                                # Continue the loop to check if more tools are needed
+                                iteration_count += 1
+                                continue
                             else:
                                 logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                         
-                        # If reasoning_steps is True and we haven't handled Ollama already, do a single non-streaming call
+                        # Handle reasoning_steps after tool execution if not already handled by Ollama
                         if reasoning_steps and not ollama_handled:
-                            resp = litellm.completion(
+                            # Make a non-streaming call to capture reasoning content
+                            reasoning_resp = litellm.completion(
                                 **self._build_completion_params(
                                     messages=messages,
                                     temperature=temperature,
@@ -934,89 +941,28 @@ class LLM:
                                     **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                                 )
                             )
-                            reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                            response_text = resp["choices"][0]["message"]["content"]
+                            reasoning_content = reasoning_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                            response_text = reasoning_resp["choices"][0]["message"]["content"]
                             
-                            # Optionally display reasoning if present
-                            if verbose and reasoning_content:
-                                display_interaction(
-                                    original_prompt,
-                                    f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
-                                    markdown=markdown,
-                                    generation_time=time.time() - start_time,
-                                    console=console
-                                )
-                            else:
-                                display_interaction(
-                                    original_prompt,
-                                    response_text,
-                                    markdown=markdown,
-                                    generation_time=time.time() - start_time,
-                                    console=console
-                                )
-                        
-                        # Otherwise do the existing streaming approach if not already handled
-                        elif not ollama_handled:
-                            # Get response after tool calls
-                            if stream:
-                                # Streaming approach
-                                if verbose:
-                                    with Live(display_generating("", current_time), console=console, refresh_per_second=4) as live:
-                                        final_response_text = ""
-                                        for chunk in litellm.completion(
-                                            **self._build_completion_params(
-                                                messages=messages,
-                                                tools=formatted_tools,
-                                                temperature=temperature,
-                                                stream=True,
-                                                **kwargs
-                                            )
-                                        ):
-                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                                content = chunk.choices[0].delta.content
-                                                final_response_text += content
-                                                live.update(display_generating(final_response_text, current_time))
-                                else:
-                                    final_response_text = ""
-                                    for chunk in litellm.completion(
-                                        **self._build_completion_params(
-                                            messages=messages,
-                                            tools=formatted_tools,
-                                            temperature=temperature,
-                                            stream=True,
-                                            **kwargs
-                                        )
-                                    ):
-                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            final_response_text += chunk.choices[0].delta.content
-                            else:
-                                # Non-streaming approach
-                                resp = litellm.completion(
-                                    **self._build_completion_params(
-                                        messages=messages,
-                                        tools=formatted_tools,
-                                        temperature=temperature,
-                                        stream=False,
-                                        **kwargs
-                                    )
-                                )
-                                final_response_text = resp.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
+                            # Store reasoning content for later use
+                            if reasoning_content:
+                                stored_reasoning_content = reasoning_content
                             
-                            final_response_text = final_response_text.strip()
-                        
-                        # Display final response
-                        if verbose:
-                            display_interaction(
-                                original_prompt,
-                                final_response_text,
-                                markdown=markdown,
-                                generation_time=time.time() - start_time,
-                                console=console
-                            )
+                            # Update messages with the response
+                            messages.append({
+                                "role": "assistant",
+                                "content": response_text
+                            })
                         
-                        return final_response_text
+                        # After tool execution, continue the loop to check if more tools are needed
+                        # instead of immediately trying to get a final response
+                        iteration_count += 1
+                        continue
                     else:
                         # No tool calls, we're done with this iteration
+                        # If we've executed tools in previous iterations, this response contains the final answer
+                        if iteration_count > 0:
+                            final_response_text = response_text.strip() if response_text else ""
                         break
                         
                 except Exception as e:
@@ -1029,15 +975,29 @@ class LLM:
             
             # No tool calls were made in this iteration, return the response
             if verbose:
-                display_interaction(
-                    original_prompt,
-                    response_text,
-                    markdown=markdown,
-                    generation_time=time.time() - start_time,
-                    console=console
-                )
+                # If we have stored reasoning content from tool execution, display it
+                if stored_reasoning_content:
+                    display_interaction(
+                        original_prompt,
+                        f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{response_text}",
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
+                else:
+                    display_interaction(
+                        original_prompt,
+                        response_text,
+                        markdown=markdown,
+                        generation_time=time.time() - start_time,
+                        console=console
+                    )
+            
+            response_text = response_text.strip() if response_text else ""
             
-            response_text = response_text.strip()
+            # Return reasoning content if reasoning_steps is True and we have it
+            if reasoning_steps and stored_reasoning_content:
+                return stored_reasoning_content
             
             # Handle output formatting
             if output_json or output_pydantic:
@@ -1053,8 +1013,8 @@ class LLM:
                     display_interaction(original_prompt, response_text, markdown=markdown,
                                      generation_time=time.time() - start_time, console=console)
                 # Return reasoning content if reasoning_steps is True
-                if reasoning_steps and reasoning_content:
-                    return reasoning_content
+                if reasoning_steps and stored_reasoning_content:
+                    return stored_reasoning_content
                 return response_text
 
             # Handle self-reflection loop
@@ -1195,7 +1155,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             if chunk and chunk.choices and chunk.choices[0].delta.content:
                                 response_text += chunk.choices[0].delta.content
                     
-                    response_text = response_text.strip()
+                    response_text = response_text.strip() if response_text else "" if response_text else ""
                     continue
 
                 except json.JSONDecodeError:
@@ -1317,118 +1277,126 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             # Format tools for LiteLLM using the shared helper
             formatted_tools = self._format_tools_for_litellm(tools)
 
-            response_text = ""
-            if reasoning_steps:
-                # Non-streaming call to capture reasoning
-                resp = await litellm.acompletion(
-                    **self._build_completion_params(
-                        messages=messages,
+            # Initialize variables for iteration loop
+            max_iterations = 10  # Prevent infinite loops
+            iteration_count = 0
+            final_response_text = ""
+            stored_reasoning_content = None  # Store reasoning content from tool execution
+
+            while iteration_count < max_iterations:
+                response_text = ""
+                reasoning_content = None
+                tool_calls = []
+                
+                if reasoning_steps and iteration_count == 0:
+                    # Non-streaming call to capture reasoning
+                    resp = await litellm.acompletion(
+                        **self._build_completion_params(
+                            messages=messages,
                         temperature=temperature,
                         stream=False,  # force non-streaming
                         **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                     )
-                )
-                reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                response_text = resp["choices"][0]["message"]["content"]
-                
-                if verbose and reasoning_content:
-                    display_interaction(
-                        "Initial reasoning:",
-                        f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
-                        markdown=markdown,
-                        generation_time=time.time() - start_time,
-                        console=console
-                    )
-                elif verbose:
-                    display_interaction(
-                        "Initial response:",
-                        response_text,
-                        markdown=markdown,
-                        generation_time=time.time() - start_time,
-                        console=console
                     )
-            else:
-                # Determine if we should use streaming based on tool support
-                use_streaming = stream
-                if formatted_tools and not self._supports_streaming_tools():
-                    # Provider doesn't support streaming with tools, use non-streaming
-                    use_streaming = False
-                
-                if use_streaming:
-                    # Streaming approach (with or without tools)
-                    tool_calls = []
+                    reasoning_content = resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
+                    response_text = resp["choices"][0]["message"]["content"]
                     
-                    if verbose:
-                        async for chunk in await litellm.acompletion(
-                            **self._build_completion_params(
-                                messages=messages,
-                                temperature=temperature,
-                                stream=True,
-                                tools=formatted_tools,
-                                **kwargs
-                            )
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta:
-                                delta = chunk.choices[0].delta
-                                response_text, tool_calls = self._process_stream_delta(
-                                    delta, response_text, tool_calls, formatted_tools
+                    if verbose and reasoning_content:
+                        display_interaction(
+                            "Initial reasoning:",
+                            f"Reasoning:\n{reasoning_content}\n\nAnswer:\n{response_text}",
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                    elif verbose:
+                        display_interaction(
+                            "Initial response:",
+                            response_text,
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                else:
+                    # Determine if we should use streaming based on tool support
+                    use_streaming = stream
+                    if formatted_tools and not self._supports_streaming_tools():
+                        # Provider doesn't support streaming with tools, use non-streaming
+                        use_streaming = False
+                    
+                    if use_streaming:
+                        # Streaming approach (with or without tools)
+                        tool_calls = []
+                        
+                        if verbose:
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    tools=formatted_tools,
+                                    **kwargs
                                 )
-                                if delta.content:
-                                    print("\033[K", end="\r")  
-                                    print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta:
+                                    delta = chunk.choices[0].delta
+                                    response_text, tool_calls = self._process_stream_delta(
+                                        delta, response_text, tool_calls, formatted_tools
+                                    )
+                                    if delta.content:
+                                        print("\033[K", end="\r")  
+                                        print(f"Generating... {time.time() - start_time:.1f}s", end="\r")
 
+                        else:
+                            # Non-verbose streaming
+                            async for chunk in await litellm.acompletion(
+                                **self._build_completion_params(
+                                    messages=messages,
+                                    temperature=temperature,
+                                    stream=True,
+                                    tools=formatted_tools,
+                                    **kwargs
+                                )
+                            ):
+                                if chunk and chunk.choices and chunk.choices[0].delta:
+                                    delta = chunk.choices[0].delta
+                                    if delta.content:
+                                        response_text += delta.content
+                                    
+                                    # Capture tool calls from streaming chunks if provider supports it
+                                    if formatted_tools and self._supports_streaming_tools():
+                                        tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
+                        
+                        response_text = response_text.strip() if response_text else "" if response_text else "" if response_text else ""
+                        
+                        # We already have tool_calls from streaming if supported
+                        # No need for a second API call!
                     else:
-                        # Non-verbose streaming
-                        async for chunk in await litellm.acompletion(
+                        # Non-streaming approach (when tools require it or streaming is disabled)
+                        tool_response = await litellm.acompletion(
                             **self._build_completion_params(
                                 messages=messages,
                                 temperature=temperature,
-                                stream=True,
+                                stream=False,
                                 tools=formatted_tools,
-                                **kwargs
+                                **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
                             )
-                        ):
-                            if chunk and chunk.choices and chunk.choices[0].delta:
-                                delta = chunk.choices[0].delta
-                                if delta.content:
-                                    response_text += delta.content
-                                
-                                # Capture tool calls from streaming chunks if provider supports it
-                                if formatted_tools and self._supports_streaming_tools():
-                                    tool_calls = self._process_tool_calls_from_stream(delta, tool_calls)
-                    
-                    response_text = response_text.strip()
-                    
-                    # We already have tool_calls from streaming if supported
-                    # No need for a second API call!
-                else:
-                    # Non-streaming approach (when tools require it or streaming is disabled)
-                    tool_response = await litellm.acompletion(
-                        **self._build_completion_params(
-                            messages=messages,
-                            temperature=temperature,
-                            stream=False,
-                            tools=formatted_tools,
-                            **{k:v for k,v in kwargs.items() if k != 'reasoning_steps'}
-                        )
-                    )
-                    response_text = tool_response.choices[0].message.get("content", "")
-                    tool_calls = tool_response.choices[0].message.get("tool_calls", [])
-                    
-                    if verbose:
-                        # Display the complete response at once
-                        display_interaction(
-                            original_prompt,
-                            response_text,
-                            markdown=markdown,
-                            generation_time=time.time() - start_time,
-                            console=console
                         )
+                        response_text = tool_response.choices[0].message.get("content", "")
+                        tool_calls = tool_response.choices[0].message.get("tool_calls", [])
+                        
+                        if verbose:
+                            # Display the complete response at once
+                            display_interaction(
+                                original_prompt,
+                                response_text,
+                                markdown=markdown,
+                                generation_time=time.time() - start_time,
+                                console=console
+                            )
 
-            # Now handle tools if we have them (either from streaming or non-streaming)
-            if tools and execute_tool_fn and tool_calls:
-                
-                if tool_calls:
+                # Now handle tools if we have them (either from streaming or non-streaming)
+                if tools and execute_tool_fn and tool_calls:
                     # Convert tool_calls to a serializable format for all providers
                     serializable_tool_calls = self._serialize_tool_calls(tool_calls)
                     messages.append({
@@ -1509,9 +1477,16 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 console=console
                             )
                         
-                        # Return the final response after processing Ollama's follow-up
+                        # Store the response for potential final return
                         if final_response_text:
-                            return final_response_text
+                            # Update messages with the response to maintain conversation context
+                            messages.append({
+                                "role": "assistant",
+                                "content": final_response_text
+                            })
+                            # Continue the loop to check if more tools are needed
+                            iteration_count += 1
+                            continue
                         else:
                             logging.warning("[OLLAMA_DEBUG] Ollama follow-up returned empty response")
                     
@@ -1576,7 +1551,28 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 if chunk and chunk.choices and chunk.choices[0].delta.content:
                                     response_text += chunk.choices[0].delta.content
 
-                    response_text = response_text.strip()
+                    response_text = response_text.strip() if response_text else "" if response_text else ""
+                    
+                    # After tool execution, update messages and continue the loop
+                    if response_text:
+                        messages.append({
+                            "role": "assistant",
+                            "content": response_text
+                        })
+                    
+                    # Store reasoning content if captured
+                    if reasoning_steps and reasoning_content:
+                        stored_reasoning_content = reasoning_content
+                    
+                    # Continue the loop to check if more tools are needed
+                    iteration_count += 1
+                    continue
+                else:
+                    # No tool calls, we're done with this iteration
+                    # If we've executed tools in previous iterations, this response contains the final answer
+                    if iteration_count > 0:
+                        final_response_text = response_text.strip()
+                    break
 
             # Handle output formatting
             if output_json or output_pydantic:
@@ -1588,13 +1584,27 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 return response_text
 
             if not self_reflect:
+                # Use final_response_text if we went through tool iterations
+                display_text = final_response_text if final_response_text else response_text
+                
+                # Display with stored reasoning content if available
                 if verbose:
-                    display_interaction(original_prompt, response_text, markdown=markdown,
-                                     generation_time=time.time() - start_time, console=console)
-                # Return reasoning content if reasoning_steps is True
-                if reasoning_steps and reasoning_content:
-                    return reasoning_content
-                return response_text
+                    if stored_reasoning_content:
+                        display_interaction(
+                            original_prompt,
+                            f"Reasoning:\n{stored_reasoning_content}\n\nAnswer:\n{display_text}",
+                            markdown=markdown,
+                            generation_time=time.time() - start_time,
+                            console=console
+                        )
+                    else:
+                        display_interaction(original_prompt, display_text, markdown=markdown,
+                                         generation_time=time.time() - start_time, console=console)
+                
+                # Return reasoning content if reasoning_steps is True and we have it
+                if reasoning_steps and stored_reasoning_content:
+                    return stored_reasoning_content
+                return display_text
 
             # Handle self-reflection
             reflection_prompt = f"""
@@ -1798,7 +1808,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             
         # Check if the response is just a JSON tool call
         try:
-            json_response = json.loads(response_text.strip())
+            json_response = json.loads(response_text.strip() if response_text else "{}")
             if not (('name' in json_response or 'function' in json_response) and 
                     not any(word in response_text.lower() for word in ['summary', 'option', 'result', 'found'])):
                 return None
@@ -2056,7 +2066,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             response_text += content
             else:
                 response = litellm.completion(**completion_params)
-                response_text = response.choices[0].message.content.strip()
+                response_text = response.choices[0].message.content.strip() if response.choices[0].message.content else ""
 
             if verbose:
                 display_interaction(
@@ -2067,7 +2077,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     console=console or self.console
                 )
             
-            return response_text.strip()
+            return response_text.strip() if response_text else ""
 
         except Exception as error:
             display_error(f"Error in response: {str(error)}")
@@ -2144,7 +2154,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                             response_text += content
             else:
                 response = await litellm.acompletion(**completion_params)
-                response_text = response.choices[0].message.content.strip()
+                response_text = response.choices[0].message.content.strip() if response.choices[0].message.content else ""
 
             if verbose:
                 display_interaction(
@@ -2155,7 +2165,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     console=console or self.console
                 )
             
-            return response_text.strip()
+            return response_text.strip() if response_text else ""
 
         except Exception as error:
             display_error(f"Error in response_async: {str(error)}")

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/praisonaiagents/llm/openai_client.py

@@ -890,45 +890,8 @@ class OpenAIClient:
                         "content": results_str
                     })
                 
-                # Check if we should continue (for tools like sequential thinking)
-                should_continue = False
-                for tool_call in tool_calls:
-                    # Handle both ToolCall dataclass and OpenAI object
-                    if isinstance(tool_call, ToolCall):
-                        function_name = tool_call.function["name"]
-                        arguments = json.loads(tool_call.function["arguments"])
-                    else:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
-                    
-                    # For sequential thinking tool, check if nextThoughtNeeded is True
-                    if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
-                        should_continue = True
-                        break
-                
-                if not should_continue:
-                    # Get final response after tool calls
-                    if stream:
-                        final_response = self.process_stream_response(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            tools=formatted_tools,
-                            start_time=start_time,
-                            console=console,
-                            display_fn=display_fn,
-                            reasoning_steps=reasoning_steps,
-                            **kwargs
-                        )
-                    else:
-                        final_response = self.create_completion(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            stream=False,
-                            **kwargs
-                        )
-                    break
+                # Continue the loop to allow more tool calls
+                # The model will see tool results and can make additional tool calls
                 
                 iteration_count += 1
             else:
@@ -1067,45 +1030,8 @@ class OpenAIClient:
                         "content": results_str
                     })
                 
-                # Check if we should continue (for tools like sequential thinking)
-                should_continue = False
-                for tool_call in tool_calls:
-                    # Handle both ToolCall dataclass and OpenAI object
-                    if isinstance(tool_call, ToolCall):
-                        function_name = tool_call.function["name"]
-                        arguments = json.loads(tool_call.function["arguments"])
-                    else:
-                        function_name = tool_call.function.name
-                        arguments = json.loads(tool_call.function.arguments)
-                    
-                    # For sequential thinking tool, check if nextThoughtNeeded is True
-                    if function_name == "sequentialthinking" and arguments.get("nextThoughtNeeded", False):
-                        should_continue = True
-                        break
-                
-                if not should_continue:
-                    # Get final response after tool calls
-                    if stream:
-                        final_response = await self.process_stream_response_async(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            tools=formatted_tools,
-                            start_time=start_time,
-                            console=console,
-                            display_fn=display_fn,
-                            reasoning_steps=reasoning_steps,
-                            **kwargs
-                        )
-                    else:
-                        final_response = await self.acreate_completion(
-                            messages=messages,
-                            model=model,
-                            temperature=temperature,
-                            stream=False,
-                            **kwargs
-                        )
-                    break
+                # Continue the loop to allow more tool calls
+                # The model will see tool results and can make additional tool calls
                 
                 iteration_count += 1
             else:

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/praisonaiagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.125
+Version: 0.0.127
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/praisonaiagents.egg-info/SOURCES.txt

@@ -64,6 +64,7 @@ praisonaiagents/tools/yfinance_tools.py
 praisonaiagents/tools/train/data/generatecot.py
 tests/test-graph-memory.py
 tests/test.py
+tests/test_fix_comprehensive.py
 tests/test_handoff_compatibility.py
 tests/test_http_stream_basic.py
 tests/test_ollama_async_fix.py

{praisonaiagents-0.0.125 → praisonaiagents-0.0.127}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.125"
+version = "0.0.127"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [

praisonaiagents-0.0.127/tests/test_fix_comprehensive.py

@@ -0,0 +1,75 @@
+"""
+Test script to verify the fix for sequential tool calling.
+The agent should:
+1. Call get_stock_price to get Google's stock price (100)
+2. Call multiply to multiply 100 by 2
+3. Return the final result (200)
+"""
+
+from praisonaiagents import Agent
+
+def get_stock_price(company_name: str) -> str:
+    """
+    Get the stock price of a company
+    
+    Args:
+        company_name (str): The name of the company
+        
+    Returns:
+        str: The stock price of the company
+    """
+    print(f"[Tool Called] get_stock_price({company_name})")
+    return f"The stock price of {company_name} is 100"
+
+def multiply(a: int, b: int) -> int:
+    """
+    Multiply two numbers
+    
+    Args:
+        a (int): First number
+        b (int): Second number
+        
+    Returns:
+        int: Product of a and b
+    """
+    print(f"[Tool Called] multiply({a}, {b})")
+    return a * b
+
+# Test with Gemini
+print("=" * 60)
+print("Testing with Gemini model")
+print("=" * 60)
+
+agent_gemini = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user. When asked to multiply a stock price, first get the stock price, then multiply it.",
+    llm="gemini/gemini-2.5-pro",
+    tools=[get_stock_price, multiply],
+    verbose=True
+)
+
+result_gemini = agent_gemini.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(f"\nFinal Result (Gemini): {result_gemini}")
+
+# Test with GPT-4
+print("\n" + "=" * 60)
+print("Testing with GPT-4 model")
+print("=" * 60)
+
+agent_gpt4 = Agent(
+    instructions="You are a helpful assistant. You can use the tools provided to you to help the user. When asked to multiply a stock price, first get the stock price, then multiply it.",
+    llm="gpt-4o",
+    tools=[get_stock_price, multiply],
+    verbose=True
+)
+
+result_gpt4 = agent_gpt4.start("what is the stock price of Google? multiply the Google stock price with 2")
+print(f"\nFinal Result (GPT-4): {result_gpt4}")
+
+# Verify results
+print("\n" + "=" * 60)
+print("Test Results Summary")
+print("=" * 60)
+print(f"Gemini result contains '200': {'200' in str(result_gemini) if result_gemini else False}")
+print(f"GPT-4 result contains '200': {'200' in str(result_gpt4) if result_gpt4 else False}")
+print(f"Gemini returned empty: {not result_gemini or result_gemini == ''}")
+print(f"GPT-4 returned empty: {not result_gpt4 or result_gpt4 == ''}")