veri-agents-external 0.1.2__tar.gz

veri_agents_external-0.1.2/.gitignore

@@ -0,0 +1,192 @@
+.turbo
+
+# go
+vendor
+
+# js
+dist
+out-tsc
+node_modules
+
+.idea
+*.iml
+.DS_Store
+
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+
+# generated tools directory
+services/attribute_connection/agent_api/app/tools/
+
+# (temporary) cached HTML directory
+services/attribute_connection/mcp_server/html

veri_agents_external-0.1.2/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: veri-agents-external
+Version: 0.1.2
+Summary: Veritone Agents Toolkit: Connectors to external software
+Author-email: Markus Toman <mtoman@veritone.com>, Teo Boley <tboley@veritone.com>
+Requires-Python: >=3.12
+Requires-Dist: veri-agents-common[langgraph]>=0.1.2
+Requires-Dist: veri-agents-knowledgebase>=0.1.1
+Provides-Extra: all
+Requires-Dist: atlassian-python-api>=4.0.4; extra == 'all'
+Requires-Dist: beautifulsoup4>=4.13.4; extra == 'all'
+Requires-Dist: langchain-community>=0.3.26; extra == 'all'
+Requires-Dist: markdownify>=1.1.0; extra == 'all'
+Requires-Dist: simple-salesforce>=1.12.6; extra == 'all'
+Requires-Dist: slack-bolt<2.0.0,>=1.20.1; extra == 'all'
+Provides-Extra: confluence
+Requires-Dist: atlassian-python-api>=4.0.4; extra == 'confluence'
+Requires-Dist: langchain-community>=0.3.26; extra == 'confluence'
+Requires-Dist: markdownify>=1.1.0; extra == 'confluence'
+Provides-Extra: dev
+Requires-Dist: atlassian-python-api>=4.0.4; extra == 'dev'
+Requires-Dist: beautifulsoup4>=4.13.4; extra == 'dev'
+Requires-Dist: langchain-community>=0.3.26; extra == 'dev'
+Requires-Dist: markdownify>=1.1.0; extra == 'dev'
+Requires-Dist: simple-salesforce>=1.12.6; extra == 'dev'
+Requires-Dist: slack-bolt<2.0.0,>=1.20.1; extra == 'dev'
+Provides-Extra: salesforce
+Requires-Dist: beautifulsoup4>=4.13.4; extra == 'salesforce'
+Requires-Dist: simple-salesforce>=1.12.6; extra == 'salesforce'
+Provides-Extra: slack
+Requires-Dist: slack-bolt<2.0.0,>=1.20.1; extra == 'slack'

veri_agents_external-0.1.2/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "veri-agents-external"
+version = "0.1.2"
+description = "Veritone Agents Toolkit: Connectors to external software"
+authors = [
+  {name = "Markus Toman", email = "mtoman@veritone.com"},
+  {name = "Teo Boley", email = "tboley@veritone.com"},
+]
+requires-python = ">=3.12"
+dependencies = [
+  "veri-agents-common[langgraph]>=0.1.2",
+  "veri-agents-knowledgebase>=0.1.1",
+]
+
+[project.optional-dependencies]
+confluence = [
+  "atlassian-python-api>=4.0.4",
+  "langchain-community>=0.3.26",
+  "markdownify>=1.1.0",
+]
+salesforce = [
+  "beautifulsoup4>=4.13.4",
+  "simple-salesforce>=1.12.6",
+]
+slack = [
+    "slack-bolt<2.0.0,>=1.20.1",
+]
+
+# as optional dep so it can be referenced in workspace pyproject.toml
+all = ["veri-agents-external[confluence,salesforce,slack]==0.1.2"]
+dev = ["veri-agents-external[all]==0.1.1"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

veri_agents_external-0.1.2/src/veri_agents_external/confluence/loader.py

@@ -0,0 +1,80 @@
+import logging
+from datetime import datetime
+from typing import Iterator
+
+from langchain_core.documents import Document
+from langchain_community.document_loaders import ConfluenceLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from veri_agents_knowledgebase.knowledgebase import DataSource, DocumentLoader
+
+logger = logging.getLogger(__name__)
+
+class ConfluenceDataSource(DataSource):
+    username: str
+    """ The username for Confluence API access. """
+    
+    api_key: str
+    """ The API key for Confluence API access. """
+
+    space_key: str
+    """ The key of the Confluence space to load documents from. """
+
+
+class ConfluenceDocumentLoader(DocumentLoader):
+    def __init__(
+        self,
+        data_source: ConfluenceDataSource,
+        include_attachments: bool = False,
+    ):
+        super().__init__(data_source)
+        self.loader = ConfluenceLoader(
+            url=str(data_source.location),
+            username=data_source.username,
+            api_key=data_source.api_key,
+            keep_markdown_format=True,
+            include_attachments=include_attachments,
+            space_key=data_source.space_key,
+            limit=50,
+            max_pages=10000,
+        )
+        self.splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500, chunk_overlap=200
+        )
+
+    def _split(self, text: str, metadata: dict) -> list[Document]:
+        """Split text into smaller chunks using the text splitter."""
+        doc = Document(page_content=text, metadata=metadata)
+        new_docs = self.splitter.split_documents([doc])
+        return new_docs
+
+    def _add_content(
+        self,
+        parent_doc: Document,
+        child_docs: list[Document],
+        text: str,
+        metadata: dict,
+    ):
+        """Add content to parent document and create child documents."""
+        if text.strip():
+            parent_doc.page_content += f"{text}\n"
+            new_docs = self._split(text, metadata)
+            child_docs.extend(new_docs)
+
+    def load_documents(
+        self, **kwargs
+    ) -> Iterator[tuple[Document, list[Document] | None]]:
+        """Load documents from Confluence and split them into parent and child documents."""
+        # Load documents using the lazy_load method
+        for doc in self.loader.lazy_load(**kwargs):
+            # Create metadata with updated timestamp
+            metadata = doc.metadata.copy()
+            metadata["last_updated"] = datetime.now().isoformat()
+            
+            # Create parent document
+            parent_doc = Document(page_content="", metadata=metadata)
+            child_docs: list[Document] = []
+            
+            # Add the full content to both parent and child documents
+            self._add_content(parent_doc, child_docs, doc.page_content, metadata)
+            
+            yield parent_doc, child_docs

veri_agents_external-0.1.2/src/veri_agents_external/salesforce/api.py

@@ -0,0 +1,506 @@
+from datetime import datetime
+import os
+import logging
+from typing import List, Optional
+
+import requests
+from pydantic import BaseModel, Field
+from simple_salesforce.api import Salesforce
+
+log = logging.getLogger(__name__)
+
+
+class KnowledgeArticle(BaseModel):
+    """
+    Pydantic model to represent a Salesforce Knowledge Article.
+    Uses Field aliases to map from Salesforce API names to Python-friendly names.
+    """
+
+    knowledge_article_id: str = Field(..., alias="KnowledgeArticleId")
+    title: Optional[str] = Field(None, alias="Title")
+    summary: Optional[str] = Field(None, alias="Summary")
+    body: Optional[str] = Field(None, alias="Body__c")
+    problem: Optional[str] = Field(None, alias="Problem__c")
+    cause: Optional[str] = Field(None, alias="Cause__c")
+    solution: Optional[str] = Field(None, alias="Solution__c")
+    public_article_link: Optional[str] = Field(None, alias="Public_Article_Link__c")
+    product: Optional[str] = Field(None, alias="Product__c")
+    marketing_product: Optional[str] = Field(None, alias="Marketing_Product__c")
+    question: Optional[str] = Field(None, alias="Question__c")
+    answer: Optional[str] = Field(None, alias="Answer__c")
+    description: Optional[str] = Field(None, alias="Description__c")
+    instructions: Optional[str] = Field(None, alias="Instructions__c")
+    release_notes: Optional[str] = Field(None, alias="Release_Notes__c")
+
+
+class Case(BaseModel):
+    """
+    Pydantic model to represent a Salesforce Case (Ticket).
+    """
+
+    id: str = Field(..., alias="Id")
+    case_number: Optional[str] = Field(None, alias="CaseNumber")
+    subject: Optional[str] = Field(None, alias="Subject")
+    status: Optional[str] = Field(None, alias="Status")
+    priority: Optional[str] = Field(None, alias="Priority")
+    origin: Optional[str] = Field(None, alias="Origin")
+    type: Optional[str] = Field(None, alias="Type")
+    description: Optional[str] = Field(None, alias="Description")
+    created_date: str = Field(..., alias="CreatedDate")
+    closed_date: Optional[str] = Field(None, alias="ClosedDate")
+    is_closed: bool = Field(..., alias="IsClosed")
+    is_escalated: bool = Field(..., alias="IsEscalated")
+    contact_email: Optional[str] = Field(None, alias="ContactEmail")
+    products: Optional[str] = Field(None, alias="Products__c")
+
+
+class SuggestedArticle(BaseModel):
+    Id: str
+    Title: Optional[str]
+
+
+class CaseArticleRecommendation(BaseModel):
+    Id: str
+    RecommendationAction: Optional[str]
+    RecommendationType: Optional[str]
+    SuggestedArticleId: Optional[str]
+    SuggestedArticle: Optional[SuggestedArticle]
+    CreatedDate: datetime
+
+
+class CaseArticleRecommendationResponse(BaseModel):
+    totalSize: int
+    done: bool
+    records: List[CaseArticleRecommendation]
+
+
+class SalesforceConnection:
+    """
+    Handles the connection and authentication with the Salesforce API.
+    """
+
+    def __init__(self, client_id: str, client_secret: str, token_url: str):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.token_url = token_url
+        self.sf = self._connect()
+
+    def is_connected(self) -> bool:
+        """
+        Checks if the Salesforce connection is established.
+        Returns:
+            bool: True if connected, False otherwise.
+        """
+        return self.sf is not None
+
+    def _connect(self):
+        """
+        Establishes the connection to Salesforce using client credentials.
+        """
+        log.info("Attempting to connect to Salesforce...")
+        try:
+            payload = {
+                "grant_type": "client_credentials",
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+            }
+            response = requests.post(self.token_url, data=payload, timeout=10)
+            response.raise_for_status()
+            response_data = response.json()
+            access_token = response_data.get("access_token")
+            instance_url = response_data.get("instance_url").rstrip(
+                "/"
+            )  # Clean trailing slash if present
+
+            if not access_token or not instance_url:
+                raise ValueError(
+                    "Access token or instance URL not found in the response."
+                )
+
+            log.info("Successfully obtained access token and instance URL.")
+            return Salesforce(instance_url=instance_url, session_id=access_token)
+
+        except requests.exceptions.RequestException as e:
+            log.error(f"Error getting access token: {e}")
+            return None
+        except (ValueError, KeyError) as e:
+            log.error(f"Error parsing authentication response: {e}")
+            return None
+
+
+def get_knowledge_articles(sf_connection, limit: int = 200000) -> List[KnowledgeArticle]:
+    """
+    Retrieves and validates knowledge articles from Salesforce.
+
+    Returns:
+        List[KnowledgeArticle]: A list of validated Pydantic models.
+    """
+    if not sf_connection.sf:
+        log.error(
+            "Cannot fetch knowledge articles: Salesforce connection is not available."
+        )
+        return []
+
+    query = f"""
+        SELECT
+            KnowledgeArticleId, Title, Summary, Body__c, Problem__c, Cause__c, Solution__c,
+            Public_Article_Link__c, Product__c, Marketing_Product__c, Question__c, Answer__c, Description__c,
+            Instructions__c, Release_Notes__c
+        FROM Knowledge__kav
+        WHERE IsDeleted = false AND PublishStatus = 'Online' AND IsLatestVersion = true AND IsMasterLanguage = true
+        LIMIT {limit}
+    """
+    try:
+        log.info("\nQuerying for Knowledge Articles...")
+        result = sf_connection.sf.query_all_iter(query)
+        validated_articles = [KnowledgeArticle.model_validate(article) for article in result]
+        return validated_articles
+    except Exception as e:
+        log.error(f"An error occurred while getting knowledge articles: {e}")
+        return []
+
+
+def get_cases(
+    sf_connection: SalesforceConnection, days_ago: int = 30, limit: int = 100
+) -> List[Case]:
+    """
+    Retrieves and validates cases (Tickets) from Salesforce.
+
+    Returns:
+        List[Case]: A list of validated Pydantic models.
+    """
+    if not sf_connection.sf:
+        log.error("Cannot fetch tickets: Salesforce connection is not available.")
+        return []
+
+    query = f"""
+        SELECT
+            Id, CaseNumber, Subject, Status, Priority, Origin, Type, Description,
+            CreatedDate, ClosedDate, IsClosed, IsEscalated, ContactEmail, Products__c
+        FROM Case
+        WHERE CreatedDate = LAST_N_DAYS:{days_ago}
+        ORDER BY CreatedDate DESC
+        LIMIT {limit}
+    """
+    try:
+        log.info(f"\nQuerying for {limit} cases from the last {days_ago} days...")
+        result = sf_connection.sf.query(query)
+        case_data = result.get("records", [])
+        log.info(f"Found {len(case_data)} cases. Validating...")
+        validated_cases = [Case.model_validate(case) for case in case_data]
+        return validated_cases
+    except Exception as e:
+        log.error(f"An error occurred while getting cases: {e}")
+        return []
+
+
+def get_case_by_id(
+    sf_connection: SalesforceConnection, case_id: str
+) -> Optional[Case]:
+    """
+    Retrieves and validates a single ticket (Case) from Salesforce by its ID.
+
+    Args:
+        sf_connection (Salesforce): An active simple_salesforce.Salesforce instance.
+        ticket_id (str): The ID of the ticket to retrieve.
+
+    Returns:
+        Optional[Case]: A validated Pydantic model of the ticket, or None if not found.
+    """
+    if not sf_connection.sf:
+        log.error("Cannot fetch ticket: Salesforce connection is not available.")
+        return None
+
+    # Sanitize case_id to prevent SOQL injection
+    sanitized_case_id = case_id.replace("'", "\\'")
+
+    query = f"""
+        SELECT
+            Id, CaseNumber, Subject, Status, Priority, Origin, Type, Description,
+            CreatedDate, ClosedDate, IsClosed, IsEscalated, ContactEmail, Products__c
+        FROM Case
+        WHERE Id = '{sanitized_case_id}'
+        LIMIT 1
+    """
+    try:
+        log.info(f"\nQuerying for Case with ID: {case_id}...")
+        result = sf_connection.sf.query(query)
+        records = result.get("records", [])
+        if not records:
+            log.info(f"No ticket found with ID: {case_id}")
+            return None
+
+        ticket_data = records[0]
+        log.info("Found ticket. Validating...")
+        validated_ticket = Case.model_validate(ticket_data)
+        return validated_ticket
+    except Exception as e:
+        log.error(f"An error occurred while getting case by ID: {e}")
+        return None
+
+
+def get_case_by_number(
+    sf_connection: SalesforceConnection, case_number: str
+) -> Optional[Case]:
+    """
+    Retrieves and validates a single ticket (Case) from Salesforce by its case number.
+
+    Args:
+        sf_connection (Salesforce): An active simple_salesforce.Salesforce instance.
+        case_number (str): The case number of the ticket to retrieve.
+
+    Returns:
+        Optional[Case]: A validated Pydantic model of the ticket, or None if not found.
+    """
+    if not sf_connection.sf:
+        log.error("Cannot fetch ticket: Salesforce connection is not available.")
+        return None
+
+    # Sanitize case_number to prevent SOQL injection
+    sanitized_case_number = case_number.replace("'", "\\'")
+
+    query = f"""
+        SELECT
+            Id, CaseNumber, Subject, Status, Priority, Origin, Type, Description,
+            CreatedDate, ClosedDate, IsClosed, IsEscalated, ContactEmail, Products__c
+        FROM Case
+        WHERE CaseNumber = '{sanitized_case_number}'
+        LIMIT 1
+    """
+    try:
+        log.info(f"\nQuerying for Case with Case Number: {case_number}...")
+        result = sf_connection.sf.query(query)
+        records = result.get("records", [])
+        if not records:
+            log.info(f"No ticket found with Case Number: {case_number}")
+            return None
+
+        ticket_data = records[0]
+        log.info("Found ticket. Validating...")
+        validated_ticket = Case.model_validate(ticket_data)
+        return validated_ticket
+    except Exception as e:
+        log.error(f"An error occurred while getting case by number: {e}")
+        return None
+
+
+def get_article_by_id(
+    sf_connection: SalesforceConnection, article_id: str
+) -> Optional[KnowledgeArticle]:
+    """
+    Retrieves and validates a single knowledge article from Salesforce by its ID.
+
+    Args:
+        sf_connection (Salesforce): An active simple_salesforce.Salesforce instance.
+        article_id (str): The ID of the knowledge article to retrieve.
+
+    Returns:
+        Optional[KnowledgeArticle]: A validated Pydantic model of the article, or None if not found.
+    """
+    if not sf_connection.sf:
+        log.error("Cannot fetch article: Salesforce connection is not available.")
+        return None
+
+    # Sanitize article_id to prevent SOQL injection
+    sanitized_article_id = article_id.replace("'", "\\'")
+
+    query = f"""
+        SELECT
+            KnowledgeArticleId, Title, Summary, Body__c, Problem__c, Cause__c, Solution__c,
+            Public_Article_Link__c, Product__c, Question__c, Answer__c, Description__c,
+            Instructions__c, Release_Notes__c
+        FROM Knowledge__kav
+        WHERE KnowledgeArticleId = '{sanitized_article_id}'
+        LIMIT 1
+    """
+    try:
+        log.info(f"\nQuerying for Article with ID: {article_id}...")
+        result = sf_connection.sf.query(query)
+        records = result.get("records", [])
+        if not records:
+            log.error(f"No article found with ID: {article_id}")
+            return None
+
+        article_data = records[0]
+        log.info("Found article. Validating...")
+        validated_article = KnowledgeArticle.model_validate(article_data)
+        return validated_article
+    except Exception as e:
+        log.error(f"An error occurred while getting article by ID: {e}")
+        return None
+
+
+def get_article_recommendation(
+    sf_connection: SalesforceConnection, ticket_id: str
+) -> Optional[list[CaseArticleRecommendation]]:
+    if not sf_connection.sf:
+        log.error("Cannot fetch article: Salesforce connection is not available.")
+        return None
+
+    soql_query = f"""
+    SELECT Id,
+        RecommendationAction,
+        RecommendationType,
+        SuggestedArticleId,
+        SuggestedArticle.Title,
+        CreatedDate
+    FROM CaseArticleRecommendation
+    WHERE CaseId = '{ticket_id}'
+    """
+
+    try:
+        results = sf_connection.sf.query_all(soql_query)
+        parsed = CaseArticleRecommendationResponse(**results)
+        return parsed.records
+    except Exception as e:
+        log.error(f"An error occurred while querying for article recommendations: {e}")
+        return None
+
+
+def describe_salesforce_object(sf_connection: SalesforceConnection, object_name: str) -> Optional[dict]:
+    """
+    Describes a Salesforce object and returns its field information.
+    
+    Args:
+        sf_connection: An active SalesforceConnection instance
+        object_name: The API name of the Salesforce object (e.g., 'Knowledge__kav', 'Case')
+    
+    Returns:
+        Dictionary containing object description or None if error
+    """
+    if not sf_connection.sf:
+        log.error(f"Cannot describe {object_name}: Salesforce connection is not available.")
+        return None
+    
+    try:
+        # Use getattr to access the object dynamically and call describe()
+        obj = getattr(sf_connection.sf, object_name)
+        description = obj.describe()
+        return description
+    except Exception as e:
+        log.error(f"An error occurred while describing {object_name}: {e}")
+        return None
+
+
+def print_object_fields(sf_connection: SalesforceConnection, object_name: str):
+    """
+    Prints all fields of a Salesforce object in a readable format.
+    
+    Args:
+        sf_connection: An active SalesforceConnection instance
+        object_name: The API name of the Salesforce object
+    """
+    print(f"\n=== {object_name} Object Fields ===")
+    description = describe_salesforce_object(sf_connection, object_name)
+    
+    if not description:
+        print(f"Failed to retrieve description for {object_name}")
+        return
+    
+    fields = description.get('fields', [])
+    print(f"Object Label: {description.get('label', 'N/A')}")
+    print(f"Total Fields: {len(fields)}")
+    print("\nFields:")
+    print("-" * 80)
+    
+    for field in sorted(fields, key=lambda x: x['name']):
+        field_name = field.get('name', 'N/A')
+        field_label = field.get('label', 'N/A')
+        field_type = field.get('type', 'N/A')
+        is_custom = field.get('custom', False)
+        is_required = not field.get('nillable', True)
+        
+        custom_indicator = " [CUSTOM]" if is_custom else ""
+        required_indicator = " [REQUIRED]" if is_required else ""
+        
+        print(f"  {field_name:<30} | {field_type:<15} | {field_label}{custom_indicator}{required_indicator}")
+    
+    print("-" * 80)
+
+
+if __name__ == "__main__":
+    CLIENT_ID = os.getenv("SALESFORCE_CLIENT_ID")
+    CLIENT_SECRET = os.getenv("SALESFORCE_CLIENT_SECRET")
+    TOKEN_URL = os.getenv("SALESFORCE_TOKEN_URL")
+    if not CLIENT_ID or not CLIENT_SECRET or not TOKEN_URL:
+        raise ValueError(
+            "Please set the SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET environment variables."
+        )
+
+    sf_conn = SalesforceConnection(CLIENT_ID, CLIENT_SECRET, TOKEN_URL)
+
+    products = set()
+    unknown_products = []
+
+    if sf_conn.sf:
+        # Print all fields for Knowledge__kav and Case objects
+        print_object_fields(sf_conn, "Knowledge__kav")
+        print_object_fields(sf_conn, "Case")
+        
+        articles = get_knowledge_articles(sf_conn)
+        if articles:
+            print("\n--- Recently Found Knowledge Articles ---")
+            for i, article in enumerate(articles):
+                if i <= 3:
+                    print(f"Title: {article.title}")
+                    print(f"Summary: {article.summary}")
+                    print(f"Body: {article.body[:100] if article.body else 'N/A'}...")
+                    print(f"Problem: {article.problem}")
+                    print(f"Cause: {article.cause}")
+                    print(f"Solution: {article.solution}")
+                    print(f"Public Article Link: {article.public_article_link}")
+                    print(f"Product: {article.product}")
+                    print(f"Marketing product: {article.marketing_product}")
+                    print(f"Question: {article.question}")
+                    print(f"Answer: {article.answer}")
+                    print(f"Description: {article.description}")
+                    print(f"Instructions: {article.instructions}")
+                    print(f"Release Notes: {article.release_notes}")
+                    print("-" * 20)
+
+                if article.marketing_product:
+                    for p in article.marketing_product.split(";"):
+                        if p:
+                            products.add(p.strip())
+                else:
+                    unknown_products.append(article.title)
+
+        print(f"Found {len(articles)} knowledge articles."  )
+        tickets = get_cases(sf_conn, days_ago=90, limit=3)
+        if tickets:
+            print("\n--- Recently Created Cases ---")
+            for ticket in tickets:
+                # Accessing data via model attributes
+                print(f"  Case Number: {ticket.case_number}")
+                print(f"    Subject: {ticket.subject}")
+                print(f"    Status: {ticket.status}")
+                print(f"    Products: {ticket.products}")
+                if ticket.description:
+                    print(f"    Description: {ticket.description[:100]}")
+                print("-" * 20)
+
+            # --- Example: Retrieve a specific ticket by its ID ---
+            first_ticket_id = tickets[0].id
+            specific_ticket = get_case_by_id(sf_conn, first_ticket_id)
+            if specific_ticket:
+                print("\n--- Details for Specific Cases ---")
+                print(f"  Case Number: {specific_ticket.case_number}")
+                if specific_ticket.description:
+                    print(f"    Description: {specific_ticket.description[:100]}")
+                # print(specific_ticket)
+                print("-" * 20)
+
+            print(f"Found {len(tickets)} tickets in the last 90 days.")
+
+            # ---- Example: Retrieve knowledge article recommendations for this specific ticket
+            #article_recommendation = get_article_recommendation(
+            #    sf_conn, first_ticket_id
+            #)
+            #if article_recommendation:
+            #    print("\n--- Article Recommendation for Specific Cases ---")
+            #    print(article_recommendation)
+            #    print("-" * 20)
+
+    print(f"Products: {', '.join(products)}")
+    print(f"Unknown product for {len(unknown_products)} articles")
+    print(f"Unknown products: {', '.join(unknown_products[:30])}")

veri_agents_external-0.1.2/src/veri_agents_external/salesforce/loader.py

@@ -0,0 +1,180 @@
+import logging
+import os
+from datetime import datetime
+from typing import Iterator, cast
+
+from bs4 import BeautifulSoup
+from langchain_core.documents import Document
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from veri_agents_knowledgebase.knowledgebase import DataSource, DocumentLoader
+
+from .api import SalesforceConnection, get_knowledge_articles
+
+log = logging.getLogger(__name__)
+
+
+class SalesforceDataSource(DataSource):
+    client_id: str
+    """ The client ID for Salesforce API access. """
+
+    client_secret: str
+    """ The client secret for Salesforce API access. """
+
+
+class SalesforceSupportDocumentLoader(DocumentLoader):
+    def __init__(
+        self, data_source: SalesforceDataSource, load_all_products: bool = False
+    ):
+        super().__init__(data_source)
+        self.load_all_products = load_all_products
+
+        self.product_name_map = {
+            "aiWare - aiWare": "aiWare",
+            "aiWare - Automate Studio": "Automate",
+            "Contact App": "Contact",
+            "GLC - Redaction Managed Service (RMS)": "Redact",
+            "Relativity (integration)": "Relativity",
+        }
+        self.splitter = RecursiveCharacterTextSplitter(
+            chunk_size=500, chunk_overlap=200
+        )
+
+    def _parse_html(self, text: str | None) -> str:
+        if not text:
+            return ""
+        soup = BeautifulSoup(text, "html.parser")
+        return soup.get_text()
+
+    def _split(self, text: str, metadata: dict):
+        doc = Document(page_content=text, metadata=metadata)
+        new_docs = self.splitter.split_documents([doc])
+        return new_docs
+
+    def _add(
+        self,
+        parent_doc: Document,
+        docs: list[Document],
+        text: str,
+        fieldname: str | None,
+        metadata: dict,
+    ):
+        if text:
+            if fieldname:
+                parent_doc.page_content += f"{fieldname}: {text}\n"
+            else:
+                parent_doc.page_content += f"{text}\n"
+            new_docs = self._split(text, metadata)
+            docs.extend(new_docs)
+
+    def load_documents(
+        self, **kwargs
+    ) -> Iterator[tuple[Document, list[Document] | None]]:
+        products_to_include = []
+
+        if "products" in kwargs:
+            products_to_include = kwargs["products"]
+
+        data_source = cast(SalesforceDataSource, self.data_source)
+        sf = SalesforceConnection(
+            token_url=str(data_source.location),
+            client_id=data_source.client_id,
+            client_secret=data_source.client_secret,
+        )
+
+        if not sf.is_connected():
+            raise ValueError(
+                "Salesforce connection failed. Please check your credentials."
+            )
+
+        articles = get_knowledge_articles(sf, limit=50000)
+
+        log.info("Found %d knowledge articles in Salesforce.", len(articles))
+
+        if not articles:
+            raise ValueError("No knowledge articles found in Salesforce.")
+
+        for article in articles:
+            summary = self._parse_html(article.summary)
+            content = self._parse_html(article.body)
+            problem = self._parse_html(article.problem)
+            cause = self._parse_html(article.cause)
+            solution = self._parse_html(article.solution)
+            question = self._parse_html(article.question)
+            answer = self._parse_html(article.answer)
+            description = self._parse_html(article.description)
+            instructions = self._parse_html(article.instructions)
+            release_notes = self._parse_html(article.release_notes)
+            title = article.title or "Untitled"
+            link = article.public_article_link or "none"
+            product = article.marketing_product or ""
+
+            # TODO: images? docling?
+
+            # TODO: can we use a metadata filter that can handle this
+            product_list = product.split(";")
+            for product in product_list:
+                if not product:
+                    continue
+                product = self.product_name_map.get(product, product)
+                if (
+                    not self.load_all_products
+                    and products_to_include
+                    and product not in products_to_include
+                ):
+                    continue
+
+                docs: list[Document] = []
+                metadata = {
+                    "source": f"{article.knowledge_article_id}_{product}",
+                    "title": title,
+                    "product": product,
+                    "link": link,
+                    "last_updated": datetime.now().isoformat(),
+                }
+                # Title as a separate document because we want to use ParentRetriever
+                parent_doc = Document(page_content="", metadata=metadata)
+                self._add(parent_doc, docs, title, "Title", metadata)
+                self._add(parent_doc, docs, summary, "Summary", metadata)
+                self._add(parent_doc, docs, problem, "Problem", metadata)
+                self._add(parent_doc, docs, cause, "Cause", metadata)
+                self._add(parent_doc, docs, solution, "Solution", metadata)
+                self._add(parent_doc, docs, question, "Question", metadata)
+                self._add(parent_doc, docs, answer, "Answer", metadata)
+                self._add(parent_doc, docs, description, "Description", metadata)
+                self._add(parent_doc, docs, instructions, "Instruction", metadata)
+                self._add(parent_doc, docs, release_notes, "Release Notes", metadata)
+                self._add(parent_doc, docs, content, None, metadata)
+                yield parent_doc, docs
+
+
+def main():
+    CLIENT_ID = os.getenv("SALESFORCE_CLIENT_ID")
+    CLIENT_SECRET = os.getenv("SALESFORCE_CLIENT_SECRET")
+    TOKEN_URL = os.getenv("SALESFORCE_TOKEN_URL")
+    if not CLIENT_ID or not CLIENT_SECRET or not TOKEN_URL:
+        raise ValueError(
+            "Please set the SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET environment variables."
+        )
+
+    # Example usage
+    ds = SalesforceDataSource(
+        name="salesforce_knowledge",
+        location=TOKEN_URL,
+        client_id=CLIENT_ID,
+        client_secret=CLIENT_SECRET,
+    )
+
+    loader = SalesforceSupportDocumentLoader(ds)
+    # loader.load_documents(products=["aiWare", "Automate", "Contact", "Redact"])
+    for doc, _ in loader.load_documents(
+        products=["aiWare", "Automate", "Contact", "Redact"]
+    ):
+        print(f"Document ID: {doc.metadata['source']}")
+        print(f"Title: {doc.metadata['title']}")
+        print(f"Product: {doc.metadata['product']}")
+        print(f"Content: {doc.page_content[:100]}...")  # Print first 100 characters
+        print()
+
+
+if __name__ == "__main__":
+    main()

veri_agents_external-0.1.2/src/veri_agents_external/salesforce/tools.py

@@ -0,0 +1,163 @@
+import requests
+import logging
+from typing import Optional, Tuple, Type, cast
+
+from langchain_core.tools import BaseTool, ToolException, InjectedToolArg
+from typing_extensions import Annotated
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+from .api import (
+    SalesforceConnection,
+    get_cases,
+    get_case_by_number,
+    # get_knowledge_articles,
+    get_article_by_id,
+)
+
+log = logging.getLogger(__name__)
+
+
+def filter_none_values(data) -> dict | list:
+    if isinstance(data, dict):
+        return {k: filter_none_values(v) for k, v in data.items() if v is not None}
+    elif isinstance(data, list):
+        return [filter_none_values(item) for item in data]
+    return data
+
+
+class SalesforceToolInput(BaseModel):
+    """Input for the Salesforce tool."""
+
+    query: str = Field(
+        description="Salesforce SQL query to execute. Use SOQL (Salesforce Object Query Language) syntax."
+    )
+
+
+class SalesforceTool(BaseTool):
+    """Generic Salesforce API tool.
+
+    Typically used as base class for more specialized Salesforce tools.
+    """
+
+    salesforce_client_id: str
+    """ The client ID for Salesforce API access. """
+
+    salesforce_client_secret: str
+    """ The client secret for Salesforce API access. """
+
+    salesforce_token_url: str
+    """ The token URL for Salesforce API access. This is typically the OAuth token endpoint. """
+
+    name: str = "salesforce_tool"
+    description: str = "Performs Salesforce queries. Use this tool if you have no other, more specialized Salesforce tool."
+    #args_schema = SalesforceToolInput
+    response_format: str = "content_and_artifact"  # type: ignore
+    handle_tool_errors: bool = True
+    allow_mutation: bool = False
+
+    def _connect(self) -> SalesforceConnection:
+        sf = SalesforceConnection(
+            token_url=self.salesforce_token_url,
+            client_id=self.salesforce_client_id,
+            client_secret=self.salesforce_client_secret,
+        )
+
+        if not sf.is_connected():
+            raise ToolException(
+                "Salesforce connection failed. Please check your credentials."
+            )
+
+        return sf
+        # articles = get_knowledge_articles(sf, limit=50000)
+
+    # def _run(
+    #     self,
+    #     gql_query: str,
+    #     # aiware_api_key: Annotated[Optional[str], InjectedToolArg]
+    # ) -> Tuple[str, dict]:
+    #     """Run the aiWARE GraphQL query."""
+    #     aiware_api_key = None
+    #     result = self._run_query(gql_query, aiware_api_key)
+    #     return str(result), {"items": result, "type": "json", "source": "aiware"}
+
+
+class SalesforceGetRecentCasesInput(BaseModel):
+    """Input for the Salesforce Get Recent Tickets tool."""
+
+    days_ago: int = Field(
+        default=90,
+        description="Number of days ago to look for cases. For example, if you want to get cases from the last 7 days, set this to 7. Default is 90 days.",
+    )
+    limit: int = Field(
+        default=10, description="Maximum number of cases to return. Default is 10."
+    )
+
+
+class SalesforceGetRecentCases(SalesforceTool):
+    """Tool to get recent Salesforce cases."""
+
+    name: str = "salesforce_recent_cases"
+    description: str = "Get recent Salesforce cases. Use this tool to get cases from the last N days. The result is a list of cases with contents."
+    args_schema = SalesforceGetRecentCasesInput
+
+    def _run(self, days_ago: int = 90, limit: int = 10) -> Tuple[str, dict]:
+        sf = self._connect()
+        result = get_cases(sf, days_ago=days_ago, limit=limit)
+        # convert list of tickets to json
+        results_json = [result.model_dump() for result in result]
+        return str(results_json), {
+            "items": results_json,
+            "type": "json",
+            "source": "salesforce",
+        }
+
+
+class SalesforceGetCaseByNumberInput(BaseModel):
+    case_number: str = Field(
+        description="Case number of the ticket to retrieve. This is the Salesforce case number of the requested case."
+    )
+
+
+class SalesforceGetCaseByNumber(SalesforceTool):
+    """Tool to get a Salesforce ticket by case number."""
+
+    name: str = "salesforce_case_by_number"
+    description: str = "Get a Salesforce case by number. Use this tool to get the contents of a specific case."
+    args_schema = SalesforceGetCaseByNumberInput
+
+    def _run(self, case_number: str) -> Tuple[str, dict]:
+        sf = self._connect()
+        result = get_case_by_number(sf, case_number)
+        if not result:
+            raise ToolException(f"Case with ID {case_number} not found.")
+        return str(result.model_dump()), {
+            "item": result.model_dump(),
+            "type": "json",
+            "source": "salesforce",
+        }
+
+
+class SalesforceGetArticleByIdInput(BaseModel):
+    article_id: str = Field(
+        description="ID of the article to retrieve. This is the Salesforce ID of the article."
+    )
+
+
+class SalesforceGetArticleById(SalesforceTool):
+    """Tool to get a Salesforce article by ID."""
+
+    name: str = "salesforce_article_by_id"
+    description: str = "Get a Salesforce article by ID. Use this tool to get the contents of a specific article."
+    args_schema = SalesforceGetArticleByIdInput
+
+    def _run(self, article_id: str) -> Tuple[str, dict]:
+        sf = self._connect()
+        result = get_article_by_id(sf, article_id)
+        if not result:
+            raise ToolException(f"Article with ID {article_id} not found.")
+        return str(result.model_dump()), {
+            "item": result.model_dump(),
+            "type": "json",
+            "source": "salesforce",
+        }