npcpy 1.0.26__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/gen/response.py

@@ -9,53 +9,127 @@ import os
 try: 
     import ollama
 except ImportError:
-    
     pass
 except OSError:
-    # Handle case where ollama is not installed or not available
+    
     print("Ollama is not installed or not available. Please install it to use this feature.")
 try:
+    import litellm
     from litellm import completion
 except ImportError:
     pass
 except OSError:
-    # Handle case where litellm is not installed or not available
+    
     pass
+
 def handle_streaming_json(api_params):
     """
-    Handles streaming responses when JSON format is requested.
-    
-    Args:
-        api_params (dict): API parameters for the completion call.
-        
-    Yields:
-        Processed chunks of the JSON response.
+    Handles streaming responses when JSON format is requested from LiteLLM.
     """
     json_buffer = ""
     stream = completion(**api_params)
-    
     for chunk in stream:
         content = chunk.choices[0].delta.content
         if content:
             json_buffer += content
-            # Try to parse as valid JSON but only yield once we have complete JSON
             try:
-                # Check if we have a complete JSON object
                 json.loads(json_buffer)
-                # If successful, yield the chunk
                 yield chunk
             except json.JSONDecodeError:
-                # Not complete JSON yet, continue buffering
                 pass
-    
-    # After the stream ends, try to ensure we have valid JSON
-    try:
-        final_json = json.loads(json_buffer)
-        # Could yield a special "completion" chunk here if needed
-    except json.JSONDecodeError:
-        # Handle case where stream ended but JSON is invalid
-        print(f"Warning: Complete stream did not produce valid JSON: {json_buffer}")
-        
+
+def get_transformers_response(
+   prompt: str = None,
+   model=None,
+   tokenizer=None, 
+   tools: list = None,
+   tool_map: Dict = None,
+   format: str = None,
+   messages: List[Dict[str, str]] = None,
+   auto_process_tool_calls: bool = False,
+   **kwargs,
+) -> Dict[str, Any]:
+   import torch
+   import json
+   import uuid
+   from transformers import AutoTokenizer, AutoModelForCausalLM
+   
+   result = {
+       "response": None,
+       "messages": messages.copy() if messages else [],
+       "raw_response": None,
+       "tool_calls": [], 
+       "tool_results": []
+   }
+   
+   if model is None or tokenizer is None:
+       model_name = model if isinstance(model, str) else "Qwen/Qwen3-1.7b"
+       tokenizer = AutoTokenizer.from_pretrained(model_name)
+       model = AutoModelForCausalLM.from_pretrained(model_name)
+       
+       if tokenizer.pad_token is None:
+           tokenizer.pad_token = tokenizer.eos_token
+   
+   if prompt:
+       if result['messages'] and result['messages'][-1]["role"] == "user":
+           result['messages'][-1]["content"] = prompt
+       else:
+           result['messages'].append({"role": "user", "content": prompt})
+   
+   if format == "json":
+       json_instruction = """If you are returning a json object, begin directly with the opening {.
+Do not include any additional markdown formatting or leading ```json tags in your response."""
+       if result["messages"] and result["messages"][-1]["role"] == "user":
+           result["messages"][-1]["content"] += "\n" + json_instruction
+
+   chat_text = tokenizer.apply_chat_template(result["messages"], tokenize=False, add_generation_prompt=True)
+   device = next(model.parameters()).device
+   inputs = tokenizer(chat_text, return_tensors="pt", padding=True, truncation=True)
+   inputs = {k: v.to(device) for k, v in inputs.items()}
+   
+       
+   with torch.no_grad():
+       outputs = model.generate(
+           **inputs,
+           max_new_tokens=256,
+           temperature=0.7,
+           do_sample=True,
+           pad_token_id=tokenizer.eos_token_id,
+       )
+   
+   response_content = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True).strip()
+   result["response"] = response_content
+   result["raw_response"] = response_content
+   result["messages"].append({"role": "assistant", "content": response_content})
+
+   if auto_process_tool_calls and tools and tool_map:
+       detected_tools = []
+       for tool in tools:
+           tool_name = tool.get("function", {}).get("name", "")
+           if tool_name in response_content:
+               detected_tools.append({
+                   "id": str(uuid.uuid4()),
+                   "function": {
+                       "name": tool_name,
+                       "arguments": "{}"
+                   }
+               })
+       
+       if detected_tools:
+           result["tool_calls"] = detected_tools
+           result = process_tool_calls(result, tool_map, "local", "transformers", result["messages"])
+   
+   if format == "json":
+       try:
+           if response_content.startswith("```json"):
+               response_content = response_content.replace("```json", "").replace("```", "").strip()
+           parsed_response = json.loads(response_content)
+           result["response"] = parsed_response
+       except json.JSONDecodeError:
+           result["error"] = f"Invalid JSON response: {response_content}"
+   
+   return result
+
         
 def get_ollama_response(
     prompt: str,
@@ -63,71 +137,58 @@ def get_ollama_response(
     images: List[str] = None,
     tools: list = None,
     tool_choice: Dict = None,
+    tool_map: Dict = None,
+    think= None ,
     format: Union[str, BaseModel] = None,
     messages: List[Dict[str, str]] = None,
     stream: bool = False,
     attachments: List[str] = None,
+    auto_process_tool_calls: bool = False,
     **kwargs,
 ) -> Dict[str, Any]:
     """
     Generates a response using the Ollama API, supporting both streaming and non-streaming.
     """
-    import ollama
+
+    options = {}
+
     image_paths = []
     if images:
         image_paths.extend(images)
     
-    # Handle attachments - simply add them to images if they exist
     if attachments:
         for attachment in attachments:
-            # Check if file exists
             if os.path.exists(attachment):
-                # Extract extension to determine file type
                 _, ext = os.path.splitext(attachment)
                 ext = ext.lower()
                 
-                # Handle image attachments
                 if ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']:
                     image_paths.append(attachment)
-                # Handle PDF attachments
                 elif ext == '.pdf':
                     try:
                         from npcpy.data.load import load_pdf
                         pdf_data = load_pdf(attachment)
                         if pdf_data is not None:
-                            # Extract text and add to prompt
-                            texts = json.loads(pdf_data['texts'].iloc[0])
-                            pdf_text = "\n\n".join([item.get('content', '') for item in texts])
-                            
                             if prompt:
-                                prompt += f"\n\nContent from PDF: {os.path.basename(attachment)}\n{pdf_text[:2000]}..."
+                                prompt += f"\n\nContent from PDF: {os.path.basename(attachment)}\n{pdf_data[:5000]}..."
                             else:
-                                prompt = f"Content from PDF: {os.path.basename(attachment)}\n{pdf_text[:2000]}..."
-                            
-                            # Add images from PDF if needed
-                            try:
-                                images_data = json.loads(pdf_data['images'].iloc[0])
-                                # We would need to save these images temporarily and add paths to image_paths
-                                # This would require more complex implementation
-                            except Exception as e:
-                                print(f"Error processing PDF images: {e}")
-                    except Exception as e:
-                        print(f"Error processing PDF attachment: {e}")
-                # Handle CSV attachments
+                                prompt = f"Content from PDF: {os.path.basename(attachment)}\n{pdf_data[:5000]}..."
+                    except Exception:
+                        pass
                 elif ext == '.csv':
                     try:
                         from npcpy.data.load import load_csv
                         csv_data = load_csv(attachment)
                         if csv_data is not None:
-                            csv_sample = csv_data.head(10).to_string()
+                            csv_sample = csv_data.head(100).to_string()
                             if prompt:
-                                prompt += f"\n\nContent from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
+                                prompt += f"\n\nContent from CSV: {os.path.basename(attachment)} (first 100 rows):\n{csv_sample} \n csv description: {csv_data.describe()}"
                             else:
-                                prompt = f"Content from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
-                    except Exception as e:
-                        print(f"Error processing CSV attachment: {e}")
-    
-    # Update the user message with processed prompt content
+                                prompt = f"Content from CSV: {os.path.basename(attachment)} (first 100 rows):\n{csv_sample} \n csv description: {csv_data.describe()}"
+                    except Exception:
+                        pass
+
+
     if prompt:
         if messages and messages[-1]["role"] == "user":
             if isinstance(messages[-1]["content"], str):
@@ -140,107 +201,231 @@ def get_ollama_response(
                 else:
                     messages[-1]["content"].append({"type": "text", "text": prompt})
         else:
+            if not messages:
+                messages = []
             messages.append({"role": "user", "content": prompt})
-    
-    # Add images to the last user message for Ollama
+    if format == "json" and not stream:
+        json_instruction = """If you are a returning a json object, begin directly with the opening {.
+            If you are returning a json array, begin directly with the opening [.
+            Do not include any additional markdown formatting or leading
+            ```json tags in your response. The item keys should be based on the ones provided
+            by the user. Do not invent new ones."""
+            
+        if messages and messages[-1]["role"] == "user":
+            if isinstance(messages[-1]["content"], list):
+                messages[-1]["content"].append({
+                    "type": "text", 
+                    "text": json_instruction
+                })
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] += "\n" + json_instruction
+                        
     if image_paths:
-        # Find the last user message or create one
-        last_user_idx = None
+        last_user_idx = -1
         for i, msg in enumerate(messages):
             if msg["role"] == "user":
                 last_user_idx = i
-        
-        if last_user_idx is None:
+        if last_user_idx == -1:
             messages.append({"role": "user", "content": ""})
             last_user_idx = len(messages) - 1
-            
-        # For Ollama, we directly attach the images to the message
         messages[last_user_idx]["images"] = image_paths
-    
-    # Prepare API parameters
+
     api_params = {
         "model": model,
         "messages": messages,
-        "stream": stream,
+        "stream": stream if not (tools and tool_map and auto_process_tool_calls) else False,
     }
-    
-    # Add tools if provided
+
     if tools:
         api_params["tools"] = tools
-    
-    # Add tool choice if specified
-    if tool_choice:
-        api_params["tool_choice"] = tool_choice
-    options = {}
-    # Add any additional parameters
+        if tool_choice:
+            options["tool_choice"] = tool_choice
+
+
+    if think is not None:
+        api_params['think'] = think
+
+    if isinstance(format, type) and not stream:
+        api_params["format"] = format.model_json_schema()
+    elif isinstance(format, str) and format == "json" and not stream:
+        api_params["format"] = "json"
+
     for key, value in kwargs.items():
         if key in [
-            "stop",
-            "temperature",
-            "top_p",
+            "stop", 
+            "temperature", 
+            "top_p", 
             "max_tokens",
             "max_completion_tokens",
-            "tools",
-            "tool_choice",
-            "extra_headers",
+            "extra_headers", 
             "parallel_tool_calls",
             "response_format",
             "user",
         ]:
             options[key] = value
-    
 
-    # Handle formatting
-    if isinstance(format, type) and not stream:
-        schema = format.model_json_schema()
-        api_params["format"] = schema
-    elif isinstance(format, str) and format == "json" and not stream:
-        api_params["format"] = "json"
-    
-    # Create standardized response structure
     result = {
         "response": None,
         "messages": messages.copy(),
         "raw_response": None,
-        "tool_calls": []
+        "tool_calls": [], 
+        "tool_results": []
     }
+
+    
+
+    
+    if not auto_process_tool_calls or not (tools and tool_map):
+        res = ollama.chat(**api_params, options=options)
+        result["raw_response"] = res
+        
+        if stream:
+            result["response"] = res  
+            return result
+        else:
+            
+            message = res.get("message", {})
+            response_content = message.get("content", "")
+            result["response"] = response_content
+            result["messages"].append({"role": "assistant", "content": response_content})
+            
+            if message.get('tool_calls'):
+                result["tool_calls"] = message['tool_calls']
+            
+            
+            if format == "json":
+                try:
+                    if isinstance(response_content, str):
+                        if response_content.startswith("```json"):
+                            response_content = (
+                                response_content.replace("```json", "")
+                                .replace("```", "")
+                                .strip()
+                            )
+                        parsed_response = json.loads(response_content)
+                        result["response"] = parsed_response
+                except json.JSONDecodeError:
+                    result["error"] = f"Invalid JSON response: {response_content}"
+            
+            return result
+
     
-    # Handle streaming
-    if stream:
-        result["response"] = ollama.chat(**api_params, options=options)
-        return result
     
-    # Non-streaming case
-    res = ollama.chat(**api_params, options = options)
+    res = ollama.chat(**api_params, options=options)
     result["raw_response"] = res
     
-    # Extract the response content
-    response_content = res.get("message", {}).get("content")
-    result["response"] = response_content
     
-    # Handle tool calls if tools were provided
-    if tools and "tool_calls" in res.get("message", {}):
-        result["tool_calls"] = res["message"]["tool_calls"]
     
-    # Append response to messages
-    result["messages"].append({"role": "assistant", "content": response_content})
+    message = res.get("message", {})
+    response_content = message.get("content", "")
     
-    # Handle JSON format if specified
-    if format == "json":
-        try:
-            if isinstance(response_content, str):
-                if response_content.startswith("```json"):
-                    response_content = (
-                        response_content.replace("```json", "")
-                        .replace("```", "")
-                        .strip()
-                    )
-                parsed_response = json.loads(response_content)
-                result["response"] = parsed_response
-        except json.JSONDecodeError:
-            result["error"] = f"Invalid JSON response: {response_content}"
     
-    return result
+    if message.get('tool_calls'):
+
+        
+        result["tool_calls"] = message['tool_calls']
+        
+        response_for_processing = {
+            "response": response_content,
+            "raw_response": res,
+            "messages": messages,
+            "tool_calls": message['tool_calls']
+        }
+        
+        
+        processed_result = process_tool_calls(response_for_processing, 
+                                              tool_map, model, 
+                                              'ollama', 
+                                              messages, 
+                                              stream=False)
+        
+        
+        if stream:
+
+            
+            
+            final_messages = processed_result["messages"]
+            
+            
+            final_api_params = {
+                "model": model,
+                "messages": final_messages,
+                "stream": True,
+            }
+            
+            if tools:
+                final_api_params["tools"] = tools
+            
+            final_stream = ollama.chat(**final_api_params, options=options)
+            processed_result["response"] = final_stream
+            
+        return processed_result
+    
+    
+    else:
+        result["response"] = response_content
+        result["messages"].append({"role": "assistant", "content": response_content})
+        
+        if stream:
+            
+            stream_api_params = {
+                "model": model,
+                "messages": messages,
+                "stream": True,
+            }
+            if tools:
+                stream_api_params["tools"] = tools
+            
+            result["response"] = ollama.chat(**stream_api_params, options=options)
+        else:
+                        
+            if format == "json":
+                try:
+                    if isinstance(llm_response, str):
+                        llm_response = llm_response.strip()
+                        
+                        if '```json' in llm_response:
+                            start = llm_response.find('```json') + 7
+                            end = llm_response.rfind('```')
+                            if end > start:
+                                llm_response = llm_response[start:end].strip()
+                        
+                        first_brace = llm_response.find('{')
+                        first_bracket = llm_response.find('[')
+                        
+                        if first_brace == -1 and first_bracket == -1:
+                            result["response"] = {}
+                            result["error"] = "No JSON found in response"
+                            return result
+                        
+                        if first_brace != -1 and (first_bracket == -1 or first_brace < first_bracket):
+                            llm_response = llm_response[first_brace:]
+                            last_brace = llm_response.rfind('}')
+                            if last_brace != -1:
+                                llm_response = llm_response[:last_brace+1]
+                        else:
+                            llm_response = llm_response[first_bracket:]
+                            last_bracket = llm_response.rfind(']')
+                            if last_bracket != -1:
+                                llm_response = llm_response[:last_bracket+1]
+                        
+                        parsed_json = json.loads(llm_response, strict=False)
+                        
+                        if "json" in parsed_json:
+                            result["response"] = parsed_json["json"]
+                        else:
+                            result["response"] = parsed_json
+                        
+                except (json.JSONDecodeError, TypeError) as e:
+                    print(f"JSON parsing error: {str(e)}")
+                    print(f"Raw response: {llm_response[:500]}")
+                    result["response"] = {}
+                    result["error"] = "Invalid JSON response"
+
+        return result
+    
+import time 
+
 
 def get_litellm_response(
     prompt: str = None,
@@ -250,41 +435,108 @@ def get_litellm_response(
     tools: list = None,
     tool_choice: Dict = None,
     tool_map: Dict = None,
+    think= None,
     format: Union[str, BaseModel] = None,
     messages: List[Dict[str, str]] = None,
     api_key: str = None,
     api_url: str = None,
     stream: bool = False,
     attachments: List[str] = None,
+    auto_process_tool_calls: bool = False, 
+    include_usage: bool = False,
     **kwargs,
 ) -> Dict[str, Any]:
-    """
-    Unified function for generating responses using litellm, supporting both streaming and non-streaming.
-    """
-    # Create standardized response structure
     result = {
         "response": None,
         "messages": messages.copy() if messages else [],
         "raw_response": None,
-        "tool_calls": []
+        "tool_calls": [], 
+        "tool_results":[],
     }
-    
-    # Handle Ollama separately
-    if provider == "ollama":
+    if provider == "ollama" and 'gpt-oss' not in model:
         return get_ollama_response(
             prompt, 
             model, 
-            images=images,
+            images=images, 
             tools=tools, 
-            tool_choice=tool_choice,
+            tool_choice=tool_choice, 
+            tool_map=tool_map,
+            think=think,
             format=format, 
             messages=messages, 
             stream=stream, 
-            attachments=attachments,
+            attachments=attachments, 
+            auto_process_tool_calls=auto_process_tool_calls, 
             **kwargs
         )
+    elif provider=='transformers':
+        return get_transformers_response(
+            prompt, 
+            model, 
+            images=images, 
+            tools=tools, 
+            tool_choice=tool_choice, 
+            tool_map=tool_map,
+            think=think,
+            format=format, 
+            messages=messages, 
+            stream=stream, 
+            attachments=attachments, 
+            auto_process_tool_calls=auto_process_tool_calls, 
+            **kwargs
+
+        )
     
-    # Handle JSON format instructions
+
+    if attachments:
+        for attachment in attachments:
+            if os.path.exists(attachment):
+                _, ext = os.path.splitext(attachment)
+                ext = ext.lower()
+                
+                if ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp']:
+                    if not images:
+                        images = []
+                    images.append(attachment)
+                elif ext == '.pdf':
+                    try:
+                        from npcpy.data.load import load_pdf
+                        pdf_data = load_pdf(attachment)
+                        if pdf_data is not None:
+                            if prompt:
+                                prompt += f"\n\nContent from PDF: {os.path.basename(attachment)}\n{pdf_data}..."
+                            else:
+                                prompt = f"Content from PDF: {os.path.basename(attachment)}\n{pdf_data}..."
+
+                    except Exception:
+                        pass
+                elif ext == '.csv':
+                    try:
+                        from npcpy.data.load import load_csv
+                        csv_data = load_csv(attachment)
+                        if csv_data is not None:
+                            csv_sample = csv_data.head(10).to_string()
+                            if prompt:
+                                prompt += f"\n\nContent from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
+                            else:
+                                prompt = f"Content from CSV: {os.path.basename(attachment)} (first 10 rows):\n{csv_sample}"
+                    except Exception:
+                        pass
+
+    if prompt:
+        if result['messages'] and result['messages'][-1]["role"] == "user":
+            if isinstance(messages[-1]["content"], str):
+                result['messages'][-1]["content"] = prompt
+            elif isinstance(result['messages'][-1]["content"], list):
+                for i, item in enumerate(result['messages'][-1]["content"]):
+                    if item.get("type") == "text":
+                        result['messages'][-1]["content"][i]["text"] = prompt
+                        break
+                else:
+                    result['messages'][-1]["content"].append({"type": "text", "text": prompt})
+        else:
+            result['messages'].append({"role": "user", "content": prompt})
+
     if format == "json" and not stream:
         json_instruction = """If you are a returning a json object, begin directly with the opening {.
             If you are returning a json array, begin directly with the opening [.
@@ -294,350 +546,298 @@ def get_litellm_response(
             
         if result["messages"] and result["messages"][-1]["role"] == "user":
             if isinstance(result["messages"][-1]["content"], list):
-                result["messages"][-1]["content"].append({
-                    "type": "text", 
-                    "text": json_instruction
-                })
+                result["messages"][-1]["content"].append({"type": "text", "text": json_instruction})
             elif isinstance(result["messages"][-1]["content"], str):
                 result["messages"][-1]["content"] += "\n" + json_instruction
-    
-    # Handle images
+
     if images:
-        last_user_idx = None
+        last_user_idx = -1
         for i, msg in enumerate(result["messages"]):
             if msg["role"] == "user":
                 last_user_idx = i
-        
-        if last_user_idx is None:
+        if last_user_idx == -1:
             result["messages"].append({"role": "user", "content": []})
             last_user_idx = len(result["messages"]) - 1
-        
         if isinstance(result["messages"][last_user_idx]["content"], str):
-            result["messages"][last_user_idx]["content"] = [
-                {"type": "text", "text": result["messages"][last_user_idx]["content"]}
-            ]
+            
+            result["messages"][last_user_idx]["content"] = [{"type": "text", 
+                                                             "text": result["messages"][last_user_idx]["content"]
+                                                             }]
+
         elif not isinstance(result["messages"][last_user_idx]["content"], list):
             result["messages"][last_user_idx]["content"] = []
-        
         for image_path in images:
             with open(image_path, "rb") as image_file:
                 image_data = base64.b64encode(compress_image(image_file.read())).decode("utf-8")
                 result["messages"][last_user_idx]["content"].append(
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
-                    }
+                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_data}"}}
                 )
+
+
     
-    # Prepare API parameters
-    api_params = {
-        "messages": result["messages"],
-    }
-    
-    # Handle provider, model, and API settings
-    if api_url is not None and provider == "openai-like":
+
+    api_params = {"messages": result["messages"]}
+
+    if include_usage:
+      litellm.include_cost_in_streaming_usage = True
+      api_params['stream_options'] = {"include_usage": True}
+
+    if api_url is not None and ('openai-like' in provider or provider == "openai-like" or provider == "openai"):
         api_params["api_base"] = api_url
         provider = "openai"
     
-    if format == "json" and not stream:
-        api_params["response_format"] = {"type": "json_object"}
-    elif isinstance(format, BaseModel):
+    
+    if provider =='enpisi' and api_url is None:
+        api_params['api_base'] = 'https://api.enpisi.com'
+        if api_key is None:
+            api_key = os.environ.get('NPC_STUDIO_LICENSE_KEY')
+            api_params['api_key'] = api_key
+        if '-npc' in model: 
+            model = model.split('-npc')[0]
+        provider = "openai"
+
+    if isinstance(format, BaseModel):
         api_params["response_format"] = format
     if model is None:
-        print('model not provided, using defaults')
         model = os.environ.get("NPCSH_CHAT_MODEL", "llama3.2")
     if provider is None:
-        provider = os.environ.get("NPCSH_CHAT_PROVIDER", "openai")
+        provider = os.environ.get("NPCSH_CHAT_PROVIDER")
 
-    if "/" not in model:
-        model_str = f"{provider}/{model}"
-    else:
-        model_str = model
-    
-    api_params["model"] = model_str
-    
-    if api_key is not None:
+    api_params["model"] = f"{provider}/{model}" if "/" not in model else model
+    if api_key is not None: 
         api_params["api_key"] = api_key
-    
-    # Add tools if provided
-    if tools:
+    if tools: 
         api_params["tools"] = tools
-    
-    # Add tool choice if specified
-    if tool_choice:
+    if tool_choice: 
         api_params["tool_choice"] = tool_choice
     
-    # Add additional parameters
     if kwargs:
         for key, value in kwargs.items():
             if key in [
-                "stop",
-                "temperature",
-                "top_p",
-                "max_tokens",
-                "max_completion_tokens",
-                "tools",
-                "tool_choice",
-                "extra_headers",
-                "parallel_tool_calls",
-                "response_format",
-                "user",
+                "stop", "temperature", "top_p", "max_tokens", "max_completion_tokens",
+                 "extra_headers", "parallel_tool_calls",
+                "response_format", "user",
             ]:
                 api_params[key] = value
-    
 
-    # Handle streaming
-    if stream:
-        #print('streaming response')
-        if format == "json":
-            print('streaming json output')
-            result["response"] = handle_streaming_json(api_params)
-        elif tools:
-            # do a call to get tool choice
-            result["response"] = completion(**api_params, stream=False)
-            result = process_tool_calls(result, tool_map, model, provider, messages, stream=True)
-            
+    if not auto_process_tool_calls or not (tools and tool_map):
+        api_params["stream"] = stream
+        resp = completion(**api_params)
+        result["raw_response"] = resp
+        
+        if stream:
+            result["response"] = resp  
+            return result
         else:
-
-            result["response"] = completion(**api_params, stream=True)
             
-        return result
+            llm_response = resp.choices[0].message.content
+            result["response"] = llm_response
+            result["messages"].append({"role": "assistant", 
+                                       "content": llm_response})
+            
+            
+            if hasattr(resp.choices[0].message, 'tool_calls') and resp.choices[0].message.tool_calls:
+                result["tool_calls"] = resp.choices[0].message.tool_calls
+            if format == "json":
+                try:
+                    if isinstance(llm_response, str):
+                        llm_response = llm_response.strip()
+                        
+                        if '```json' in llm_response:
+                            start = llm_response.find('```json') + 7
+                            end = llm_response.rfind('```')
+                            if end > start:
+                                llm_response = llm_response[start:end].strip()
+                        
+                        first_brace = llm_response.find('{')
+                        first_bracket = llm_response.find('[')
+                        
+                        if first_brace == -1 and first_bracket == -1:
+                            result["response"] = {}
+                            result["error"] = "No JSON found in response"
+                            return result
+                        
+                        if first_brace != -1 and (first_bracket == -1 or first_brace < first_bracket):
+                            llm_response = llm_response[first_brace:]
+                            last_brace = llm_response.rfind('}')
+                            if last_brace != -1:
+                                llm_response = llm_response[:last_brace+1]
+                        else:
+                            llm_response = llm_response[first_bracket:]
+                            last_bracket = llm_response.rfind(']')
+                            if last_bracket != -1:
+                                llm_response = llm_response[:last_bracket+1]
+                        
+                        parsed_json = json.loads(llm_response, strict=False)
+                        
+                        if "json" in parsed_json:
+                            result["response"] = parsed_json["json"]
+                        else:
+                            result["response"] = parsed_json
+                        
+                except (json.JSONDecodeError, TypeError) as e:
+                    print(f"JSON parsing error: {str(e)}")
+                    print(f"Raw response: {llm_response[:500]}")
+                    result["response"] = {}
+                    result["error"] = "Invalid JSON response"
+            
+            return result
+
     
-    # Non-streaming case
     
-    resp = completion(**api_params)
-    result["raw_response"] = resp
+    initial_api_params = api_params.copy()
+    initial_api_params["stream"] = False
     
-    # Extract response content
-    llm_response = resp.choices[0].message.content
-    result["response"] = llm_response
     
-    # Extract tool calls if any
-    if hasattr(resp.choices[0].message, 'tool_calls') and resp.choices[0].message.tool_calls:
-        result["tool_calls"] = resp.choices[0].message.tool_calls
+    resp = completion(**initial_api_params)
+    result["raw_response"] = resp
     
-    # Handle JSON format requests
-    if format == "json":
-        try:
-            if isinstance(llm_response, str):
-                # Clean up JSON response if needed
-                if llm_response.startswith("```json"):
-                    llm_response = llm_response.replace("```json", "").replace("```", "").strip()
-                parsed_json = json.loads(llm_response)
-                
-                if "json" in parsed_json:
-                    result["response"] = parsed_json["json"]
-                else:
-                    result["response"] = parsed_json
-                
-        except (json.JSONDecodeError, TypeError) as e:
-            print(f"JSON parsing error: {str(e)}")
-            print(f"Raw response: {llm_response}")
-            result["error"] = "Invalid JSON response"
-    
-    # Add assistant response to message history
-    result["messages"].append(
-        {
-            "role": "assistant",
-            "content": (
-                llm_response if isinstance(llm_response, str) else str(llm_response)
-            ),
-        }
-    )
     
-    return result
+    has_tool_calls = hasattr(resp.choices[0].message, 'tool_calls') and resp.choices[0].message.tool_calls
+    
+    if has_tool_calls:
 
+        
+        result["tool_calls"] = resp.choices[0].message.tool_calls
+        
+        
+        processed_result = process_tool_calls(result, 
+                                              tool_map, 
+                                              model, 
+                                              provider, 
+                                              result["messages"], 
+                                              stream=False)
+        
+        
+        if stream:
 
-def handle_streaming_json(api_params):
-    """
-    Handles streaming responses when JSON format is requested.
-    """
-    json_buffer = ""
-    stream = completion(**api_params)
-    
-    for chunk in stream:
-        content = chunk.choices[0].delta.content
-        if content:
-            json_buffer += content
-            # Try to parse as valid JSON but only yield once we have complete JSON
-            try:
-                # Check if we have a complete JSON object
-                json.loads(json_buffer)
-                # If successful, yield the chunk
-                yield chunk
-            except json.JSONDecodeError:
-                # Not complete JSON yet, continue buffering
-                pass
-    
-    # After the stream ends, try to ensure we have valid JSON
-    try:
-        final_json = json.loads(json_buffer)
-        # Could yield a special "completion" chunk here if needed
-    except json.JSONDecodeError:
-        # Handle case where stream ended but JSON is invalid
-        print(f"Warning: Complete stream did not produce valid JSON: {json_buffer}")
+            
+
+            clean_messages = []
+            for msg in processed_result["messages"]:
+                if msg.get('role') == 'assistant' and 'tool_calls' in msg:
+                    continue  
+                                
+                else:
+                    clean_messages.append(msg)
+            
+            final_api_params = api_params.copy()
+            final_api_params["messages"] = clean_messages
+            final_api_params["stream"] = True
 
 
+            final_api_params = api_params.copy()
+            final_api_params["messages"] = clean_messages
+            final_api_params["stream"] = True
+            if "tools" in final_api_params:
+                del final_api_params["tools"]
+            if "tool_choice" in final_api_params:
+                del final_api_params["tool_choice"]
 
-def process_tool_calls(response_dict, tool_map, model, provider, messages, stream=False):
-    """
-    Process tool calls from a response and execute corresponding tools.
-    
-    Args:
-        response_dict (dict): The response dictionary from get_litellm_response or get_ollama_response
-        tool_map (dict): Mapping of tool names to their implementation functions
-        model (str): The model to use for follow-up responses
-        provider (str): The provider to use for follow-up responses
-        messages (list): The current message history
-        stream (bool): Whether to stream the response
+            final_stream = completion(**final_api_params)
+
+            
+            final_stream = completion(**final_api_params)
+            processed_result["response"] = final_stream
+            
+        return processed_result
         
-    Returns:
-        dict: Updated response dictionary with tool results and final response
-    """
-    
+        
+    else:
+        llm_response = resp.choices[0].message.content
+        result["messages"].append({"role": "assistant", "content": llm_response})
+        
+        if stream:
+            def string_chunk_generator():
+                chunk_size = 1
+                for i, char in enumerate(llm_response):
+                    yield type('MockChunk', (), {
+                        'id': f'mock-chunk-{i}',
+                        'object': 'chat.completion.chunk',
+                        'created': int(time.time()),
+                        'model': model or 'unknown',
+                        'choices': [type('Choice', (), {
+                            'index': 0,
+                            'delta': type('Delta', (), {
+                                'content': char,
+                                'role': 'assistant' if i == 0 else None
+                            })(),
+                            'finish_reason': 'stop' if i == len(llm_response) - 1 else None
+                        })()]
+                    })()
+            
+            result["response"] = string_chunk_generator()
+        else:
+            result["response"] = llm_response
+    return result            
+def process_tool_calls(response_dict, tool_map, model, provider, messages, stream=False):
     result = response_dict.copy()
     result["tool_results"] = []
-    #print(tool_map)
     
-    # Make sure messages is initialized
     if "messages" not in result:
         result["messages"] = messages if messages else []
     
-    # Extract tool calls from the response
-    if "response" in result:
-        if hasattr(result["response"], "choices") and hasattr(result["response"].choices[0], "message"):
-            tool_calls = result["response"].choices[0].message.tool_calls
-        elif isinstance(result["response"], dict) and "tool_calls" in result["response"]:
-            tool_calls = result["response"]["tool_calls"]
-        else:
-            tool_calls = None
-    else:
-        tool_calls = None
+    tool_calls = result.get("tool_calls", [])
     
-    if tool_calls is not None:
-        for tool_call in tool_calls:
-            
-            # Extract tool details - handle both Ollama and LiteLLM formats
-            if isinstance(tool_call, dict):  # Ollama format
-                tool_id = tool_call.get("id", str(uuid.uuid4()))
-                tool_name = tool_call.get("function", {}).get("name")
-                arguments_str = tool_call.get("function", {}).get("arguments", "{}")
-            else:  # LiteLLM format - expect object with attributes
-                tool_id = getattr(tool_call, "id", str(uuid.uuid4()))
-                # Handle function as either attribute or dict
-                if hasattr(tool_call, "function"):
-                    if isinstance(tool_call.function, dict):
-                        tool_name = tool_call.function.get("name")
-                        arguments_str = tool_call.function.get("arguments", "{}")
-                    else:
-                        tool_name = getattr(tool_call.function, "name", None)
-                        arguments_str = getattr(tool_call.function, "arguments", "{}")
-                else:
-                    raise ValueError("Jinx call missing function attribute or property")
-            
-            # Parse arguments
-            if not arguments_str:
-                arguments = {}
-            else:
-                try:
-                    arguments = json.loads(arguments_str) if isinstance(arguments_str, str) else arguments_str
-                except json.JSONDecodeError:
-                    arguments = {"raw_arguments": arguments_str}
+    if not tool_calls:
+        return result
+    
+    for tool_call in tool_calls:
+        tool_id = str(uuid.uuid4())
+        tool_name = None
+        arguments = {}
+        
 
-            render_markdown('# tool_call \n - '+ tool_name + '\n - ' + str(arguments))
+        if isinstance(tool_call, dict):
+            tool_id = tool_call.get("id", str(uuid.uuid4()))
+            tool_name = tool_call.get("function", {}).get("name")
+            arguments_str = tool_call.get("function", {}).get("arguments", "{}")
+        else:
+            tool_id = getattr(tool_call, "id", str(uuid.uuid4()))
+            if hasattr(tool_call, "function"):
+                func_obj = tool_call.function
+                tool_name = getattr(func_obj, "name", None)
+                arguments_str = getattr(func_obj, "arguments", "{}")
+            else:
+                continue
 
-            
-            # Execute the tool if it exists in the tool map
-            if tool_name in tool_map:
-                try:
-                    # Try calling with keyword arguments first
-                    tool_result = tool_map[tool_name](**arguments)
-                except TypeError:
-                    # If that fails, try calling with the arguments as a single parameter
-                    tool_result = tool_map[tool_name](arguments)
-                # Convert tool result to a serializable format
-                serializable_result = None
-                tool_result_str = ""
-                
-                try:
-                    # Check if it's TextContent or similar with .text attribute
-                    if hasattr(tool_result, 'content') and isinstance(tool_result.content, list):
-                        content_list = tool_result.content
-                        text_parts = []
-                        for item in content_list:
-                            if hasattr(item, 'text'):
-                                text_parts.append(item.text)
-                        tool_result_str = " ".join(text_parts)
-                        serializable_result = {"text": tool_result_str}
-                    # Handle other common types
-                    elif hasattr(tool_result, 'model_dump'):
-                        serializable_result = tool_result.model_dump()
-                        tool_result_str = str(serializable_result)
-                    elif hasattr(tool_result, 'to_dict'):
-                        serializable_result = tool_result.to_dict()
-                        tool_result_str = str(serializable_result)
-                    elif hasattr(tool_result, '__dict__'):
-                        serializable_result = tool_result.__dict__
-                        tool_result_str = str(serializable_result)
-                    elif isinstance(tool_result, (dict, list)):
-                        serializable_result = tool_result
-                        tool_result_str = json.dumps(tool_result)
-                    else:
-                        # Fall back to string representation
-                        tool_result_str = str(tool_result)
-                        serializable_result = {"text": tool_result_str}
-                except Exception as e:
-                    tool_result_str = f"Error serializing result: {str(e)}"
-                    serializable_result = {"error": tool_result_str}
-                
-                # Store the serializable result
-                result["tool_results"].append({
-                    "tool_call_id": tool_id,
-                    "tool_name": tool_name,
-                    "arguments": arguments,
-                    "result": serializable_result
-                })
-                
-                # Add the tool call message
-                result["messages"].append({
-                    "role": "assistant",
-                    "content": None,
-                    "tool_calls": [
-                        {
-                            "id": tool_id,
-                            "type": "function",
-                            "function": {
-                                "name": tool_name,
-                                "arguments": json.dumps(arguments)
-                            }
-                        }
-                    ]
-                })
-                
-                # Add the tool response message with string content
-                result["messages"].append({
-                    "role": "tool",
-                    "tool_call_id": tool_id,
-                    "content": tool_result_str
-                })
-        
-        # Follow up with a request to the LLM
-        follow_up_prompt = "Based on the tool results, please provide a helpful response."
+        try:
+            arguments = json.loads(arguments_str) if isinstance(arguments_str, str) else arguments_str
+        except json.JSONDecodeError:
+            arguments = {"raw_arguments": arguments_str}
         
-        # Get follow-up response
-        follow_up_response = get_litellm_response(
-            prompt=follow_up_prompt,
-            model=model,
-            provider=provider,
-            messages=result["messages"],
-            stream=stream,
-        )
         
-        # Update the result
-        if isinstance(follow_up_response, dict):
-            if "response" in follow_up_response:
-                result["response"] = follow_up_response["response"]
-            if "messages" in follow_up_response:
-                result["messages"] = follow_up_response["messages"]
+        if tool_name in tool_map:
+            tool_result = None
+            tool_result_str = ""
+            serializable_result = None
+
+            try:
+                tool_result = tool_map[tool_name](**arguments)
+            except Exception as e:
+                tool_result = f"Error executing tool '{tool_name}': {str(e)}. Tool map is : {tool_map}"
+
+            try:
+                tool_result_str = json.dumps(tool_result, default=str)
+                try:
+                    serializable_result = json.loads(tool_result_str)
+                except json.JSONDecodeError:
+                    serializable_result = {"result": tool_result_str}
+            except Exception as e_serialize:
+                tool_result_str = f"Error serializing result for {tool_name}: {str(e_serialize)}"
+                serializable_result = {"error": tool_result_str}
+            
+            result["tool_results"].append({
+                "tool_call_id": tool_id,
+                "tool_name": tool_name,
+                "arguments": arguments,
+                "result": serializable_result
+            })
+            
+            
+            result["messages"].append({
+                "role": "assistant",
+                "content": f'The results of the tool call for {tool_name} with {arguments} are as follows:' +tool_result_str
+            })
     
     return result