sunholo 0.113.2__py3-none-any.whl → 0.114.1__py3-none-any.whl

sunholo/chunker/doc_handling.py

@@ -12,10 +12,14 @@ import tempfile
 import traceback
 import json
 import os
-from langchain.docstore.document import Document
-
-from langchain.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
+try:
+    from langchain.docstore.document import Document
+    from langchain.prompts import PromptTemplate
+    from langchain_core.output_parsers import StrOutputParser
+except ImportError:
+    Document = None
+    PromptTemplate = None
+    StrOutputParser = None
 
 def send_doc_to_docstore(docs, vector_name):
 
@@ -53,6 +57,9 @@ def send_doc_to_docstore(docs, vector_name):
 
 def create_big_doc(docs):
 
+    if not Document:
+        raise ImportError("Document object requires langchain installed")
+
     if not docs:
         return None, None, None
     
@@ -107,6 +114,9 @@ def create_big_doc(docs):
 
 def summarise_docs(docs, vector_name, summary_threshold_default=10000, model_limit_default=25000):
 
+    if not PromptTemplate or not StrOutputParser:
+        raise ImportError("PromptTemplate and StrOutputParser requires langchain installed")
+    
     if not docs:
         return None
     

sunholo/chunker/loaders.py

@@ -13,11 +13,12 @@
 #   limitations under the License.
 try:
     from langchain_unstructured import UnstructuredLoader
+    from langchain_community.document_loaders import GitLoader
+    from langchain_community.document_loaders import GoogleDriveLoader
 except ImportError:
     UnstructuredLoader = None
-
-from langchain_community.document_loaders import GitLoader
-from langchain_community.document_loaders import GoogleDriveLoader
+    GitLoader=None
+    GoogleDriveLoader=None
 
 from ..custom_logging import log
 from .pdfs import read_pdf_file
@@ -43,56 +44,56 @@ def convert_to_txt(file_path):
     shutil.copyfile(file_path, txt_file)
     return txt_file
 
+if GoogleDriveLoader is not None:
+    class MyGoogleDriveLoader(GoogleDriveLoader):
+        url: Optional[str] = Field(None)
 
-class MyGoogleDriveLoader(GoogleDriveLoader):
-    url: Optional[str] = Field(None)
-
-    def __init__(self, url, *args, **kwargs):
-        super().__init__(*args, **kwargs, file_ids=['dummy']) # Pass dummy value
-        self.url = url
-
-    def _extract_id(self, url):
-        parsed_url = urlparse(unquote(url))
-        path_parts = parsed_url.path.split('/')
-        
-        # Iterate over the parts
-        for part in path_parts:
-            # IDs are typically alphanumeric and at least a few characters long
-            # So let's say that to be an ID, a part has to be at least 15 characters long
-            if all(char.isalnum() or char in ['_', '-'] for char in part) and len(part) >= 15:
-                return part
-        
-        # Return None if no ID was found
-        return None
+        def __init__(self, url, *args, **kwargs):
+            super().__init__(*args, **kwargs, file_ids=['dummy']) # Pass dummy value
+            self.url = url
 
-    def load_from_url(self, url: str):
-        id = self._extract_id(url)
-        from googleapiclient.errors import HttpError
-        from googleapiclient.discovery import build
-
-        # Identify type of URL
-        try:
-            service = build("drive", "v3", credentials=self._load_credentials())
-            file = service.files().get(fileId=id).execute()
-        except HttpError as err:
-            log.error(f"Error loading file {url}: {str(err)}")
-            raise
-
-        mime_type = file["mimeType"]
-
-        if "folder" in mime_type:
-            # If it's a folder, load documents from the folder
-            return self._load_documents_from_folder(id)
-        else:
-            # If it's not a folder, treat it as a single file
-            if mime_type == "application/vnd.google-apps.document":
-                return [self._load_document_from_id(id)]
-            elif mime_type == "application/vnd.google-apps.spreadsheet":
-                return self._load_sheet_from_id(id)
-            elif mime_type == "application/pdf":
-                return [self._load_file_from_id(id)]
+        def _extract_id(self, url):
+            parsed_url = urlparse(unquote(url))
+            path_parts = parsed_url.path.split('/')
+            
+            # Iterate over the parts
+            for part in path_parts:
+                # IDs are typically alphanumeric and at least a few characters long
+                # So let's say that to be an ID, a part has to be at least 15 characters long
+                if all(char.isalnum() or char in ['_', '-'] for char in part) and len(part) >= 15:
+                    return part
+            
+            # Return None if no ID was found
+            return None
+
+        def load_from_url(self, url: str):
+            id = self._extract_id(url)
+            from googleapiclient.errors import HttpError
+            from googleapiclient.discovery import build
+
+            # Identify type of URL
+            try:
+                service = build("drive", "v3", credentials=self._load_credentials())
+                file = service.files().get(fileId=id).execute()
+            except HttpError as err:
+                log.error(f"Error loading file {url}: {str(err)}")
+                raise
+
+            mime_type = file["mimeType"]
+
+            if "folder" in mime_type:
+                # If it's a folder, load documents from the folder
+                return self._load_documents_from_folder(id)
             else:
-                return []
+                # If it's not a folder, treat it as a single file
+                if mime_type == "application/vnd.google-apps.document":
+                    return [self._load_document_from_id(id)]
+                elif mime_type == "application/vnd.google-apps.spreadsheet":
+                    return self._load_sheet_from_id(id)
+                elif mime_type == "application/pdf":
+                    return [self._load_file_from_id(id)]
+                else:
+                    return []
 
 def ignore_files(filepath):
     """Returns True if the given path's file extension is found within 

sunholo/chunker/message_data.py

@@ -29,8 +29,10 @@ try:
 except ImportError:
     BlobServiceClient = None
 
-from langchain.schema import Document
-
+try:
+    from langchain.schema import Document
+except ImportError:
+    Document = None
 
 from .splitter import chunk_doc_to_docs
 from .pdfs import split_pdf_to_pages

sunholo/chunker/publish.py

@@ -3,8 +3,11 @@ from ..pubsub import PubSubManager
 from ..utils.parsers import contains_url, extract_urls
 from ..utils.gcp_project import get_gcp_project
 
-from langchain.schema import Document
-
+try:
+    from langchain.schema import Document
+except ImportError:
+    Document=None
+    
 def publish_if_urls(the_content, vector_name):
     """
     Extracts URLs and puts them in a queue for processing on PubSub

sunholo/chunker/splitter.py

@@ -13,12 +13,17 @@
 #   limitations under the License.
 from ..custom_logging import log
 from ..utils.parsers import remove_whitespace
-from langchain.schema import Document
-import langchain.text_splitter as text_splitter
+
 from .images import upload_doc_images
 from .doc_handling import send_doc_to_docstore, summarise_docs
 from ..database.uuid import generate_uuid_from_object_id
 
+try:
+    from langchain.schema import Document
+    import langchain.text_splitter as text_splitter
+except ImportError:
+    Document=None
+    text_splitter=None
 
 def chunk_doc_to_docs(documents: list, extension: str = ".md", min_size: int = 800, vector_name=None, **kwargs):
     """Turns a Document object into a list of many Document chunks.

sunholo/components/retriever.py

@@ -17,13 +17,17 @@ from ..utils import ConfigManager
 from .llm import get_embeddings
 from ..utils.gcp_project import get_gcp_project
 
-from langchain.retrievers import MergerRetriever
-from langchain_community.retrievers import GoogleCloudEnterpriseSearchRetriever
-# https://python.langchain.com/docs/integrations/retrievers/merger_retriever
-from langchain_community.document_transformers import EmbeddingsRedundantFilter
-from langchain.retrievers.document_compressors import DocumentCompressorPipeline
-from langchain.retrievers import ContextualCompressionRetriever
-
+try:
+    from langchain.retrievers import MergerRetriever
+    # https://python.langchain.com/docs/integrations/retrievers/merger_retriever
+    from langchain_community.document_transformers import EmbeddingsRedundantFilter
+    from langchain.retrievers.document_compressors import DocumentCompressorPipeline
+    from langchain.retrievers import ContextualCompressionRetriever
+except ImportError:
+    MergerRetriever=None
+    EmbeddingsRedundantFilter=None
+    DocumentCompressorPipeline=None
+    ContextualCompressionRetriever=None
 
 
 def load_memories(vector_name:str=None, config:ConfigManager=None):

sunholo/embedder/embed_chunk.py

@@ -17,8 +17,11 @@ import json
 import datetime
 import uuid
 
-from langchain.schema import Document
-
+try:
+    from langchain.schema import Document
+except ImportError:
+    Document = None
+    
 from ..components import get_embeddings, pick_vectorstore, load_memories, pick_embedding
 from ..custom_logging import log
 from ..database.uuid import generate_uuid_from_object_id

sunholo/genai/process_funcs_cls.py

@@ -12,21 +12,21 @@ from collections import deque
 try:
     import google.generativeai as genai
     import proto
-    from google.generativeai.types import RequestOptions, GenerateContentResponse
     from google.api_core import retry
     from google.generativeai import ChatSession
     from google.api_core.exceptions import RetryError
+    from google.generativeai.types import RequestOptions, GenerateContentResponse
 except ImportError:
     genai = None
     ChatSession = None
+    GenerateContentResponse = None
 
 from .images import extract_gs_images_and_genai_upload
 
 if TYPE_CHECKING:
     from google.generativeai.protos import Part
     from google.generativeai import ChatSession
-
-
+    from google.generativeai.types import RequestOptions, GenerateContentResponse
 
 class GenAIFunctionProcessor:
     """
@@ -89,9 +89,19 @@ class GenAIFunctionProcessor:
         self.trace = trace
         self.parent_observation_id = parent_observation_id
         
+        # agent loops
         self.last_api_requests_and_responses = []
         self._validate_functions()
 
+        self.loop_span = None
+        self.token_queue = []
+        self.loop_text = ""
+        self.loop_content = []
+        self.loop_guardrail = 0
+        self.big_result = []
+        self.usage_metadata = {}
+        self.functions_called =[]
+
     def construct_tools(self) -> dict:
         """
         Constructs a dictionary of tools (functions) specific to the application.
@@ -249,7 +259,6 @@ class GenAIFunctionProcessor:
         """
         api_requests_and_responses = []
 
-
         if not full_response:
             log.info("No response was found to process")
             return api_requests_and_responses
@@ -272,7 +281,7 @@ class GenAIFunctionProcessor:
                     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} (Total Characters: {len(params)})")
+                log.info(f"== Executing {function_name} with params {params} (Total Characters: {len(params)})")
                 if len(params)>8000:
                     log.warning(f"Total parameters are over 8000 characters - it may not work properly: {params[:10000]}....[{len(params)}]")
 
@@ -413,6 +422,202 @@ class GenAIFunctionProcessor:
             # If it's a primitive value, return it as is
             return value
 
+    """
+        self.loop_span = None
+        self.token_queue = None
+        self.loop_chat = None
+        self.loop_text = None
+        self.loop_content = None
+        self.loop_guardrail = None
+    """
+
+    def _loop_update_content(self):
+        if self.loop_text:
+            # update content relying on gemini chat history, and the parsed function result objects
+            if self.loop_executed_responses:
+                self.loop_content = self.loop_executed_responses
+            else:
+                self.loop_content = [f"[{self.loop_guardrail}] Agent: {self.loop_text}"]
+            # if text includes gs:// try to download it
+            image_uploads = extract_gs_images_and_genai_upload(self.loop_text)
+            if image_uploads:
+                for img in image_uploads:
+                    log.info(f"Adding {img=}")
+                    self.loop_content.append(img)
+                    self.loop_content.append(f"{img.name} was created by agent and added")
+            log.info(f"[{self.loop_guardrail}] Updated content:\n{self.loop_text}")
+            self.big_result.append(self.loop_text)
+        else:
+            log.warning(f"[{self.loop_guardrail}] No content created this loop")
+            self.loop_content = [f"[{self.loop_guardrail}] Agent: ERROR - No response was found for loop [{self.loop_guardrail}]"]
+
+    def _loop_handle_executed_responses(self, response):
+        try:
+            self.loop_executed_responses = self.process_funcs(response, loop_span=self.loop_span) 
+        except Exception as err:
+            log.error(f"Error in executions: {str(err)}")
+            self.token_queue.append(f"{str(err)} for {response=}")
+
+        log.info(f"[{self.loop_guardrail}] {self.loop_executed_responses=}")
+
+        if self.loop_executed_responses:  
+            self.token_queue.append("\n-- Agent Actions:\n")
+            fn_exec = self.loop_span.span(name="function_actions", input=self.loop_executed_responses) if self.loop_span else None
+            for executed_response in self.loop_executed_responses:
+                token = ""
+                fn = executed_response.function_response.name
+                fn_args = executed_response.function_response.response.get("args")
+                fn_result = executed_response.function_response.response["result"]
+                fn_log = f"{fn}({fn_args})"
+                log.info(fn_log)
+                self.functions_called.append(fn_log)
+                self.token_queue.append(f"\n-- {fn_log} ...executing...\n") if fn != "decide_to_go_on" else ""
+                while self.token_queue:
+                    token = self.token_queue.popleft()
+                    self.loop_callback.on_llm_new_token(token=token)
+
+                log.info(f"{fn_log} created a result={type(fn_result)=}")
+                fn_exec_one = fn_exec.span(name=fn, input=fn_args) if fn_exec else None
+                
+                fn_result_json = None
+                # Convert MapComposite to a standard Python dictionary
+                if isinstance(fn_result, proto.marshal.collections.maps.MapComposite):
+                    fn_result_json = self.convert_composite_to_native(fn_result)
+                elif isinstance(fn_result, proto.marshal.collections.repeated.RepeatedComposite):
+                    fn_result = self.convert_composite_to_native(fn_result)
+                elif isinstance(fn_result, dict):
+                    fn_result_json = fn_result
+                elif isinstance(fn_result, str):
+                    try:
+                        if isinstance(fn_result_json, str):
+                            fn_result_json = json.loads(fn_result_json)
+                    except json.JSONDecodeError:
+                        log.warning(f"{fn_result} was not JSON decoded")
+                    except Exception as err:
+                        log.warning(f"{fn_result} was not json decoded due to unknown exception: {str(err)} {traceback.format_exc()}")
+                else:
+                    log.warning(f"Unrecognised type for {fn_log}: {type(fn_result)}")
+                
+                # should be a string or a dict by now
+                log.info(f"Processed {fn_log} to {fn_result_json=} type: {type(fn_result_json)}")
+                
+                if fn == "decide_to_go_on":
+                    log.info(f"{fn_result_json=} {type(fn_result)}")
+                    if fn_result_json:
+                        token = f"\n{'STOPPING' if not fn_result_json.get('go_on') else 'CONTINUE'}: {fn_result_json.get('chat_summary')}\n"
+                    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=}\n"
+                else:
+
+                    token = f"--- {fn_log} result --- \n"
+                    # if json dict we look for keys to extract
+                    if fn_result_json:
+                        log.info(f"{fn_result_json} dict parsing")
+                        if fn_result_json.get('stdout'):
+                            text = fn_result_json.get('stdout')
+                            token += self.remove_invisible_characters(text)
+                        if fn_result_json.get('stderr'):
+                            text = fn_result_json.get('stdout')
+                            token += self.remove_invisible_characters(text)
+                        # If neither 'stdout' nor 'stderr' is present, dump the entire JSON
+                        if 'stdout' not in fn_result_json and 'stderr' not in fn_result_json:
+                            log.info(f"No recognised keys ('stdout' or 'stderr') in dict: {fn_result_json=} - dumping it all")
+                            token += f"{json.dumps(fn_result_json, indent=2)}\n"  # Added `indent=2` for readability
+                    else:
+                        # probably a string, just return it
+                        log.info(f"{fn_result_json} non-dict (String?) parsing")
+                        token += f"{self.remove_invisible_characters(fn_result)}\n--- end ---\n"
+                
+                self.loop_text += token
+                self.token_queue.append(token)
+                fn_exec_one.end(output=token) if fn_exec_one else None
+            fn_exec.end(output=self.loop_text) if fn_exec else None        
+
+        else:
+            token = f"\n[{self.loop_guardrail}] No function executions were performed\n"
+            self.token_queue.append(token)
+            self.loop_text += token
+            
+    def _loop_output_text(self, response:GenerateContentResponse):
+        if not response:
+            return
+        
+        for chunk in response:
+            if not chunk:
+                continue
+
+            log.debug(f"[{self.loop_guardrail}] {chunk=}")
+            try:
+                if hasattr(chunk, 'text') and isinstance(chunk.text, str):
+                    token = chunk.text
+                    self.token_queue.append(token)
+                    self.loop_text += token
+                else:
+                    log.info("skipping chunk with no text")
+                
+            except ValueError as err:
+                self.token_queue.append(f"{str(err)} for {chunk=}")
+
+    def _loop_metadata(self, response:GenerateContentResponse, gen=None):
+        loop_metadata = None
+        if response:
+            loop_metadata = response.usage_metadata
+            if loop_metadata:
+                self.usage_metadata = {
+                    "prompt_token_count": self.usage_metadata["prompt_token_count"] + (loop_metadata.prompt_token_count or 0),
+                    "candidates_token_count": self.usage_metadata["candidates_token_count"] + (loop_metadata.candidates_token_count or 0),
+                    "total_token_count": self.usage_metadata["total_token_count"] + (loop_metadata.total_token_count or 0),
+                }
+                self.token_queue.append((
+                    "\n-- Agent response -- " 
+                    f"Loop tokens: [{loop_metadata.prompt_token_count}]/[{self.usage_metadata['prompt_token_count']}] "
+                    f"Session tokens: [{loop_metadata.total_token_count}]/[{self.usage_metadata['total_token_count']}] \n"
+                ))
+            gen.end(output=response.to_dict()) if gen else None
+        else:
+            gen.end(output="No response received") if gen else None
+        
+        return loop_metadata
+
+    def _loop_call_agent(self, chat:ChatSession):
+        response=None
+        gen=None
+        try:
+            self.token_queue.append("\n= Calling Agent =\n")
+            loop_content = self.loop_content
+            gen = self.loop_span.generation(
+                name=f"loop_{self.loop_guardrail}",
+                model=self.model_name,
+                input = {'content': self.loop_content},
+            ) if self.loop_span else None
+
+            log.info(f"{loop_content=}")
+            response: GenerateContentResponse = chat.send_message(loop_content, request_options=RequestOptions(
+                                    retry=retry.Retry(
+                                        initial=1, 
+                                        multiplier=2, 
+                                        maximum=10, 
+                                        timeout=60
+                                    )
+                                    ))
+        except RetryError as err:
+            msg = f"Retry error - lets try again if its occured less than twice: {str(err)}"
+            log.warning(msg)
+            self.token_queue.append(msg)
+            self.loop_text += msg
+            
+        except Exception as e:
+            msg = f"Error sending {loop_content} to model: {str(e)}"
+            if "finish_reason: 10" in str(e):
+                    msg = (f"I encounted an error on the previous step when sending this data: {json.dumps(loop_content)}"
+                            " -- Can you examine what was sent and identify why? If possible correct it so we can answer the original user question.")
+            log.error(msg + f"{traceback.format_exc()}")
+            self.token_queue.append(msg)
+            self.loop_text += msg
+        
+        return response, gen
+
     def run_agent_loop(self, chat:ChatSession, content:list, callback=None, guardrail_max=10, loop_return=3): # type: ignore
         """
         Runs the agent loop, sending messages to the orchestrator, processing responses, and executing functions.
@@ -429,17 +634,14 @@ class GenAIFunctionProcessor:
         """
         if not callback:
             callback = self.IOCallback()
-        guardrail = 0
-        big_result = []
-        usage_metadata = {
+        self.big_result = []
+        self.usage_metadata = {
             "prompt_token_count": 0,
             "candidates_token_count": 0,
             "total_token_count": 0
         }
-        functions_called =[]
-        function_results = []
-        # Initialize token queue to ensure sequential processing
-        token_queue = deque()
+        
+        self.functions_called =[]
 
         span = self.trace.span(
             name=f"GenAIFunctionProcesser_{self.__class__.__name__}",
@@ -447,223 +649,73 @@ class GenAIFunctionProcessor:
             input = {'content': content},
         ) if self.trace else None
 
-        while guardrail < guardrail_max:
+        self.loop_span = None
+        # Initialize token queue to ensure sequential processing
+        self.token_queue = deque()
+        self.loop_text = ""
+        self.loop_content = content
+        self.loop_guardrail = 0
+        self.loop_executed_responses = []
+        self.loop_callback = callback
 
-            token_queue.append(f"\n----Loop [{guardrail}] Start------\nFunctions: {list(self.funcs.keys())}\n")
+        while self.loop_guardrail < guardrail_max:
+            self.token_queue.append(f"\n----Loop [{self.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 [{self.loop_guardrail}] =="
 
-            log.info(f"== Start input content for loop [{guardrail}]\n ## Content: {content_parse}")
-            this_text = ""  # reset for this loop
+            log.info(f"== Start input content for loop [{self.loop_guardrail}]\n ## Content: {content_parse}")
+            
+            # resets for this loop
+            self.loop_text = ""  
             response = None
-            executed_responses = []
-            loop_span = span.span(
-                name=f"loop_{guardrail}",
+            self.loop_executed_responses = []
+
+            self.loop_span = span.span(
+                name=f"loop_{self.loop_guardrail}",
                 model=self.model_name,
-                input = {'content': content},
+                input = {'content': self.loop_content},
             ) if span else None
 
-            try:
-                token_queue.append("\n= Calling Agent =\n")
-
-                gen = loop_span.generation(
-                    name=f"loop_{guardrail}",
-                    model=self.model_name,
-                    input = {'content': content},
-                ) if loop_span else None
-
-                response: GenerateContentResponse = chat.send_message(content, request_options=RequestOptions(
-                                        retry=retry.Retry(
-                                            initial=1, 
-                                            multiplier=2, 
-                                            maximum=10, 
-                                            timeout=60
-                                        )
-                                       ))
-            except RetryError as err:
-                msg = f"Retry error - lets try again if its occured less than twice: {str(err)}"
-                log.warning(msg)
-                token_queue.append(msg)
-                this_text += msg
-                
-            except Exception as e:
-                msg = f"Error sending {content} to model: {str(e)}"
-                if "finish_reason: 10" in str(e):
-                    msg = "The Gemini API does not work with this input - you need to try something else. Error is: finish_reason: 10"
-                log.error(msg + f"{traceback.format_exc()}")
-                token_queue.append(msg)
-                this_text += msg
-
-            if response:
-                loop_metadata = response.usage_metadata
-                if loop_metadata:
-                    usage_metadata = {
-                        "prompt_token_count": usage_metadata["prompt_token_count"] + (loop_metadata.prompt_token_count or 0),
-                        "candidates_token_count": usage_metadata["candidates_token_count"] + (loop_metadata.candidates_token_count or 0),
-                        "total_token_count": usage_metadata["total_token_count"] + (loop_metadata.total_token_count or 0),
-                    }
-                    token_queue.append((
-                        "\n-- Agent response -- " 
-                        f"Loop tokens: [{loop_metadata.prompt_token_count}]/[{usage_metadata['prompt_token_count']}] "
-                        f"Session tokens: [{loop_metadata.total_token_count}]/[{usage_metadata['total_token_count']}] \n"
-                    ))
-                loop_metadata = None
-                gen.end(output=response.to_dict()) if gen else None
-            else:
-                gen.end(output="No response received") if gen else None
-
-            if not response:
-                response = []
-            for chunk in response:
-                if not chunk:
-                    continue
-
-                log.debug(f"[{guardrail}] {chunk=}")
-                try:
-                    if hasattr(chunk, 'text') and isinstance(chunk.text, str):
-                        token = chunk.text
-                        token_queue.append(token)
-                        this_text += token
-                    else:
-                        log.info("skipping chunk with no text")
-                    
-                except ValueError as err:
-                    token_queue.append(f"{str(err)} for {chunk=}")
-            try:
-                executed_responses = self.process_funcs(response, loop_span=loop_span) 
-            except Exception as err:
-                log.error(f"Error in executions: {str(err)}")
-                token_queue.append(f"{str(err)} for {response=}")
-
-            log.info(f"[{guardrail}] {executed_responses=}")
-
-            if executed_responses:  
-                token_queue.append("\n-- Agent Actions:\n")
-                fn_exec = loop_span.span(name="function_actions", input=executed_responses) if loop_span else None
-                for executed_response in executed_responses:
-                    token = ""
-                    fn = executed_response.function_response.name
-                    fn_args = executed_response.function_response.response.get("args")
-                    fn_result = executed_response.function_response.response["result"]
-                    fn_log = f"{fn}({fn_args})"
-                    log.info(fn_log)
-                    functions_called.append(fn_log)
-                    function_results.append(fn_result)
-                    token_queue.append(f"\n-- {fn_log} ...executing...\n") if fn != "decide_to_go_on" else ""
-                    while token_queue:
-                        token = token_queue.popleft()
-                        callback.on_llm_new_token(token=token)
-
-                    log.info(f"{fn_log} created a result={type(fn_result)=}")
-                    fn_exec_one = fn_exec.span(name=fn, input=fn_args) if fn_exec else None
-                    
-                    fn_result_json = None
-                    # Convert MapComposite to a standard Python dictionary
-                    if isinstance(fn_result, proto.marshal.collections.maps.MapComposite):
-                        fn_result_json = self.convert_composite_to_native(fn_result)
-                    elif isinstance(fn_result, proto.marshal.collections.repeated.RepeatedComposite):
-                        fn_result = self.convert_composite_to_native(fn_result)
-                    elif isinstance(fn_result, dict):
-                        fn_result_json = fn_result
-                    elif isinstance(fn_result, str):
-                        try:
-                            if isinstance(fn_result_json, str):
-                                fn_result_json = json.loads(fn_result_json)
-                        except json.JSONDecodeError:
-                            log.warning(f"{fn_result} was not JSON decoded")
-                        except Exception as err:
-                            log.warning(f"{fn_result} was not json decoded due to unknown exception: {str(err)} {traceback.format_exc()}")
-                    else:
-                        log.warning(f"Unrecognised type for {fn_log}: {type(fn_result)}")
-                    
-                    # should be a string or a dict by now
-                    log.info(f"Processed {fn_log} to {fn_result_json=} type: {type(fn_result_json)}")
-                    
-                    if fn == "decide_to_go_on":
-                        log.info(f"{fn_result_json=} {type(fn_result)}")
-                        if fn_result_json:
-                            token = f"\n{'STOPPING' if not fn_result_json.get('go_on') else 'CONTINUE'}: {fn_result_json.get('chat_summary')}\n"
-                        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=}\n"
-                    else:
+            response, gen = self._loop_call_agent(chat)
 
-                        token = f"--- {fn_log} result --- \n"
-                        # if json dict we look for keys to extract
-                        if fn_result_json:
-                            log.info(f"{fn_result_json} dict parsing")
-                            if fn_result_json.get('stdout'):
-                                text = fn_result_json.get('stdout')
-                                token += self.remove_invisible_characters(text)
-                            if fn_result_json.get('stderr'):
-                                text = fn_result_json.get('stdout')
-                                token += self.remove_invisible_characters(text)
-                            # If neither 'stdout' nor 'stderr' is present, dump the entire JSON
-                            if 'stdout' not in fn_result_json and 'stderr' not in fn_result_json:
-                                log.info(f"No recognised keys ('stdout' or 'stderr') in dict: {fn_result_json=} - dumping it all")
-                                token += f"{json.dumps(fn_result_json, indent=2)}\n"  # Added `indent=2` for readability
-                        else:
-                            # probably a string, just return it
-                            log.info(f"{fn_result_json} non-dict (String?) parsing")
-                            token += f"{self.remove_invisible_characters(fn_result)}\n--- end ---\n"
-                    
-                    this_text += token
-                    token_queue.append(token)
-                    fn_exec_one.end(output=token) if fn_exec_one else None
-                fn_exec.end(output=this_text) if fn_exec else None        
+            loop_metadata = self._loop_metadata(response, gen)
 
-            else:
-                token = "\nNo function executions were found\n"
-                token_queue.append(token)
-                this_text += token
-
-            if this_text:
-                #content.append(f"Agent: {this_text}")    
-                # update content relying on gemini chat history instead, and the parsed function result objects
-                content = executed_responses
-                # if text includes gs:// try to download it
-                image_uploads = extract_gs_images_and_genai_upload(this_text)
-                if image_uploads:
-                    for img in image_uploads:
-                        log.info(f"Adding {img=}")
-                        content.append(img)
-                        content.append(f"{img.name} was created by agent and added")
-                log.info(f"[{guardrail}] Updated content:\n{this_text}")
-                big_result.append(this_text)
-            else:
-                log.warning(f"[{guardrail}] No content created this loop")
-                content = [f"Agent: ERROR - No response was found for loop [{guardrail}]"]
+            self._loop_output_text(response)
+
+            self._loop_handle_executed_responses(response)
+
+            self._loop_update_content()
 
-            token_queue.append(f"\n----Loop [{guardrail}] End------\n{usage_metadata}\n----------------------")
-            loop_span.end(output=content, metadata=loop_metadata) if loop_span else None
+            self.token_queue.append(f"\n----Loop [{self.loop_guardrail}] End------\n{self.usage_metadata}\n----------------------")
+            self.loop_span.end(output=self.loop_content, metadata=loop_metadata) if self.loop_span else None
 
             go_on_check = self.check_function_result("decide_to_go_on", {"go_on": False})
             if go_on_check:
                 log.info("Breaking agent loop")
                 break
             
-            while token_queue:
-                token = token_queue.popleft()
-                callback.on_llm_new_token(token=token)
+            while self.token_queue:
+                token = self.token_queue.popleft()
+                self.loop_callback.on_llm_new_token(token=token)
             
-            guardrail += 1
-            if guardrail > guardrail_max:
+            self.loop_guardrail += 1
+            if self.loop_guardrail > guardrail_max:
                 log.warning(f"Guardrail kicked in, more than {guardrail_max} loops")
                 break
         
-        while token_queue:
-            token = token_queue.popleft()
-            callback.on_llm_new_token(token=token)
+        while self.token_queue:
+            token = self.token_queue.popleft()
+            self.loop_callback.on_llm_new_token(token=token)
         
-        usage_metadata["functions_called"] = functions_called
+        self.usage_metadata["functions_called"] = self.functions_called
 
-        big_text = "\n".join(big_result[-loop_return:])
-        span.end(output=big_text, metadata=usage_metadata) if span else None
+        big_text = "\n".join(self.big_result[-loop_return:])
+        span.end(output=big_text, metadata=self.sage_metadata) if span else None
 
-        return big_text, usage_metadata
+        return big_text, self.usage_metadata
 
     class IOCallback:
         """

sunholo/streaming/content_buffer.py

@@ -12,8 +12,13 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 from typing import Any, Dict, List, Union
-from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
-from langchain.schema import LLMResult
+
+try:
+    from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+    from langchain.schema import LLMResult
+except ImportError:
+    StreamingStdOutCallbackHandler = None
+    LLMResult = None
 
 import threading
 import asyncio

sunholo/summarise/summarise.py

@@ -18,14 +18,24 @@ from ..custom_logging import log
 from ..components import get_llm
 from ..chunker.splitter import chunk_doc_to_docs
 
-from langchain.prompts import PromptTemplate
-from langchain.chat_models import ChatVertexAI
-from langchain.chat_models import ChatOpenAI
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain.llms import OpenAI
-from langchain.llms import VertexAI
-from langchain.chains.summarize import load_summarize_chain
-from langchain.schema import Document
+try:
+    from langchain.prompts import PromptTemplate
+    from langchain.chat_models import ChatVertexAI
+    from langchain.chat_models import ChatOpenAI
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    from langchain.llms import OpenAI
+    from langchain.llms import VertexAI
+    from langchain.chains.summarize import load_summarize_chain
+    from langchain.schema import Document
+except ImportError:
+    PromptTemplate=None
+    ChatVertexAI=None
+    ChatOpenAI=None
+    ChatGoogleGenerativeAI=None
+    OpenAI=None
+    VertexAI=None
+    load_summarize_chain=None
+    Document=None
 
 prompt_template = """Write a summary for below, including key concepts, people and distinct information but do not add anything that is not in the original text:
 

{sunholo-0.113.2.dist-info → sunholo-0.114.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.113.2
+Version: 0.114.1
 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.113.2.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.114.1.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0
@@ -81,6 +81,11 @@ Requires-Dist: tenacity; extra == "all"
 Requires-Dist: tiktoken; extra == "all"
 Requires-Dist: unstructured[all-docs,local-inference]; extra == "all"
 Requires-Dist: xlwings; extra == "all"
+Provides-Extra: langchain
+Requires-Dist: langchain==0.2.16; extra == "langchain"
+Requires-Dist: langchain_experimental==0.0.65; extra == "langchain"
+Requires-Dist: langchain-community==0.2.17; extra == "langchain"
+Requires-Dist: langsmith==0.1.143; extra == "langchain"
 Provides-Extra: azure
 Requires-Dist: azure-identity; extra == "azure"
 Requires-Dist: azure-storage-blob; extra == "azure"

{sunholo-0.113.2.dist-info → sunholo-0.114.1.dist-info}/RECORD

@@ -31,16 +31,16 @@ sunholo/bots/github_webhook.py,sha256=5pQPRLM_wxxcILVaIzUDV8Kt7Arcm2dL1r1kMMHA52
 sunholo/bots/webapp.py,sha256=EIMxdAJ_xtufwJmvnn7N_Fb_1hZ9DjhJ0Kf_hp02vEU,1926
 sunholo/chunker/__init__.py,sha256=A5canS0XPgisHu0OZ7sVdILgEHGzgH9kpkDi4oBwLZk,135
 sunholo/chunker/azure.py,sha256=MVF9_-QdKUoJqlpEJ49pv2sdjMDxEiMNxzmO7w5nWDQ,3270
-sunholo/chunker/doc_handling.py,sha256=UAf9BmUMpKCKRlAMl1qNZK6xDNYWk1z3ARoftWoa_54,8734
+sunholo/chunker/doc_handling.py,sha256=t_lDazHfJbs4Q2Ruq2MvBBeJRfsjjQkzMxKuX8qQKBI,9087
 sunholo/chunker/encode_metadata.py,sha256=hxxd9KU35Xi0Z_EL8kt_oD66pKfBLhEjBImC16ew-Eo,1919
 sunholo/chunker/images.py,sha256=id2PBu6XyGEOtgafq2v0c9_O6kxaC_pYFMnbsIitkSg,1868
-sunholo/chunker/loaders.py,sha256=YwzCARJiWosNr3WGYuvWYCk_Y5jEnz6xcGCITDPytx8,10847
-sunholo/chunker/message_data.py,sha256=EaiY7_HClpcfPUAYaAm6Zk5ReeZ9s9F_jBVd0kDgI-4,10836
+sunholo/chunker/loaders.py,sha256=5NXrMxV-WdbFpxeLhFzccw0_zhf1UQ7yKFFeaMkc9Bc,11105
+sunholo/chunker/message_data.py,sha256=-gnF9cKIuo-aA6jhCXrAm6U2K9tL5GbeCQ3nMJfaxUQ,10884
 sunholo/chunker/pdfs.py,sha256=njDPop751GMHi3cOwIKd2Yct-_lWR2gqcB7WykfHphs,2480
 sunholo/chunker/process_chunker_data.py,sha256=uO-YOEHIjAOy0ZMJ0vea9OMNsQBISHfhbtgoyuHiP6s,3598
-sunholo/chunker/publish.py,sha256=AX5u-fcyDytED67IfizMzvOMcYPXEo6XBJvyk_7maK8,2939
+sunholo/chunker/publish.py,sha256=8TrvmX51aQPvht11myxm0G4tuI3iqAM2wL2x8MWkfX4,2990
 sunholo/chunker/pubsub.py,sha256=48bhuAcszN7LGe3-ksPSLHHhq0uKxiXOrizck5qpcP0,1012
-sunholo/chunker/splitter.py,sha256=QLAEsJOpEYFZr9-UGZUuAlNVyjfCWb8jvzCHg0rVShE,6751
+sunholo/chunker/splitter.py,sha256=WltIA6LYELwG0FEtiDKclgRtKuw3rXI2myFOQM4LkIs,6826
 sunholo/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/cli/chat_vac.py,sha256=sYPzUDwwwebJvIobv3GRW_xbQQ4BTy9G-WHdarGCHB0,23705
 sunholo/cli/cli.py,sha256=Bhyrs8GEtJTbsvPYufEY184ra13eusATXAnJClJ_LGY,4474
@@ -55,7 +55,7 @@ sunholo/cli/swagger.py,sha256=absYKAU-7Yd2eiVNUY-g_WLl2zJfeRUNdWQ0oH8M_HM,1564
 sunholo/cli/vertex.py,sha256=8130YCarxHL1UC3aqblNmUwGZTXbkdL4Y_FOnZJsWiI,2056
 sunholo/components/__init__.py,sha256=IDoylb74zFKo6NIS3RQqUl0PDFBGVxM1dfUmO7OJ44U,176
 sunholo/components/llm.py,sha256=8iyY6K1ZiiJx9MGL1fY5CHh8CD3YYhwEA6O8B44tkxE,13004
-sunholo/components/retriever.py,sha256=bKIVT7_18Ut3OJd0E0jyiISPnD9qkHWVjcQPT4i1_G8,7720
+sunholo/components/retriever.py,sha256=Wmchv3huAM4w7DIS-a5Lp9Hi7M8pE6vZdxgseiT9SXk,7820
 sunholo/components/vectorstore.py,sha256=xKk7micTRwZckaI7U6PxvFz_ZSjCH48xPTDYiDcv2tc,5913
 sunholo/database/__init__.py,sha256=bpB5Nk21kwqYj-qdVnvNgXjLsbflnH4g-San7OHMqR4,283
 sunholo/database/alloydb.py,sha256=x1zUMB-EVWbE2Zvp4nAs2Z-tB_kOZmS45H2lwVHdYnk,11678
@@ -76,7 +76,7 @@ sunholo/discovery_engine/create_new.py,sha256=jWg5LW-QpFE8zq50ShaQJB3Wu8loiWB0P4
 sunholo/discovery_engine/discovery_engine_client.py,sha256=jfIayVUOPM4svGF1S5Kk60rIG-xSo_e3zOHtBRg0nZA,22002
 sunholo/discovery_engine/get_ai_search_chunks.py,sha256=hsFGOQugSeTMPEaQ16XTs_D45F8NABBm2IsAEdTk7kQ,4316
 sunholo/embedder/__init__.py,sha256=sI4N_CqgEVcrMDxXgxKp1FsfsB4FpjoXgPGkl4N_u4I,44
-sunholo/embedder/embed_chunk.py,sha256=_FdO4-9frUJlDPqXv2Ai49ejUrrMTMGti3D7bfJGfy8,6984
+sunholo/embedder/embed_chunk.py,sha256=sy--Gtf8x0N2KcGnPaDyS2GIVrZjxml4HZ9smlY-B5A,7037
 sunholo/excel/__init__.py,sha256=AqTMN9K4qJYi4maEgoORc5oxDVGO_eqmwzDaVP37JgY,56
 sunholo/excel/plugin.py,sha256=rl3FoECZ6Ts8KKExPrbPwr3u3CegZfsevmcjgUXAlhE,4033
 sunholo/gcs/__init__.py,sha256=SZvbsMFDko40sIRHTHppA37IijvJTae54vrhooEF5-4,90
@@ -89,7 +89,7 @@ sunholo/genai/__init__.py,sha256=6SWK7uV5F625J-P3xQoD6WKL59a9RSaidj-Guslyt8Q,192
 sunholo/genai/file_handling.py,sha256=Z3E7TR1DnP9WnneeEGC8LcT6k-9GFxwXDPaVZWw8HLE,8366
 sunholo/genai/images.py,sha256=EyjsDqt6XQw99pZUQamomCpMOoIah9bp3XY94WPU7Ms,1678
 sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
-sunholo/genai/process_funcs_cls.py,sha256=h-AiG99_wFgRdl7-tW9HkmVCDQyH0m2HT1Y7I-Hq5Lg,31940
+sunholo/genai/process_funcs_cls.py,sha256=D6eNrc3vtTZzwdkacZNOSfit499N_o0C5AHspyUJiYE,33690
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=o1RhwBGOtVK0MIdD55fAIMCkJsxTksi8GD5uoqVKI-8,184
 sunholo/invoke/async_class.py,sha256=G8vD2H94fpBc37mSJSQODEKJ67P2mPQEHabtDaLOvxE,8033
@@ -119,12 +119,12 @@ sunholo/qna/retry.py,sha256=yMw7RTkw-RXCzfENPJOt8c32mXlpvOR589EGkvK-6yI,2028
 sunholo/senses/__init__.py,sha256=fbWqVwwzkV5uRSb8lQzo4pn0ja_VYVWbUYapurSowBs,39
 sunholo/senses/stream_voice.py,sha256=VpCmooEKghBT1jPJe9mX7gKggGqY6qt-bpO7hwY4sPE,18122
 sunholo/streaming/__init__.py,sha256=MpbydI2UYo_adttPQFkxNM33b-QRyNEbrKJx0C2AGPc,241
-sunholo/streaming/content_buffer.py,sha256=0LHMwH4ctq5kjhIgMFNH0bA1RL0jMISlLVzzLcFrvv4,12766
+sunholo/streaming/content_buffer.py,sha256=pSAoajCIDm8KM4TWkR-XptI925m_hSPQuEy0ea9Uq-c,12863
 sunholo/streaming/langserve.py,sha256=hi7q8WY8DPKrALl9m_dOMxWOdE-iEuk7YW05SVDFIX8,6514
 sunholo/streaming/stream_lookup.py,sha256=hYg1DbdSE_QNJ8ZB-ynXJlWgvFjrGvwoUsGJu_E0pRQ,360
 sunholo/streaming/streaming.py,sha256=gSxLuwK-5-t5D1AjcHf838BY-L4jvdkdn_xePl-DK3o,16635
 sunholo/summarise/__init__.py,sha256=MZk3dblUMODcPb1crq4v-Z508NrFIpkSWNf9FIO8BcU,38
-sunholo/summarise/summarise.py,sha256=95A-6PXFGanjona8DvZPnnIHLbzZ2ip5hO0wOAJQhfw,3791
+sunholo/summarise/summarise.py,sha256=XYOdBrTYRSinEOvbwfGKayk-5ELdQFucNuzZ7XSmXeQ,4028
 sunholo/terraform/__init__.py,sha256=yixxEltc3n9UpZaVi05GlgS-YRq_DVGjUc37I9ajeP4,76
 sunholo/terraform/tfvars_editor.py,sha256=-TBBWbALYb5HLFYwD2s70Kp27ys6fzIyreBFOT5kqqY,13142
 sunholo/tools/__init__.py,sha256=5NuYpwwTX81qGUWvgwfItoSLXteNnp7KjgD7IPZUFjI,53
@@ -150,9 +150,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.113.2.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.113.2.dist-info/METADATA,sha256=9yE39JdBTtbh1f1ef9n7RfqWnTJGd-VAnilQWEmnfrE,8786
-sunholo-0.113.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sunholo-0.113.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.113.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.113.2.dist-info/RECORD,,
+sunholo-0.114.1.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.114.1.dist-info/METADATA,sha256=lWw4qaMtyejzXYgVbiCet8p9o3ZIsw7a4Ov03Bw_HNc,9056
+sunholo-0.114.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sunholo-0.114.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.114.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.114.1.dist-info/RECORD,,