npcsh 0.3.31__py3-none-any.whl → 0.3.32__py3-none-any.whl

npcsh/response.py

@@ -1,120 +1,28 @@
-from typing import Any, Dict, Generator, List, Union
-from pydantic import BaseModel
+import json
+import requests
+import base64
 import os
-import anthropic
-from openai import OpenAI
-from google.generativeai import types
-from google import genai
+from PIL import Image
+from typing import Any, Dict, Generator, List, Union
 
-import google.generativeai as genai
-from .npc_sysenv import (
+from pydantic import BaseModel
+from npcsh.npc_sysenv import (
     get_system_message,
     compress_image,
     available_chat_models,
     available_reasoning_models,
 )
 
-import json
-import requests
-import base64
-from PIL import Image
-
-
-def get_deepseek_response(
-    prompt: str,
-    model: str,
-    images: List[Dict[str, str]] = None,
-    npc: Any = None,
-    tools: list = None,
-    format: Union[str, BaseModel] = None,
-    messages: List[Dict[str, str]] = None,
-    api_key: str = None,
-    **kwargs,
-) -> Dict[str, Any]:
-    """
-    Function Description:
-        This function generates a response using the DeepSeek API.
-    Args:
-        prompt (str): The prompt for generating the response.
-        model (str): The model to use for generating the response.
-    Keyword Args:
-        images (List[Dict[str, str]]): The list of images.
-        npc (Any): The NPC object.
-        format (str): The format of the response.
-        messages (List[Dict[str, str]]): The list of messages.
-    Returns:
-        Any: The response generated by the DeepSeek API.
-
-
-    """
-    if api_key is None:
-        api_key = os.getenv("DEEPSEEK_API_KEY", None)
-    client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com")
-
-    # print(client)
-
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    if messages is None or len(messages) == 0:
-        messages = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": [{"type": "text", "text": prompt}]},
-        ]
-    if images:
-        for image in images:
-            # print(f"Image file exists: {os.path.exists(image['file_path'])}")
-
-            with open(image["file_path"], "rb") as image_file:
-                image_data = base64.b64encode(compress_image(image_file.read())).decode(
-                    "utf-8"
-                )
-                messages[-1]["content"].append(
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{image_data}",
-                        },
-                    }
-                )
-    # print(messages)
-    # print(model)
-    response_format = None if format == "json" else format
-    if response_format is None:
-        completion = client.chat.completions.create(model=model, messages=messages)
-        llm_response = completion.choices[0].message.content
-        items_to_return = {"response": llm_response}
-
-        items_to_return["messages"] = messages
-        # print(llm_response, model)
-        if format == "json":
-            try:
-                items_to_return["response"] = json.loads(llm_response)
+from litellm import completion
 
-                return items_to_return
-            except json.JSONDecodeError:
-                print(f"Warning: Expected JSON response, but received: {llm_response}")
-                return {"error": "Invalid JSON response"}
-        else:
-            items_to_return["messages"].append(
-                {"role": "assistant", "content": llm_response}
-            )
-            return items_to_return
+# import litellm
 
-    else:
-        if model in available_reasoning_models:
-            raise NotImplementedError("Reasoning models do not support JSON output.")
-        try:
-            completion = client.beta.chat.completions.parse(
-                model=model, messages=messages, response_format=response_format
-            )
-            items_to_return = {"response": completion.choices[0].message.parsed.dict()}
-            items_to_return["messages"] = messages
+# litellm._turn_on_debug()
 
-            items_to_return["messages"].append(
-                {"role": "assistant", "content": completion.choices[0].message.parsed}
-            )
-            return items_to_return
-        except Exception as e:
-            print("pydantic outputs not yet implemented with deepseek?")
+try:
+    import ollama
+except:
+    pass
 
 
 def get_ollama_response(
@@ -197,55 +105,46 @@ def get_ollama_response(
 
     return result
 
-    # except Exception as e:
-    #    return {"error": f"Exception occurred: {e}"}
 
-
-def get_openai_response(
+def get_litellm_response(
     prompt: str,
     model: str,
+    provider: str = None,
     images: List[Dict[str, str]] = None,
     npc: Any = None,
     tools: list = None,
     format: Union[str, BaseModel] = None,
-    api_key: str = None,
     messages: List[Dict[str, str]] = None,
+    api_key: str = None,
+    api_url: str = None,
+    tool_choice: Dict = None,
     **kwargs,
-):
+) -> Dict[str, Any]:
     """
-    Function Description:
-        This function generates a response using the OpenAI API.
-    Args:
-        prompt (str): The prompt for generating the response.
-        model (str): The model to use for generating the response.
-    Keyword Args:
-        images (List[Dict[str, str]]): The list of images.
-        npc (Any): The NPC object.
-        format (str): The format of the response.
-        api_key (str): The API key for accessing the OpenAI API.
-        messages (List[Dict[str, str]]): The list of messages.
-    Returns:
-        Any: The response generated by the OpenAI API.
+    Improved version with consistent JSON parsing
     """
-
-    # try:
-    if api_key is None:
-        api_key = os.environ.get("OPENAI_API_KEY", "")
-        if len(api_key) == 0:
-            raise ValueError("API key not found.")
-    client = OpenAI(api_key=api_key)
-    # print(npc)
+    if provider == "ollama":
+        return get_ollama_response(
+            prompt, model, images, npc, tools, format, messages, **kwargs
+        )
 
     system_message = get_system_message(npc) if npc else "You are a helpful assistant."
+    if format == "json":
+        prompt += """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 is None or len(messages) == 0:
         messages = [
             {"role": "system", "content": system_message},
             {"role": "user", "content": [{"type": "text", "text": prompt}]},
         ]
+
     if images:
         for image in images:
-            # print(f"Image file exists: {os.path.exists(image['file_path'])}")
-
             with open(image["file_path"], "rb") as image_file:
                 image_data = base64.b64encode(compress_image(image_file.read())).decode(
                     "utf-8"
@@ -253,371 +152,121 @@ def get_openai_response(
                 messages[-1]["content"].append(
                     {
                         "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{image_data}",
-                        },
+                        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
                     }
                 )
-    # print(model)
-    response_format = None if format == "json" else format
-    if response_format is None:
-        completion = client.chat.completions.create(model=model, messages=messages)
-        llm_response = completion.choices[0].message.content
-        items_to_return = {"response": llm_response}
-
-        items_to_return["messages"] = messages
-        # print(llm_response, model)
-        if format == "json":
-            if model in available_reasoning_models:
-                raise NotImplementedError(
-                    "Reasoning models do not support JSON output."
-                )
-            try:
-                if isinstance(llm_response, str):
-                    if llm_response.startswith("```json"):
-                        llm_response = (
-                            llm_response.replace("```json", "")
-                            .replace("```", "")
-                            .strip()
-                        )
-                    llm_response = json.loads(llm_response)
-                items_to_return["response"] = llm_response
-                return items_to_return
+    api_params = {
+        "messages": messages,
+    }
+    if provider is None:
+        split = model.split("/")
+        if len(split) == 2:
+            provider = split[0]
+        # if provider == "ollama":
+        # uncomment the two lines below once litellm works better with ollama
+        # litellm works better with ollama_chat
+        # api_params["api_base"] = "http://localhost:11434"
+        # provider = "ollama_chat"
+        api_params["format"] = format
+
+    # else:
+    if api_url is not None:
+        # the default api_url is for npcsh's NPCSH_API_URL
+        # for an openai-like provider.
+        # so the proviuder should only ever be openai-like
+        if provider == "openai-like":
+            api_params["api_base"] = api_url
 
-            except json.JSONDecodeError:
-                print(f"Warning: Expected JSON response, but received: {llm_response}")
-                return {"error": "Invalid JSON response"}
-        else:
-            items_to_return["messages"].append(
-                {"role": "assistant", "content": llm_response}
-            )
-            return items_to_return
+    if format == "json":
+        api_params["response_format"] = {"type": "json_object"}
+    elif format is not None:
+        # pydantic model
+        api_params["response_format"] = format
 
+    if "/" not in model:  # litellm expects provder/model so let ppl provide like that
+        model_str = f"{provider}/{model}"
     else:
-        completion = client.beta.chat.completions.parse(
-            model=model, messages=messages, response_format=response_format
-        )
-        items_to_return = {"response": completion.choices[0].message.parsed.dict()}
-        items_to_return["messages"] = messages
-
-        items_to_return["messages"].append(
-            {"role": "assistant", "content": completion.choices[0].message.parsed}
-        )
-        return items_to_return
-    # except Exception as e:
-    #    print("openai api key", api_key)
-    #    print(f"Error interacting with OpenAI: {e}")
-    #    return f"Error interacting with OpenAI: {e}"
-
-
-def get_anthropic_response(
-    prompt: str,
-    model: str,
-    images: List[Dict[str, str]] = None,
-    npc: Any = None,
-    tools: list = None,
-    format: str = None,
-    api_key: str = None,
-    messages: List[Dict[str, str]] = None,
-    **kwargs,
-):
-    """
-    Function Description:
-        This function generates a response using the Anthropic API.
-    Args:
-        prompt (str): The prompt for generating the response.
-        model (str): The model to use for generating the response.
-    Keyword Args:
-        images (List[Dict[str, str]]): The list of images.
-        npc (Any): The NPC object.
-        format (str): The format of the response.
-        api_key (str): The API key for accessing the Anthropic API.
-        messages (List[Dict[str, str]]): The list of messages.
-    Returns:
-        Any: The response generated by the Anthropic API.
-    """
+        model_str = model
+    api_params["model"] = model_str
+    if api_key is not None:
+        api_params["api_key"] = api_key
+    # Add tools if provided
+    if tools:
+        api_params["tools"] = tools
+    # Add tool choice if specified
+    if tool_choice:
+        api_params["tool_choice"] = tool_choice
+    if kwargs:
+        for key, value in kwargs.items():
+            # minimum parameter set for anthropic to work
+            if key in [
+                "stream",
+                "stop",
+                "temperature",
+                "top_p",
+                "max_tokens",
+                "max_completion_tokens",
+                "tools",
+                "tool_choice",
+                "extra_headers",
+                "parallel_tool_calls",
+                "response_format",
+                "user",
+            ]:
+                api_params[key] = value
 
     try:
-        if api_key is None:
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-        client = anthropic.Anthropic(api_key=api_key)
-
-        if messages[0]["role"] == "system":
-            system_message = messages[0]
-            messages = messages[1:]
-        elif npc is not None:
-            system_message = get_system_message(npc)
-
-        # Preprocess messages to ensure content is a list of dicts
-        for message in messages:
-            if isinstance(message["content"], str):
-                message["content"] = [{"type": "text", "text": message["content"]}]
-        # Add images if provided
-        if images:
-            for img in images:
-                with open(img["file_path"], "rb") as image_file:
-                    img["data"] = base64.b64encode(image_file.read()).decode("utf-8")
-                    img["media_type"] = "image/jpeg"
-                    messages[-1]["content"].append(
-                        {
-                            "type": "image",
-                            "source": {
-                                "type": "base64",
-                                "media_type": img["media_type"],
-                                "data": img["data"],
-                            },
-                        }
-                    )
+        # print(api_params)
+        # litellm completion appears to have some
+        # ollama issues, so will default to our
+        # custom implementation until we can revisit
+        # when its likely more better supported
+        resp = completion(
+            **api_params,
+        )
 
-        # Prepare API call parameters
+        # Get the raw response content
+        llm_response = resp.choices[0].message.content
 
-        api_params = {
-            "model": model,
+        # Prepare return dict
+        items_to_return = {
+            "response": llm_response,
             "messages": messages,
-            "max_tokens": kwargs.get("max_tokens", 8192),
-            "stream": False,
-            "system": system_message,
+            "raw_response": resp,  # Include the full response for debugging
         }
 
-        # Add tools if provided
-        if tools:
-            api_params["tools"] = tools
-
-        # Add tool choice if specified
-        if tool_choice:
-            api_params["tool_choice"] = tool_choice
-
-        # Make the API call
-        response = client.messages.create(**api_params)
-
-        llm_response = message.content[0].text
-        items_to_return = {"response": llm_response}
-        messages.append(
-            {"role": "assistant", "content": {"type": "text", "text": llm_response}}
-        )
-        items_to_return["messages"] = messages
-
-        # Handle JSON format if requested
+        # Handle JSON format requests
+        print(format)
         if format == "json":
             try:
                 if isinstance(llm_response, str):
-                    if llm_response.startswith("```json"):
-                        llm_response = (
-                            llm_response.replace("```json", "")
-                            .replace("```", "")
-                            .strip()
-                        )
-                    llm_response = json.loads(llm_response)
-                items_to_return["response"] = llm_response
+                    print("converting the json")
+                    loaded = json.loads(llm_response)
+                else:
+                    loaded = llm_response  # Assume it's already parsed
+                if "json" in loaded:
+                    items_to_return["response"] = loaded["json"]
+                else:
+                    items_to_return["response"] = loaded
+
+            except (json.JSONDecodeError, TypeError) as e:
+                print(f"JSON parsing error: {str(e)}")
+                print(f"Raw response: {llm_response}")
+                items_to_return["error"] = "Invalid JSON response"
                 return items_to_return
-            except json.JSONDecodeError:
-                print(f"Warning: Expected JSON response, but received: {llm_response}")
-                return {"response": llm_response, "error": "Invalid JSON response"}
-        else:
-            # only append to messages if the response is not json
-            messages.append({"role": "assistant", "content": llm_response})
-        # print("teststea")
-        return items_to_return
-
-    except Exception as e:
-        return f"Error interacting with Anthropic llm response: {e}"
-
-
-def get_openai_like_response(
-    prompt: str,
-    model: str,
-    api_url: str,
-    api_key: str = None,
-    npc: Any = None,
-    tools: list = None,
-    images: list = None,
-    messages: list = None,
-    format=None,
-    **kwargs,
-) -> Dict[str, Any]:
-    """
-    Function Description:
-        This function generates a response using  API.
-        penai-like
-    Args:
-        prompt (str): The prompt for generating the response.
-        model (str): The model to use for generating the response.
-    Keyword Args:
-        images (List[Dict[str, str]]): The list of images.
-        npc (Any): The NPC object.
-        format (str): The format of the response.
-        messages (List[Dict[str, str]]): The list of messages.
-    Returns:
-        Any: The response generated by the DeepSeek API.
-
-
-    """
-    if api_key is None:
-        api_key = "dummy_api_key"
-    client = OpenAI(api_key=api_key, base_url=api_url)
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    if messages is None or len(messages) == 0:
-        messages = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": [{"type": "text", "text": prompt}]},
-        ]
-    if images:
-        for image in images:
-            # print(f"Image file exists: {os.path.exists(image['file_path'])}")
-
-            with open(image["file_path"], "rb") as image_file:
-                image_data = base64.b64encode(compress_image(image_file.read())).decode(
-                    "utf-8"
-                )
-                messages[-1]["content"].append(
-                    {
-                        "type": "image_url",
-                        "image_url": {
-                            "url": f"data:image/jpeg;base64,{image_data}",
-                        },
-                    }
-                )
-
-    response_format = None if format == "json" else format
-    if response_format is None:
-        completion = client.chat.completions.create(model=model, messages=messages)
-        llm_response = completion.choices[0].message.content
-        items_to_return = {"response": llm_response}
-
-        items_to_return["messages"] = messages
-        # print(llm_response, model)
-        if format == "json":
-            if model in available_reasoning_models:
-                raise NotImplementedError(
-                    "Reasoning models do not support JSON output."
-                )
-            try:
-                if isinstance(llm_response, str):
-                    if llm_response.startswith("```json"):
-                        llm_response = (
-                            llm_response.replace("```json", "")
-                            .replace("```", "")
-                            .strip()
-                        )
-                    # print(llm_response)
-                    items_to_return["response"] = json.loads(llm_response)
-                return items_to_return
-            except json.JSONDecodeError:
-                print(f"Warning: Expected JSON response, but received: {llm_response}")
-                return {"error": "Invalid JSON response"}
-        else:
-            items_to_return["messages"].append(
-                {"role": "assistant", "content": llm_response}
-            )
-            return items_to_return
-
-    else:
-        if model in available_reasoning_models:
-            raise NotImplementedError("Reasoning models do not support JSON output.")
-
-        completion = client.beta.chat.completions.parse(
-            model=model, messages=messages, response_format=response_format
-        )
-
-        items_to_return = {"response": completion.choices[0].message.parsed.dict()}
-        items_to_return["messages"] = messages
 
+        # Add assistant response to message history
         items_to_return["messages"].append(
-            {"role": "assistant", "content": completion.choices[0].message.parsed}
-        )
-        return items_to_return
-
-
-def get_gemini_response(
-    prompt: str,
-    model: str,
-    images: List[Dict[str, str]] = None,
-    npc: Any = None,
-    tools: list = None,
-    format: Union[str, BaseModel] = None,
-    messages: List[Dict[str, str]] = None,
-    api_key: str = None,
-    **kwargs,
-) -> Dict[str, Any]:
-    """
-    Generates a response using the Gemini API.
-    """
-    # Configure the Gemini API
-    if api_key is None:
-        genai.configure(api_key=gemini_api_key)
-
-    # Prepare the system message
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-    model = genai.GenerativeModel(model, system_instruction=system_message)
-
-    # Extract just the content to send to the model
-    if messages is None or len(messages) == 0:
-        content_to_send = prompt
-    else:
-        # Get the latest message's content
-        latest_message = messages[-1]
-        content_to_send = (
-            latest_message["parts"][0]
-            if "parts" in latest_message
-            else latest_message.get("content", prompt)
+            {
+                "role": "assistant",
+                "content": (
+                    llm_response if isinstance(llm_response, str) else str(llm_response)
+                ),
+            }
         )
-    history = []
-    if messages:
-        for msg in messages:
-            if "content" in msg:
-                # Convert content to parts format
-                history.append({"role": msg["role"], "parts": [msg["content"]]})
-            else:
-                # Already in parts format
-                history.append(msg)
-    # If no history, create a new message list
-    if not history:
-        history = [{"role": "user", "parts": [prompt]}]
-    elif isinstance(prompt, str):  # Add new prompt to existing history
-        history.append({"role": "user", "parts": [prompt]})
-
-    # Handle images if provided
-    # Handle images by adding them to the last message's parts
-    if images:
-        for image in images:
-            with open(image["file_path"], "rb") as image_file:
-                img = Image.open(image_file)
-                history[-1]["parts"].append(img)
-    # Generate the response
-    # try:
-    # Send the entire conversation history to maintain context
-    response = model.generate_content(history)
-    llm_response = response.text
-
-    # Filter out empty parts
-    if isinstance(llm_response, list):
-        llm_response = " ".join([part for part in llm_response if part.strip()])
-    elif not llm_response.strip():
-        llm_response = ""
 
-    # Prepare the return dictionary
-    items_to_return = {"response": llm_response, "messages": history}
-    # print(llm_response, type(llm_response))
-
-    # Handle JSON format if specified
-    if format == "json":
-        if isinstance(llm_response, str):
-            if llm_response.startswith("```json"):
-                llm_response = (
-                    llm_response.replace("```json", "").replace("```", "").strip()
-                )
-
-        try:
-            items_to_return["response"] = json.loads(llm_response)
-        except json.JSONDecodeError:
-            print(f"Warning: Expected JSON response, but received: {llm_response}")
-            return {"error": "Invalid JSON response"}
-    else:
-        # Append the model's response to the messages
-        history.append({"role": "model", "parts": [llm_response]})
-        items_to_return["messages"] = history
-
-    return items_to_return
+        return items_to_return
 
-    # except Exception as e:
-    #    return {"error": f"Error generating response: {str(e)}"}
+    except Exception as e:
+        print(f"Error in get_litellm_response: {str(e)}")
+        return {"error": str(e), "messages": messages, "response": None}