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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 2.1.14
+Version: 2.2.0
 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.14 → langchain_timbr-2.2.0}/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.14'
-__version_tuple__ = version_tuple = (2, 1, 14)
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)
 
 __commit_id__ = commit_id = None

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

@@ -247,6 +247,8 @@ class ExecuteTimbrQueryChain(Chain):
             concept_name = inputs.get("concept", self._concept)
             is_sql_valid = True
             error = None
+            identify_concept_reason = None
+            generate_sql_reason = None
             reasoning_status = None
             rows = []
             usage_metadata = {}
@@ -270,6 +272,8 @@ class ExecuteTimbrQueryChain(Chain):
                         is_sql_valid = True
 
                     error = generate_res.get("error")
+                    identify_concept_reason = generate_res.get("identify_concept_reason")
+                    generate_sql_reason = generate_res.get("generate_sql_reason")
                     usage_metadata = self._summarize_usage_metadata(usage_metadata, generate_res.get("usage_metadata", {}))
                 
                 is_sql_not_tried = not any(sql.lower().strip() == gen.lower().strip() for gen in generated)
@@ -305,6 +309,8 @@ class ExecuteTimbrQueryChain(Chain):
                 "concept": concept_name,
                 "error": error if not is_sql_valid else None,
                 "reasoning_status": reasoning_status,
+                "identify_concept_reason": identify_concept_reason,
+                "generate_sql_reason": generate_sql_reason,
                 self.usage_metadata_key: usage_metadata,
             }
 

{langchain_timbr-2.1.14 → langchain_timbr-2.2.0}/src/langchain_timbr/langchain/generate_timbr_sql_chain.py

@@ -206,6 +206,8 @@ class GenerateTimbrSqlChain(Chain):
             "concept": concept,
             "is_sql_valid": generate_res.get("is_sql_valid"),
             "error": generate_res.get("error"),
+            "identify_concept_reason": generate_res.get("identify_concept_reason"),
+            "generate_sql_reason": generate_res.get("generate_sql_reason"),
             "reasoning_status": generate_res.get("reasoning_status"),
             self.usage_metadata_key: generate_res.get("usage_metadata"),
         }

{langchain_timbr-2.1.14 → langchain_timbr-2.2.0}/src/langchain_timbr/langchain/timbr_sql_agent.py

@@ -181,6 +181,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": None,
                     "concept": None,
                     "reasoning_status": None,
+                    "identify_concept_reason": None,
+                    "generate_sql_reason": None,
                     "usage_metadata": {},
                 },
                 log="Empty input received"
@@ -210,6 +212,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "error": result.get("error", None),
                     "reasoning_status": result.get("reasoning_status", None),
                     "usage_metadata": usage_metadata,
+                    "identify_concept_reason": None,
+                    "generate_sql_reason": None,
                 },
                 log=f"Successfully executed query on concept: {result.get('concept', '')}"
             )
@@ -224,6 +228,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": None,
                     "concept": None,
                     "reasoning_status": None,
+                    "identify_concept_reason": None,
+                    "generate_sql_reason": None,
                     "usage_metadata": {},
                 },
                 log=error_context
@@ -245,6 +251,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": None,
                     "concept": None,
                     "reasoning_status": None,
+                    "identify_concept_reason": None,
+                    "generate_sql_reason": None,
                     "usage_metadata": {},
                 },
                 log="Empty or whitespace-only input received"
@@ -286,6 +294,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "concept": result.get("concept", ""),
                     "error": result.get("error", None),
                     "reasoning_status": result.get("reasoning_status", None),
+                    "identify_concept_reason": result.get("identify_concept_reason", None),
+                    "generate_sql_reason": result.get("generate_sql_reason", None),
                     "usage_metadata": usage_metadata,
                 },
                 log=f"Successfully executed query on concept: {result.get('concept', '')}"
@@ -301,6 +311,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": None,
                     "concept": None,
                     "reasoning_status": None,
+                    "identify_concept_reason": None,
+                    "generate_sql_reason": None,
                     "usage_metadata": {},
                 },
                 log=error_context

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

@@ -179,6 +179,8 @@ class ValidateTimbrSqlChain(Chain):
         schema = self._schema
         concept = self._concept
         reasoning_status = None
+        identify_concept_reason = None
+        generate_sql_reason = None
 
         is_sql_valid, error, sql = validate_sql(sql, self._get_conn_params())
         if not is_sql_valid:
@@ -211,6 +213,8 @@ class ValidateTimbrSqlChain(Chain):
             is_sql_valid = generate_res.get("is_sql_valid")
             reasoning_status = generate_res.get("reasoning_status")
             error = generate_res.get("error")
+            identify_concept_reason = generate_res.get("identify_concept_reason")
+            generate_sql_reason = generate_res.get("generate_sql_reason")
 
         return {
             "sql": sql,
@@ -219,5 +223,7 @@ class ValidateTimbrSqlChain(Chain):
             "is_sql_valid": is_sql_valid,
             "error": error,
             "reasoning_status": reasoning_status,
+            "identify_concept_reason": identify_concept_reason,
+            "generate_sql_reason": generate_sql_reason,
             self.usage_metadata_key: usage_metadata,
         }

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

@@ -268,6 +268,7 @@ def determine_concept(
 ) -> dict[str, Any]:
     usage_metadata = {}
     determined_concept_name = None
+    identify_concept_reason = None
     schema = 'dtimbr'
     
     # Use config default timeout if none provided
@@ -339,10 +340,21 @@ def determine_concept(
             if debug:
                 usage_metadata['determine_concept']["p_hash"] = encrypt_prompt(prompt)
 
-            response_text = _get_response_text(response)
-            candidate = response_text.strip()
+            # Try to parse as JSON first (with 'result' and 'reason' keys)
+            try:
+                parsed_response = _parse_json_from_llm_response(response)
+                if isinstance(parsed_response, dict) and 'result' in parsed_response:
+                    candidate = parsed_response.get('result', '').strip()
+                    identify_concept_reason = parsed_response.get('reason', None)
+                else:
+                    # Fallback to plain text if JSON doesn't have expected structure
+                    candidate = _get_response_text(response).strip()
+            except (json.JSONDecodeError, ValueError):
+                # If not JSON, treat as plain text (backwards compatibility)
+                candidate = _get_response_text(response).strip()
+            
             if should_validate and candidate not in concepts_and_views.keys():
-                error = f"Concept '{determined_concept_name}' not found in the list of concepts."
+                error = f"Concept '{candidate}' not found in the list of concepts."
                 continue
             
             determined_concept_name = candidate
@@ -356,6 +368,7 @@ def determine_concept(
     return {
         "concept_metadata": concepts_and_views.get(determined_concept_name) if determined_concept_name else None,
         "concept": determined_concept_name,
+        "identify_concept_reason": identify_concept_reason,
         "schema": schema,
         "usage_metadata": usage_metadata,
     }
@@ -423,14 +436,45 @@ def _build_rel_columns_str(relationships: list[dict], columns_tags: Optional[dic
     return '.\n'.join(rel_str_arr) if rel_str_arr else ''
 
 
-def _parse_sql_from_llm_response(response: Any) -> str:
+def _parse_sql_and_reason_from_llm_response(response: Any) -> dict:
+    """
+    Parse SQL & reason from LLM response. Handles both plain SQL strings and JSON format with 'result' and 'reason' keys.
+    
+    Returns:
+        dict with 'sql' and 'reason' keys (reason may be None if not provided)
+    """
+    # Try to parse as JSON first
+    try:
+        parsed_json = _parse_json_from_llm_response(response)
+        
+        # Extract SQL from 'result' key and reason from 'reason' key
+        if isinstance(parsed_json, dict) and 'result' in parsed_json:
+            sql = parsed_json.get('result', '')
+            reason = parsed_json.get('reason', None)
+            
+            # Clean the SQL
+            sql = (sql
+                   .replace("```sql", "")
+                   .replace("```", "")
+                   .replace('SELECT \n', 'SELECT ')
+                   .replace(';', '')
+                   .strip())
+            
+            return {'sql': sql, 'reason': reason}
+    except (json.JSONDecodeError, ValueError):
+        # If not JSON, treat as plain SQL string (backwards compatibility)
+        pass
+    
+    # Fallback to plain text parsing
     response_text = _get_response_text(response)
-    return (response_text
-            .replace("```sql", "")
-            .replace("```", "")
-            .replace('SELECT \n', 'SELECT ')
-            .replace(';', '')
-            .strip())
+    sql = (response_text
+           .replace("```sql", "")
+           .replace("```", "")
+           .replace('SELECT \n', 'SELECT ')
+           .replace(';', '')
+           .strip())
+    
+    return {'sql': sql, 'reason': None}
 
 
 def _get_active_datasource(conn_params: dict) -> dict:
@@ -438,6 +482,38 @@ def _get_active_datasource(conn_params: dict) -> dict:
     return datasources[0] if datasources else None
 
 
+def _parse_json_from_llm_response(response: Any) -> dict:
+    """
+    Parse JSON from LLM response. Handles markdown code blocks and extracts valid JSON.
+    
+    Args:
+        response: LLM response object
+        
+    Returns:
+        dict containing parsed JSON
+        
+    Raises:
+        json.JSONDecodeError: If response cannot be parsed as JSON
+        ValueError: If response format is unexpected
+    """
+    response_text = _get_response_text(response)
+    
+    # Remove markdown code block markers if present
+    content = response_text.strip()
+    if content.startswith("```json"):
+        content = content[7:]  # Remove ```json
+    elif content.startswith("```"):
+        content = content[3:]  # Remove ```
+    
+    if content.endswith("```"):
+        content = content[:-3]  # Remove closing ```
+    
+    content = content.strip()
+    
+    # Parse and return JSON
+    return json.loads(content)
+
+
 def _evaluate_sql_enable_reasoning(
     question: str,
     sql_query: str,
@@ -463,22 +539,8 @@ def _evaluate_sql_enable_reasoning(
     
     response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
     
-    # Extract JSON from response content (handle markdown code blocks)
-    content = response.content.strip()
-    
-    # Remove markdown code block markers if present
-    if content.startswith("```json"):
-        content = content[7:]  # Remove ```json
-    elif content.startswith("```"):
-        content = content[3:]  # Remove ```
-    
-    if content.endswith("```"):
-        content = content[:-3]  # Remove closing ```
-    
-    content = content.strip()
-    
     # Parse JSON response
-    evaluation = json.loads(content)
+    evaluation = _parse_json_from_llm_response(response)
     
     return {
         "evaluation": evaluation,
@@ -571,11 +633,9 @@ def _build_sql_generation_context(
 def _generate_sql_with_llm(
     question: str,
     llm: LLM,
-    conn_params: dict,
     generate_sql_prompt: Any,
     current_context: dict,
     note: str,
-    should_validate_sql: bool,
     timeout: int,
     debug: bool = False,
 ) -> dict:
@@ -614,8 +674,12 @@ def _generate_sql_with_llm(
     
     response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
     
+    # Parse response which now includes both SQL and reason
+    parsed_response = _parse_sql_and_reason_from_llm_response(response)
+    
     result = {
-        "sql": _parse_sql_from_llm_response(response),
+        "sql": parsed_response['sql'],
+        "generate_sql_reason": parsed_response['reason'],
         "apx_token_count": apx_token_count,
         "usage_metadata": _extract_usage_metadata(response),
         "is_valid": True,
@@ -625,11 +689,163 @@ def _generate_sql_with_llm(
     if debug:
         result["p_hash"] = encrypt_prompt(prompt)
     
-    if should_validate_sql:
-        result["is_valid"], result["error"], result["sql"] = validate_sql(result["sql"], conn_params)
     
     return result
 
+def handle_generate_sql_reasoning(
+    sql_query: str,
+    question: str,
+    llm: LLM,
+    conn_params: dict,
+    schema: str,
+    concept: str,
+    concept_metadata: dict,
+    include_tags: bool,
+    exclude_properties: list,
+    db_is_case_sensitive: bool,
+    max_limit: int,
+    reasoning_steps: int,
+    note: str,
+    graph_depth: int,
+    usage_metadata: dict,
+    timeout: int,
+    debug: bool,
+) -> tuple[str, int, str]:
+    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
+    context_graph_depth = graph_depth
+    reasoned_sql = sql_query
+    reasoned_sql_reason = None
+    for step in range(reasoning_steps):
+        try:
+            # Step 1: Evaluate the current SQL
+            eval_result = _evaluate_sql_enable_reasoning(
+                question=question,
+                sql_query=reasoned_sql,
+                llm=llm,
+                conn_params=conn_params,
+                timeout=timeout,
+            )
+            
+            usage_metadata[f'sql_reasoning_step_{step + 1}'] = {
+                "approximate": eval_result['apx_token_count'],
+                **eval_result['usage_metadata'],
+            }
+            
+            evaluation = eval_result['evaluation']
+            reasoning_status = evaluation.get("assessment", "partial").lower()
+            
+            if reasoning_status == "correct":
+                break
+            
+            # Step 2: Regenerate SQL with feedback
+            evaluation_note = note + f"\n\nThe previously generated SQL: `{reasoned_sql}` 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,
+                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,
+                timeout=timeout,
+                debug=debug,
+            )
+            
+            reasoned_sql = regen_result['sql']
+            reasoned_sql_reason = regen_result['generate_sql_reason']
+            error = regen_result['error']
+
+            step_key = f'generate_sql_reasoning_step_{step + 1}'
+            usage_metadata[step_key] = {
+                "approximate": regen_result['apx_token_count'],
+                **regen_result['usage_metadata'],
+            }
+            if debug and 'p_hash' in regen_result:
+                usage_metadata[step_key]['p_hash'] = regen_result['p_hash']
+
+            if error:
+                raise Exception(error)
+            
+        except TimeoutError as e:
+            raise Exception(f"LLM call timed out: {str(e)}")
+        except Exception as e:
+            print(f"Warning: LLM reasoning failed: {e}")
+            break
+    
+    return reasoned_sql, context_graph_depth, reasoned_sql_reason
+
+def handle_validate_generate_sql(
+    sql_query: str,
+    question: str,
+    llm: LLM,
+    conn_params: dict,
+    generate_sql_prompt: Any,
+    schema: str,
+    concept: str,
+    concept_metadata: dict,
+    include_tags: bool,
+    exclude_properties: list,
+    db_is_case_sensitive: bool,
+    max_limit: int,
+    graph_depth: int,
+    retries: int,
+    timeout: int,
+    debug: bool,
+    usage_metadata: dict,
+) -> tuple[bool, str, str]:
+    is_sql_valid, error, sql_query = validate_sql(sql_query, conn_params)
+    validation_attempt = 0
+  
+    while validation_attempt < retries and not is_sql_valid:
+        validation_attempt += 1
+        validation_err_txt = f"\nThe generated SQL (`{sql_query}`) was invalid with error: {error}. Please generate a corrected query that achieves the intended result." if error and "snowflake" not in llm._llm_type else ""
+
+        regen_result = _generate_sql_with_llm(
+            question=question,
+            llm=llm,
+            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=graph_depth,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit),
+            note=validation_err_txt,
+            timeout=timeout,
+            debug=debug,
+        )
+        
+        regen_error = regen_result['error']
+        sql_query = regen_result['sql']
+
+        validation_key = f'generate_sql_validation_regen_{validation_attempt}'
+        usage_metadata[validation_key] = {
+            "approximate": regen_result['apx_token_count'],
+            **regen_result['usage_metadata'],
+        }
+        if debug and 'p_hash' in regen_result:
+            usage_metadata[validation_key]['p_hash'] = regen_result['p_hash']
+
+        if regen_error:
+            raise Exception(regen_error)
+        
+        is_sql_valid, error, sql_query = validate_sql(sql_query, conn_params)
+
+    return is_sql_valid, error, sql_query
 
 def generate_sql(
         question: str,
@@ -656,13 +872,11 @@ def generate_sql(
     usage_metadata = {}
     concept_metadata = None
     reasoning_status = 'correct'
-    
+
     # Use config default timeout if none provided
     if timeout is None:
         timeout = config.llm_timeout
     
-    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
-   
     if concept and concept != "" and (schema is None or schema != "vtimbr"):
         concepts_list = [concept]
     elif concept and concept != "" and schema == "vtimbr":
@@ -682,154 +896,105 @@ def generate_sql(
         debug=debug,
         timeout=timeout,
     )
-    concept, schema, concept_metadata = determine_concept_res.get('concept'), determine_concept_res.get('schema'), determine_concept_res.get('concept_metadata')
+
+    concept = determine_concept_res.get('concept')
+    identify_concept_reason = determine_concept_res.get('identify_concept_reason', None)
+    schema = determine_concept_res.get('schema')
+    concept_metadata = determine_concept_res.get('concept_metadata')
     usage_metadata.update(determine_concept_res.get('usage_metadata', {}))
 
     if not concept:
         raise Exception("No relevant concept found for the query.")
 
+    generate_sql_prompt = get_generate_sql_prompt_template(conn_params)
     sql_query = None
-    iteration = 0
-    is_sql_valid = True
+    generate_sql_reason = None
+    is_sql_valid = True  # Assume valid by default; set to False only if validation fails
     error = ''
-    while sql_query is None or (should_validate_sql and iteration < retries and not is_sql_valid):
-        iteration += 1
-        err_txt = f"\nThe original SQL (`{sql_query}`) was invalid with error: {error}. Please generate a corrected query." if error and "snowflake" not in llm._llm_type else ""
 
-        try:
-            result = _generate_sql_with_llm(
+    try:
+        result = _generate_sql_with_llm(
+            question=question,
+            llm=llm,
+            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=graph_depth,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit),
+            note=note,
+            timeout=timeout,
+            debug=debug,
+        )
+        
+        usage_metadata['generate_sql'] = {
+            "approximate": result['apx_token_count'],
+            **result['usage_metadata'],
+        }
+        if debug and 'p_hash' in result:
+            usage_metadata['generate_sql']["p_hash"] = result['p_hash']
+        
+        sql_query = result['sql']
+        generate_sql_reason = result.get('generate_sql_reason', None)
+        error = result['error']
+
+        if error:
+            raise Exception(error)
+        
+        if enable_reasoning and sql_query is not None:
+            sql_query, graph_depth, generate_sql_reason = handle_generate_sql_reasoning(
+                sql_query=sql_query,
+                question=question,
+                llm=llm,
+                conn_params=conn_params,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit,
+                reasoning_steps=reasoning_steps,
+                note=note,
+                graph_depth=graph_depth,
+                usage_metadata=usage_metadata,
+                timeout=timeout,
+                debug=debug,
+            )
+
+        if should_validate_sql or enable_reasoning:
+            # Validate & regenerate only once if reasoning enabled and validation is disabled
+            validate_retries = 1 if not should_validate_sql else retries
+            is_sql_valid, error, sql_query = handle_validate_generate_sql(
+                sql_query=sql_query,
                 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=graph_depth,
-                    include_tags=include_tags,
-                    exclude_properties=exclude_properties,
-                    db_is_case_sensitive=db_is_case_sensitive,
-                    max_limit=max_limit),
-                note=note + err_txt,
-                should_validate_sql=should_validate_sql,
+                schema=schema,
+                concept=concept,
+                concept_metadata=concept_metadata,
+                include_tags=include_tags,
+                exclude_properties=exclude_properties,
+                db_is_case_sensitive=db_is_case_sensitive,
+                max_limit=max_limit,
+                graph_depth=graph_depth,
+                retries=validate_retries,
                 timeout=timeout,
                 debug=debug,
+                usage_metadata=usage_metadata,
             )
-            
-            usage_metadata['generate_sql'] = {
-                "approximate": result['apx_token_count'],
-                **result['usage_metadata'],
-            }
-            if debug and 'p_hash' in result:
-                usage_metadata['generate_sql']["p_hash"] = result['p_hash']
-            
-            sql_query = result['sql']
-            is_sql_valid = result['is_valid']
-            error = result['error']
-            
-        except TimeoutError as e:
-            error = f"LLM call timed out: {str(e)}"
-            raise Exception(error)
-        except Exception as e:
-            error = f"LLM call failed: {str(e)}"
-            if should_validate_sql:
-                continue
-            else:
-                raise Exception(error)
-    
-    
-    if enable_reasoning and sql_query is not None:
-        for step in range(reasoning_steps):
-            try:
-                # Step 1: Evaluate the current SQL
-                eval_result = _evaluate_sql_enable_reasoning(
-                    question=question,
-                    sql_query=sql_query,
-                    llm=llm,
-                    conn_params=conn_params,
-                    timeout=timeout,
-                )
-                
-                usage_metadata[f'sql_reasoning_step_{step + 1}'] = {
-                    "approximate": eval_result['apx_token_count'],
-                    **eval_result['usage_metadata'],
-                }
-                
-                evaluation = eval_result['evaluation']
-                reasoning_status = evaluation.get("assessment", "partial").lower()
-                
-                if reasoning_status == "correct":
-                    break
-                
-                # 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
-                
-                # 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_sql
-                is_sql_valid = regen_is_valid
-                error = regen_error
-                
-            except TimeoutError as e:
-                raise Exception(f"LLM call timed out: {str(e)}")
-            except Exception as e:
-                print(f"Warning: LLM reasoning failed: {e}")
-                break
+    except TimeoutError as e:
+        error = f"LLM call timed out: {str(e)}"
+        raise Exception(error)
+    except Exception as e:
+        error = f"LLM call failed: {str(e)}"
+        raise Exception(error)
     
     return {
         "sql": sql_query,
@@ -837,6 +1002,8 @@ def generate_sql(
         "schema": schema,
         "error": error if not is_sql_valid else None,
         "is_sql_valid": is_sql_valid if should_validate_sql else None,
+        "identify_concept_reason": identify_concept_reason,
+        "generate_sql_reason": generate_sql_reason,
         "reasoning_status": reasoning_status,
         "usage_metadata": usage_metadata,
     }

{langchain_timbr-2.1.14 → langchain_timbr-2.2.0}/tests/integration/test_langchain_chains.py

@@ -27,6 +27,8 @@ class TestIdentifyTimbrConceptChain:
         print("IdentifyTimbrConceptChain result:", result)
         assert "concept" in result, "Chain should return a 'concept'"
         assert result["concept"], "Returned concept should not be empty"
+        assert "identify_concept_reason" in result, "Chain should return a 'identify_concept_reason'"
+        assert result["identify_concept_reason"], "Returned identify_concept_reason should not be empty"
         assert chain.usage_metadata_key in result, "Chain should return 'usage_metadata'"
         assert len(result[chain.usage_metadata_key]) == 1 and 'determine_concept' in result[chain.usage_metadata_key], "Usage metadata should contain only 'determine_concept'"
 
@@ -63,6 +65,11 @@ class TestGenerateTimbrSqlChain:
         assert "concept" in result and result["concept"], "Concept name should be returned"
         assert chain.usage_metadata_key in result, "Chain should return 'usage_metadata'"
         assert len(result[chain.usage_metadata_key]) == 2 and 'determine_concept' in result[chain.usage_metadata_key] and 'generate_sql' in result[chain.usage_metadata_key], "Usage metadata should contain both 'determine_concept' and 'generate_sql'"
+        assert "identify_concept_reason" in result, "Chain should return a 'identify_concept_reason'"
+        assert result["identify_concept_reason"], "Returned identify_concept_reason should not be empty"
+        assert "generate_sql_reason" in result, "Chain should return a 'generate_sql_reason'"
+        assert result["generate_sql_reason"], "Returned generate_sql_reason should not be empty"
+
 
     def test_generate_timbr_sql_with_limit_chain(self, llm, config):
         """Test SQL generation with row limit."""