langchain-timbr 2.1.12__tar.gz → 2.1.14__tar.gz

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/.github/workflows/install-dependencies-and-run-tests.yml

@@ -22,6 +22,7 @@ env:
   JWT_PASSWORD: ${{ secrets.JWT_PASSWORD }}
   JWT_SCOPE: ${{ secrets.JWT_SCOPE }}
   JWT_SECRET: ${{ secrets.JWT_SECRET }}
+  LLM_TIMEOUT: ${{ secrets.LLM_TIMEOUT }}
 
 jobs:
   test-python-310:

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 2.1.12
+Version: 2.1.14
 Summary: LangChain & LangGraph extensions that parse LLM prompts into Timbr semantic SQL and execute them.
 Project-URL: Homepage, https://github.com/WPSemantix/langchain-timbr
 Project-URL: Documentation, https://docs.timbr.ai/doc/docs/integration/langchain-sdk/

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.1.12'
-__version_tuple__ = version_tuple = (2, 1, 12)
+__version__ = version = '2.1.14'
+__version_tuple__ = version_tuple = (2, 1, 14)
 
 __commit_id__ = commit_id = None

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/config.py

@@ -19,7 +19,7 @@ llm_model = os.environ.get('LLM_MODEL')
 llm_api_key = os.environ.get('LLM_API_KEY')
 llm_temperature = os.environ.get('LLM_TEMPERATURE', 0.0)
 llm_additional_params = os.environ.get('LLM_ADDITIONAL_PARAMS', '')
-llm_timeout = to_integer(os.environ.get('LLM_TIMEOUT', 60))  # Default 60 seconds timeout
+llm_timeout = to_integer(os.environ.get('LLM_TIMEOUT', 120))  # Default 120 seconds timeout
 
 # Optional for Azure OpenAI with Service Principal authentication
 llm_tenant_id = os.environ.get('LLM_TENANT_ID', None)

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/langchain/execute_timbr_query_chain.py

@@ -252,7 +252,7 @@ class ExecuteTimbrQueryChain(Chain):
             usage_metadata = {}
 
             if sql and self._should_validate_sql:
-                is_sql_valid, error = validate_sql(sql, self._get_conn_params())
+                is_sql_valid, error, sql = validate_sql(sql, self._get_conn_params())
 
             is_infered = False
             iteration = 0

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/langchain/validate_timbr_sql_chain.py

@@ -180,7 +180,7 @@ class ValidateTimbrSqlChain(Chain):
         concept = self._concept
         reasoning_status = None
 
-        is_sql_valid, error = validate_sql(sql, self._get_conn_params())
+        is_sql_valid, error, sql = validate_sql(sql, self._get_conn_params())
         if not is_sql_valid:
             prompt_extension = self._note + '\n' if self._note else ""
             generate_res = generate_sql(

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/langgraph/execute_timbr_query_node.py

@@ -102,7 +102,7 @@ class ExecuteSemanticQueryNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-            prompt = state.messages[-1].content if state.messages[-1] else None
+            prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
             prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/langgraph/generate_timbr_sql_node.py

@@ -94,7 +94,7 @@ class GenerateTimbrSqlNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-            prompt = state.messages[-1].content if (state.messages and state.messages[-1]) else None
+            prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
             prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/langgraph/identify_concept_node.py

@@ -66,7 +66,7 @@ class IdentifyConceptNode:
 
     def run(self, state: StateGraph) -> dict:
         try:
-          prompt = state.messages[-1].content if state.messages[-1] else None
+          prompt = state.messages[-1].get('content') if state.messages[-1] and 'content' in state.messages[-1] else None
         except Exception:
           prompt = state.get('prompt', None)
 

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/utils/timbr_llm_utils.py

@@ -52,14 +52,14 @@ def _clean_snowflake_prompt(prompt: Any) -> None:
     prompt[1].content = clean_func(prompt[1].content)  # User message
 
 
-def _call_llm_with_timeout(llm: LLM, prompt: Any, timeout: int = 60) -> Any:
+def _call_llm_with_timeout(llm: LLM, prompt: Any, timeout: int = 120) -> Any:
     """
     Call LLM with timeout to prevent hanging.
     
     Args:
         llm: The LLM instance
         prompt: The prompt to send
-        timeout: Timeout in seconds (default: 60)
+        timeout: Timeout in seconds (default: 120)
         
     Returns:
         LLM response
@@ -626,7 +626,7 @@ def _generate_sql_with_llm(
         result["p_hash"] = encrypt_prompt(prompt)
     
     if should_validate_sql:
-        result["is_valid"], result["error"] = validate_sql(result["sql"], conn_params)
+        result["is_valid"], result["error"], result["sql"] = validate_sql(result["sql"], conn_params)
     
     return result
 
@@ -763,42 +763,67 @@ def generate_sql(
                 if reasoning_status == "correct":
                     break
                 
-                # Step 2: Regenerate SQL with feedback
-                evaluation_note = note + f"\n\nThe previously generated SQL: `{sql_query}` was assessed as '{evaluation.get('assessment')}' because: {evaluation.get('reasoning', '*could not determine cause*')}. Please provide a corrected SQL query that better answers the question: '{question}'."
+                # Step 2: Regenerate SQL with feedback (with validation retries)
+                evaluation_note = note + f"\n\nThe previously generated SQL: `{sql_query}` was assessed as '{evaluation.get('assessment')}' because: {evaluation.get('reasoning', '*could not determine cause*')}. Please provide a corrected SQL query that better answers the question: '{question}'.\n\nCRITICAL: Return ONLY the SQL query without any explanation or comments."
                 
                 # Increase graph depth for 2nd+ reasoning attempts, up to max of 3
                 context_graph_depth = min(3, int(graph_depth) + step) if graph_depth < 3 and step > 0 else graph_depth
-                regen_result = _generate_sql_with_llm(
-                    question=question,
-                    llm=llm,
-                    conn_params=conn_params,
-                    generate_sql_prompt=generate_sql_prompt,
-                    current_context=_build_sql_generation_context(
-                        conn_params=conn_params,
-                        schema=schema,
-                        concept=concept,
-                        concept_metadata=concept_metadata,
-                        graph_depth=context_graph_depth,
-                        include_tags=include_tags,
-                        exclude_properties=exclude_properties,
-                        db_is_case_sensitive=db_is_case_sensitive,
-                        max_limit=max_limit),
-                    note=evaluation_note,
-                    should_validate_sql=should_validate_sql,
-                    timeout=timeout,
-                    debug=debug,
-                )
                 
-                usage_metadata[f'generate_sql_reasoning_step_{step + 1}'] = {
-                    "approximate": regen_result['apx_token_count'],
-                    **regen_result['usage_metadata'],
-                }
-                if debug and 'p_hash' in regen_result:
-                    usage_metadata[f'generate_sql_reasoning_step_{step + 1}']['p_hash'] = regen_result['p_hash']
+                # Regenerate SQL with validation retries
+                # Always validate during reasoning to ensure quality, regardless of global should_validate_sql flag
+                validation_iteration = 0
+                regen_is_valid = False
+                regen_error = ''
+                regen_sql = None
+                
+                while validation_iteration < retries and (regen_sql is None or not regen_is_valid):
+                    validation_iteration += 1
+                    validation_err_txt = f"\nThe regenerated SQL (`{regen_sql}`) was invalid with error: {regen_error}. Please generate a corrected query." if regen_error and "snowflake" not in llm._llm_type else ""
+                    
+                    regen_result = _generate_sql_with_llm(
+                        question=question,
+                        llm=llm,
+                        conn_params=conn_params,
+                        generate_sql_prompt=generate_sql_prompt,
+                        current_context=_build_sql_generation_context(
+                            conn_params=conn_params,
+                            schema=schema,
+                            concept=concept,
+                            concept_metadata=concept_metadata,
+                            graph_depth=context_graph_depth,
+                            include_tags=include_tags,
+                            exclude_properties=exclude_properties,
+                            db_is_case_sensitive=db_is_case_sensitive,
+                            max_limit=max_limit),
+                        note=evaluation_note + validation_err_txt,
+                        should_validate_sql=True,  # Always validate during reasoning
+                        timeout=timeout,
+                        debug=debug,
+                    )
+                    
+                    regen_sql = regen_result['sql']
+                    regen_is_valid = regen_result['is_valid']
+                    regen_error = regen_result['error']
+                    
+                    # Track token usage for each validation iteration
+                    if validation_iteration == 1:
+                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}'] = {
+                            "approximate": regen_result['apx_token_count'],
+                            **regen_result['usage_metadata'],
+                        }
+                        if debug and 'p_hash' in regen_result:
+                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}']['p_hash'] = regen_result['p_hash']
+                    else:
+                        usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}'] = {
+                            "approximate": regen_result['apx_token_count'],
+                            **regen_result['usage_metadata'],
+                        }
+                        if debug and 'p_hash' in regen_result:
+                            usage_metadata[f'generate_sql_reasoning_step_{step + 1}_validation_{validation_iteration}']['p_hash'] = regen_result['p_hash']
                 
-                sql_query = regen_result['sql']
-                is_sql_valid = regen_result['is_valid']
-                error = regen_result['error']
+                sql_query = regen_sql
+                is_sql_valid = regen_is_valid
+                error = regen_error
                 
             except TimeoutError as e:
                 raise Exception(f"LLM call timed out: {str(e)}")

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/src/langchain_timbr/utils/timbr_utils.py

@@ -154,24 +154,37 @@ def get_datasources(conn_params: dict, filter_active: Optional[bool] = False) ->
     return res
 
 
-def validate_sql(sql: str, conn_params: dict) -> tuple[bool, str]:
+def _validate(sql: str, conn_params: dict) -> bool:
+    explain_sql = f"EXPLAIN {sql}"
+    explain_res = run_query(explain_sql, conn_params)
+    
+    query_sql = f"SELECT * FROM ({sql.replace(';', '')}) explainable_query WHERE 1=0"
+    query_res = run_query(query_sql, conn_params)
+
+    return to_boolean(explain_res and explain_res[0].get('PLAN') and query_res is not None)
+
+
+def validate_sql(sql: str, conn_params: dict) -> tuple[bool, str, str]:
     if not sql:
         raise Exception("Please provide SQL to validate.")
     
-    explain_res = None
-    query_res = None
+    is_valid = False
     error = None
 
     try:
-        explain_sql = f"EXPLAIN {sql}"
-        explain_res = run_query(explain_sql, conn_params)
-        
-        query_sql = f"SELECT * FROM ({sql.replace(';', '')}) explainable_query WHERE 1=0"
-        query_res = run_query(query_sql, conn_params)
+        is_valid = _validate(sql, conn_params)
     except Exception as e:
         error = str(getattr(e, 'doc', e))
-
-    return to_boolean(explain_res and explain_res[0].get('PLAN') and query_res is not None), error
+        if not sql.upper().startswith("SELECT"):
+            sql = sql[sql.upper().index("SELECT"):]
+            try:
+                is_valid = _validate(sql, conn_params)
+                if is_valid:
+                    error = None
+            except Exception:
+                pass
+
+    return is_valid, error, sql
 
 
 def _should_ignore_tag(tag_name: str) -> bool:

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/tests/integration/test_langgraph_nodes.py

@@ -29,7 +29,7 @@ class TestLangGraphNodes:
         # Create a test state payload.
         state = {
             "prompt": config["test_prompt"],
-            "messages": [{ "content": config["test_prompt"] }],
+            # "messages": [{ "content": config["test_prompt"] }],
         }
         result = node(state)
         print("IdentifyConceptNode result:", result)
@@ -111,3 +111,24 @@ class TestLangGraphNodes:
         print("GenerateResponseNode result:", result)
         assert "answer" in result, "Result should contain 'answer'"
         assert result["answer"], "Answer should not be empty"
+
+    def test_execute_node_with_state_graph(self, llm, config):
+        """Test basic ExecuteSemanticQueryNode functionality."""
+        from langgraph.graph import StateGraph
+        state = StateGraph(dict)
+        state.messages = [{"content": config["test_prompt"]}]
+
+        execute_query_node = ExecuteSemanticQueryNode(
+            llm=llm,
+            url=config["timbr_url"],
+            token=config["timbr_token"],
+            ontology=config["timbr_ontology"],
+            verify_ssl=config["verify_ssl"],
+        )
+
+        output = execute_query_node(state)
+
+        print("ExecuteSemanticQueryNode result:", output)
+        assert "rows" in output, "Result should contain 'rows'"
+        assert isinstance(output["rows"], list), "'rows' should be a list"
+        assert output["sql"], "SQL should be present in the result"

{langchain_timbr-2.1.12 → langchain_timbr-2.1.14}/tests/integration/test_timeout_functionality.py

@@ -13,14 +13,14 @@ from unittest.mock import Mock
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'langchain_timbr'))
 
 
-def _call_llm_with_timeout(llm, prompt, timeout: int = 60):
+def _call_llm_with_timeout(llm, prompt, timeout: int = 120):
     """
     Call LLM with timeout to prevent hanging.
     
     Args:
         llm: The LLM instance (mock for testing)
         prompt: The prompt to send
-        timeout: Timeout in seconds (default: 60)
+        timeout: Timeout in seconds (default: 120)
         
     Returns:
         LLM response