llumo 0.2.41__py3-none-any.whl → 0.2.43__py3-none-any.whl

llumo/client.py

@@ -8,10 +8,12 @@ import json
 import uuid
 import warnings
 import os
-
+from typing import List, Dict, Optional
 import itertools
 import pandas as pd
-from typing import List, Dict
+from typing import List, Dict, Any
+
+
 from .models import AVAILABLEMODELS, getProviderFromModel, Provider
 from .execution import ModelExecutor
 from .exceptions import LlumoAIError
@@ -50,6 +52,7 @@ class LlumoClient:
         self.evals = []
         self.processMapping = {}
         self.definationMapping = {}
+        self.ALL_USER_AIM =  ['incorrectOutput', 'incorrectInput', 'hallucination', 'ragQuality', 'contextMismanagement', 'toolCallIssues', 'agentReasoning', 'stuckAgents', 'jsonErrors', 'highLatency', 'highCost', 'safetyBlocks', 'modelRouting', 'systemErrors', 'promptAdherence']
 
     def validateApiKey(self, evalName="Input Bias"):
         headers = {
@@ -780,7 +783,9 @@ class LlumoClient:
             self,
             data,
             promptTemplate="",
-            systemInstructions = ""
+            systemInstructions = "",
+            multiTurnChat=False,
+            createMultipleLogs = True
 
     ):
         if isinstance(data, dict):
@@ -788,7 +793,7 @@ class LlumoClient:
         elif not isinstance(data, list):
             raise ValueError("Data should be a dict or a list of dicts.")
 
-        dataframe = pd.DataFrame(data).astype(str)
+        dataframe = pd.DataFrame(data).astype(str).replace(to_replace="nan",value = "")
         workspaceID = None
         email = None
 
@@ -820,49 +825,72 @@ class LlumoClient:
         allBatches = []
         for index, row in dataframe.iterrows():
             # Extract required fields
+            query = row.get("query", "")
+            context = row.get("context", "")
+
             tools = row.get("tools", "")
             groundTruth = row.get("groundTruth", "")
-            messageHistory = row.get("messageHistory", "")
-            intermediateSteps = row.get("intermediateSteps", "")
-            output = row.get("output", "")
 
-            # Initialize query and context
-            query = ""
-            context = ""
+            if  multiTurnChat==False:
+                # ---- SINGLE TURN (existing behavior) ----
+                messageHistory = row.get("messageHistory", "")
 
-            # Process prompt template if provided
-            if promptTemplate:
-                # Extract template variables
-                keys = re.findall(r"{{(.*?)}}", promptTemplate)
+            else:
+                # ---- MULTI TURN ----
+                multiTurnData = createMessageHistory(data, index)
 
-                if not all([key in dataframe.columns for key in keys]):
-                    raise LlumoAIError.InvalidPromptTemplate()
+                if createMultipleLogs==True:
+                    # each row will get history till that point
+                    messageHistory = multiTurnData
+                else:
+                    # only final API call should contain full history
+                    if index == len(dataframe) - 1:
+                        messageHistory = multiTurnData
+                    else:
+                        messageHistory = ""
 
-                # Populate template and separate query/context
-                populated_template = promptTemplate
-                for key in keys:
-                    value = row.get(key, "")
-                    if isinstance(value, str):
-                        length = len(value.split()) * 1.5
-                        if length <= 50:
-                            # Short value - include in query via template
-                            temp_obj = {key: value}
-                            populated_template = getInputPopulatedPrompt(populated_template, temp_obj)
-                        else:
-                            # Long value - add to context
-                            context += f" {key}: {value}, "
 
-                query = populated_template.strip()
 
-                # Add any remaining context from other fields
-                if not context.strip():
-                    for key, value in row.items():
-                        if key not in keys and isinstance(value, str) and value.strip():
-                            context += f" {key}: {value}, "
-            else:
-                # No prompt template - use direct query and context fields
-                query = row.get("query", "")
-                context = row.get("context", "")
+            intermediateSteps = row.get("intermediateSteps", "")
+            output = row.get("output", "")
+
+            # # Initialize query and context
+            # query = ""
+            # context = ""
+            #
+            # # Process prompt template if provided
+            # if promptTemplate:
+            #     # Extract template variables
+            #     keys = re.findall(r"{{(.*?)}}", promptTemplate)
+            #
+            #     if not all([key in dataframe.columns for key in keys]):
+            #         raise LlumoAIError.InvalidPromptTemplate()
+            #
+            #     # Populate template and separate query/context
+            #     populated_template = promptTemplate
+            #     for key in keys:
+            #         value = row.get(key, "")
+            #         if isinstance(value, str):
+            #             length = len(value.split()) * 1.5
+            #             if length <= 50:
+            #                 # Short value - include in query via template
+            #                 temp_obj = {key: value}
+            #                 populated_template = getInputPopulatedPrompt(populated_template, temp_obj)
+            #             else:
+            #                 # Long value - add to context
+            #                 context += f" {key}: {value}, "
+            #
+            #     query = populated_template.strip()
+            #
+            #     # Add any remaining context from other fields
+            #     if not context.strip():
+            #         for key, value in row.items():
+            #             if key not in keys and isinstance(value, str) and value.strip():
+            #                 context += f" {key}: {value}, "
+            # else:
+            #     # No prompt template - use direct query and context fields
+            #     query = row.get("query", "")
+            #     context = row.get("context", "")
 
             INPUT_TOKEN_PRICE = 0.0000025
             OUTPUT_TOKEN_PRICE = 0.00001
@@ -885,9 +913,13 @@ class LlumoClient:
                  "totalTokens": totalTokens,
                  "cost": round(cost, 8),
                  "modelsUsed": "gpt-4o",
-                 "latency":round(random.uniform(1,1.6),2)
+                 "latency":round(random.uniform(1,1.6),2),
+                "promptTemplate": promptTemplate,
+                "systemInstructions": systemInstructions
+
 
             }
+
             currentTime = datetime(2025, 8, 2, 10, 20, 15, tzinfo=timezone.utc)
             createdAt = currentTime.strftime("%Y-%m-%dT%H:%M:%S.000Z")
             rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
@@ -910,8 +942,7 @@ class LlumoClient:
                 "columnID":rowID,
                 "rowID":columnID,
                 "latency": random.randint(1000, 1500),
-                "promptTemplate":promptTemplate,
-                "systemInstructions":systemInstructions
+
 
             }
 
@@ -2082,14 +2113,147 @@ class LlumoClient:
                     definationMapping=self.definationMapping,
                 )
 
-    def get_evaluate_multiple(
-        self,
-        data,
-        evals
-    ) -> List:
+    # def get_evaluate_multiple(
+    #     self,
+    #     data,
+    #     evals
+    # ) -> List:
+
+    #     print("Evaluating multiple data with evals:", data, evals)
 
-        print("Evaluating multiple data with evals:", data, evals)
+    #     dataID = uuid.uuid4().hex[:36]
 
+    #     self.validateApiKey()
+
+    #     if not self.workspaceID:
+    #         raise LlumoAIError("Workspace ID not found after validation.")
+
+    #     payload = {
+    #         "dataID": dataID,
+    #         "data": data,
+    #         "evals": evals,
+    #         "workspaceID": self.workspaceID,
+    #         "playgroundID": self.playgroundID,
+    #     }
+
+    #     print("payload", payload)
+
+    #     # Create evaluation
+    #     requests.post(
+    #         "https://backend-api.llumo.ai/api/v1/sdk/create-evaluation-Multiple",
+    #         json=payload,
+    #         headers={
+    #             "Content-Type": "application/json",
+    #             "Authorization": f"Bearer {self.apiKey}",
+    #         },
+    #     )
+
+    #     final_result_data = []
+
+    #     cursor = "0-0"
+    #     limit = 10
+    #     all_data_fetched = False
+
+    #     while not all_data_fetched:
+    #         try:
+    #             response = requests.get(
+    #                 "https://backend-api.llumo.ai/api/v1/sdk/poll",
+    #                 params={
+    #                     "cursor": cursor,
+    #                     "dataID": dataID,
+    #                     "limit": limit,
+    #                 },
+    #             )
+
+    #             response_data = response.json()
+    #             result_data = response_data.get("debugLog", {})
+    #             print("resultData", result_data)
+
+    #             results = result_data.get("results", [])
+    #             final_result_data.extend(results)
+
+    #             cursor = result_data.get("nextCursor")
+
+    #             if len(final_result_data) == len(data):
+    #                 all_data_fetched = True
+
+    #             time.sleep(10)
+
+    #         except Exception as error:
+    #             print("error", error)
+    #             all_data_fetched = True
+
+    #     # Shape results
+    #     formatted_results = []
+
+    #     for row in final_result_data:
+    #         score: Dict[str, float | None] = {}
+    #         reasoning: Dict[str, str] = {}
+
+    #         for eval_name in evals:
+    #             details = row.get(eval_name)
+
+    #             if isinstance(details, dict):
+    #                 if isinstance(details.get("value"), (int, float)):
+    #                     score[eval_name] = details.get("value")
+    #                 else:
+    #                     score[eval_name] = details.get("score")
+    #                 reasoning[eval_name] = details.get("reasoning", "")
+
+    #             elif "score" in row:
+    #                 score[eval_name] = (
+    #                     row["score"] if isinstance(row["score"], (int, float)) else None
+    #                 )
+    #                 reasoning[eval_name] = row.get("reasoning", "")
+    #             else:
+    #                 score[eval_name] = None
+    #                 reasoning[eval_name] = ""
+
+    #         formatted_row = {
+    #             "context": row.get("context", ""),
+    #             "query": row.get("query", ""),
+    #             "output": row.get("output", ""),
+    #             "score": score,
+    #             "reasoning": reasoning,
+    #         }
+
+    #         print(formatted_row)
+    #         formatted_results.append(formatted_row)
+
+    #     return formatted_results
+
+    def getEvaluateMultiple(
+            self,
+            data,
+            evals,
+            promptTemplate="",
+            systemInstructions="",
+            multiTurnChat=False,
+            createMultipleLogs=True
+    ):
+        # print("Evaluating multiple data with evals:", data, evals)
+        try:
+            self.validateApiKey()
+        except Exception as e:
+            print(f"Error during API key validation: {str(e)}")
+            if hasattr(e, "response") and getattr(e, "response", None) is not None:
+                print(f"Status code: {e.response.status_code}")
+                print(f"Response content: {e.response.text[:500]}...")
+            raise
+
+        userHits = checkUserHits(
+            self.workspaceID,
+            self.hasSubscribed,
+            self.trialEndDate,
+            self.subscriptionEndDate,
+            self.hitsAvailable,
+            len(data),
+        )
+
+        if not userHits["success"]:
+            raise LlumoAIError.InsufficientCredits(userHits["message"])
+
+        print("✅ SDK integration successful!")
         dataID = uuid.uuid4().hex[:36]
 
         self.validateApiKey()
@@ -2097,6 +2261,38 @@ class LlumoClient:
         if not self.workspaceID:
             raise LlumoAIError("Workspace ID not found after validation.")
 
+        if promptTemplate:
+            for row in data:
+                row["promptTemplate"] = promptTemplate
+        if systemInstructions:
+            for row in data:
+                row["systemInstructions"] = systemInstructions
+
+        if multiTurnChat == True:
+            if createMultipleLogs == True:
+                dataWithMessageHistory = []
+                for indx, row in enumerate(data):
+                    messageHistory = createMessageHistory(data, currentIndex=indx)
+                    rowCopy = row.copy()
+                    rowCopy["messageHistory"] = messageHistory
+                    dataWithMessageHistory.append(rowCopy)
+                data = dataWithMessageHistory
+            else:
+                dataWithMessageHistory = []
+                for indx, row in enumerate(data):
+                    if indx == len(data) - 1:
+                        messageHistory = createMessageHistory(data, currentIndex=indx)
+                        rowCopy = row.copy()
+                        rowCopy["messageHistory"] = messageHistory
+                        dataWithMessageHistory.append(rowCopy)
+                    else:
+                        row["messageHistory"] = ""
+                        dataWithMessageHistory.append(row)
+
+                data = dataWithMessageHistory
+
+        # print("DATA:")
+        # print(data)
         payload = {
             "dataID": dataID,
             "data": data,
@@ -2105,7 +2301,7 @@ class LlumoClient:
             "playgroundID": self.playgroundID,
         }
 
-        print("payload", payload)
+        # print("payload", payload)
 
         # Create evaluation
         requests.post(
@@ -2123,6 +2319,7 @@ class LlumoClient:
         limit = 10
         all_data_fetched = False
 
+        print("✅ Evaluation Started...")
         while not all_data_fetched:
             try:
                 response = requests.get(
@@ -2136,7 +2333,7 @@ class LlumoClient:
 
                 response_data = response.json()
                 result_data = response_data.get("debugLog", {})
-                print("resultData", result_data)
+                # print("resultData", result_data)
 
                 results = result_data.get("results", [])
                 final_result_data.extend(results)
@@ -2179,17 +2376,163 @@ class LlumoClient:
                     reasoning[eval_name] = ""
 
             formatted_row = {
-                "context": row.get("context", ""),
                 "query": row.get("query", ""),
+                "context": row.get("context", ""),
                 "output": row.get("output", ""),
                 "score": score,
                 "reasoning": reasoning,
             }
 
-            print(formatted_row)
+            # print(formatted_row)
             formatted_results.append(formatted_row)
 
-        return formatted_results
+        return {"llumoEval": formatted_results}
+
+
+    def getInsights(self,logs:List,userAim:List[str],promptTemplate:str = ""
+                    ,systemInstructions:str="",multiTurnChat=False,createMultipleLogs=True):
+
+        try:
+            self.validateApiKey()
+        except Exception as e:
+            print(f"Error during API key validation: {str(e)}")
+            if hasattr(e, "response") and getattr(e, "response", None) is not None:
+                print(f"Status code: {e.response.status_code}")
+                print(f"Response content: {e.response.text[:500]}...")
+            raise
+
+        userHits = checkUserHits(
+            self.workspaceID,
+            self.hasSubscribed,
+            self.trialEndDate,
+            self.subscriptionEndDate,
+            self.hitsAvailable,
+            1,
+        )
+
+        if not userHits["success"]:
+            raise LlumoAIError.InsufficientCredits(userHits["message"])
+
+        if len(logs)==0 :
+            raise LlumoAIError.emptyLogList()
+
+        if not isinstance(userAim, list):
+            raise TypeError(f"userAim must be list, got {type(userAim).__name__}")
+
+        if any(aim not in self.ALL_USER_AIM for aim in userAim):
+            errorMessage = f"Please pass a valid user aim. Only acceptable user aims are->{self.ALL_USER_AIM}"
+            raise LlumoAIError.invalidUserAim(details=errorMessage)
+
+
+
+        if multiTurnChat == True:
+            if createMultipleLogs == True:
+                dataWithMessageHistory = []
+                for indx, row in enumerate(logs):
+                    messageHistory = createMessageHistory(logs, currentIndex=indx)
+                    rowCopy = row.copy()
+                    rowCopy["messageHistory"] = messageHistory
+                    dataWithMessageHistory.append(rowCopy)
+                logs= dataWithMessageHistory
+            else:
+                dataWithMessageHistory = []
+                for indx, row in enumerate(logs):
+                    if indx == len(logs) - 1:
+                        messageHistory = createMessageHistory(logs, currentIndex=indx)
+                        rowCopy = row.copy()
+                        rowCopy["messageHistory"] = messageHistory
+                        dataWithMessageHistory.append(rowCopy)
+                    else:
+                        row["messageHistory"] = ""
+                        dataWithMessageHistory.append(row)
+                logs = dataWithMessageHistory
+
+        if (promptTemplate!="") or systemInstructions!="":
+            logs = addPromptAndInstructionInLogs(logData = logs ,promptTemplate=promptTemplate,systemInstruction=systemInstructions)
+
+        # print("[LOGS: ]")
+        # print(logs)
+
+        # 1. Create Report
+        print("✅ Generating Insights Now....")
+        dataID = uuid.uuid4().hex[:36]
+        try:
+            payload = {
+                "data":logs,
+                "userAim":userAim,
+                "dataID":dataID
+            }
+            create_url = "https://backend-api.llumo.ai/api/v1/sdk/create-insight-report"
+            response = requests.post(create_url, json=payload)
+
+            # Check if request was successful
+            response.raise_for_status()
+
+            # print(f"Create Response: {response.json()}")
+        except requests.exceptions.RequestException as e:
+            # Check for response data in the error
+            error_data = e.response.json() if e.response else str(e)
+            print(f"Error in create request: {error_data}")
+            return
+
+        # 2. Poll for Results
+        # print("\n--- Starting Polling ---")
+        cursor = '0-0'
+        is_complete = False
+        max_polls = 20
+        poll_count = 0
+
+        insight_result = []
+        while not is_complete and poll_count < max_polls:
+            poll_count += 1
+
+            try:
+                poll_params = {
+                    'dataID': dataID,
+                    'cursor': cursor,
+                    'limit': 10
+                }
+                poll_url = f"https://backend-api.llumo.ai/api/v1/sdk/poll-insight-report"
+                poll_response = requests.get(poll_url, params=poll_params)
+                poll_response.raise_for_status()
+
+                data = poll_response.json()
+                # Accessing nested data: pollResponse.data.debugLog
+                debug_log = data.get('debugLog', {})
+                results = debug_log.get('results', [])
+                next_cursor = debug_log.get('nextCursor')
+
+                if results:
+                    insight_result.extend(results)
+
+                # Logic to handle cursor movement
+                if next_cursor == cursor and not results:
+                    # print("Long poll returned empty (timeout). Continuing...")
+                    pass
+                else:
+                    cursor = next_cursor
+
+                # Break condition for test (heuristic)
+                if len(insight_result):
+                    break
+
+            except requests.exceptions.RequestException as e:
+                error_msg = e.response.json() if e.response else str(e)
+                # print(f"Error in poll request: {error_msg}")
+
+                if e.response is not None and e.response.status_code == 404:
+                    # print("Resource not ready yet...")
+                    pass
+                else:
+                    # Fatal error, break the loop
+                    break
+
+            # Small delay to prevent tight loop (Equivalent to await sleep(1000))
+            time.sleep(1)
+
+        # llumoInsight = formattedInsightResponse(llmResponse=insight_result)
+
+        return {"llumoInsight": insight_result}
 
 
 class SafeDict(dict):

llumo/exceptions.py

@@ -1,3 +1,4 @@
+
 class LlumoAIError(Exception):
     """Base class for all Llumo SDK-related errors."""
 
@@ -54,6 +55,14 @@ class LlumoAIError(Exception):
     def providerError(details):
         return LlumoAIError(details)
 
+    @staticmethod
+    def emptyLogList(details= "List of log object is empty. Ensure your logs have at least 1 log object."):
+        return LlumoAIError(details)
+
+    @staticmethod
+    def invalidUserAim(details= ""):
+        return LlumoAIError(details)
+
     # @staticmethod
     # def dateNotFound():
     #     return LlumoAIError("Trial end date or subscription end date not found for the given user.")

llumo/helpingFuntions.py

@@ -29,6 +29,9 @@ createInsightUrl="https://app.llumo.ai/api/external/generate-insight-from-eval-f
 
 getCustomAnalyticsUrl="https://app.llumo.ai/api/workspace/get-all-analytics"
 
+
+
+
 def getProcessID():
     return f"{int(time.time() * 1000)}{uuid.uuid4()}"
 
@@ -739,6 +742,8 @@ def getCustomAnalytics(workspaceID):
         return {}
 
 
+def normalize_md(s: str) -> str:
+    return "\n".join(line.lstrip() for line in s.splitlines())
 
 def postForDebugLogs(record: {},workspaceID):
     url = "https://backend-api.llumo.ai/api/v1/get-debug-log-for-upload"
@@ -834,3 +839,104 @@ def addSelectedTools(run: dict) -> dict:
                 current_agent_step["metadata"]["toolSelected"].append(tool_name)
 
     return run
+
+def createMessageHistory(data, currentIndex = 0):
+    conversationHistory = []
+    for dataObj in data[:currentIndex]:
+        conversationHistory.append(dataObj)
+    return f"{conversationHistory}"
+
+
+def addPromptAndInstructionInLogs(logData=None,promptTemplate= "",systemInstruction=""):
+    logDataWithPrompt = []
+    for data in logData:
+        if isinstance(data,str):
+            logDataWithPrompt.append(data + f"**promptTemplate**={promptTemplate}\n **systemInstruction**={systemInstruction}")
+        elif isinstance(data,dict):
+            data["promptTemplate"]= promptTemplate
+            data["systemInstruction"]= systemInstruction
+            logDataWithPrompt.append(data)
+
+        else:
+            return logData
+    return logDataWithPrompt
+
+
+def dataPollingFuncForEval(headers,post_payload,poll_params,data_len:int):
+    postUrl = "https://backend-api.llumo.ai/api/v1/sdk/create-evaluation-Multiple"
+    pollUrl = "https://backend-api.llumo.ai/api/v1/sdk/poll"
+
+    # Create evaluation
+    requests.post(
+        url= postUrl,
+        json=post_payload,
+        headers=headers,
+    )
+    # print("payload", payload)
+
+    final_result_data = []
+    all_data_fetched = False
+
+    print("✅ Evaluation Started...")
+    while not all_data_fetched:
+        try:
+            response = requests.get(
+                pollUrl,
+                params=poll_params,
+            )
+
+            response_data = response.json()
+            result_data = response_data.get("debugLog", {})
+            # print("resultData", result_data)
+
+            results = result_data.get("results", [])
+            final_result_data.extend(results)
+
+            cursor = result_data.get("nextCursor")
+
+            if len(final_result_data) == data_len:
+                all_data_fetched = True
+
+            time.sleep(10)
+
+        except Exception as error:
+            print("error", error)
+            all_data_fetched = True
+    return final_result_data
+
+def formattedInsightResponse(llmResponse):
+    try:
+        response = llmResponse
+        jsonResponse = response.json().get("response", {})
+        reasons = "\n- ".join(jsonResponse['reason'])
+        solutions = "\n- ".join(jsonResponse['solution'])
+        examples = "\n- ".join(jsonResponse['examples'])
+
+        formattedResponse = f"""
+        # 🔍 **{jsonResponse['insightTitle'].strip()}**
+        ---
+        ## 🧠 **Insight**
+        > {jsonResponse['insight'].strip()}
+        ---
+        ## 📝 **Description**
+        {jsonResponse['shortDescription'].strip()}
+        ---
+        ## 🔎 **Root Causes**
+        - {reasons.strip()}
+        ---
+        ## 🛠 **Solutions**
+        - {solutions.strip()}
+        ---
+        ## 📌 **Examples**
+        - {examples.strip()}
+        ---
+        """
+        formattedResponse = normalize_md(formattedResponse)
+        llumoInsight = formattedResponse
+
+
+
+    except Exception as e:
+        print("An error occurred. Please try again.")
+        llumoInsight = e
+    return llumoInsight

llumo/llumoLogger.py

@@ -2,9 +2,10 @@ import requests
 
 
 class LlumoLogger:
-    def __init__(self, apiKey: str, playground: str):
+    def __init__(self, apiKey: str, project: str):
         self.apiKey = apiKey
-        self.playground = playground
+        # self.playground = playground
+        self.playground = project
         self.workspaceID = None
         self.playgroundID = None
         self.userEmailID = None

llumo/llumoSessionContext.py

@@ -102,9 +102,10 @@ class LlumoSessionContext(LlumoClient):
                 "totalTokens": "",
                 "cost": "",
                 "modelsUsed": "gpt-4o",
+                "promptTemplate": promptTemplate,
+                "systemInstructions": systemInstructions
                        },
-            "promptTemplate":promptTemplate,
-            "systemInstructions":systemInstructions
+
         }
 
         self.threadLlumoRun = _ctxLlumoRun.set(llumoRun)

{llumo-0.2.41.dist-info → llumo-0.2.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llumo
-Version: 0.2.41
+Version: 0.2.43
 Summary: Python SDK for interacting with the Llumo ai API.
 Home-page: https://www.llumo.ai/
 Author: Llumo

{llumo-0.2.41.dist-info → llumo-0.2.43.dist-info}/RECORD

@@ -2,19 +2,19 @@ llumo/__init__.py,sha256=kkuppu7ZPiVZFdnYzJ9BM3syMbYHOSZLpwKwAvGHsnY,311
 llumo/callback.py,sha256=XQbImLnd64_B2Iir-FCaJcL5Kmpm3RlXJH2zDRXk_yk,25135
 llumo/callbacks-0.py,sha256=TEIOCWRvk2UYsTmBMBsnlgpqWvr-2y3a6d0w_e96NRM,8958
 llumo/chains.py,sha256=6lCgLseh04RUgc6SahhmvQj82quay2Mi1j8gPUlx8Es,2923
-llumo/client.py,sha256=YTNdvtv03BVDNHeLypHQadDN2PpXsyOk0dM8hc7P-Ts,83205
-llumo/exceptions.py,sha256=1OyhN9YL9LcyUPUsqYHq6Rret0udATZAwMVJaio2_Ec,2123
+llumo/client.py,sha256=yuvh81zxkck-QvgqRSwTSGtLohkNBj28B_wsSf27NuQ,95904
+llumo/exceptions.py,sha256=lUugHX1EorGse_5dU4vBRU82TNkN6VDaAq6JGOcfzaA,2381
 llumo/execution.py,sha256=nWbJ7AvWuUPcOb6i-JzKRna_PvF-ewZTiK8skS-5n3w,1380
 llumo/functionCalling.py,sha256=D5jYapu1rIvdIJNUYPYMTyhQ1H-6nkwoOLMi6eekfUE,7241
 llumo/google.py,sha256=6y9YnDFDRHv6-sQNT5LIsV9p31BCN0B9eow5KTRBWfM,2185
-llumo/helpingFuntions.py,sha256=eMR2Rq8vw4X5sIESOvjOBrEvyYE00Eq7XlQjV66eVcg,29977
-llumo/llumoLogger.py,sha256=ALM4461jItWcvYL9HzTGmB-X-M77YF_9PTeTPxtmP_E,2223
-llumo/llumoSessionContext.py,sha256=XA2SIXKh62NRz1qxkvhpo7ziOhushG2CkJgjUWlmvFw,14880
+llumo/helpingFuntions.py,sha256=4ompFeWq-mr67NkbiSUGvqFnQPtffIXUIYzGyihOqLs,33083
+llumo/llumoLogger.py,sha256=syFerZgosq1xm2EkE-o6xBhEg7zE07X9ASao39ZEECQ,2256
+llumo/llumoSessionContext.py,sha256=QaiQtB13dITTVINpzEAEVlO-fpW362XkgMjM1W4EHoo,14891
 llumo/models.py,sha256=aVEZsOOoQx5LeNtwSyBxqvrINq0izH3QWu_YjsMPE6o,2910
 llumo/openai.py,sha256=VstBzaORe8Tq0feUIIEszzcN1oq6TJfkPviaCr5d3Bw,8950
 llumo/sockets.py,sha256=pfWz1zTEiwqJhdbSy3i3_Y4WlIdJ3cuac11wMePeBS0,6130
-llumo-0.2.41.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
-llumo-0.2.41.dist-info/METADATA,sha256=pamF6aPT4DF9NO1361IN4dcJ63O2YUCxdeMPPut2bd0,1662
-llumo-0.2.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llumo-0.2.41.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.2.41.dist-info/RECORD,,
+llumo-0.2.43.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
+llumo-0.2.43.dist-info/METADATA,sha256=z1TDEUY-imh53V2TxceOUO9_XXEmMuynH6RpfYEQPEc,1662
+llumo-0.2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llumo-0.2.43.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.2.43.dist-info/RECORD,,