ws-bom-robot-app 0.0.96__py3-none-any.whl → 0.0.97__py3-none-any.whl

ws_bom_robot_app/llm/agent_lcel.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any, Optional, Literal
 from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain_core.runnables import RunnableLambda
@@ -12,8 +12,10 @@ from ws_bom_robot_app.llm.defaut_prompt import default_prompt, tool_prompt
 
 class AgentLcel:
 
-    def __init__(self, llm: LlmInterface, sys_message: str, sys_context: AgentContext, tools: list, rules: LlmRules = None):
+    def __init__(self, llm: LlmInterface, sys_message: str, sys_context: AgentContext, tools: list, ouput_model: str | dict = None,  rules: LlmRules = None):
         self.sys_message = chevron.render(template=sys_message,data=sys_context)
+        self.ouput_model = ouput_model
+        self.output_parser =  None
         self.__llm = llm
         self.__tools = tools
         self.rules = rules
@@ -27,6 +29,10 @@ class AgentLcel:
         message : LlmMessage = input[self.memory_key][-1]
         rules_prompt = await get_rules(self.embeddings, self.rules, message.content) if self.rules else ""
         system = default_prompt + (tool_prompt(render_text_description(self.__tools)) if len(self.__tools)>0 else "") + self.sys_message + rules_prompt
+        if isinstance(self.ouput_model, dict):
+          output_parser = self.__llm.get_parser(type="json", model=self.ouput_model)
+          system += "\n\nFormat instructions:\n{format_instructions}".strip()
+
         prompt = ChatPromptTemplate(
             messages=[
                 SystemMessage(content=system), #from ("system",system) to avoid improper f-string substitutions
@@ -35,6 +41,13 @@ class AgentLcel:
             ],
             template_format=None,
             )
+        if output_parser:
+          prompt.partial(
+              format_instructions=output_parser.get_format_instructions()
+            )
+          self.output_parser = output_parser
+        else:
+          self.output_parser = self.__llm.get_parser(type="text")
         return prompt
 
     def __create_agent(self) -> AgentExecutor:
@@ -45,6 +58,6 @@ class AgentLcel:
           }
           | RunnableLambda(self.__create_prompt)
           | self.__llm_with_tools
-          | self.__llm.get_parser()
+          | self.__llm.get_parser("text", None if not self.output_parser else "json", self.ouput_model)
       )
       return AgentExecutor(agent=agent,tools=self.__tools,verbose=False)

ws_bom_robot_app/llm/main.py

@@ -127,6 +127,7 @@ async def __stream(rq: StreamRequest, ctx: Request, queue: Queue, formatted: boo
       sys_message=rq.system_message,
       sys_context=rq.system_context,
       tools=get_structured_tools(__llm, tools=rq.app_tools, callbacks=[callbacks], queue=queue),
+      ouput_model=rq.jsonOutputModel,
       rules=rq.rules
   )
   try:

ws_bom_robot_app/llm/models/api.py

@@ -150,6 +150,8 @@ class LlmApp(BaseModel):
   app_tools: Optional[List[LlmAppTool]] = Field([], validation_alias=AliasChoices("appTools","app_tools"))
   vector_type: Optional[str] = "faiss"
   vector_db: Optional[str] = Field(None, validation_alias=AliasChoices("vectorDb","vector_db"))
+  output_model: Optional[str] = Field(None, validation_alias=AliasChoices("outputModel","output_model"))
+  jsonOutputModel: Optional[dict] = Field(None, validation_alias=AliasChoices("jsonOutputModel","json_output_model"))
   rules: Optional[LlmRules] = None
   fine_tuned_model: Optional[str] = Field(None, validation_alias=AliasChoices("fineTunedModel","fine_tuned_model"))
   lang_chain_tracing: Optional[bool] = Field(False, validation_alias=AliasChoices("langChainTracing","lang_chain_tracing"))

ws_bom_robot_app/llm/providers/llm_manager.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Literal
 from urllib.parse import urlparse
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseChatModel
@@ -34,9 +34,14 @@ class LlmInterface:
         from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages
         return format_to_openai_tool_messages(intermediate_steps=intermadiate_steps)
 
-    def get_parser(self):
+    def get_parser(self, type: Literal["text", "json"] = "text", model: Optional[dict] = None):
         from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
+        from langchain_core.output_parsers import JsonOutputParser
+        from pydantic import create_model
+        if type == "json":
+          return JsonOutputParser(pydantic_object=create_model('json_schema', **{k: (type(v), ...) for k, v in model.items()}))
         return OpenAIToolsAgentOutputParser()
+
     async def _format_multimodal_image_message(self, message: dict) -> dict:
         return {
             "type": "image_url",

ws_bom_robot_app/llm/vector_store/integration/api.py

@@ -0,0 +1,216 @@
+import asyncio, logging, aiohttp
+from ws_bom_robot_app.llm.vector_store.integration.base import IntegrationStrategy
+from langchain_core.documents import Document
+from ws_bom_robot_app.llm.vector_store.loader.base import Loader
+from typing import List, Union, Optional, Dict, Any, Literal
+from pydantic import BaseModel, Field, AliasChoices, field_validator
+import json
+import os
+
+
+class AuthConfig(BaseModel):
+  """
+  Configuration for API authentication.
+
+  Attributes:
+    type: Type of authentication (bearer, basic, api_key, custom, none)
+    token: Bearer token or API key value
+    username: Username for basic auth
+    password: Password for basic auth
+    header_name: Custom header name for API key
+    prefix: Prefix for the auth value (e.g., 'Bearer', 'Token')
+  """
+  type: Literal["bearer", "basic", "api_key", "custom", "none"] = Field(default="none")
+  token: Optional[str] = Field(default=None)
+  username: Optional[str] = Field(default=None)
+  password: Optional[str] = Field(default=None)
+  header_name: Optional[str] = Field(default=None, validation_alias=AliasChoices("headerName", "header_name"))
+  prefix: Optional[str] = Field(default=None)
+
+
+class ApiParams(BaseModel):
+  """
+  Generic API Integration Parameters.
+
+  Attributes:
+    url: The base URL of the API endpoint
+    method: HTTP method (GET, POST, PUT, DELETE, PATCH)
+    headers: Custom headers to include in the request
+    params: Query parameters for the request
+    body: Request body for POST/PUT/PATCH requests
+    auth: Authentication configuration
+    response_data_path: JSON path to extract data from response (e.g., 'data.items', 'results')
+    max_retries: Maximum number of retry attempts for failed requests
+    retry_delay: Base delay in seconds between retries (uses exponential backoff)
+    timeout: Request timeout in seconds
+  """
+  url: str = Field(validation_alias=AliasChoices("url", "endpoint"))
+  method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"] = Field(default="GET")
+  headers: Optional[Dict[str, str]] = Field(default_factory=dict)
+  params: Optional[Dict[str, Any]] = Field(default_factory=dict)
+  body: Optional[Union[Dict[str, Any], str]] = Field(default=None)
+  auth: Optional[AuthConfig] = Field(default_factory=lambda: AuthConfig())
+  response_data_path: Optional[str] = Field(default=None, validation_alias=AliasChoices("responseDataPath", "response_data_path"))
+  max_retries: int = Field(default=5, validation_alias=AliasChoices("maxRetries", "max_retries"))
+  retry_delay: float = Field(default=1.0, validation_alias=AliasChoices("retryDelay", "retry_delay"))
+  timeout: int = Field(default=30)
+
+  @field_validator('auth', mode='before')
+  @classmethod
+  def parse_auth(cls, v):
+    """Parse auth config from dict if needed"""
+    if isinstance(v, dict):
+      return AuthConfig(**v)
+    return v or AuthConfig()
+
+
+class Api(IntegrationStrategy):
+  """
+  Generic API Integration that supports:
+  - Multiple HTTP methods (GET, POST, PUT, DELETE, PATCH)
+  - Various authentication types (Bearer, Basic, API Key, Custom)
+  - Custom headers and parameters
+  - Automatic retry with exponential backoff
+  - Flexible response data extraction
+  """
+
+  def __init__(self, knowledgebase_path: str, data: dict[str, Union[str, int, list]]):
+    super().__init__(knowledgebase_path, data)
+    self.__data = ApiParams.model_validate(self.data)
+
+  def working_subdirectory(self) -> str:
+    return 'api_integration'
+
+  async def run(self) -> None:
+    """Fetch data from the API and save to JSON file"""
+    _data = await self.__fetch_data()
+    json_file_path = os.path.join(self.working_directory, 'api_data.json')
+    with open(json_file_path, 'w', encoding='utf-8') as f:
+      json.dump(_data, f, ensure_ascii=False, indent=2)
+    logging.info(f"Saved {len(_data) if isinstance(_data, list) else 1} items to {json_file_path}")
+
+  async def load(self) -> list[Document]:
+    """Load data from API and convert to documents"""
+    await self.run()
+    await asyncio.sleep(1)
+    return await Loader(self.working_directory).load()
+
+  def __prepare_headers(self) -> Dict[str, str]:
+    """Prepare request headers with authentication"""
+    headers = self.__data.headers.copy() if self.__data.headers else {}
+
+    # Add Content-Type if not present
+    if 'Content-Type' not in headers and self.__data.method in ["POST", "PUT", "PATCH"]:
+      headers['Content-Type'] = 'application/json'
+
+    # Add authentication
+    auth = self.__data.auth
+    if auth.type == "bearer":
+      prefix = auth.prefix or "Bearer"
+      headers['Authorization'] = f"{prefix} {auth.token}"
+    elif auth.type == "basic":
+      import base64
+      credentials = f"{auth.username}:{auth.password}"
+      encoded = base64.b64encode(credentials.encode()).decode()
+      headers['Authorization'] = f"Basic {encoded}"
+    elif auth.type == "api_key" and auth.header_name:
+      prefix = f"{auth.prefix} " if auth.prefix else ""
+      headers[auth.header_name] = f"{prefix}{auth.token}"
+
+    return headers
+
+  def __get_nested_value(self, data: Any, path: Optional[str]) -> Any:
+    """Extract nested value from data using dot notation path"""
+    if not path:
+      return data
+
+    keys = path.split('.')
+    current = data
+    for key in keys:
+      if isinstance(current, dict):
+        current = current.get(key)
+      elif isinstance(current, list) and key.isdigit():
+        current = current[int(key)]
+      else:
+        return None
+
+      if current is None:
+        return None
+
+    return current
+
+  async def __make_request(
+    self,
+    url: str,
+    headers: Dict[str, str],
+    params: Optional[Dict[str, Any]] = None
+  ) -> Dict[str, Any]:
+    """Make HTTP request with retry logic"""
+    retry_count = 0
+
+    while retry_count <= self.__data.max_retries:
+      try:
+        timeout = aiohttp.ClientTimeout(total=self.__data.timeout)
+
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+          request_kwargs = {
+            "headers": headers,
+            "params": params or self.__data.params
+          }
+
+          # Add body for POST/PUT/PATCH
+          if self.__data.method in ["POST", "PUT", "PATCH"] and self.__data.body:
+            if isinstance(self.__data.body, dict):
+              request_kwargs["json"] = self.__data.body
+            else:
+              request_kwargs["data"] = self.__data.body
+
+          async with session.request(
+            self.__data.method,
+            url,
+            **request_kwargs
+          ) as response:
+            # Check response status
+            if response.status == 429:  # Rate limit
+              retry_count += 1
+              if retry_count > self.__data.max_retries:
+                raise Exception("Rate limit exceeded. Maximum retries reached.")
+
+              wait_time = self.__data.retry_delay * (2 ** retry_count)
+              logging.warning(f"Rate limited. Waiting {wait_time}s (Attempt {retry_count}/{self.__data.max_retries})")
+              await asyncio.sleep(wait_time)
+              continue
+
+            response.raise_for_status()
+
+            # Parse response
+            try:
+              data = await response.json()
+              return data
+            except aiohttp.ContentTypeError:
+              text = await response.text()
+              logging.warning(f"Non-JSON response received: {text[:200]}")
+              return {"text": text}
+
+      except aiohttp.ClientError as e:
+        retry_count += 1
+        if retry_count > self.__data.max_retries:
+          raise Exception(f"Request failed after {self.__data.max_retries} retries: {e}")
+
+        wait_time = self.__data.retry_delay * (2 ** retry_count)
+        logging.warning(f"Request error: {e}. Retrying in {wait_time}s...")
+        await asyncio.sleep(wait_time)
+        continue
+
+    raise Exception("Maximum retries exceeded")
+
+  async def __fetch_data(self) -> Any:
+    """Fetch data from API"""
+    headers = self.__prepare_headers()
+    response = await self.__make_request(self.__data.url, headers)
+
+    # Extract data from response using path if specified
+    data = self.__get_nested_value(response, self.__data.response_data_path)
+    result = data if data is not None else response
+
+    return result

ws_bom_robot_app/llm/vector_store/integration/manager.py

@@ -14,6 +14,7 @@ from ws_bom_robot_app.llm.vector_store.integration.sitemap import Sitemap
 from ws_bom_robot_app.llm.vector_store.integration.slack import Slack
 from ws_bom_robot_app.llm.vector_store.integration.thron import Thron
 from ws_bom_robot_app.llm.vector_store.integration.shopify import Shopify
+from ws_bom_robot_app.llm.vector_store.integration.api import Api
 class IntegrationManager:
   _list: dict[str, Type[IntegrationStrategy]] = {
     "llmkbazure": Azure,
@@ -30,6 +31,7 @@ class IntegrationManager:
     "llmkbslack": Slack,
     "llmkbthron": Thron,
     "llmkbshopify": Shopify,
+    "llmkbapi": Api,
   }
   @classmethod
   def get_strategy(cls, name: str, knowledgebase_path: str, data: dict[str, str]) -> IntegrationStrategy:

{ws_bom_robot_app-0.0.96.dist-info → ws_bom_robot_app-0.0.97.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ws_bom_robot_app
-Version: 0.0.96
+Version: 0.0.97
 Summary: A FastAPI application serving ws bom/robot/llm platform ai.
 Home-page: https://github.com/websolutespa/bom
 Author: Websolute Spa

{ws_bom_robot_app-0.0.96.dist-info → ws_bom_robot_app-0.0.97.dist-info}/RECORD

@@ -10,21 +10,21 @@ ws_bom_robot_app/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 ws_bom_robot_app/llm/agent_context.py,sha256=uatHJ8wcRly6h0S762BgfzDMpmcwCHwNzwo37aWjeE0,1305
 ws_bom_robot_app/llm/agent_description.py,sha256=5IP0qFSJvaE3zjGS7f0W1DuiegP0RHXRMBoDC5pCofA,4779
 ws_bom_robot_app/llm/agent_handler.py,sha256=HAg3qmj-QY_k7P-GfAKna1tKdmZaTHrZbNWJc0eol3A,7858
-ws_bom_robot_app/llm/agent_lcel.py,sha256=QRgGkdVXCwDXWjJj8R8qaYeLqUfpaYjtRnl3GrZCwVM,2530
+ws_bom_robot_app/llm/agent_lcel.py,sha256=vKgUN7Kt7HXhzSjC6WfRGWE_hvULf1BeGmBkM_z6tKk,3203
 ws_bom_robot_app/llm/api.py,sha256=jMoiKiD5HNxGu6gTb5_qZ5UU8d2uJ7UVrdLseDStI6o,7634
 ws_bom_robot_app/llm/defaut_prompt.py,sha256=D9dn8yPveu0bVwGM1wQWLYftmBs5O76o0R_caLLll8w,1121
 ws_bom_robot_app/llm/evaluator.py,sha256=tUyPX1oGZEjSiO4JixwNlgv6BI9cUHSmcAsTCpBnIn4,13322
-ws_bom_robot_app/llm/main.py,sha256=GZ6Bkb3rNl4xf2ZXGkl9bhZrIRsvi40vUIRDJ-WwRAc,5828
+ws_bom_robot_app/llm/main.py,sha256=q1bBhh3b6xgR6Z1YmfSOYkCJnhAjixjyAcq09LtxUds,5867
 ws_bom_robot_app/llm/nebuly_handler.py,sha256=wFO2UG849kv5hmjM5EoOp0Jsloy-BtQjrRh4pVosnfU,8163
 ws_bom_robot_app/llm/feedbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/feedbacks/feedback_manager.py,sha256=vNcZLG9IKhurAk7hjBqyFgQTjnh3Cd4GnxeYsX7ZdiA,2922
 ws_bom_robot_app/llm/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/models/api.py,sha256=bahqx9rdP6jM9Kk9VGkqT-bhASJeuAzO_5Ir6tBxDIU,12212
+ws_bom_robot_app/llm/models/api.py,sha256=v2rKz4kuyA4IQr49LVxijE8fMzX19BzSR0pqaeOQnYo,12437
 ws_bom_robot_app/llm/models/base.py,sha256=1TqxuTK3rjJEALn7lvgoen_1ba3R2brAgGx6EDTtDZo,152
 ws_bom_robot_app/llm/models/feedback.py,sha256=pYNQGxNOBgeAAfdJLI95l7ePLBI5tVdsgnyjp5oMOQU,1722
 ws_bom_robot_app/llm/models/kb.py,sha256=oVSw6_dmNxikAHrPqcfxDXz9M0ezLIYuxpgvzfs_Now,9514
 ws_bom_robot_app/llm/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ws_bom_robot_app/llm/providers/llm_manager.py,sha256=oVeEmZUnR1ysV-BI_zpwQ-gpXqmhSzjKFQQAHtaFGSI,16596
+ws_bom_robot_app/llm/providers/llm_manager.py,sha256=XVmuiL2jQAmYpENx-kDmvuDaWwO80TdcyKVFi9vB7kw,16945
 ws_bom_robot_app/llm/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ws_bom_robot_app/llm/tools/tool_builder.py,sha256=CtZwJ94aj0YGA3yVWkyCUxNE7WgU2zWjhl_tEfEskxw,3432
 ws_bom_robot_app/llm/tools/tool_manager.py,sha256=avoFERE0v9MFQ3pUBMug8eGYIXbIYl7NqkP1kjNee7s,15439
@@ -49,6 +49,7 @@ ws_bom_robot_app/llm/vector_store/db/faiss.py,sha256=rCMq_dhg1-NM8G5L_VEdDIvgmkW
 ws_bom_robot_app/llm/vector_store/db/manager.py,sha256=5rqBvc0QKmHFUgVHqBAr1Y4FZRl-w-ylGMjgXZywrdA,533
 ws_bom_robot_app/llm/vector_store/db/qdrant.py,sha256=StBB0ODUiKkrXEUKZvZDF_XyJb6ypvIWpoHQPONcglA,2133
 ws_bom_robot_app/llm/vector_store/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ws_bom_robot_app/llm/vector_store/integration/api.py,sha256=0fW2uKW3P_WaX8J18LRTMTVZ1VP3t_bHkocDtm1f_uc,8184
 ws_bom_robot_app/llm/vector_store/integration/azure.py,sha256=OEa96Dlf1CX0tjrTjX4KP3D_HTn249ukc9sluPbdOyU,3389
 ws_bom_robot_app/llm/vector_store/integration/base.py,sha256=4zI1TtacyVw0jcY0wFv_4y93iX2cgFGn6rAGXd-nSxk,4331
 ws_bom_robot_app/llm/vector_store/integration/confluence.py,sha256=TMmGe53tHRTgHJ7nA8DqZVodo3aMEzHrrSdl0-I0-S0,4350
@@ -57,7 +58,7 @@ ws_bom_robot_app/llm/vector_store/integration/gcs.py,sha256=P-NKwNag6fkY3bzFvVkA
 ws_bom_robot_app/llm/vector_store/integration/github.py,sha256=1J4Ph3s58ngEIH5HyCMeeD6lVo2GzdU8y41BvPSLZcc,2441
 ws_bom_robot_app/llm/vector_store/integration/googledrive.py,sha256=pQQKWsAskg_6FgC4PVmKY1fMvM8BiFxlUVhh5ERBOF4,5016
 ws_bom_robot_app/llm/vector_store/integration/jira.py,sha256=LPxSXPf268FKTS3wnejssDw6_GIpEPJ3QaNgRgPnb60,6718
-ws_bom_robot_app/llm/vector_store/integration/manager.py,sha256=S5z8LK_RcsCmWvLiBX-cea44CpVAXccND47oUOJ0Yus,1898
+ws_bom_robot_app/llm/vector_store/integration/manager.py,sha256=K_Ymfb4xqm33g7gyu5SW7csFMs0r7FeptIRfeZrUm1w,1987
 ws_bom_robot_app/llm/vector_store/integration/s3.py,sha256=_SAuPfyK7lIz7Jq1LiBavkF1lre5yqe6DGlMYnxMa4o,3317
 ws_bom_robot_app/llm/vector_store/integration/sftp.py,sha256=g6f-FKkEktx7nJahb7RKyQ4pM9wGik0_xXMDfWup-1c,2845
 ws_bom_robot_app/llm/vector_store/integration/sharepoint.py,sha256=DhBcAwgr1u-dQ_8TxeLPu7kzr_EDogCRQeBrIULtWfo,4898
@@ -69,7 +70,7 @@ ws_bom_robot_app/llm/vector_store/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 ws_bom_robot_app/llm/vector_store/loader/base.py,sha256=GjUS2oaz0LHOSal5pipBkomZtrYUNcKPSd8bzhUU5Dc,6889
 ws_bom_robot_app/llm/vector_store/loader/docling.py,sha256=IOv1A0HSIWiHWQFzI4fdApfxrKgXOqwmC3mPXlKplqQ,4012
 ws_bom_robot_app/llm/vector_store/loader/json_loader.py,sha256=LDppW0ZATo4_1hh-KlsAM3TLawBvwBxva_a7k5Oz1sc,858
-ws_bom_robot_app-0.0.96.dist-info/METADATA,sha256=-CABRo25yuOPMqmaE_DrR1AGXZkkAY3LZDSx6jZBYXY,10116
-ws_bom_robot_app-0.0.96.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ws_bom_robot_app-0.0.96.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
-ws_bom_robot_app-0.0.96.dist-info/RECORD,,
+ws_bom_robot_app-0.0.97.dist-info/METADATA,sha256=MNyfG6YQ70X3KYYW9fJC38EcTpP9YU5UTnYPjnwNMeQ,10116
+ws_bom_robot_app-0.0.97.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ws_bom_robot_app-0.0.97.dist-info/top_level.txt,sha256=Yl0akyHVbynsBX_N7wx3H3ZTkcMLjYyLJs5zBMDAKcM,17
+ws_bom_robot_app-0.0.97.dist-info/RECORD,,