sunholo 0.92.2__tar.gz → 0.92.3__tar.gz

{sunholo-0.92.2 → sunholo-0.92.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.92.2
+Version: 0.92.3
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.92.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.92.3.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.92.2 → sunholo-0.92.3}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-version = '0.92.2'
+version = '0.92.3'
 
 setup(
     name='sunholo',

{sunholo-0.92.2 → sunholo-0.92.3}/sunholo/agents/flask/vac_routes.py

@@ -9,7 +9,7 @@ from ...qna.parsers import parse_output
 from ...streaming import start_streaming_chat
 from ...archive import archive_qa
 from ...custom_logging import log
-from ...utils.config import load_config
+from ...utils import ConfigManager
 from ...utils.version import sunholo_version
 import os
 from ...gcs.add_file import add_file_to_gcs, handle_base64_image
@@ -178,7 +178,7 @@ if __name__ == "__main__":
         if span:
             generation = span.generation(
                 name="start_streaming_chat",
-                metadata=vac_config,
+                metadata=vac_config.configs_by_kind,
                 input = all_input,
                 completion_start_time=str(int(datetime.datetime.now().timestamp())),
                 model=vac_config.get("model") or vac_config.get("llm")
@@ -264,7 +264,7 @@ if __name__ == "__main__":
         trace = prep["trace"]
         span = prep["span"]
         command_response = prep["command_response"]
-        vac_config = prep["vac_config"]
+        vac_config: ConfigManager = prep["vac_config"]
         all_input = prep["all_input"]
 
         if command_response:
@@ -274,9 +274,9 @@ if __name__ == "__main__":
             if span:
                 generation = span.generation(
                     name="vac_interpreter",
-                    metadata=vac_config,
+                    metadata=vac_config.configs_by_kind,
                     input = all_input,
-                    model=vac_config.get("model") or vac_config.get("llm")
+                    model=vac_config.vacConfig("model") or vac_config.vacConfig("llm")
                 )
             bot_output = observed_vac_interpreter(
                 question=all_input["user_input"],
@@ -534,13 +534,14 @@ if __name__ == "__main__":
         trace = self.create_langfuse_trace(request, vector_name, trace_id)
         log.info(f"Using existing langfuse trace: {trace_id}")
         
-        config, _ = load_config("config/llm_config.yaml")
-        vac_configs = config.get("vac")
-        if vac_configs:
-            vac_config = vac_configs[vector_name]
+        #config, _ = load_config("config/llm_config.yaml")
+        try:
+            vac_config = ConfigManager(vector_name)
+        except Exception as e:
+            raise ValueError(f"Unable to find vac_config for {vector_name} - {str(e)}")
 
         if trace:
-            trace.update(input=data, metadata=vac_config)
+            trace.update(input=data, metadata=vac_config.configs_by_kind)
 
         user_input = data.pop('user_input').strip()
         stream_wait_time = data.pop('stream_wait_time', 7)
@@ -563,7 +564,7 @@ if __name__ == "__main__":
         if trace:
             span = trace.span(
                 name="VAC",
-                metadata=vac_config,
+                metadata=vac_config.configs_by_kind,
                 input = all_input
             )
         command_response = handle_special_commands(user_input, vector_name, paired_messages)

{sunholo-0.92.2 → sunholo-0.92.3}/sunholo/genai/process_funcs_cls.py

@@ -10,6 +10,7 @@ import json
 
 try:
     import google.generativeai as genai
+    import proto
 except ImportError:
     genai = None
 
@@ -75,6 +76,8 @@ class GenAIFunctionProcessor:
 
         This method should be overridden in subclasses to provide the specific
         function implementations required for the application.
+        
+        Note: All functions need arguments to avoid errors.
 
         Returns:
             dict: A dictionary where keys are function names and values are function objects
@@ -160,17 +163,24 @@ class GenAIFunctionProcessor:
             result = part[2]
 
             if func_name == function_name:
-                if isinstance(result, list) and target_value in result:
-                    log.info(f"Target value '{target_value}' found in the result of function '{function_name}'.")
-                    return True
-                elif isinstance(result, dict) and isinstance(target_value, dict):
-                    for key, expected_value in target_value.items():
-                        if key in result:
-                            if result[key] == expected_value:
-                                log.info(f"The key '{key}' has the same value in both dictionaries.")
-                                return True
+                # Try to decode the result if it's a string
+                if isinstance(result, str):
+                    try:
+                        result = json.loads(result)
+                    except json.JSONDecodeError:
+                        log.warning(f"Failed to decode JSON result for function {function_name}: {result}")
+                        continue  # Skip this result if decoding fails
+
+                normalized_target_value = {k: v for k, v in target_value.items()} if isinstance(target_value, dict) else target_value
+                log.info(f"{normalized_target_value=} {result=}") 
+
+                if isinstance(result, dict) and isinstance(normalized_target_value, dict):
+                    for key, expected_value in normalized_target_value.items():
+                        if key in result and result[key] == expected_value:
+                            log.info(f"The key '{key}' has the expected value in both dictionaries.")
+                            return True
                     return False
-                elif result == target_value:
+                elif result == normalized_target_value:
                     log.info(f"Target value '{target_value}' found in the result of function '{function_name}'.")
                     return True
 
@@ -227,16 +237,30 @@ class GenAIFunctionProcessor:
             if fn := part.function_call:
                 # Extract parameters for the function call
                 function_name = fn.name
-                params_obj = {key: val for key, val in fn.args.items()}
+                
+                # Handle empty parameters
+                if fn.args is None or not fn.args:
+                    params_obj = {}
+                else:
+                    params_obj = {key: val for key, val in fn.args.items()}
+
                 params = ', '.join(f'{key}={val}' for key, val in params_obj.items())
                 log.info(f"Executing {function_name} with params {params}")
 
                 # Check if the function is in our dictionary of available functions
                 if function_name in self.funcs:
+                    fn_exec = self.funcs[function_name]
                     try:
-                        # Execute the function with the provided parameters
-                        result = self.funcs[function_name](**params_obj)
-                        log.info(f"Got result from {function_name}: {result}")
+                        if not isinstance(fn_exec, genai.protos.FunctionDeclaration):
+                            # Execute the function with the provided parameters
+                            result = fn_exec(**params_obj)
+                            log.info(f"Got result from {function_name}: {result}")
+                        else:
+                            fn_result = type(fn).to_dict(fn)
+                            result = fn_result.get("result")
+                            if not result:
+                                log.warning("No result found for {function_name}")
+                            log.info(f"No execution of {function_name} as a FunctionDeclatation object, just returning args {result}")
                     except Exception as err:
                         error_message = f"Error in {function_name}: {str(err)}"
                         traceback_details = traceback.format_exc()
@@ -350,13 +374,13 @@ class GenAIFunctionProcessor:
         while guardrail < guardrail_max:
 
             callback.on_llm_new_token(
-                token=f"\n----Loop [{guardrail}] Start------\nFunctions:\n{self.funcs.keys()}\n"
+                token=f"\n----Loop [{guardrail}] Start------\nFunctions: {list(self.funcs.keys())}\n"
             )
 
             content_parse = ""
             for i, chunk in enumerate(content):
                 content_parse += f"\n - {i}) {chunk}"
-                content_parse += f"\n== End input content for loop [{guardrail}] =="
+            content_parse += f"\n== End input content for loop [{guardrail}] =="
 
             log.info(f"== Start input content for loop [{guardrail}]\n ## Content: {content_parse}")
             this_text = ""  # reset for this loop
@@ -367,7 +391,7 @@ class GenAIFunctionProcessor:
                 response = chat.send_message(content, stream=True)
                 
             except Exception as e:
-                msg = f"Error sending {content} to model: {str(e)}"
+                msg = f"Error sending {content} to model: {str(e)} - {traceback.format_exc()}"
                 log.info(msg)
                 callback.on_llm_new_token(token=msg)
                 break
@@ -421,6 +445,9 @@ class GenAIFunctionProcessor:
                     callback.on_llm_new_token(token=f"\n--- function calling: {fn_log} ...\n")
 
                     try:
+                            # Convert MapComposite to a standard Python dictionary
+                        if isinstance(fn_result, proto.marshal.collections.maps.MapComposite):
+                            fn_result = dict(fn_result)
                         fn_result_json = json.loads(fn_result)
                         if not isinstance(fn_result_json, dict):
                             log.warning(f"{fn_result} was loaded but is not a dictionary")
@@ -433,9 +460,15 @@ class GenAIFunctionProcessor:
                         fn_result_json = None
 
                     if fn == "decide_to_go_on":
-                        token = f"\n\n{'STOPPING' if not fn_result.get('go_on') else 'CONTINUE'}: {fn_result.get('chat_summary')}"
+                        log.info(f"{fn_result_json} {fn_result=} {type(fn_result)}")
+                        go_on_args = fn_result_json
+                        if go_on_args:
+                            token = f"\n\n{'STOPPING' if not go_on_args.get('go_on') else 'CONTINUE'}: {go_on_args.get('chat_summary')}"
+                        else:
+                            log.warning(f"{fn_result_json} did not work for decide_to_go_on")
+                            token = f"Error calling decide_to_go_on with {fn_result_json}\n"
                     else:
-                        token = f"--- function call result: {fn_log} ---"
+                        token = f"--- {fn} call result: \n"
                         if fn_result_json:
                             if fn_result_json.get('stdout'):
                                 text = fn_result_json.get('stdout').encode('utf-8').decode('unicode_escape')
@@ -444,9 +477,9 @@ class GenAIFunctionProcessor:
                                 text = fn_result_json.get('stdout').encode('utf-8').decode('unicode_escape')
                                 token += text
                             if not fn_result_json.get('stdout') and fn_result_json.get('stderr'):
-                                token += f" - result:\n{fn_result}\n"
+                                token += f"{fn_result}\n"
                         else:
-                            token += f" - result:\n{fn_result}\n"
+                            token += f"{fn_result}\n--- {fn} result end ---\n"
                     
                     big_text += token
                     this_text += token
@@ -479,11 +512,10 @@ class GenAIFunctionProcessor:
                 break
         
         usage_metadata["functions_called"] = functions_called
-        usage_metadata["function_results"] = function_results
+        #usage_metadata["function_results"] = function_results
 
         return big_text, usage_metadata
 
-    # needs to be static to avoid bound methods in function call
     @staticmethod
     def decide_to_go_on(go_on: bool, chat_summary: str) -> dict:
         """
@@ -503,4 +535,4 @@ class GenAIFunctionProcessor:
         Returns:
             boolean: True to carry on, False to continue
         """
-        return {"go_on": go_on, "chat_summary": chat_summary}
+        return json.dumps({"go_on": go_on, "chat_summary": chat_summary})

{sunholo-0.92.2 → sunholo-0.92.3}/sunholo/utils/config_class.py

@@ -26,6 +26,7 @@ class ConfigManager:
         agent = config.vacConfig("agent")
         ```
         """
+        print(f"Current working directory: {os.getcwd()}")
         if os.getenv("VAC_CONFIG_FOLDER") is None:
             print("WARNING: No VAC_CONFIG_FOLDER environment variable was specified")
         local_config_folder = os.path.join(os.getcwd(), "config")

{sunholo-0.92.2 → sunholo-0.92.3}/sunholo.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.92.2
+Version: 0.92.3
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.92.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.92.3.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0