npcpy 1.2.31__tar.gz → 1.2.32__tar.gz

{npcpy-1.2.31/npcpy.egg-info → npcpy-1.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.31
+Version: 1.2.32
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.31 → npcpy-1.2.32}/npcpy/gen/response.py

@@ -378,21 +378,50 @@ def get_ollama_response(
             
             result["response"] = ollama.chat(**stream_api_params, options=options)
         else:
-            
+                        
             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}"
-        
+                    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 
@@ -553,7 +582,7 @@ def get_litellm_response(
       litellm.include_cost_in_streaming_usage = True
       api_params['stream_options'] = {"include_usage": True}
 
-    if api_url is not None and (provider == "openai-like" or provider == "openai"):
+    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"
     
@@ -609,14 +638,37 @@ def get_litellm_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):
-                        if llm_response.startswith("```json"):
-                            llm_response = llm_response.replace("```json", "").replace("```", "").strip()
-                        parsed_json = json.loads(llm_response)
+                        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"]
@@ -625,7 +677,8 @@ def get_litellm_response(
                         
                 except (json.JSONDecodeError, TypeError) as e:
                     print(f"JSON parsing error: {str(e)}")
-                    print(f"Raw response: {llm_response}")
+                    print(f"Raw response: {llm_response[:500]}")
+                    result["response"] = {}
                     result["error"] = "Invalid JSON response"
             
             return result

{npcpy-1.2.31 → npcpy-1.2.32}/npcpy/llm_funcs.py

@@ -594,7 +594,7 @@ def handle_jinx_call(
             render_markdown(f""" ## jinx OUTPUT FROM CALLING {jinx_name} \n \n output:{jinx_output['output']}""" )            
             response = get_llm_response(f"""
                 The user had the following request: {command}. 
-                Here were the jinx outputs from calling {jinx_name}: {jinx_output}
+                Here were the jinx outputs from calling {jinx_name}: {jinx_output.get('output', '')}
                 
                 Given the jinx outputs and the user request, please format a simple answer that 
                 provides the answer without requiring the user to carry out any further steps.

{npcpy-1.2.31 → npcpy-1.2.32}/npcpy/npc_sysenv.py

@@ -144,7 +144,7 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                 
                 models = fetch_custom_models()
                 for model in models:
-                    available_models[model] = provider_name
+                    available_models[model] = 'openai-like'
                     
                 logging.info(
                     f"Loaded {len(models)} models "
@@ -157,32 +157,56 @@ def get_locally_available_models(project_directory, airplane_mode=False):
                     f"custom provider '{provider_name}': {e}"
                 )
     
-
+    
     airplane_mode = False
     if not airplane_mode:
         timeout_seconds = 3.5
         
 
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
-            if 'NPC_STUDIO_LICENSE_KEY' in env_vars or os.environ.get('NPC_STUDIO_LICENSE_KEY'):
-                try:
-                    def fetch_enpisi_models():
-                        import requests
-
-                        api_url = 'https://api.enpisi.com'
-                        headers = {
-                            'Authorization': f"Bearer {env_vars.get('NPC_STUDIO_LICENSE_KEY') or os.environ.get('NPC_STUDIO_LICENSE_KEY')}",
-                            'Content-Type': 'application/json'
-                        }
-                        response = requests.get(f"{api_url}/models", headers=headers)
-
-                        return [model['id'] for model in response.json().get('data','')]
-                    for model in fetch_enpisi_models():
-                        available_models[model+'-npc'] = 'enpisi'
-
-                except Exception as e:
-                    logging.error(f"Error fetching NPC Studio models: {e}")
+          
+            if 'NPCSH_API_URL' in env_vars or os.environ.get('NPCSH_API_URL'):
+              try:
+                  import requests
+                  
+                  def fetch_custom_models():
+                      base_url = env_vars.get('NPCSH_API_URL') or os.environ.get('NPCSH_API_URL')                      
+                      models_endpoint = f"{base_url.rstrip('/')}/models"
+                      response = requests.get(
+                          models_endpoint, 
+
+                          timeout=3.5
+                      )
+                      
+                      if response.status_code == 200:
+                          data = response.json()
+                          
+                          if isinstance(data, dict) and 'data' in data:
+                              return [
+                                  m['id'] for m in data['data'] 
+                                  if 'id' in m
+                              ]
+                          elif isinstance(data, list):
+                              return [
+                                  m['id'] for m in data 
+                                  if isinstance(m, dict) and 'id' in m
+                              ]
+                      return []
+                  
+                  models = fetch_custom_models()
+                  for model in models:
+                      available_models[model] = 'openai-like'
+                      
 
+                
+                  
+              except Exception as e:
+                  logging.warning(
+                      f"Failed to load models from "
+                      f"custom provider 'openai-like': {e}"
+                  )
+  
+            
             if "ANTHROPIC_API_KEY" in env_vars or os.environ.get("ANTHROPIC_API_KEY"):
                 try:
                     import anthropic

{npcpy-1.2.31 → npcpy-1.2.32}/npcpy/serve.py

@@ -2166,6 +2166,7 @@ def stream():
             model=model,
             provider=provider, 
             npc=npc_object, 
+            api_url = npc_object.api_url if npc_object.api_url else None,
             team=team_object,
             stream=True, 
             attachments=attachment_paths_for_llm,

{npcpy-1.2.31 → npcpy-1.2.32/npcpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: npcpy
-Version: 1.2.31
+Version: 1.2.32
 Summary: npcpy is the premier open-source library for integrating LLMs and Agents into python systems.
 Home-page: https://github.com/NPC-Worldwide/npcpy
 Author: Christopher Agostino

{npcpy-1.2.31 → npcpy-1.2.32}/setup.py

@@ -83,7 +83,7 @@ extra_files = package_files("npcpy/npc_team/")
 
 setup(
     name="npcpy",
-    version="1.2.31",
+    version="1.2.32",
     packages=find_packages(exclude=["tests*"]),
     install_requires=base_requirements,  
     extras_require={