langchain-timbr 2.1.4__py3-none-any.whl → 2.1.6__py3-none-any.whl

langchain_timbr/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.1.4'
-__version_tuple__ = version_tuple = (2, 1, 4)
+__version__ = version = '2.1.6'
+__version_tuple__ = version_tuple = (2, 1, 6)
 
 __commit_id__ = commit_id = None

langchain_timbr/config.py

@@ -27,4 +27,8 @@ llm_client_id = os.environ.get('LLM_CLIENT_ID', None)
 llm_client_secret = os.environ.get('LLM_CLIENT_SECRET', None)
 llm_endpoint = os.environ.get('LLM_ENDPOINT', None)
 llm_api_version = os.environ.get('LLM_API_VERSION', None)
-llm_scope = os.environ.get('LLM_SCOPE', "https://cognitiveservices.azure.com/.default")  # e.g. "api://<your-client-id>/.default"
+llm_scope = os.environ.get('LLM_SCOPE', "https://cognitiveservices.azure.com/.default")  # e.g. "api://<your-client-id>/.default"
+
+# Whether to enable reasoning during SQL generation
+with_reasoning = to_boolean(os.environ.get('WITH_REASONING', 'false'))
+reasoning_steps = to_integer(os.environ.get('REASONING_STEPS', 2))

langchain_timbr/langchain/execute_timbr_query_chain.py

@@ -42,6 +42,8 @@ class ExecuteTimbrQueryChain(Chain):
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        with_reasoning: Optional[bool] = config.with_reasoning,
+        reasoning_steps: Optional[int] = config.reasoning_steps,
         debug: Optional[bool] = False,
         **kwargs,
     ):
@@ -69,6 +71,8 @@ class ExecuteTimbrQueryChain(Chain):
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+        :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
         :param kwargs: Additional arguments to pass to the base
         :return: A list of rows from the Timbr query
 
@@ -137,6 +141,8 @@ class ExecuteTimbrQueryChain(Chain):
         self._jwt_tenant_id = jwt_tenant_id
         self._debug = to_boolean(debug)
         self._conn_params = conn_params or {}
+        self._with_reasoning = to_boolean(with_reasoning)
+        self._reasoning_steps = to_integer(reasoning_steps)
 
 
     @property
@@ -209,6 +215,8 @@ class ExecuteTimbrQueryChain(Chain):
             note=(self._note or '') + err_txt,
             db_is_case_sensitive=self._db_is_case_sensitive,
             graph_depth=self._graph_depth,
+            with_reasoning=self._with_reasoning,
+            reasoning_steps=self._reasoning_steps,
             debug=self._debug,
         )
 
@@ -239,6 +247,7 @@ class ExecuteTimbrQueryChain(Chain):
             concept_name = inputs.get("concept", self._concept)
             is_sql_valid = True
             error = None
+            reasoning_status = None
             usage_metadata = {}
 
             if sql and self._should_validate_sql:
@@ -255,6 +264,7 @@ class ExecuteTimbrQueryChain(Chain):
                     schema_name = generate_res.get("schema", schema_name)
                     concept_name = generate_res.get("concept", concept_name)
                     is_sql_valid = generate_res.get("is_sql_valid")
+                    reasoning_status = generate_res.get("reasoning_status")
                     if not is_sql_valid and not self._should_validate_sql:
                         is_sql_valid = True
 
@@ -293,6 +303,7 @@ class ExecuteTimbrQueryChain(Chain):
                 "schema": schema_name,
                 "concept": concept_name,
                 "error": error if not is_sql_valid else None,
+                "reasoning_status": reasoning_status,
                 self.usage_metadata_key: usage_metadata,
             }
 

langchain_timbr/langchain/generate_answer_chain.py

@@ -34,8 +34,8 @@ class GenerateAnswerChain(Chain):
         :param verify_ssl: Whether to verify SSL certificates (default is True).
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
-        :param note: Optional additional note to extend our llm prompt
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param note: Optional additional note to extend our llm prompt
         
         ## Example
         ```

langchain_timbr/langchain/generate_timbr_sql_chain.py

@@ -39,6 +39,8 @@ class GenerateTimbrSqlChain(Chain):
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        with_reasoning: Optional[bool] = config.with_reasoning,
+        reasoning_steps: Optional[int] = config.reasoning_steps,
         debug: Optional[bool] = False,
         **kwargs,
     ):
@@ -64,6 +66,9 @@ class GenerateTimbrSqlChain(Chain):
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+        :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
+        :param debug: Whether to enable debug mode for detailed logging
         :param kwargs: Additional arguments to pass to the base
         
         ## Example
@@ -129,6 +134,8 @@ class GenerateTimbrSqlChain(Chain):
         self._jwt_tenant_id = jwt_tenant_id
         self._debug = to_boolean(debug)
         self._conn_params = conn_params or {}
+        self._with_reasoning = to_boolean(with_reasoning)
+        self._reasoning_steps = to_integer(reasoning_steps)
 
 
     @property
@@ -184,6 +191,8 @@ class GenerateTimbrSqlChain(Chain):
             note=self._note,
             db_is_case_sensitive=self._db_is_case_sensitive,
             graph_depth=self._graph_depth,
+            with_reasoning=self._with_reasoning,
+            reasoning_steps=self._reasoning_steps,
             debug=self._debug,
         )
         
@@ -197,5 +206,6 @@ class GenerateTimbrSqlChain(Chain):
             "concept": concept,
             "is_sql_valid": generate_res.get("is_sql_valid"),
             "error": generate_res.get("error"),
+            "reasoning_status": generate_res.get("reasoning_status"),
             self.usage_metadata_key: generate_res.get("usage_metadata"),
         }

langchain_timbr/langchain/timbr_sql_agent.py

@@ -6,6 +6,7 @@ from langchain.schema import AgentAction, AgentFinish
 from ..utils.general import parse_list, to_boolean, to_integer
 from .execute_timbr_query_chain import ExecuteTimbrQueryChain
 from .generate_answer_chain import GenerateAnswerChain
+from .. import config
 
 class TimbrSqlAgent(BaseSingleActionAgent):
     def __init__(
@@ -34,6 +35,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        with_reasoning: Optional[bool] = config.with_reasoning,
+        reasoning_steps: Optional[int] = config.reasoning_steps,
         debug: Optional[bool] = False
     ):
         """
@@ -61,6 +64,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+        :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
 
         ## Example
         ```
@@ -113,6 +118,8 @@ class TimbrSqlAgent(BaseSingleActionAgent):
             is_jwt=to_boolean(is_jwt),
             jwt_tenant_id=jwt_tenant_id,
             conn_params=conn_params,
+            with_reasoning=to_boolean(with_reasoning),
+            reasoning_steps=to_integer(reasoning_steps),
             debug=to_boolean(debug),
         )
         self._generate_answer = to_boolean(generate_answer)
@@ -173,6 +180,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "sql": None,
                     "schema": None,
                     "concept": None,
+                    "reasoning_status": None,
                     "usage_metadata": {},
                 },
                 log="Empty input received"
@@ -200,6 +208,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": result.get("schema", ""),
                     "concept": result.get("concept", ""),
                     "error": result.get("error", None),
+                    "reasoning_status": result.get("reasoning_status", None),
                     "usage_metadata": usage_metadata,
                 },
                 log=f"Successfully executed query on concept: {result.get('concept', '')}"
@@ -214,6 +223,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "sql": None,
                     "schema": None,
                     "concept": None,
+                    "reasoning_status": None,
                     "usage_metadata": {},
                 },
                 log=error_context
@@ -234,6 +244,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "sql": None,
                     "schema": None,
                     "concept": None,
+                    "reasoning_status": None,
                     "usage_metadata": {},
                 },
                 log="Empty or whitespace-only input received"
@@ -274,6 +285,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "schema": result.get("schema", ""),
                     "concept": result.get("concept", ""),
                     "error": result.get("error", None),
+                    "reasoning_status": result.get("reasoning_status", None),
                     "usage_metadata": usage_metadata,
                 },
                 log=f"Successfully executed query on concept: {result.get('concept', '')}"
@@ -288,6 +300,7 @@ class TimbrSqlAgent(BaseSingleActionAgent):
                     "sql": None,
                     "schema": None,
                     "concept": None,
+                    "reasoning_status": None,
                     "usage_metadata": {},
                 },
                 log=error_context
@@ -332,6 +345,8 @@ def create_timbr_sql_agent(
     is_jwt: Optional[bool] = False,
     jwt_tenant_id: Optional[str] = None,
     conn_params: Optional[dict] = None,
+    with_reasoning: Optional[bool] = config.with_reasoning,
+    reasoning_steps: Optional[int] = config.reasoning_steps,
     debug: Optional[bool] = False
 ) -> AgentExecutor:
     """
@@ -361,6 +376,8 @@ def create_timbr_sql_agent(
     :param is_jwt: Whether to use JWT authentication (default is False).
     :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
     :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+    :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+    :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
 
     Returns:
         AgentExecutor: Configured agent executor ready to use
@@ -427,6 +444,8 @@ def create_timbr_sql_agent(
         is_jwt=is_jwt,
         jwt_tenant_id=jwt_tenant_id,
         conn_params=conn_params,
+        with_reasoning=with_reasoning,
+        reasoning_steps=reasoning_steps,
         debug=debug,
     )
     

langchain_timbr/langgraph/execute_timbr_query_node.py

@@ -3,7 +3,7 @@ from langchain.llms.base import LLM
 from langgraph.graph import StateGraph
 
 from ..langchain.execute_timbr_query_chain import ExecuteTimbrQueryChain
-
+from .. import config
 
 class ExecuteSemanticQueryNode:
     """
@@ -36,6 +36,8 @@ class ExecuteSemanticQueryNode:
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        with_reasoning: Optional[bool] = config.with_reasoning,
+        reasoning_steps: Optional[int] = config.reasoning_steps,
         debug: Optional[bool] = False,
         **kwargs,
     ):
@@ -63,6 +65,8 @@ class ExecuteSemanticQueryNode:
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+        :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
         :return: A list of rows from the Timbr query
         """
         self.chain = ExecuteTimbrQueryChain(
@@ -89,6 +93,8 @@ class ExecuteSemanticQueryNode:
             is_jwt=is_jwt,
             jwt_tenant_id=jwt_tenant_id,
             conn_params=conn_params,
+            with_reasoning=with_reasoning,
+            reasoning_steps=reasoning_steps,
             debug=debug,
             **kwargs,
         )

langchain_timbr/langgraph/generate_response_node.py

@@ -20,6 +20,7 @@ class GenerateResponseNode:
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        note: Optional[str] = '',
         debug: Optional[bool] = False,
         **kwargs,
     ):
@@ -31,6 +32,7 @@ class GenerateResponseNode:
         :param is_jwt: Whether to use JWT authentication (default is False).
         :param jwt_tenant_id: JWT tenant ID for multi-tenant environments (required when is_jwt=True).
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param note: Optional additional note to extend our llm prompt
         """
         self.chain = GenerateAnswerChain(
             llm=llm,
@@ -40,6 +42,7 @@ class GenerateResponseNode:
             is_jwt=is_jwt,
             jwt_tenant_id=jwt_tenant_id,
             conn_params=conn_params,
+            note=note,
             debug=debug,
             **kwargs,
         )

langchain_timbr/langgraph/generate_timbr_sql_node.py

@@ -3,6 +3,7 @@ from langchain.llms.base import LLM
 from langgraph.graph import StateGraph
 
 from ..langchain.generate_timbr_sql_chain import GenerateTimbrSqlChain
+from .. import config
 
 class GenerateTimbrSqlNode:
     """
@@ -32,6 +33,8 @@ class GenerateTimbrSqlNode:
         is_jwt: Optional[bool] = False,
         jwt_tenant_id: Optional[str] = None,
         conn_params: Optional[dict] = None,
+        with_reasoning: Optional[bool] = config.with_reasoning,
+        reasoning_steps: Optional[int] = config.reasoning_steps,
         debug: Optional[bool] = False,
         **kwargs,
     ):
@@ -57,6 +60,8 @@ class GenerateTimbrSqlNode:
         :param is_jwt: Whether to use JWT authentication (default: False)
         :param jwt_tenant_id: Tenant ID for JWT authentication when using multi-tenant setup
         :param conn_params: Extra Timbr connection parameters sent with every request (e.g., 'x-api-impersonate-user').
+        :param with_reasoning: Whether to enable reasoning during SQL generation (default is False).
+        :param reasoning_steps: Number of reasoning steps to perform if reasoning is enabled (default is 2).
         """
         self.chain = GenerateTimbrSqlChain(
             llm=llm,
@@ -80,6 +85,8 @@ class GenerateTimbrSqlNode:
             is_jwt=is_jwt,
             jwt_tenant_id=jwt_tenant_id,
             conn_params=conn_params,
+            with_reasoning=with_reasoning,
+            reasoning_steps=reasoning_steps,
             debug=debug,
             **kwargs,
         )

langchain_timbr/llm_wrapper/llm_wrapper.py

@@ -15,6 +15,7 @@ class LlmTypes(Enum):
   Snowflake = 'snowflake-cortex'
   Databricks = 'chat-databricks'
   VertexAI = 'chat-vertexai'
+  Bedrock = 'amazon_bedrock_converse_chat'
   Timbr = 'timbr'
 
 
@@ -252,6 +253,28 @@ class LlmWrapper(LLM):
         credentials=creds,
         **params,
       )
+    elif is_llm_type(llm_type, LlmTypes.Bedrock):
+      from langchain_aws import ChatBedrockConverse
+      llm_model = model or "openai.gpt-oss-20b-1:0"
+      params = self._add_temperature(LlmTypes.Bedrock.name, llm_model, **llm_params)
+
+      aws_region = pop_param_value(params, ['aws_region', 'llm_region', 'region'])
+      if aws_region:
+        params['region_name'] = aws_region
+      aws_access_key_id = pop_param_value(params, ['aws_access_key_id', 'llm_access_key_id', 'access_key_id'])
+      if aws_access_key_id:
+        params['aws_access_key_id'] = aws_access_key_id
+      aws_secret_access_key = pop_param_value(params, ['aws_secret_access_key', 'llm_secret_access_key', 'secret_access_key'], default=api_key)
+      if aws_secret_access_key:
+        params['aws_secret_access_key'] = aws_secret_access_key
+      aws_session_token = pop_param_value(params, ['aws_session_token', 'llm_session_token', 'session_token'])
+      if aws_session_token:
+        params['aws_session_token'] = aws_session_token
+
+      return ChatBedrockConverse(
+        model=llm_model,
+        **params,
+      )
     else:
       raise ValueError(f"Unsupported LLM type: {llm_type}")
 
@@ -324,6 +347,31 @@ class LlmWrapper(LLM):
         if self.client.credentials:
           client = genai.Client(credentials=self.client.credentials, vertexai=True, project=self.client.project, location=self.client.location)
           models = [m.name.split('/')[-1] for m in client.models.list()]
+      elif is_llm_type(self._llm_type, LlmTypes.Bedrock):
+        import boto3
+        
+        # Extract SecretStr values properly
+        aws_access_key_id = getattr(self.client, 'aws_access_key_id', None)
+        if aws_access_key_id and hasattr(aws_access_key_id, '_secret_value'):
+          aws_access_key_id = aws_access_key_id._secret_value
+        
+        aws_secret_access_key = getattr(self.client, 'aws_secret_access_key', None)
+        if aws_secret_access_key and hasattr(aws_secret_access_key, '_secret_value'):
+          aws_secret_access_key = aws_secret_access_key._secret_value
+        
+        aws_session_token = getattr(self.client, 'aws_session_token', None)
+        if aws_session_token and hasattr(aws_session_token, '_secret_value'):
+          aws_session_token = aws_session_token._secret_value
+        
+        bedrock_client = boto3.client(
+          service_name='bedrock',
+          region_name=getattr(self.client, 'region_name', None),
+          aws_access_key_id=aws_access_key_id,
+          aws_secret_access_key=aws_secret_access_key,
+          aws_session_token=aws_session_token,
+        )
+        response = bedrock_client.list_foundation_models()
+        models = [model['modelId'] for model in response.get('modelSummaries', [])]
 
     except Exception:
       # If model list fetching throws an exception, return default value using get_supported_models
@@ -341,6 +389,9 @@ class LlmWrapper(LLM):
 
 
   def _call(self, prompt, **kwargs):
+    # TODO: Remove this condition on next langchain-timbr major release
+    if is_llm_type(self._llm_type, LlmTypes.Bedrock):
+      return self.client.invoke(prompt, **kwargs)
     return self.client(prompt, **kwargs)
 
 

langchain_timbr/utils/timbr_llm_utils.py

@@ -4,7 +4,8 @@ import base64, hashlib
 from cryptography.fernet import Fernet
 from datetime import datetime
 import concurrent.futures
-import time
+import json
+from langchain_core.messages import HumanMessage, SystemMessage
 
 from .timbr_utils import get_datasources, get_tags, get_concepts, get_concept_properties, validate_sql, get_properties_description, get_relationships_description
 from .prompt_service import (
@@ -135,7 +136,7 @@ def _prompt_to_string(prompt: Any) -> str:
     return prompt_text.strip()
 
 
-def _calculate_token_count(llm: LLM, prompt: str) -> int:
+def _calculate_token_count(llm: LLM, prompt: str | list[Any]) -> int:
     """
     Calculate the token count for a given prompt text using the specified LLM.
     Falls back to basic if the LLM doesn't support token counting.
@@ -187,21 +188,103 @@ def _get_response_text(response: Any) -> str:
     return response_text
 
 def _extract_usage_metadata(response: Any) -> dict:
-    usage_metadata = response.response_metadata
-
-    if usage_metadata and 'usage' in usage_metadata:
-        usage_metadata = usage_metadata['usage']
-
-    if not usage_metadata and 'usage_metadata' in response:
-        usage_metadata = response.usage_metadata
-        if usage_metadata and 'usage' in usage_metadata:
-            usage_metadata = usage_metadata['usage']
-
-    if not usage_metadata and 'usage' in response:
-        usage_metadata = response.usage
-        if usage_metadata and 'usage' in usage_metadata:
-            usage_metadata = usage_metadata['usage']
-
+    """
+    Extract usage metadata from LLM response across different providers.
+    
+    Different providers return usage data in different formats:
+    - OpenAI/AzureOpenAI: response.response_metadata['token_usage'] or response.usage_metadata
+    - Anthropic: response.response_metadata['usage'] or response.usage_metadata
+    - Google/VertexAI: response.usage_metadata
+    - Bedrock: response.response_metadata['usage'] or response.response_metadata (direct ResponseMetadata)
+    - Snowflake: response.response_metadata['usage']
+    - Databricks: response.usage_metadata or response.response_metadata
+    """
+    usage_metadata = {}
+    
+    # Try to get response_metadata first (most common)
+    if hasattr(response, 'response_metadata') and response.response_metadata:
+        resp_meta = response.response_metadata
+        
+        # Check for 'usage' key (Anthropic, Bedrock, Snowflake)
+        if 'usage' in resp_meta:
+            usage_metadata = resp_meta['usage']
+        # Check for 'token_usage' key (OpenAI/AzureOpenAI)
+        elif 'token_usage' in resp_meta:
+            usage_metadata = resp_meta['token_usage']
+        # Check for direct token fields in response_metadata (some Bedrock responses)
+        elif any(key in resp_meta for key in ['input_tokens', 'output_tokens', 'total_tokens', 
+                                                'prompt_tokens', 'completion_tokens']):
+            usage_metadata = {
+                k: v for k, v in resp_meta.items() 
+                if k in ['input_tokens', 'output_tokens', 'total_tokens', 
+                        'prompt_tokens', 'completion_tokens']
+            }
+    
+    # Try usage_metadata attribute (Google, VertexAI, some others)
+    if not usage_metadata and hasattr(response, 'usage_metadata') and response.usage_metadata:
+        usage_meta = response.usage_metadata
+        if isinstance(usage_meta, dict):
+            # If it has a nested 'usage' key
+            if 'usage' in usage_meta:
+                usage_metadata = usage_meta['usage']
+            else:
+                usage_metadata = usage_meta
+        else:
+            # Handle case where usage_metadata is an object with attributes
+            usage_metadata = {
+                k: getattr(usage_meta, k) 
+                for k in dir(usage_meta) 
+                if not k.startswith('_') and not callable(getattr(usage_meta, k))
+            }
+    
+    # Try direct usage attribute (fallback)
+    if not usage_metadata and hasattr(response, 'usage') and response.usage:
+        usage = response.usage
+        if isinstance(usage, dict):
+            if 'usage' in usage:
+                usage_metadata = usage['usage']
+            else:
+                usage_metadata = usage
+        else:
+            # Handle case where usage is an object with attributes
+            usage_metadata = {
+                k: getattr(usage, k) 
+                for k in dir(usage) 
+                if not k.startswith('_') and not callable(getattr(usage, k))
+            }
+    
+    # Normalize token field names to standard format
+    # Different providers use different names: input_tokens vs prompt_tokens, etc.
+    if usage_metadata:
+        normalized = {}
+        
+        # Map various input token field names
+        if 'input_tokens' in usage_metadata:
+            normalized['input_tokens'] = usage_metadata['input_tokens']
+        elif 'prompt_tokens' in usage_metadata:
+            normalized['input_tokens'] = usage_metadata['prompt_tokens']
+        
+        # Map various output token field names
+        if 'output_tokens' in usage_metadata:
+            normalized['output_tokens'] = usage_metadata['output_tokens']
+        elif 'completion_tokens' in usage_metadata:
+            normalized['output_tokens'] = usage_metadata['completion_tokens']
+        
+        # Map total tokens
+        if 'total_tokens' in usage_metadata:
+            normalized['total_tokens'] = usage_metadata['total_tokens']
+        elif 'input_tokens' in normalized and 'output_tokens' in normalized:
+            # Calculate total if not provided
+            normalized['total_tokens'] = normalized['input_tokens'] + normalized['output_tokens']
+        
+        # Keep any other metadata fields that don't conflict
+        for key, value in usage_metadata.items():
+            if key not in ['input_tokens', 'prompt_tokens', 'output_tokens', 
+                          'completion_tokens', 'total_tokens']:
+                normalized[key] = value
+        
+        return normalized if normalized else usage_metadata
+    
     return usage_metadata
 
 def determine_concept(
@@ -396,6 +479,149 @@ def _get_active_datasource(conn_params: dict) -> dict:
     return datasources[0] if datasources else None
 
 
+def _evaluate_sql_with_reasoning(
+    question: str,
+    sql_query: str,
+    llm: LLM,
+    timeout: int,
+) -> dict:
+    """
+    Evaluate if the generated SQL correctly answers the business question.
+    
+    Returns:
+        dict with 'assessment' ('correct'|'partial'|'incorrect') and 'reasoning'
+    """
+    system_prompt = """You are an expert SQL and data analysis evaluator for Timbr.ai knowledge graph queries.
+
+**IMPORTANT CONTEXT:**
+- This system uses Timbr.ai, which extends SQL with semantic graph layer, including traversals, measures and more
+- Field names may use special Timbr syntax that is NOT standard SQL but is VALID in this system:
+  * `measure.<measure_name>` - References computed measures (e.g., measure.total_balance_amount)
+  * `<relationship>[target_table].<property>` - Graph traversal syntax (e.g., has_account[Account].account_name)
+  * These are translated by Timbr to standard SQL before execution
+- DO NOT mark queries as incorrect based on field name syntax - Timbr validates this before execution
+
+Evaluate whether the generated query correctly addresses the business question:
+- **correct**: The query fully and accurately answers the question
+- **partial**: The query is partially correct or incomplete
+- **incorrect**: The query does not address the question or is wrong
+
+Return your evaluation as a JSON object with this exact structure:
+{
+  "assessment": "<correct|partial|incorrect>",
+  "reasoning": "<short but precise sentence explaining your assessment>"
+}
+
+Be concise and objective."""
+
+    user_prompt = f"""**Business Question:**
+{question}
+
+**Generated SQL Query:**
+```sql
+{sql_query}
+```
+
+Please evaluate this result."""
+    
+    messages = [
+        SystemMessage(content=system_prompt),
+        HumanMessage(content=user_prompt)
+    ]
+
+    apx_token_count = _calculate_token_count(llm, messages)
+    if hasattr(llm, "_llm_type") and "snowflake" in llm._llm_type:
+        _clean_snowflake_prompt(messages)
+    
+    response = _call_llm_with_timeout(llm, messages, 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)
+    
+    return {
+        "evaluation": evaluation,
+        "apx_token_count": apx_token_count,
+        "usage_metadata": _extract_usage_metadata(response),
+    }
+
+
+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:
+    """
+    Generate SQL using LLM based on the provided context and note.
+    This function is used for both initial SQL generation and regeneration with feedback.
+    
+    Args:
+        current_context: dict containing datasource_type, schema, concept, concept_description,
+                        concept_tags, columns_str, measures_context, transitive_context,
+                        sensitivity_txt, max_limit, cur_date
+        note: Additional instructions/feedback to include in the prompt
+    
+    Returns:
+        dict with 'sql', 'is_valid', 'error', 'apx_token_count', 'usage_metadata', 'p_hash' (if debug)
+    """
+    prompt = generate_sql_prompt.format_messages(
+        current_date=current_context['cur_date'],
+        datasource_type=current_context['datasource_type'],
+        schema=current_context['schema'],
+        concept=f"`{current_context['concept']}`",
+        description=current_context['concept_description'],
+        tags=current_context['concept_tags'],
+        question=question,
+        columns=current_context['columns_str'],
+        measures_context=current_context['measures_context'],
+        transitive_context=current_context['transitive_context'],
+        sensitivity_context=current_context['sensitivity_txt'],
+        max_limit=current_context['max_limit'],
+        note=note,
+    )
+
+    apx_token_count = _calculate_token_count(llm, prompt)
+    if hasattr(llm, "_llm_type") and "snowflake" in llm._llm_type:
+        _clean_snowflake_prompt(prompt)
+    
+    response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
+    
+    result = {
+        "sql": _parse_sql_from_llm_response(response),
+        "apx_token_count": apx_token_count,
+        "usage_metadata": _extract_usage_metadata(response),
+        "is_valid": True,
+        "error": None,
+    }
+    
+    if debug:
+        result["p_hash"] = encrypt_prompt(prompt)
+    
+    if should_validate_sql:
+        result["is_valid"], result["error"] = validate_sql(result["sql"], conn_params)
+    
+    return result
+
+
 def generate_sql(
         question: str,
         llm: LLM,
@@ -413,11 +639,14 @@ def generate_sql(
         note: Optional[str] = '',
         db_is_case_sensitive: Optional[bool] = False,
         graph_depth: Optional[int] = 1,
+        with_reasoning: Optional[bool] = False,
+        reasoning_steps: Optional[int] = 2,
         debug: Optional[bool] = False,
         timeout: Optional[int] = None,
     ) -> dict[str, str]:
     usage_metadata = {}
     concept_metadata = None
+    reasoning_status = 'correct'
     
     # Use config default timeout if none provided
     if timeout is None:
@@ -466,6 +695,34 @@ def generate_sql(
     if rel_prop_str:
         measures_str += f"\n{rel_prop_str}"
 
+
+    # Build context descriptions
+    sensitivity_txt = "- Ensure value comparisons are case-insensitive, e.g., use LOWER(column) = 'value'.\n" if db_is_case_sensitive else ""
+    measures_context = f"- {MEASURES_DESCRIPTION}: {measures_str}\n" if measures_str else ""
+    has_transitive_relationships = any(
+        rel.get('is_transitive')
+        for rel in relationships.values()
+    ) if relationships else False
+    transitive_context = f"- {TRANSITIVE_RELATIONSHIP_DESCRIPTION}\n" if has_transitive_relationships else ""
+    concept_description = f"- Description: {concept_metadata.get('description')}\n" if concept_metadata and concept_metadata.get('description') else ""
+    concept_tags = concept_metadata.get('tags') if concept_metadata and concept_metadata.get('tags') else ""
+    cur_date = datetime.now().strftime("%Y-%m-%d")
+
+    # Build context dict for SQL generation
+    current_context = {
+        'cur_date': cur_date,
+        'datasource_type': datasource_type or 'standard sql',
+        'schema': schema,
+        'concept': concept,
+        'concept_description': concept_description or "",
+        'concept_tags': concept_tags or "",
+        'columns_str': columns_str,
+        'measures_context': measures_context,
+        'transitive_context': transitive_context,
+        'sensitivity_txt': sensitivity_txt,
+        'max_limit': max_limit,
+    }
+
     sql_query = None
     iteration = 0
     is_sql_valid = True
@@ -474,39 +731,30 @@ def generate_sql(
         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 ""
 
-        sensitivity_txt = "- Ensure value comparisons are case-insensitive, e.g., use LOWER(column) = 'value'.\n" if db_is_case_sensitive else ""
-
-        measures_context = f"- {MEASURES_DESCRIPTION}: {measures_str}\n" if measures_str else ""
-        has_transitive_relationships = any(
-            rel.get('is_transitive')
-            for rel in relationships.values()
-        ) if relationships else False
-        transitive_context = f"- {TRANSITIVE_RELATIONSHIP_DESCRIPTION}\n" if has_transitive_relationships else ""
-        concept_description = f"- Description: {concept_metadata.get('description')}\n" if concept_metadata and concept_metadata.get('description') else ""
-        concept_tags = concept_metadata.get('tags') if concept_metadata and concept_metadata.get('tags') else ""
-        cur_date = datetime.now().strftime("%Y-%m-%d")
-        prompt = generate_sql_prompt.format_messages(
-            current_date=cur_date,
-            datasource_type=datasource_type or 'standard sql',
-            schema=schema,
-            concept=f"`{concept}`",
-            description=concept_description or "",
-            tags=concept_tags or "",
-            question=question,
-            columns=columns_str,
-            measures_context=measures_context,
-            transitive_context=transitive_context,
-            sensitivity_context=sensitivity_txt,
-            max_limit=max_limit,
-            note=note + err_txt,
-        )
-
-        apx_token_count = _calculate_token_count(llm, prompt)
-        if "snowflake" in llm._llm_type:
-            _clean_snowflake_prompt(prompt)
-        
         try:
-            response = _call_llm_with_timeout(llm, prompt, timeout=timeout)
+            result = _generate_sql_with_llm(
+                question=question,
+                llm=llm,
+                conn_params=conn_params,
+                generate_sql_prompt=generate_sql_prompt,
+                current_context=current_context,
+                note=note + err_txt,
+                should_validate_sql=should_validate_sql,
+                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']
+            is_sql_valid = result['is_valid']
+            error = result['error']
+            
         except TimeoutError as e:
             error = f"LLM call timed out: {str(e)}"
             raise Exception(error)
@@ -516,18 +764,61 @@ def generate_sql(
                 continue
             else:
                 raise Exception(error)
-
-        usage_metadata['generate_sql'] = {
-            "approximate": apx_token_count,
-            **_extract_usage_metadata(response),
-        }
-        if debug:
-            usage_metadata['generate_sql']["p_hash"] = encrypt_prompt(prompt)
-
-        sql_query = _parse_sql_from_llm_response(response)
-
-        if should_validate_sql:
-            is_sql_valid, error = validate_sql(sql_query, conn_params)
+    
+    
+    if with_reasoning and sql_query is not None:
+        for step in range(reasoning_steps):
+            try:
+                # Step 1: Evaluate the current SQL
+                eval_result = _evaluate_sql_with_reasoning(
+                    question=question,
+                    sql_query=sql_query,
+                    llm=llm,
+                    timeout=timeout,
+                )
+                
+                usage_metadata[f'sql_reasoning_step_{step}'] = {
+                    "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: `{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}'."
+                
+                regen_result = _generate_sql_with_llm(
+                    question=question,
+                    llm=llm,
+                    conn_params=conn_params,
+                    generate_sql_prompt=generate_sql_prompt,
+                    current_context=current_context,
+                    note=evaluation_note,
+                    should_validate_sql=should_validate_sql,
+                    timeout=timeout,
+                    debug=debug,
+                )
+                
+                usage_metadata[f'generate_sql_reasoning_step_{step}'] = {
+                    "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}']['p_hash'] = regen_result['p_hash']
+                
+                sql_query = regen_result['sql']
+                is_sql_valid = regen_result['is_valid']
+                error = regen_result['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 {
         "sql": sql_query,
@@ -535,6 +826,7 @@ 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,
+        "reasoning_status": reasoning_status,
         "usage_metadata": usage_metadata,
     }
 

{langchain_timbr-2.1.4.dist-info → langchain_timbr-2.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-timbr
-Version: 2.1.4
+Version: 2.1.6
 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/
@@ -19,44 +19,17 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: <3.13,>=3.10
-Requires-Dist: anthropic==0.42.0
-Requires-Dist: azure-identity==1.25.0; python_version >= '3.11'
-Requires-Dist: azure-identity>=1.16.1; python_version == '3.10'
 Requires-Dist: cryptography==45.0.7; python_version >= '3.11'
 Requires-Dist: cryptography>=44.0.3; python_version == '3.10'
-Requires-Dist: databricks-langchain==0.7.1
-Requires-Dist: databricks-sdk==0.64.0
-Requires-Dist: google-generativeai==0.8.4
-Requires-Dist: langchain-anthropic==0.3.5; python_version >= '3.11'
-Requires-Dist: langchain-anthropic>=0.3.1; python_version == '3.10'
 Requires-Dist: langchain-community==0.3.30; python_version >= '3.11'
-Requires-Dist: langchain-community>=0.3.20; python_version == '3.10'
-Requires-Dist: langchain-core==0.3.78; python_version >= '3.11'
-Requires-Dist: langchain-core>=0.3.58; python_version == '3.10'
-Requires-Dist: langchain-google-genai==2.0.10; python_version >= '3.11'
-Requires-Dist: langchain-google-genai>=2.0.9; python_version == '3.10'
-Requires-Dist: langchain-google-vertexai==2.1.2; python_version >= '3.11'
-Requires-Dist: langchain-google-vertexai>=2.0.28; python_version == '3.10'
-Requires-Dist: langchain-openai==0.3.34; python_version >= '3.11'
-Requires-Dist: langchain-openai>=0.3.16; python_version == '3.10'
-Requires-Dist: langchain-tests==0.3.22; python_version >= '3.11'
-Requires-Dist: langchain-tests>=0.3.20; python_version == '3.10'
+Requires-Dist: langchain-community>=0.3.27; python_version == '3.10'
+Requires-Dist: langchain-core>=0.3.80
 Requires-Dist: langchain==0.3.27; python_version >= '3.11'
 Requires-Dist: langchain>=0.3.25; python_version == '3.10'
 Requires-Dist: langgraph==0.6.8; python_version >= '3.11'
 Requires-Dist: langgraph>=0.3.20; python_version == '3.10'
-Requires-Dist: openai==2.1.0; python_version >= '3.11'
-Requires-Dist: openai>=1.77.0; python_version == '3.10'
-Requires-Dist: opentelemetry-api==1.38.0; python_version == '3.10'
-Requires-Dist: opentelemetry-sdk==1.38.0; python_version == '3.10'
 Requires-Dist: pydantic==2.10.4
-Requires-Dist: pytest==8.3.4
-Requires-Dist: pytimbr-api==2.0.0; python_version >= '3.11'
-Requires-Dist: pytimbr-api>=2.0.0; python_version == '3.10'
-Requires-Dist: snowflake-snowpark-python==1.39.1; python_version >= '3.11'
-Requires-Dist: snowflake-snowpark-python>=1.39.1; python_version == '3.10'
-Requires-Dist: snowflake==1.8.0; python_version >= '3.11'
-Requires-Dist: snowflake>=1.8.0; python_version == '3.10'
+Requires-Dist: pytimbr-api>=2.1.0
 Requires-Dist: tiktoken==0.8.0
 Requires-Dist: transformers==4.57.0; python_version >= '3.11'
 Requires-Dist: transformers>=4.53; python_version == '3.10'
@@ -70,6 +43,7 @@ Requires-Dist: databricks-sdk==0.64.0; extra == 'all'
 Requires-Dist: google-generativeai==0.8.4; extra == 'all'
 Requires-Dist: langchain-anthropic==0.3.5; (python_version >= '3.11') and extra == 'all'
 Requires-Dist: langchain-anthropic>=0.3.1; (python_version == '3.10') and extra == 'all'
+Requires-Dist: langchain-aws<1,>=0.2.35; extra == 'all'
 Requires-Dist: langchain-google-genai==2.0.10; (python_version >= '3.11') and extra == 'all'
 Requires-Dist: langchain-google-genai>=2.0.9; (python_version == '3.10') and extra == 'all'
 Requires-Dist: langchain-google-vertexai==2.1.2; (python_version >= '3.11') and extra == 'all'
@@ -97,6 +71,8 @@ Requires-Dist: langchain-openai==0.3.34; (python_version >= '3.11') and extra ==
 Requires-Dist: langchain-openai>=0.3.16; (python_version == '3.10') and extra == 'azure-openai'
 Requires-Dist: openai==2.1.0; (python_version >= '3.11') and extra == 'azure-openai'
 Requires-Dist: openai>=1.77.0; (python_version == '3.10') and extra == 'azure-openai'
+Provides-Extra: bedrock
+Requires-Dist: langchain-aws==0.2.35; extra == 'bedrock'
 Provides-Extra: databricks
 Requires-Dist: databricks-langchain==0.7.1; extra == 'databricks'
 Requires-Dist: databricks-sdk==0.64.0; extra == 'databricks'
@@ -158,7 +134,7 @@ python -m pip install langchain-timbr
 
 ### Install with selected LLM providers
 
-#### One of: openai, anthropic, google, azure_openai, snowflake, databricks, vertex_ai (or 'all')
+#### One of: openai, anthropic, google, azure_openai, snowflake, databricks, vertex_ai, bedrock (or 'all')
 
 ```bash
 python -m pip install 'langchain-timbr[<your selected providers, separated by comma w/o space>]'

langchain_timbr-2.1.6.dist-info/RECORD

@@ -0,0 +1,28 @@
+langchain_timbr/__init__.py,sha256=gxd6Y6QDmYZtPlYVdXtPIy501hMOZXHjWh2qq4qzt_s,828
+langchain_timbr/_version.py,sha256=EwjLAOHxpsOZpfhlwgV2gSqwFh_1AQNnM-WrOk4-4zg,704
+langchain_timbr/config.py,sha256=CdDuUKbI_sdjNkGVk_QEmeqQHjFlJjBY1VI19JuBG2o,1601
+langchain_timbr/timbr_llm_connector.py,sha256=mdkWskpvmXZre5AzVFn6KfPnVH5YN5MIwfEoXWBLMgY,13170
+langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
+langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=6USOkCJih0yGk7PgYW_zTHJfip4DpFcvkD-VhI2dMp0,16302
+langchain_timbr/langchain/generate_answer_chain.py,sha256=nteA4QZp9CAOskTBl_CokwaMlqnR2g2GvKz2mLs9WVY,4871
+langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=XmEkEU4q8t66GJZE-pWAAWqYYFFfv9ej6DzjRiTVNRw,9797
+langchain_timbr/langchain/identify_concept_chain.py,sha256=kuzg0jJQpFGIiaxtNhdQ5K4HXveLVwONFNsoipPCteE,7169
+langchain_timbr/langchain/timbr_sql_agent.py,sha256=tIcr2SCSb5LnOA3zreZbzOvVgR8e2NFv4HaLVcLUNCg,20790
+langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=OcE_7yfb9xpD-I4OS7RG1bY4-yi1UicjvGegOv_vkQU,9567
+langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
+langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=UddbYiQya_-QlZm-QdImxpvzfiNiRDHyiLAHdpTEzXc,5984
+langchain_timbr/langgraph/generate_response_node.py,sha256=opwscNEXabaSyCFLbzGQFkDFEymJurhNU9aAtm1rnOk,2375
+langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=TekD9D0rM4aKuzS50Kzwkbshei5NHbTTVTXUC41dnyU,5360
+langchain_timbr/langgraph/identify_concept_node.py,sha256=aiLDFEcz_vM4zZ_ULe1SvJKmI-e4Fb2SibZQaEPz_eY,3649
+langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=-2fuieCz1hv6ua-17zfonme8LQ_OoPnoOBTdGSXkJgs,4793
+langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=j94DqIGECXyfAVayLC7VaNxs_8n1qYFiHY2Qvt2B3Bc,17537
+langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
+langchain_timbr/utils/general.py,sha256=KkehHvIj8GoQ_0KVXLcUVeaYaTtkuzgXmYYx2TXJhI4,10253
+langchain_timbr/utils/prompt_service.py,sha256=QT7kiq72rQno77z1-tvGGD7HlH_wdTQAl_1teSoKEv4,11373
+langchain_timbr/utils/temperature_supported_models.json,sha256=d3UmBUpG38zDjjB42IoGpHTUaf0pHMBRSPY99ao1a3g,1832
+langchain_timbr/utils/timbr_llm_utils.py,sha256=6CHCwMHOPZtLjxh49a4UoxGxgTmuOUO3R8sJMHsGKxI,34970
+langchain_timbr/utils/timbr_utils.py,sha256=SvmQ0wYicODNhmo8c-5_KPDBAfrBVBkUfoO8sPItQhk,17759
+langchain_timbr-2.1.6.dist-info/METADATA,sha256=imT7XLtey6gdk7WJlp6ZcYnndjCE6hAJ6QPzQmgcyJo,10724
+langchain_timbr-2.1.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_timbr-2.1.6.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
+langchain_timbr-2.1.6.dist-info/RECORD,,

{langchain_timbr-2.1.4.dist-info → langchain_timbr-2.1.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

langchain_timbr-2.1.4.dist-info/RECORD

@@ -1,28 +0,0 @@
-langchain_timbr/__init__.py,sha256=gxd6Y6QDmYZtPlYVdXtPIy501hMOZXHjWh2qq4qzt_s,828
-langchain_timbr/_version.py,sha256=TYs-mU9m9aJFweRpjovqttRQsYRnpbbHHMifXX9ryi4,704
-langchain_timbr/config.py,sha256=PEtvNgvnA9UseZJjKgup_O6xdG-VYk3N11nH8p8W1Kg,1410
-langchain_timbr/timbr_llm_connector.py,sha256=mdkWskpvmXZre5AzVFn6KfPnVH5YN5MIwfEoXWBLMgY,13170
-langchain_timbr/langchain/__init__.py,sha256=ejcsZKP9PK0j4WrrCCcvBXpDpP-TeRiVb21OIUJqix8,580
-langchain_timbr/langchain/execute_timbr_query_chain.py,sha256=pedMajyKDI2ZaoyVp1r64nHX015Wy-r96HoJrRlCh48,15579
-langchain_timbr/langchain/generate_answer_chain.py,sha256=XsaQrgBFwoC9ne3jpnuHueUXL1PzNQ75ECC_HVA61Ks,4871
-langchain_timbr/langchain/generate_timbr_sql_chain.py,sha256=3Z0ut78AFCNHKwLwOYH44hzJDIOA-zNF0x8Tjyrvzp4,9098
-langchain_timbr/langchain/identify_concept_chain.py,sha256=kuzg0jJQpFGIiaxtNhdQ5K4HXveLVwONFNsoipPCteE,7169
-langchain_timbr/langchain/timbr_sql_agent.py,sha256=HntpalzCZ-PlHd7na5V0syCMqrREFUpppGM4eHstaZQ,19574
-langchain_timbr/langchain/validate_timbr_sql_chain.py,sha256=OcE_7yfb9xpD-I4OS7RG1bY4-yi1UicjvGegOv_vkQU,9567
-langchain_timbr/langgraph/__init__.py,sha256=mKBFd0x01jWpRujUWe-suX3FFhenPoDxrvzs8I0mum0,457
-langchain_timbr/langgraph/execute_timbr_query_node.py,sha256=rPx_V3OOh-JTGOwrEopHmOmFuM-ngBZdswkW9oZ43hU,5536
-langchain_timbr/langgraph/generate_response_node.py,sha256=BLmsDZfbhncRpO7PEfDpy7CnPE7a55j8QV5jfg30heQ,2247
-langchain_timbr/langgraph/generate_timbr_sql_node.py,sha256=wkau-NajblSVzNIro9IyqawULvz3XaCYSEdYW95vWco,4911
-langchain_timbr/langgraph/identify_concept_node.py,sha256=aiLDFEcz_vM4zZ_ULe1SvJKmI-e4Fb2SibZQaEPz_eY,3649
-langchain_timbr/langgraph/validate_timbr_query_node.py,sha256=-2fuieCz1hv6ua-17zfonme8LQ_OoPnoOBTdGSXkJgs,4793
-langchain_timbr/llm_wrapper/llm_wrapper.py,sha256=_oQZQHJUWskIm2L-86jUGwM5ZhaE34fCsueLHhg4Le0,14944
-langchain_timbr/llm_wrapper/timbr_llm_wrapper.py,sha256=sDqDOz0qu8b4WWlagjNceswMVyvEJ8yBWZq2etBh-T0,1362
-langchain_timbr/utils/general.py,sha256=KkehHvIj8GoQ_0KVXLcUVeaYaTtkuzgXmYYx2TXJhI4,10253
-langchain_timbr/utils/prompt_service.py,sha256=QT7kiq72rQno77z1-tvGGD7HlH_wdTQAl_1teSoKEv4,11373
-langchain_timbr/utils/temperature_supported_models.json,sha256=d3UmBUpG38zDjjB42IoGpHTUaf0pHMBRSPY99ao1a3g,1832
-langchain_timbr/utils/timbr_llm_utils.py,sha256=_4Qz5SX5cXW1Rl_fSBcE9P3uPEaI8DBg3GpXA4uQGoI,23102
-langchain_timbr/utils/timbr_utils.py,sha256=SvmQ0wYicODNhmo8c-5_KPDBAfrBVBkUfoO8sPItQhk,17759
-langchain_timbr-2.1.4.dist-info/METADATA,sha256=Wtzy14BfbEujvuYozb4XcaUz6pp87zxjNNBbt9Z5wSQ,12268
-langchain_timbr-2.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain_timbr-2.1.4.dist-info/licenses/LICENSE,sha256=0ITGFk2alkC7-e--bRGtuzDrv62USIiVyV2Crf3_L_0,1065
-langchain_timbr-2.1.4.dist-info/RECORD,,