sunholo 0.118.0__py3-none-any.whl → 0.118.1__py3-none-any.whl

sunholo/chunker/message_data.py

@@ -29,7 +29,7 @@ try:
 except ImportError:
     BlobServiceClient = None
 
-from ..types import Document
+from ..langchain_types import Document
 
 from .splitter import chunk_doc_to_docs
 from .pdfs import split_pdf_to_pages

sunholo/chunker/pdfs.py

@@ -14,7 +14,7 @@
 import os
 import pathlib
 from ..custom_logging import log
-from ..types import Document
+from ..langchain_types import Document
 
 def split_pdf_to_pages(pdf_path, temp_dir):
 

sunholo/chunker/publish.py

@@ -2,7 +2,7 @@ from ..custom_logging import log
 from ..pubsub import PubSubManager
 from ..utils.parsers import contains_url, extract_urls
 from ..utils.gcp_project import get_gcp_project
-from ..types import Document
+from ..langchain_types import Document
     
 def publish_if_urls(the_content, vector_name):
     """

sunholo/{types.py → langchain_types.py}

@@ -1,10 +1,9 @@
-from typing import Any, Dict, Optional, TYPE_CHECKING, Union
 from dataclasses import dataclass, asdict
 import json
+from typing import Dict, Any
 
-if TYPE_CHECKING:
-    from langchain.schema import Document as LangchainDocument
-
+# Note: Moved TYPE_CHECKING to only be used where needed
+from typing import TYPE_CHECKING
 
 @dataclass
 class Document:
@@ -36,7 +35,8 @@ class Document:
         """Convert to JSON string - for compatibility with LangChain's Document."""
         return json.dumps(self.to_dict())
 
-def convert_to_langchain_doc(doc: Document) -> Union[Any, "LangchainDocument"]:
+# Move the type checking import and annotation inside the function
+def convert_to_langchain_doc(doc: Document) -> Any:  # Remove Union and LangchainDocument from return type
     """Convert our Document to a LangChain Document.
     
     Returns Any when LangChain isn't available to avoid type errors.

sunholo/templates/agent/agent_service.py

@@ -0,0 +1,157 @@
+
+from sunholo.utils import ConfigManager
+from sunholo.vertex import (
+    init_genai,
+)
+
+from tools.your_agent import get_quarto, quarto_content, QuartoProcessor
+
+from my_log import log
+
+init_genai()
+
+# kwargs supports - image_uri, mime
+def vac_stream(question: str, vector_name:str, chat_history=[], callback=None, **kwargs):
+    
+    config=ConfigManager(vector_name)
+    processor = QuartoProcessor(config)
+
+    orchestrator = get_quarto(config, processor)
+    if not orchestrator:
+        msg = f"No quarto model could be configured for {vector_name}"
+        log.error(msg)
+        callback.on_llm_end(response=msg)
+        return {"answer": msg}
+
+    chat = orchestrator.start_chat()
+
+    guardrail = 0
+    guardrail_max = kwargs.get('max_steps', 10)
+    big_text = ""
+    usage_metadata = None
+    functions_called = []
+    result=None
+    last_responses=None
+    while guardrail < guardrail_max:
+
+        content = quarto_content(question, chat_history)
+        log.info(f"# Loop [{guardrail}] - {content=}")
+        response = chat.send_message(content, stream=True)
+        this_text = "" # reset for this loop
+        log.debug(f"[{guardrail}] {response}")
+
+        for chunk in response:
+            try:
+                log.debug(f"[{guardrail}] {chunk=}")
+                # Check if 'text' is an attribute of chunk and if it's a string
+                if hasattr(chunk, 'text') and isinstance(chunk.text, str):
+                    token = chunk.text
+                else:
+                    function_names = []
+                    try:
+                        for part in chunk.candidates[0].content.parts:
+                            if fn := part.function_call:
+                                params = {key: val for key, val in fn.args.items()}
+                                func_args = ",".join(f"{key}={value}" for key, value in params.items())
+                                log.info(f"Found function call: {fn.name}({func_args})")
+                                function_names.append(f"{fn.name}({func_args})")
+                                functions_called.append(f"{fn.name}({func_args})")
+                    except Exception as err:
+                        log.warning(f"{str(err)}")
+
+                    token = ""  # Handle the case where 'text' is not available
+                    
+                    if processor.last_api_requests_and_responses:
+                        if processor.last_api_requests_and_responses != last_responses:
+                            last_responses = processor.last_api_requests_and_responses
+                        for last_response in last_responses:
+                            result=None # reset for this function response
+                            if last_response:
+                                log.info(f"[{guardrail}] {last_response=}")
+                                
+                                # Convert the last_response to a string by extracting relevant information
+                                function_name = last_response[0]
+                                arguments = last_response[1]
+                                result = last_response[2]
+                                func_args = ",".join(f"{key}={value}" for key, value in arguments.items())
+
+                                if f"{function_name}({func_args})" not in function_names:
+                                    log.warning(f"skipping {function_name}({func_args}) as not in execution list")
+                                    continue
+
+                                token = f"\n## Loop [{guardrail}] Function call: {function_name}({func_args}):\n"
+
+                                if function_name == "decide_to_go_on":
+                                    token += f"# go_on={result}\n"
+                                else:
+                                    log.info("Adding result for: {function_name}")
+                                    token += result
+
+                callback.on_llm_new_token(token=token)
+                big_text += token
+                this_text += token
+                
+                if not usage_metadata:
+                    chunk_metadata = chunk.usage_metadata
+                    usage_metadata = {
+                        "prompt_token_count": chunk_metadata.prompt_token_count,
+                        "candidates_token_count": chunk_metadata.candidates_token_count,
+                        "total_token_count": chunk_metadata.total_token_count,
+                    }
+
+            except ValueError as err:
+                callback.on_llm_new_token(token=str(err))
+        
+        # change response to one with executed functions
+        response = processor.process_funcs(response)
+
+        if this_text:
+            chat_history.append(("<waiting for ai>", this_text))
+            log.info(f"[{guardrail}] Updated chat_history: {chat_history}")
+
+        go_on_check = processor.check_function_result("decide_to_go_on", False)
+        if go_on_check:
+            log.info("Breaking agent loop")
+            break
+        
+        guardrail += 1
+        if guardrail > guardrail_max:
+            log.warning("Guardrail kicked in, more than 10 loops")
+            break
+
+    callback.on_llm_end(response=big_text)
+    log.info(f"orchestrator.response: {big_text}")
+
+    metadata = {
+        "question:": question,
+        "chat_history": chat_history,
+        "usage_metadata": usage_metadata,
+        "functions_called": functions_called
+    }
+
+    return {"answer": big_text or "No answer was given", "metadata": metadata}
+
+
+def vac(question: str, vector_name: str, chat_history=[], **kwargs):
+    # Create a callback that does nothing for streaming if you don't want intermediate outputs
+    class NoOpCallback:
+        def on_llm_new_token(self, token):
+            pass
+        def on_llm_end(self, response):
+            pass
+
+    # Use the NoOpCallback for non-streaming behavior
+    callback = NoOpCallback()
+
+    # Pass all arguments to vac_stream and use the final return
+    result = vac_stream(
+        question=question, 
+        vector_name=vector_name, 
+        chat_history=chat_history, 
+        callback=callback, 
+        **kwargs
+    )
+
+    return result
+
+

sunholo/templates/agent/app.py

@@ -0,0 +1,16 @@
+import os
+
+from sunholo.agents import VACRoutes, create_app
+
+from vac_service import vac_stream, vac
+
+app = create_app(__name__)
+
+# Register the Q&A routes with the specific interpreter functions
+# creates /vac/<vector_name> and /vac/streaming/<vector_name>
+VACRoutes(app, vac_stream, vac)
+
+if __name__ == "__main__":
+    import os
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)
+

sunholo/templates/agent/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("sunholo")

sunholo/templates/agent/tools/your_agent.py

@@ -0,0 +1,78 @@
+from sunholo.genai import GenAIFunctionProcessor
+from sunholo.utils import ConfigManager
+
+from my_log import log
+
+
+class QuartoProcessor(GenAIFunctionProcessor):
+    def construct_tools(self) -> dict:
+        tools = self.config.vacConfig("tools")
+        quarto_config = tools.get("quarto")
+        
+        def decide_to_go_on(go_on: bool):
+            """
+            Examine the chat history.  If the answer to the user's question has been answered, then go_on=False.
+            If the chat history indicates the answer is still being looked for, then go_on=True.
+            If there is no chat history, then go_on=True.
+            If there is an error that can't be corrected or solved by you, then go_on=False.
+            If there is an error but you think you can solve it by correcting your function arguments (such as an incorrect source), then go_on=True
+            If you want to ask the user a question or for some more feedback, then go_on=False.
+            
+            Args:
+                go_on: boolean Whether to continue searching or fetching from the AlloyDB database
+            
+            Returns:
+                boolean: True to carry on, False to continue
+            """
+            return go_on
+
+        def quarto_render() -> dict:
+            """
+            ...
+            
+            Args:
+            
+            
+            Returns:
+                
+            """
+            pass
+
+        return {
+            "quarto_render": quarto_render,
+            "decide_to_go_on": decide_to_go_on
+        }
+
+def quarto_content(question: str, chat_history=[]) -> str:
+    prompt_config = ConfigManager("quarto")
+    alloydb_template = prompt_config.promptConfig("quarto_template")
+    
+    conversation_text = ""
+    for human, ai in chat_history:
+        conversation_text += f"Human: {human}\nAI: {ai}\n"
+
+    return alloydb_template.format(the_question=question, chat_history=conversation_text[-10000:])
+
+
+def get_quarto(config:ConfigManager, processor:QuartoProcessor):
+
+    tools = config.vacConfig('tools')
+
+    if tools and tools.get('quarto'):
+        model_name = None
+        if config.vacConfig('llm') != "vertex":
+            model_name = 'gemini-1.5-flash'
+        alloydb_model = processor.get_model(
+            system_instruction=(
+                    "You are a helpful Quarto agent that helps users create and render Quarto documents. "
+                    "When you think the answer has been given to the satisfaction of the user, or you think no answer is possible, or you need user confirmation or input, you MUST use the decide_to_go_on(go_on=False) function"
+                    "When you want to ask the question to the user, mark the go_on=False in the function"
+                ),
+            model_name=model_name
+        )
+
+        if alloydb_model:
+            return alloydb_model
+
+    log.error("Error initializing quarto model")    
+    return None

sunholo/templates/agent/vac_service.py

@@ -0,0 +1,73 @@
+from my_log import log
+from sunholo.utils import ConfigManager
+
+# VAC specific imports 
+
+#TODO: Developer to update to their own implementation
+from sunholo.vertex import init_vertex, get_vertex_memories
+from vertexai.preview.generative_models import GenerativeModel
+
+#TODO: change this to a streaming VAC function
+def vac_stream(question: str, vector_name, chat_history=[], callback=None, **kwargs):
+
+    rag_model = create_model(vector_name)
+
+    # streaming model calls
+    response = rag_model.generate_content(question, stream=True)
+    for chunk in response:
+        try:
+            callback.on_llm_new_token(token=chunk.text)
+        except ValueError as err:
+            callback.on_llm_new_token(token=str(err))
+    
+    callback.on_llm_end(response=response)
+    log.info(f"rag_model.response: {response}")
+
+    metadata = {
+        "chat_history": chat_history
+    }
+
+    return {"answer": response.text, "metadata": metadata}
+
+
+
+#TODO: change this to a batch VAC function
+def vac(question: str, vector_name: str, chat_history=[], **kwargs):
+    # Create a callback that does nothing for streaming if you don't want intermediate outputs
+    class NoOpCallback:
+        def on_llm_new_token(self, token):
+            pass
+        def on_llm_end(self, response):
+            pass
+
+    # Use the NoOpCallback for non-streaming behavior
+    callback = NoOpCallback()
+
+    # Pass all arguments to vac_stream and use the final return
+    result = vac_stream(
+        question=question, 
+        vector_name=vector_name, 
+        chat_history=chat_history, 
+        callback=callback, 
+        **kwargs
+    )
+
+    return result
+
+
+# TODO: common model setup to both batching and streaming
+def create_model(vac):
+    config = ConfigManager(vac)
+
+    init_vertex()
+    corpus_tools = get_vertex_memories(config)
+
+    model = config.vacConfig("model")
+
+    # Create a gemini-pro model instance
+    # https://ai.google.dev/api/python/google/generativeai/GenerativeModel#streaming
+    rag_model = GenerativeModel(
+        model_name=model or "gemini-1.5-flash", tools=[corpus_tools]
+    )
+
+    return rag_model

sunholo/templates/project/app.py

@@ -0,0 +1,17 @@
+import os
+
+from sunholo.agents import VACRoutes, create_app
+
+from vac_service import vac_stream
+
+app = create_app(__name__)
+
+# Register the Q&A routes with the specific interpreter functions
+# creates endpoints /vac/streaming/<vector_name> and /vac/<vector_name> etc.
+VACRoutes(app, vac_stream)
+
+# start via `python app.py`
+if __name__ == "__main__":
+    import os
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)
+

sunholo/templates/project/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("sunholo")

sunholo/templates/project/vac_service.py

@@ -0,0 +1,71 @@
+from my_log import log
+from sunholo.utils import ConfigManager
+
+# VAC specific imports 
+
+#TODO: Developer to update to their own implementation
+from sunholo.genai import init_genai, genai_safety
+import google.generativeai as genai
+
+#TODO: change this to a streaming VAC function for your use case
+def vac_stream(question: str, vector_name:str, chat_history=[], callback=None, **kwargs):
+
+    model = create_model(vector_name)
+
+    # create chat history for genai model
+    # https://ai.google.dev/api/generate-content
+    contents = []
+    for human, ai in chat_history:
+        if human:
+            contents.append({"role":"user", "parts":[{"text": human}]})
+        
+        if ai:
+            contents.append({"role":"model", "parts":[{"text": ai}]})
+
+
+    # the user question at the end of contents list
+    contents.append({"role":"user", "parts":[{"text": question}]})
+
+    log.info(contents)
+    # streaming model calls
+    response = model.generate_content(contents, stream=True)
+    chunks=""
+    for chunk in response:
+        if chunk and chunk.text:
+            try:
+                callback.on_llm_new_token(token=chunk.text)
+                chunks += chunk.text
+            except ValueError as err:
+                callback.on_llm_new_token(token=str(err))
+    
+    # stream has finished, full response is also returned
+    callback.on_llm_end(response=response)
+    log.info(f"model.response: {response}")
+
+    metadata = {
+        "question": question,
+        "vector_name": vector_name,
+        "chat_history": chat_history
+    }
+
+    # to not return this dict at the end of the stream, pass stream_only: true in request
+    return {"answer": chunks, "metadata": metadata}
+
+
+# TODO: example model setup function
+def create_model(vac):
+    config = ConfigManager(vac)
+
+    init_genai()
+
+    # get a setting from the config vacConfig object (returns None if not found)
+    model = config.vacConfig("model")
+
+    # Create a gemini-flash model instance
+    # https://ai.google.dev/api/python/google/generativeai/GenerativeModel#streaming
+    genai_model = genai.GenerativeModel(
+        model_name=model or "gemini-1.5-flash",
+         safety_settings=genai_safety()
+    )
+
+    return genai_model

sunholo/templates/system_services/app.py

@@ -0,0 +1,49 @@
+import os
+import traceback
+
+# app.py
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from my_log import log
+
+app = FastAPI()
+
+@app.get("/")
+def home():
+    """Simple endpoint to indicate that the app is running."""
+    return {"message": "Hello, service!"}
+
+@app.post("/system_service/<param>")
+async def system_service(request: Request):
+    """
+    Pubsub message parsed and sent to Langfuse ID server
+    """
+    data = await request.json()
+
+    try:
+        #TODO: add stuff here
+        meta = ""
+        return {"status": "success", "message": meta}
+    except Exception as err:
+        log.error(f'EVAL_ERROR: Error when sending {data} to /pubsub_to_langfuse: {str(err)} traceback: {traceback.format_exc()}')
+        return JSONResponse(status_code=200, content={"status": "error", "message": f'{str(err)} traceback: {traceback.format_exc()}'})
+
+@app.post("/test_endpoint")
+async def test_me(request: Request):
+    """
+    Endpoint to send trace_ids directly for evals then sent to Langfuse ID server
+    """
+    data = await request.json()
+
+    try:
+        #TODO: do something here
+        meta = ""
+        return {"status": "success", "message": meta}
+    except Exception as err:
+        log.error(f'EVAL_ERROR: Error when sending {data} to /direct_evals: {str(err)} traceback: {traceback.format_exc()}')
+        return JSONResponse(status_code=500, content={"status": "error", "message": f'{str(err)} traceback: {traceback.format_exc()}'})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)), debug=True)

sunholo/templates/system_services/my_log.py

@@ -0,0 +1,3 @@
+from sunholo.custom_logging import setup_logging
+
+log = setup_logging("system")

{sunholo-0.118.0.dist-info → sunholo-0.118.1.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.2
 Name: sunholo
-Version: 0.118.0
+Version: 0.118.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.118.0.tar.gz
-Author: Holosun ApS
-Author-email: multivac@sunholo.com
+Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
+Project-URL: Homepage, https://github.com/sunholo-data/sunholo-py
+Project-URL: Download, https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz
 Keywords: llms,devops,google_cloud_platform
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -16,6 +15,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aiohttp
@@ -24,6 +24,9 @@ Requires-Dist: pydantic
 Requires-Dist: requests
 Requires-Dist: ruamel.yaml
 Requires-Dist: tenacity
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
 Provides-Extra: all
 Requires-Dist: aiohttp; extra == "all"
 Requires-Dist: anthropic[vertex]; extra == "all"
@@ -169,18 +172,6 @@ Requires-Dist: numpy; extra == "tts"
 Requires-Dist: sounddevice; extra == "tts"
 Provides-Extra: video
 Requires-Dist: opencv-python; extra == "video"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: download-url
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: summary
 
 [![PyPi Version](https://img.shields.io/pypi/v/sunholo.svg)](https://pypi.python.org/pypi/sunholo/)
 

{sunholo-0.118.0.dist-info → sunholo-0.118.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sunholo/__init__.py,sha256=Ap2yX2ITBVt_vkloYipUM8OwW14g6aor2NX7LWp0-mI,1133
 sunholo/custom_logging.py,sha256=YfIN1oP3dOEkkYkyRBU8BGS3uJFGwUDsFCl8mIVbwvE,12225
-sunholo/types.py,sha256=xdNNb4bR7O4jY9NTNzeeiX5VYjVxCGzYWy8hUXemxr0,1764
+sunholo/langchain_types.py,sha256=uZ4zvgej_f7pLqjtu4YP7qMC_eZD5ym_5x4pyvA1Ih4,1834
 sunholo/agents/__init__.py,sha256=X2I3pPkGeKWjc3d0QgSpkTyqD8J8JtrEWqwrumf1MMc,391
 sunholo/agents/chat_history.py,sha256=Gph_CdlP2otYnNdR1q1Umyyyvcad2F6K3LxU5yBQ9l0,5387
 sunholo/agents/dispatch_to_qa.py,sha256=AwLS41oK6iS8xre-HuWjS4jj9dvU-evWI58EYfG65fg,8879
@@ -36,10 +36,10 @@ sunholo/chunker/doc_handling.py,sha256=t_lDazHfJbs4Q2Ruq2MvBBeJRfsjjQkzMxKuX8qQK
 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=5NXrMxV-WdbFpxeLhFzccw0_zhf1UQ7yKFFeaMkc9Bc,11105
-sunholo/chunker/message_data.py,sha256=iPrYUQRjjCGoVDvnqGEudkXi1PdbOwxey6v08_-GF2g,10826
-sunholo/chunker/pdfs.py,sha256=DFZdsvAQt8qMvg7d-3dj29ULgKJZYXy4qGdORLmE790,2467
+sunholo/chunker/message_data.py,sha256=bpb8QWQttqazm5lr7fTFJ5JDwf-P0SQ5cOIf6NikNyI,10836
+sunholo/chunker/pdfs.py,sha256=xwbuMJrbypcyPXfZ8tiUidWeMr80C2NhfTC1mwa8SHY,2477
 sunholo/chunker/process_chunker_data.py,sha256=uO-YOEHIjAOy0ZMJ0vea9OMNsQBISHfhbtgoyuHiP6s,3598
-sunholo/chunker/publish.py,sha256=Y-4w59iVGoXCKaun9jMWVR7Cqprb9mTZGiaVk5y_zrY,2933
+sunholo/chunker/publish.py,sha256=IDud-NhRcEZFv9GkyWJFRKwfptIU052kSPKEx8AYW68,2943
 sunholo/chunker/pubsub.py,sha256=48bhuAcszN7LGe3-ksPSLHHhq0uKxiXOrizck5qpcP0,1012
 sunholo/chunker/splitter.py,sha256=RfekLPkjhCcNd1PFXIj_FxusJMJ8_3cyWl7bsYvtQ0g,7068
 sunholo/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -125,6 +125,20 @@ sunholo/streaming/stream_lookup.py,sha256=hYg1DbdSE_QNJ8ZB-ynXJlWgvFjrGvwoUsGJu_
 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=UnycBVLLEXK1HitCOG2zW3XIyxMrw47xoVf6e2OC9A0,4150
+sunholo/templates/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/templates/agent/agent_service.py,sha256=s2PZZNo287StnkiNIb7S05TWgx0oSJgcAtTWvKz1H2E,6184
+sunholo/templates/agent/app.py,sha256=HK9xXjAoHzuYJQo43ddl1NjRAc7GY4tq6VMxVVUaEyA,413
+sunholo/templates/agent/my_log.py,sha256=otLxNHIGsm4-fsoeagsykoqvBsqM3RlwCgEhsbdtfHA,81
+sunholo/templates/agent/vac_service.py,sha256=FFnZrg0ohG2J4mfwbSIh8v4pgTNNJhN3Ng0jQtrg51c,2109
+sunholo/templates/agent/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/templates/agent/tools/your_agent.py,sha256=vUeAnuIRK3d8Z4TcYQ80bBtPzDsXsUwl_hldt_lw4Uw,2920
+sunholo/templates/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/templates/project/app.py,sha256=skoIQRyTvWUT689RVCMYFDDuYSwkEw-6EsbGTIFLCA4,446
+sunholo/templates/project/my_log.py,sha256=otLxNHIGsm4-fsoeagsykoqvBsqM3RlwCgEhsbdtfHA,81
+sunholo/templates/project/vac_service.py,sha256=Xdfzmcidm4P-IlkjvkQZ47rC6ERRevSI1TchimjRDVg,2213
+sunholo/templates/system_services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sunholo/templates/system_services/app.py,sha256=sJvYP1FC8ufWffr1pqKekVWeZiLMKq5HBWaRKxq8f64,1621
+sunholo/templates/system_services/my_log.py,sha256=BkGSGkwyqIjU6W44BfsOhZbNs2XfzEvmKbfryfI3tBY,80
 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 +164,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.118.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.118.0.dist-info/METADATA,sha256=b8HJvu2GA9AJqTfFcqKBRCw8ArVt71zvQwDUAKuKK3A,9752
-sunholo-0.118.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-sunholo-0.118.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.118.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.118.0.dist-info/RECORD,,
+sunholo-0.118.1.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.118.1.dist-info/METADATA,sha256=_1l01je_MwmiGCriNA97uLBd1TJB04gcfXOUljF3T2Y,9641
+sunholo-0.118.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+sunholo-0.118.1.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.118.1.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.118.1.dist-info/RECORD,,