praisonaiagents 0.0.54__py3-none-any.whl → 0.0.56__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -97,36 +97,79 @@ def process_stream_chunks(chunks):
         
         content_list = []
         reasoning_list = []
+        tool_calls = []
+        current_tool_call = None
 
+        # First pass: Get initial tool call data
         for chunk in chunks:
             if not hasattr(chunk, "choices") or not chunk.choices:
                 continue
             
-            # Track usage from each chunk
-            if hasattr(chunk, "usage"):
-                completion_tokens += getattr(chunk.usage, "completion_tokens", 0)
-                prompt_tokens += getattr(chunk.usage, "prompt_tokens", 0)
-                
             delta = getattr(chunk.choices[0], "delta", None)
             if not delta:
                 continue
-                
+
+            # Handle content and reasoning
             if hasattr(delta, "content") and delta.content:
                 content_list.append(delta.content)
             if hasattr(delta, "reasoning_content") and delta.reasoning_content:
                 reasoning_list.append(delta.reasoning_content)
+            
+            # Handle tool calls
+            if hasattr(delta, "tool_calls") and delta.tool_calls:
+                for tool_call_delta in delta.tool_calls:
+                    if tool_call_delta.index is not None and tool_call_delta.id:
+                        # Found the initial tool call
+                        current_tool_call = {
+                            "id": tool_call_delta.id,
+                            "type": "function",
+                            "function": {
+                                "name": tool_call_delta.function.name,
+                                "arguments": ""
+                            }
+                        }
+                        while len(tool_calls) <= tool_call_delta.index:
+                            tool_calls.append(None)
+                        tool_calls[tool_call_delta.index] = current_tool_call
+                        current_tool_call = tool_calls[tool_call_delta.index]
+                    elif current_tool_call is not None and hasattr(tool_call_delta.function, "arguments"):
+                        if tool_call_delta.function.arguments:
+                            current_tool_call["function"]["arguments"] += tool_call_delta.function.arguments
+
+        # Remove any None values and empty tool calls
+        tool_calls = [tc for tc in tool_calls if tc and tc["id"] and tc["function"]["name"]]
 
         combined_content = "".join(content_list) if content_list else ""
         combined_reasoning = "".join(reasoning_list) if reasoning_list else None
         finish_reason = getattr(last_chunk.choices[0], "finish_reason", None) if hasattr(last_chunk, "choices") and last_chunk.choices else None
 
+        # Create ToolCall objects
+        processed_tool_calls = []
+        if tool_calls:
+            try:
+                from openai.types.chat import ChatCompletionMessageToolCall
+                for tc in tool_calls:
+                    tool_call = ChatCompletionMessageToolCall(
+                        id=tc["id"],
+                        type=tc["type"],
+                        function={
+                            "name": tc["function"]["name"],
+                            "arguments": tc["function"]["arguments"]
+                        }
+                    )
+                    processed_tool_calls.append(tool_call)
+            except Exception as e:
+                print(f"Error processing tool call: {e}")
+
         message = ChatCompletionMessage(
             content=combined_content,
-            reasoning_content=combined_reasoning
+            role="assistant",
+            reasoning_content=combined_reasoning,
+            tool_calls=processed_tool_calls if processed_tool_calls else None
         )
         
         choice = Choice(
-            finish_reason=finish_reason,
+            finish_reason=finish_reason or "tool_calls" if processed_tool_calls else None,
             index=0,
             message=message
         )
@@ -528,6 +571,53 @@ Your Goal: {self.goal}
     def __str__(self):
         return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
 
+    def _process_stream_response(self, messages, temperature, start_time, formatted_tools=None, reasoning_steps=False):
+        """Process streaming response and return final response"""
+        try:
+            # Create the response stream
+            response_stream = client.chat.completions.create(
+                model=self.llm,
+                messages=messages,
+                temperature=temperature,
+                tools=formatted_tools if formatted_tools else None,
+                stream=True
+            )
+            
+            full_response_text = ""
+            reasoning_content = ""
+            chunks = []
+            
+            # Create Live display with proper configuration
+            with Live(
+                display_generating("", start_time),
+                console=self.console,
+                refresh_per_second=4,
+                transient=True,
+                vertical_overflow="ellipsis",
+                auto_refresh=True
+            ) as live:
+                for chunk in response_stream:
+                    chunks.append(chunk)
+                    if chunk.choices[0].delta.content:
+                        full_response_text += chunk.choices[0].delta.content
+                        live.update(display_generating(full_response_text, start_time))
+                    
+                    # Update live display with reasoning content if enabled
+                    if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
+                        rc = chunk.choices[0].delta.reasoning_content
+                        if rc:
+                            reasoning_content += rc
+                            live.update(display_generating(f"{full_response_text}\n[Reasoning: {reasoning_content}]", start_time))
+            
+            # Clear the last generating display with a blank line
+            self.console.print()
+            final_response = process_stream_chunks(chunks)
+            return final_response
+            
+        except Exception as e:
+            display_error(f"Error in stream processing: {e}")
+            return None
+
     def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, reasoning_steps=False):
         start_time = time.time()
         logging.debug(f"{self.name} sending messages to LLM: {messages}")
@@ -554,20 +644,31 @@ Your Goal: {self.goal}
                     logging.warning(f"Tool {tool} not recognized")
 
         try:
-            initial_response = client.chat.completions.create(
-                model=self.llm,
-                messages=messages,
-                temperature=temperature,
-                tools=formatted_tools if formatted_tools else None,
-                stream=False
-            )
+            if stream:
+                # Process as streaming response with formatted tools
+                final_response = self._process_stream_response(
+                    messages, 
+                    temperature, 
+                    start_time, 
+                    formatted_tools=formatted_tools if formatted_tools else None,
+                    reasoning_steps=reasoning_steps
+                )
+            else:
+                # Process as regular non-streaming response
+                final_response = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    tools=formatted_tools if formatted_tools else None,
+                    stream=False
+                )
 
-            tool_calls = getattr(initial_response.choices[0].message, 'tool_calls', None)
+            tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
 
             if tool_calls:
                 messages.append({
-                    "role": "assistant",
-                    "content": initial_response.choices[0].message.content,
+                    "role": "assistant", 
+                    "content": final_response.choices[0].message.content,
                     "tool_calls": tool_calls
                 })
 
@@ -590,55 +691,24 @@ Your Goal: {self.goal}
                         "content": results_str
                     })
 
-            if stream:
-                response_stream = client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=True
-                )
-                full_response_text = ""
-                reasoning_content = ""
-                chunks = []
-                
-                # Create Live display with proper configuration
-                with Live(
-                    display_generating("", start_time),
-                    console=self.console,
-                    refresh_per_second=4,
-                    transient=True,
-                    vertical_overflow="ellipsis",
-                    auto_refresh=True
-                ) as live:
-                    for chunk in response_stream:
-                        chunks.append(chunk)
-                        if chunk.choices[0].delta.content:
-                            full_response_text += chunk.choices[0].delta.content
-                            live.update(display_generating(full_response_text, start_time))
-                        
-                        # Update live display with reasoning content if enabled
-                        if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
-                            rc = chunk.choices[0].delta.reasoning_content
-                            if rc:
-                                reasoning_content += rc
-                                live.update(display_generating(f"{full_response_text}\n[Reasoning: {reasoning_content}]", start_time))
-                
-                # Clear the last generating display with a blank line
-                self.console.print()
-                
-                final_response = process_stream_chunks(chunks)
-                return final_response
-            else:
-                if tool_calls:
+                # Get final response after tool calls
+                if stream:
+                    final_response = self._process_stream_response(
+                        messages, 
+                        temperature, 
+                        start_time,
+                        formatted_tools=formatted_tools if formatted_tools else None,
+                        reasoning_steps=reasoning_steps
+                    )
+                else:
                     final_response = client.chat.completions.create(
                         model=self.llm,
                         messages=messages,
                         temperature=temperature,
                         stream=False
                     )
-                    return final_response
-                else:
-                    return initial_response
+
+            return final_response
 
         except Exception as e:
             display_error(f"Error in chat completion: {e}")
@@ -758,8 +828,7 @@ Your Goal: {self.goal}
 
                     tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
                     response_text = response.choices[0].message.content.strip()
-
-                    if tool_calls:
+                    if tool_calls: ## TODO: Most likely this tool call is already called in _chat_completion, so maybe we can remove this.
                         messages.append({
                             "role": "assistant",
                             "content": response_text,

praisonaiagents/llm/llm.py

@@ -17,6 +17,8 @@ from ..main import (
 from rich.console import Console
 from rich.live import Live
 
+# TODO: Include in-build tool calling in LLM class
+# TODO: Restructure so that duplicate calls are not made (Sync with agent.py)
 class LLMContextLengthExceededException(Exception):
     """Raised when LLM context length is exceeded"""
     def __init__(self, message: str):

praisonaiagents/process/process.py

@@ -44,6 +44,8 @@ class Process:
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
+
+        # TODO: start task with loop feature is not available in aworkflow method
         
         while current_task:
             current_iter += 1
@@ -350,9 +352,10 @@ Provide a JSON with the structure:
                             if row:  # Skip empty rows
                                 task_desc = row[0]  # Take first column
                                 row_task = Task(
-                                    description=task_desc,  # Keep full row as description
+                                    description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
                                     agent=start_task.agent,
-                                    name=task_desc,       # Use first column as name
+                                    name=f"{start_task.name}_{i+1}" if start_task.name else task_desc,
+                                    expected_output=getattr(start_task, 'expected_output', None),
                                     is_start=(i == 0),
                                     task_type="task",
                                     condition={
@@ -374,9 +377,10 @@ Provide a JSON with the structure:
                         previous_task = None
                         for i, line in enumerate(lines):
                             row_task = Task(
-                                description=line.strip(),
+                                description=f"{start_task.description}\n{line.strip()}" if start_task.description else line.strip(),
                                 agent=start_task.agent,
-                                name=line.strip(),
+                                name=f"{start_task.name}_{i+1}" if start_task.name else line.strip(),
+                                expected_output=getattr(start_task, 'expected_output', None),
                                 is_start=(i == 0),
                                 task_type="task",
                                 condition={

{praisonaiagents-0.0.54.dist-info → praisonaiagents-0.0.56.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.54
+Version: 0.0.56
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.54.dist-info → praisonaiagents-0.0.56.dist-info}/RECORD

@@ -1,7 +1,7 @@
 praisonaiagents/__init__.py,sha256=JtPibbmeFv3meIb3vkKjckB0p7m-Vqt2RYPwOH8P41k,1228
 praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=Rd2ZCToraAoe57UDT1JfrB03ffRKtZ-Tct9avFcZyT4,54257
+praisonaiagents/agent/agent.py,sha256=VZPci7g_LAvTz7_rWvWAZ1JgCGKQc1vSfI6x0fqi2os,57598
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=94YPQl-hl-EPY6-Xk2Rj9wlIs9YtiLQbsutSOXWX8QI,36156
 praisonaiagents/agents/autoagents.py,sha256=bjC2O5oZmoJItJXIMPTWc2lsp_AJC9tMiTQOal2hwPA,13532
@@ -9,10 +9,10 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=M6xh9cuO0KZjzpAkHZrnktxw4eCmXLymoZqMoXeq-0U,50352
+praisonaiagents/llm/llm.py,sha256=4QBFSi2c13qJmYqhwZS7XgiC8YL5K8lbxbUoqR9Y6xM,50481
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=_1Nk37kOYakPaUWAJff86rP0ENyykXqMnhTp8E0efuE,30802
+praisonaiagents/process/process.py,sha256=gP3QQxxFO4oUw_HYLf8MoyWyaj_104LIL_AbwLiBxaU,31261
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
 praisonaiagents/tools/__init__.py,sha256=-0lV5n5cG54vYW6REjXIfuJnCLKnfQIDlXsySCaPB9s,7347
@@ -35,7 +35,7 @@ praisonaiagents/tools/wikipedia_tools.py,sha256=pGko-f33wqXgxJTv8db7TbizY5XnzBQR
 praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxNMMs1A,17122
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
-praisonaiagents-0.0.54.dist-info/METADATA,sha256=Zfzek1Y53OzW35U-lLAX5mTpdS0xxV57mCDdHhcSfYo,830
-praisonaiagents-0.0.54.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.54.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.54.dist-info/RECORD,,
+praisonaiagents-0.0.56.dist-info/METADATA,sha256=oh3zNT8tijRBVIJGlTGOlnMXtlKgTIWvILTKj1f5W2Y,830
+praisonaiagents-0.0.56.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.56.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.56.dist-info/RECORD,,