trustgraph-base 1.7.1__tar.gz → 1.7.5__tar.gz

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 1.7.1
+Version: 1.7.5
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Author-email: "trustgraph.ai" <security@trustgraph.ai>
 Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/api/__init__.py

@@ -34,7 +34,26 @@ from .types import (
 )
 
 # Exceptions
-from .exceptions import ProtocolException, ApplicationException
+from .exceptions import (
+    ProtocolException,
+    TrustGraphException,
+    AgentError,
+    ConfigError,
+    DocumentRagError,
+    FlowError,
+    GatewayError,
+    GraphRagError,
+    LLMError,
+    LoadError,
+    LookupError,
+    NLPQueryError,
+    ObjectsQueryError,
+    RequestError,
+    StructuredQueryError,
+    UnexpectedError,
+    # Legacy alias
+    ApplicationException,
+)
 
 __all__ = [
     # Core API
@@ -75,6 +94,21 @@ __all__ = [
 
     # Exceptions
     "ProtocolException",
-    "ApplicationException",
+    "TrustGraphException",
+    "AgentError",
+    "ConfigError",
+    "DocumentRagError",
+    "FlowError",
+    "GatewayError",
+    "GraphRagError",
+    "LLMError",
+    "LoadError",
+    "LookupError",
+    "NLPQueryError",
+    "ObjectsQueryError",
+    "RequestError",
+    "StructuredQueryError",
+    "UnexpectedError",
+    "ApplicationException",  # Legacy alias
 ]
 

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/api/async_socket_client.py

@@ -130,18 +130,26 @@ class AsyncSocketClient:
                 content=resp.get("content", ""),
                 end_of_message=resp.get("end_of_message", False)
             )
-        elif chunk_type == "final-answer":
+        elif chunk_type == "answer" or chunk_type == "final-answer":
             return AgentAnswer(
                 content=resp.get("content", ""),
                 end_of_message=resp.get("end_of_message", False),
                 end_of_dialog=resp.get("end_of_dialog", False)
             )
+        elif chunk_type == "action":
+            # Agent action chunks - treat as thoughts for display purposes
+            return AgentThought(
+                content=resp.get("content", ""),
+                end_of_message=resp.get("end_of_message", False)
+            )
         else:
             # RAG-style chunk (or generic chunk)
+            # Text-completion uses "response" field, RAG uses "chunk" field, Prompt uses "text" field
+            content = resp.get("response", resp.get("chunk", resp.get("text", "")))
             return RAGChunk(
-                content=resp.get("chunk", ""),
+                content=content,
                 end_of_stream=resp.get("end_of_stream", False),
-                error=resp.get("error")
+                error=None  # Errors are always thrown, never stored
             )
 
     async def aclose(self):

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/api/collection.py

@@ -41,9 +41,7 @@ class Collection:
                     collection = v["collection"],
                     name = v["name"],
                     description = v["description"],
-                    tags = v["tags"],
-                    created_at = v["created_at"],
-                    updated_at = v["updated_at"]
+                    tags = v["tags"]
                 )
                 for v in collections
             ]
@@ -76,9 +74,7 @@ class Collection:
                     collection = v["collection"],
                     name = v["name"],
                     description = v["description"],
-                    tags = v["tags"],
-                    created_at = v["created_at"],
-                    updated_at = v["updated_at"]
+                    tags = v["tags"]
                 )
             return None
         except Exception as e:

trustgraph_base-1.7.5/trustgraph/api/exceptions.py

@@ -0,0 +1,134 @@
+"""
+TrustGraph API Exceptions
+
+Exception hierarchy for errors returned by TrustGraph services.
+Each service error type maps to a specific exception class.
+"""
+
+# Protocol-level exceptions (communication errors)
+class ProtocolException(Exception):
+    """Raised when WebSocket protocol errors occur"""
+    pass
+
+
+# Base class for all TrustGraph application errors
+class TrustGraphException(Exception):
+    """Base class for all TrustGraph service errors"""
+    def __init__(self, message: str, error_type: str = None):
+        super().__init__(message)
+        self.message = message
+        self.error_type = error_type
+
+
+# Service-specific exceptions
+class AgentError(TrustGraphException):
+    """Agent service error"""
+    pass
+
+
+class ConfigError(TrustGraphException):
+    """Configuration service error"""
+    pass
+
+
+class DocumentRagError(TrustGraphException):
+    """Document RAG retrieval error"""
+    pass
+
+
+class FlowError(TrustGraphException):
+    """Flow management error"""
+    pass
+
+
+class GatewayError(TrustGraphException):
+    """API Gateway error"""
+    pass
+
+
+class GraphRagError(TrustGraphException):
+    """Graph RAG retrieval error"""
+    pass
+
+
+class LLMError(TrustGraphException):
+    """LLM service error"""
+    pass
+
+
+class LoadError(TrustGraphException):
+    """Data loading error"""
+    pass
+
+
+class LookupError(TrustGraphException):
+    """Lookup/search error"""
+    pass
+
+
+class NLPQueryError(TrustGraphException):
+    """NLP query service error"""
+    pass
+
+
+class ObjectsQueryError(TrustGraphException):
+    """Objects query service error"""
+    pass
+
+
+class RequestError(TrustGraphException):
+    """Request processing error"""
+    pass
+
+
+class StructuredQueryError(TrustGraphException):
+    """Structured query service error"""
+    pass
+
+
+class UnexpectedError(TrustGraphException):
+    """Unexpected/unknown error"""
+    pass
+
+
+# Mapping from error type string to exception class
+ERROR_TYPE_MAPPING = {
+    "agent-error": AgentError,
+    "config-error": ConfigError,
+    "document-rag-error": DocumentRagError,
+    "flow-error": FlowError,
+    "gateway-error": GatewayError,
+    "graph-rag-error": GraphRagError,
+    "llm-error": LLMError,
+    "load-error": LoadError,
+    "lookup-error": LookupError,
+    "nlp-query-error": NLPQueryError,
+    "objects-query-error": ObjectsQueryError,
+    "request-error": RequestError,
+    "structured-query-error": StructuredQueryError,
+    "unexpected-error": UnexpectedError,
+}
+
+
+def raise_from_error_dict(error_dict: dict) -> None:
+    """
+    Raise appropriate exception from TrustGraph error dictionary.
+
+    Args:
+        error_dict: Dictionary with 'type' and 'message' keys
+
+    Raises:
+        Appropriate TrustGraphException subclass based on error type
+    """
+    error_type = error_dict.get("type", "unexpected-error")
+    message = error_dict.get("message", "Unknown error")
+
+    # Look up exception class, default to UnexpectedError
+    exception_class = ERROR_TYPE_MAPPING.get(error_type, UnexpectedError)
+
+    # Raise the appropriate exception
+    raise exception_class(message, error_type)
+
+
+# Legacy exception for backwards compatibility
+ApplicationException = TrustGraphException

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/api/socket_client.py

@@ -6,7 +6,7 @@ from typing import Optional, Dict, Any, Iterator, Union, List
 from threading import Lock
 
 from . types import AgentThought, AgentObservation, AgentAnswer, RAGChunk, StreamingChunk
-from . exceptions import ProtocolException, ApplicationException
+from . exceptions import ProtocolException, raise_from_error_dict
 
 
 class SocketClient:
@@ -126,7 +126,7 @@ class SocketClient:
                 raise ProtocolException(f"Response ID mismatch")
 
             if "error" in response:
-                raise ApplicationException(response["error"])
+                raise_from_error_dict(response["error"])
 
             if "response" not in response:
                 raise ProtocolException(f"Missing response in message")
@@ -171,11 +171,15 @@ class SocketClient:
                     continue  # Ignore messages for other requests
 
                 if "error" in response:
-                    raise ApplicationException(response["error"])
+                    raise_from_error_dict(response["error"])
 
                 if "response" in response:
                     resp = response["response"]
 
+                    # Check for errors in response chunks
+                    if "error" in resp:
+                        raise_from_error_dict(resp["error"])
+
                     # Parse different chunk types
                     chunk = self._parse_chunk(resp)
                     yield chunk
@@ -198,18 +202,26 @@ class SocketClient:
                 content=resp.get("content", ""),
                 end_of_message=resp.get("end_of_message", False)
             )
-        elif chunk_type == "final-answer":
+        elif chunk_type == "answer" or chunk_type == "final-answer":
             return AgentAnswer(
                 content=resp.get("content", ""),
                 end_of_message=resp.get("end_of_message", False),
                 end_of_dialog=resp.get("end_of_dialog", False)
             )
+        elif chunk_type == "action":
+            # Agent action chunks - treat as thoughts for display purposes
+            return AgentThought(
+                content=resp.get("content", ""),
+                end_of_message=resp.get("end_of_message", False)
+            )
         else:
             # RAG-style chunk (or generic chunk)
+            # Text-completion uses "response" field, RAG uses "chunk" field, Prompt uses "text" field
+            content = resp.get("response", resp.get("chunk", resp.get("text", "")))
             return RAGChunk(
-                content=resp.get("chunk", ""),
+                content=content,
                 end_of_stream=resp.get("end_of_stream", False),
-                error=resp.get("error")
+                error=None  # Errors are always thrown, never stored
             )
 
     def close(self) -> None:

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/api/types.py

@@ -49,8 +49,6 @@ class CollectionMetadata:
     name : str
     description : str
     tags : List[str]
-    created_at : str
-    updated_at : str
 
 # Streaming chunk types
 
@@ -79,5 +77,6 @@ class AgentAnswer(StreamingChunk):
 @dataclasses.dataclass
 class RAGChunk(StreamingChunk):
     """RAG streaming chunk"""
+    chunk_type: str = "rag"
     end_of_stream: bool = False
     error: Optional[Dict[str, str]] = None

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/base/__init__.py

@@ -33,4 +33,5 @@ from . tool_service import ToolService
 from . tool_client import ToolClientSpec
 from . agent_client import AgentClientSpec
 from . structured_query_client import StructuredQueryClientSpec
+from . collection_config_handler import CollectionConfigHandler
 

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/base/async_processor.py

@@ -258,9 +258,9 @@ class AsyncProcessor:
         PulsarClient.add_args(parser)
 
         parser.add_argument(
-            '--config-queue',
+            '--config-push-queue',
             default=default_config_queue,
-            help=f'Config push queue {default_config_queue}',
+            help=f'Config push queue (default: {default_config_queue})',
         )
 
         parser.add_argument(

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/base/cassandra_config.py

@@ -13,14 +13,15 @@ from typing import Optional, Tuple, List, Any
 def get_cassandra_defaults() -> dict:
     """
     Get default Cassandra configuration values from environment variables or fallback defaults.
-    
+
     Returns:
-        dict: Dictionary with 'host', 'username', and 'password' keys
+        dict: Dictionary with 'host', 'username', 'password', and 'keyspace' keys
     """
     return {
         'host': os.getenv('CASSANDRA_HOST', 'cassandra'),
         'username': os.getenv('CASSANDRA_USERNAME'),
-        'password': os.getenv('CASSANDRA_PASSWORD')
+        'password': os.getenv('CASSANDRA_PASSWORD'),
+        'keyspace': os.getenv('CASSANDRA_KEYSPACE')
     }
 
 
@@ -53,82 +54,108 @@ def add_cassandra_args(parser: argparse.ArgumentParser) -> None:
         password_help += " (default: <set>)"
         if 'CASSANDRA_PASSWORD' in os.environ:
             password_help += " [from CASSANDRA_PASSWORD]"
-    
+
+    keyspace_help = "Cassandra keyspace (default: service-specific)"
+    if defaults['keyspace']:
+        keyspace_help = f"Cassandra keyspace (default: {defaults['keyspace']})"
+        if 'CASSANDRA_KEYSPACE' in os.environ:
+            keyspace_help += " [from CASSANDRA_KEYSPACE]"
+
     parser.add_argument(
         '--cassandra-host',
         default=defaults['host'],
         help=host_help
     )
-    
+
     parser.add_argument(
         '--cassandra-username',
         default=defaults['username'],
         help=username_help
     )
-    
+
     parser.add_argument(
         '--cassandra-password',
         default=defaults['password'],
         help=password_help
     )
 
+    parser.add_argument(
+        '--cassandra-keyspace',
+        default=defaults['keyspace'],
+        help=keyspace_help
+    )
+
 
 def resolve_cassandra_config(
     args: Optional[Any] = None,
     host: Optional[str] = None,
     username: Optional[str] = None,
-    password: Optional[str] = None
-) -> Tuple[List[str], Optional[str], Optional[str]]:
+    password: Optional[str] = None,
+    default_keyspace: Optional[str] = None
+) -> Tuple[List[str], Optional[str], Optional[str], Optional[str]]:
     """
     Resolve Cassandra configuration from various sources.
-    
+
     Can accept either argparse args object or explicit parameters.
     Converts host string to list format for Cassandra driver.
-    
+
     Args:
-        args: Optional argparse namespace with cassandra_host, cassandra_username, cassandra_password
+        args: Optional argparse namespace with cassandra_host, cassandra_username, cassandra_password, cassandra_keyspace
         host: Optional explicit host parameter (overrides args)
         username: Optional explicit username parameter (overrides args)
         password: Optional explicit password parameter (overrides args)
-    
+        default_keyspace: Optional default keyspace if not specified elsewhere
+
     Returns:
-        tuple: (hosts_list, username, password)
+        tuple: (hosts_list, username, password, keyspace)
     """
     # If args provided, extract values
+    keyspace = None
     if args is not None:
         host = host or getattr(args, 'cassandra_host', None)
         username = username or getattr(args, 'cassandra_username', None)
         password = password or getattr(args, 'cassandra_password', None)
-    
+        keyspace = getattr(args, 'cassandra_keyspace', None)
+
     # Apply defaults if still None
     defaults = get_cassandra_defaults()
     host = host or defaults['host']
     username = username or defaults['username']
     password = password or defaults['password']
-    
+    keyspace = keyspace or defaults['keyspace'] or default_keyspace
+
     # Convert host string to list
     if isinstance(host, str):
         hosts = [h.strip() for h in host.split(',') if h.strip()]
     else:
         hosts = host
-    
-    return hosts, username, password
 
+    return hosts, username, password, keyspace
 
-def get_cassandra_config_from_params(params: dict) -> Tuple[List[str], Optional[str], Optional[str]]:
+
+def get_cassandra_config_from_params(
+    params: dict,
+    default_keyspace: Optional[str] = None
+) -> Tuple[List[str], Optional[str], Optional[str], Optional[str]]:
     """
     Extract and resolve Cassandra configuration from a parameters dictionary.
-    
+
     Args:
         params: Dictionary of parameters that may contain Cassandra configuration
-    
+        default_keyspace: Optional default keyspace if not specified in params
+
     Returns:
-        tuple: (hosts_list, username, password)
+        tuple: (hosts_list, username, password, keyspace)
     """
     # Get Cassandra parameters
     host = params.get('cassandra_host')
     username = params.get('cassandra_username')
     password = params.get('cassandra_password')
-    
+
     # Use resolve function to handle defaults and list conversion
-    return resolve_cassandra_config(host=host, username=username, password=password)
+    return resolve_cassandra_config(
+        host=host,
+        username=username,
+        password=password,
+        default_keyspace=default_keyspace
+    )

trustgraph_base-1.7.5/trustgraph/base/collection_config_handler.py

@@ -0,0 +1,127 @@
+"""
+Handler for storage services to process collection configuration from config push
+"""
+
+import json
+import logging
+from typing import Dict, Set
+
+logger = logging.getLogger(__name__)
+
+class CollectionConfigHandler:
+    """
+    Handles collection configuration from config push messages for storage services.
+
+    Storage services should:
+    1. Inherit from this class along with their service base class
+    2. Call register_config_handler(self.on_collection_config) in __init__
+    3. Implement create_collection(user, collection, metadata) method
+    4. Implement delete_collection(user, collection) method
+    """
+
+    def __init__(self, **kwargs):
+        # Track known collections: {(user, collection): metadata_dict}
+        self.known_collections: Dict[tuple, dict] = {}
+        # Pass remaining kwargs up the inheritance chain
+        super().__init__(**kwargs)
+
+    async def on_collection_config(self, config: dict, version: int):
+        """
+        Handle config push messages and extract collection information
+
+        Args:
+            config: Configuration dictionary from ConfigPush message
+            version: Configuration version number
+        """
+        logger.info(f"Processing collection configuration (version {version})")
+
+        # Extract collections from config
+        if "collection" not in config:
+            logger.debug("No collection configuration in config push")
+            return
+
+        collection_config = config["collection"]
+
+        # Track which collections we've seen in this config
+        current_collections: Set[tuple] = set()
+
+        # Process each collection in the config
+        for key, value_json in collection_config.items():
+            try:
+                # Parse user:collection key
+                if ":" not in key:
+                    logger.warning(f"Invalid collection key format (expected user:collection): {key}")
+                    continue
+
+                user, collection = key.split(":", 1)
+                current_collections.add((user, collection))
+
+                # Parse metadata
+                metadata = json.loads(value_json)
+
+                # Check if this is a new collection or updated
+                collection_key = (user, collection)
+                if collection_key not in self.known_collections:
+                    logger.info(f"New collection detected: {user}/{collection}")
+                    await self.create_collection(user, collection, metadata)
+                    self.known_collections[collection_key] = metadata
+                else:
+                    # Collection already exists, update metadata if changed
+                    if self.known_collections[collection_key] != metadata:
+                        logger.info(f"Collection metadata updated: {user}/{collection}")
+                        # Most storage services don't need to do anything for metadata updates
+                        # They just need to know the collection exists
+                        self.known_collections[collection_key] = metadata
+
+            except Exception as e:
+                logger.error(f"Error processing collection config for key {key}: {e}", exc_info=True)
+
+        # Find collections that were deleted (in known but not in current)
+        deleted_collections = set(self.known_collections.keys()) - current_collections
+        for user, collection in deleted_collections:
+            logger.info(f"Collection deleted: {user}/{collection}")
+            try:
+                await self.delete_collection(user, collection)
+                del self.known_collections[(user, collection)]
+            except Exception as e:
+                logger.error(f"Error deleting collection {user}/{collection}: {e}", exc_info=True)
+
+        logger.debug(f"Collection config processing complete. Known collections: {len(self.known_collections)}")
+
+    async def create_collection(self, user: str, collection: str, metadata: dict):
+        """
+        Create a collection in the storage backend.
+
+        Subclasses must implement this method.
+
+        Args:
+            user: User ID
+            collection: Collection ID
+            metadata: Collection metadata dictionary
+        """
+        raise NotImplementedError("Storage service must implement create_collection method")
+
+    async def delete_collection(self, user: str, collection: str):
+        """
+        Delete a collection from the storage backend.
+
+        Subclasses must implement this method.
+
+        Args:
+            user: User ID
+            collection: Collection ID
+        """
+        raise NotImplementedError("Storage service must implement delete_collection method")
+
+    def collection_exists(self, user: str, collection: str) -> bool:
+        """
+        Check if a collection is known to exist
+
+        Args:
+            user: User ID
+            collection: Collection ID
+
+        Returns:
+            True if collection exists, False otherwise
+        """
+        return (user, collection) in self.known_collections

trustgraph_base-1.7.5/trustgraph/base_version.py

@@ -0,0 +1 @@
+__version__ = "1.7.5"

{trustgraph_base-1.7.1 → trustgraph_base-1.7.5}/trustgraph/messaging/translators/collection.py

@@ -15,8 +15,6 @@ class CollectionManagementRequestTranslator(MessageTranslator):
             name=data.get("name"),
             description=data.get("description"),
             tags=data.get("tags"),
-            created_at=data.get("created_at"),
-            updated_at=data.get("updated_at"),
             tag_filter=data.get("tag_filter"),
             limit=data.get("limit")
         )
@@ -38,10 +36,6 @@ class CollectionManagementRequestTranslator(MessageTranslator):
             result["description"] = obj.description
         if obj.tags is not None:
             result["tags"] = list(obj.tags)
-        if obj.created_at is not None:
-            result["created_at"] = obj.created_at
-        if obj.updated_at is not None:
-            result["updated_at"] = obj.updated_at
         if obj.tag_filter is not None:
             result["tag_filter"] = list(obj.tag_filter)
         if obj.limit is not None:
@@ -73,9 +67,7 @@ class CollectionManagementResponseTranslator(MessageTranslator):
                     collection=coll_data.get("collection"),
                     name=coll_data.get("name"),
                     description=coll_data.get("description"),
-                    tags=coll_data.get("tags"),
-                    created_at=coll_data.get("created_at"),
-                    updated_at=coll_data.get("updated_at")
+                    tags=coll_data.get("tags", [])
                 ))
 
         return CollectionManagementResponse(
@@ -104,9 +96,7 @@ class CollectionManagementResponseTranslator(MessageTranslator):
                     "collection": coll.collection,
                     "name": coll.name,
                     "description": coll.description,
-                    "tags": list(coll.tags) if coll.tags else [],
-                    "created_at": coll.created_at,
-                    "updated_at": coll.updated_at
+                    "tags": list(coll.tags) if coll.tags else []
                 })
 
         print("RESULT IS", result, flush=True)