praisonaiagents 0.0.127__tar.gz → 0.0.128__tar.gz

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

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

{praisonaiagents-0.0.127 → praisonaiagents-0.0.128}/praisonaiagents/agents/agents.py

@@ -480,24 +480,22 @@ Context:
         )
         
         if self.process == "workflow":
-            # Collect all tasks that should run in parallel
-            parallel_tasks = []
+            tasks_to_run = []
             async for task_id in process.aworkflow():
-                if self.tasks[task_id].async_execution and self.tasks[task_id].is_start:
-                    parallel_tasks.append(task_id)
-                elif parallel_tasks:
-                    # Execute collected parallel tasks
-                    await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
-                    parallel_tasks = []
-                    # Run the current non-parallel task
-                    if self.tasks[task_id].async_execution:
-                        await self.arun_task(task_id)
-                    else:
-                        self.run_task(task_id)
-            
-            # Execute any remaining parallel tasks
-            if parallel_tasks:
-                await asyncio.gather(*[self.arun_task(t) for t in parallel_tasks])
+                if self.tasks[task_id].async_execution:
+                    tasks_to_run.append(self.arun_task(task_id))
+                else:
+                    # If we encounter a sync task, we must wait for the previous async tasks to finish.
+                    if tasks_to_run:
+                        await asyncio.gather(*tasks_to_run)
+                        tasks_to_run = []
+                    
+                    # Run sync task in an executor to avoid blocking the event loop
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, self.run_task, task_id)
+
+            if tasks_to_run:
+                await asyncio.gather(*tasks_to_run)
                 
         elif self.process == "sequential":
             async for task_id in process.asequential():

{praisonaiagents-0.0.127 → praisonaiagents-0.0.128}/praisonaiagents/agents/autoagents.py

@@ -136,7 +136,7 @@ class AutoAgents(PraisonAIAgents):
             completion_checker=completion_checker,
             max_retries=max_retries,
             process=process,
-            manager_llm=manager_llm
+            manager_llm=manager_llm or self.llm
         )
 
     def _display_agents_and_tasks(self, agents: List[Agent], tasks: List[Task]):

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

@@ -858,102 +858,6 @@ class LLM:
                             iteration_count += 1
                             continue
 
-                        # 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)
-                        
-                        if ollama_params:
-                            # Get response based on streaming mode
-                            if stream:
-                                # Streaming approach
-                                if verbose:
-                                    with Live(display_generating("", start_time), console=console, refresh_per_second=4) as live:
-                                        response_text = ""
-                                        for chunk in litellm.completion(
-                                            **self._build_completion_params(
-                                                messages=ollama_params["follow_up_messages"],
-                                                temperature=temperature,
-                                                stream=True
-                                            )
-                                        ):
-                                            if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                                content = chunk.choices[0].delta.content
-                                                response_text += content
-                                                live.update(display_generating(response_text, start_time))
-                                else:
-                                    response_text = ""
-                                    for chunk in litellm.completion(
-                                        **self._build_completion_params(
-                                            messages=ollama_params["follow_up_messages"],
-                                            temperature=temperature,
-                                            stream=True
-                                        )
-                                    ):
-                                        if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                            response_text += chunk.choices[0].delta.content
-                            else:
-                                # Non-streaming approach
-                                resp = litellm.completion(
-                                    **self._build_completion_params(
-                                        messages=ollama_params["follow_up_messages"],
-                                        temperature=temperature,
-                                        stream=False
-                                    )
-                                )
-                                response_text = resp.get("choices", [{}])[0].get("message", {}).get("content", "") or ""
-                            
-                            # Set flag to indicate Ollama was handled
-                            ollama_handled = True
-                            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
-                            if final_response_text and verbose:
-                                display_interaction(
-                                    ollama_params["original_prompt"],
-                                    final_response_text,
-                                    markdown=markdown,
-                                    generation_time=time.time() - start_time,
-                                    console=console
-                                )
-                            
-                            # Update messages and continue the loop instead of returning
-                            if 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")
-                        
-                        # Handle reasoning_steps after tool execution if not already handled by Ollama
-                        if reasoning_steps and not ollama_handled:
-                            # Make a non-streaming call to capture reasoning content
-                            reasoning_resp = litellm.completion(
-                                **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 = reasoning_resp["choices"][0]["message"].get("provider_specific_fields", {}).get("reasoning_content")
-                            response_text = reasoning_resp["choices"][0]["message"]["content"]
-                            
-                            # Store reasoning content for later use
-                            if reasoning_content:
-                                stored_reasoning_content = reasoning_content
-                            
-                            # Update messages with the response
-                            messages.append({
-                                "role": "assistant",
-                                "content": 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
@@ -1430,68 +1334,8 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                     # Get response after tool calls
                     response_text = ""
                     
-                    # 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)
-                    
-                    if ollama_params:
-                        # Get response with streaming
-                        if verbose:
-                            response_text = ""
-                            async for chunk in await litellm.acompletion(
-                                **self._build_completion_params(
-                                    messages=ollama_params["follow_up_messages"],
-                                    temperature=temperature,
-                                    stream=stream
-                                )
-                            ):
-                                if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    content = chunk.choices[0].delta.content
-                                    response_text += content
-                                    print("\033[K", end="\r")
-                                    print(f"Processing results... {time.time() - start_time:.1f}s", end="\r")
-                        else:
-                            response_text = ""
-                            async for chunk in await litellm.acompletion(
-                                **self._build_completion_params(
-                                    messages=ollama_params["follow_up_messages"],
-                                    temperature=temperature,
-                                    stream=stream
-                                )
-                            ):
-                                if chunk and chunk.choices and chunk.choices[0].delta.content:
-                                    response_text += chunk.choices[0].delta.content
-                        
-                        # Set flag to indicate Ollama was handled
-                        ollama_handled = True
-                        final_response_text = response_text.strip()
-                        logging.debug(f"[OLLAMA_DEBUG] Ollama follow-up response: {final_response_text[:200]}...")
-                        
-                        # Display the response if we got one
-                        if final_response_text and verbose:
-                            display_interaction(
-                                ollama_params["original_prompt"],
-                                final_response_text,
-                                markdown=markdown,
-                                generation_time=time.time() - start_time,
-                                console=console
-                            )
-                        
-                        # Store the response for potential final return
-                        if 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 no special handling was needed or if it's not an Ollama model
-                    if reasoning_steps and not ollama_handled:
+                    # If no special handling was needed
+                    if reasoning_steps:
                         # Non-streaming call to capture reasoning
                         resp = await litellm.acompletion(
                             **self._build_completion_params(
@@ -1521,7 +1365,7 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                                 generation_time=time.time() - start_time,
                                 console=console
                             )
-                    elif not ollama_handled:
+                    else:
                         # Get response after tool calls with streaming if not already handled
                         if verbose:
                             async for chunk in await litellm.acompletion(
@@ -1790,67 +1634,6 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 
         litellm.callbacks = events
 
-    def _handle_ollama_model(self, response_text: str, tool_results: List[Any], messages: List[Dict], original_prompt: Union[str, List[Dict]]) -> Optional[Dict[str, Any]]:
-        """
-        Handle special Ollama model requirements when processing tool results.
-        
-        Args:
-            response_text: The initial response text from the model
-            tool_results: List of tool execution results
-            messages: The conversation messages list
-            original_prompt: The original user prompt
-            
-        Returns:
-            Dict with follow-up parameters if Ollama needs special handling, None otherwise
-        """
-        if not self._is_ollama_provider() or not tool_results:
-            return None
-            
-        # Check if the response is just a JSON tool call
-        try:
-            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
-                
-            logging.debug("Detected Ollama returning only tool call JSON, preparing follow-up call to process results")
-            
-            # Extract the original user query from messages
-            original_query = ""
-            for msg in reversed(messages):  # Look from the end to find the most recent user message
-                if msg.get("role") == "user":
-                    content = msg.get("content", "")
-                    # Handle list content (multimodal)
-                    if isinstance(content, list):
-                        for item in content:
-                            if isinstance(item, dict) and item.get("type") == "text":
-                                original_query = item.get("text", "")
-                                break
-                    else:
-                        original_query = content
-                    if original_query:
-                        break
-            
-            # Create a shorter follow-up prompt with all tool results
-            # If there's only one result, use it directly; otherwise combine them
-            if len(tool_results) == 1:
-                results_text = json.dumps(tool_results[0], indent=2)
-            else:
-                results_text = json.dumps(tool_results, indent=2)
-            
-            follow_up_prompt = f"Results:\n{results_text}\nProvide Answer to this Original Question based on the above results: '{original_query}'"
-            logging.debug(f"[OLLAMA_DEBUG] Original query extracted: {original_query}")
-            logging.debug(f"[OLLAMA_DEBUG] Follow-up prompt: {follow_up_prompt[:200]}...")
-            
-            # Return parameters for follow-up call
-            return {
-                "follow_up_messages": [{"role": "user", "content": follow_up_prompt}],
-                "original_prompt": original_prompt
-            }
-            
-        except (json.JSONDecodeError, KeyError):
-            # Not a JSON response or not a tool call format
-            return None
 
     def _build_completion_params(self, **override_params) -> Dict[str, Any]:
         """Build parameters for litellm completion calls with all necessary config"""

{praisonaiagents-0.0.127 → praisonaiagents-0.0.128}/praisonaiagents/process/process.py

@@ -469,16 +469,18 @@ Subtask: {st.name}
                 logging.debug(f"Task type: {task_to_check.task_type}")
                 logging.debug(f"Task status before reset check: {task_to_check.status}")
                 logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+                logging.debug(f"Task async_execution: {task_to_check.async_execution}")
 
                 if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
                     task_to_check.task_type != "loop" and # Removed "decision" from exclusion
                     not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
-                           for t in self.tasks.values())):
-                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                           for t in self.tasks.values()) and
+                    not task_to_check.async_execution):  # Don't reset async parallel tasks
+                    logging.debug(f"=== Resetting non-loop, non-decision, non-parallel task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask/parallel or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
 
             # Handle loop progression
@@ -1099,16 +1101,18 @@ Subtask: {st.name}
                 logging.debug(f"Task type: {task_to_check.task_type}")
                 logging.debug(f"Task status before reset check: {task_to_check.status}")
                 logging.debug(f"Task rerun: {getattr(task_to_check, 'rerun', True)}") # default to True if not set
+                logging.debug(f"Task async_execution: {task_to_check.async_execution}")
 
                 if (getattr(task_to_check, 'rerun', True) and # Corrected condition - reset only if rerun is True (or default True)
                     task_to_check.task_type != "loop" and # Removed "decision" from exclusion
                     not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_")
-                           for t in self.tasks.values())):
-                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                           for t in self.tasks.values()) and
+                    not task_to_check.async_execution):  # Don't reset async parallel tasks
+                    logging.debug(f"=== Resetting non-loop, non-decision, non-parallel task {subtask_name} to 'not started' ===")
                     self.tasks[task_id].status = "not started"
                     logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
                 else:
-                    logging.debug(f"=== Skipping reset for loop/decision/subtask or rerun=False: {subtask_name} ===")
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask/parallel or rerun=False: {subtask_name} ===")
                     logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
 
 

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

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

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

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