trustgraph-flow 1.3.2__tar.gz → 1.3.3__tar.gz

{trustgraph_flow-1.3.2 → trustgraph_flow-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-flow
-Version: 1.3.2
+Version: 1.3.3
 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
@@ -38,6 +38,7 @@ Requires-Dist: pyyaml
 Requires-Dist: qdrant-client
 Requires-Dist: rdflib
 Requires-Dist: requests
+Requires-Dist: strawberry-graphql
 Requires-Dist: tabulate
 Requires-Dist: tiktoken
 Requires-Dist: urllib3

{trustgraph_flow-1.3.2 → trustgraph_flow-1.3.3}/pyproject.toml

@@ -40,6 +40,7 @@ dependencies = [
     "qdrant-client",
     "rdflib",
     "requests",
+    "strawberry-graphql",
     "tabulate",
     "tiktoken",
     "urllib3",
@@ -87,12 +88,12 @@ librarian = "trustgraph.librarian:run"
 mcp-tool = "trustgraph.agent.mcp_tool:run"
 metering = "trustgraph.metering:run"
 objects-write-cassandra = "trustgraph.storage.objects.cassandra:run"
+objects-query-cassandra = "trustgraph.query.objects.cassandra:run"
 oe-write-milvus = "trustgraph.storage.object_embeddings.milvus:run"
 pdf-decoder = "trustgraph.decoding.pdf:run"
 pdf-ocr-mistral = "trustgraph.decoding.mistral_ocr:run"
 prompt-template = "trustgraph.prompt.template:run"
 rev-gateway = "trustgraph.rev_gateway:run"
-rows-write-cassandra = "trustgraph.storage.rows.cassandra:run"
 run-processing = "trustgraph.processing:run"
 text-completion-azure = "trustgraph.model.text_completion.azure:run"
 text-completion-azure-openai = "trustgraph.model.text_completion.azure_openai:run"

{trustgraph_flow-1.3.2 → trustgraph_flow-1.3.3}/trustgraph/agent/react/service.py

@@ -18,6 +18,7 @@ from ... schema import AgentRequest, AgentResponse, AgentStep, Error
 
 from . tools import KnowledgeQueryImpl, TextCompletionImpl, McpToolImpl, PromptImpl
 from . agent_manager import AgentManager
+from ..tool_filter import validate_tool_config, filter_tools_by_group_and_state, get_next_state
 
 from . types import Final, Action, Tool, Argument
 
@@ -142,6 +143,9 @@ class Processor(AgentService):
                             f"Tool type {impl_id} not known"
                         )
                     
+                    # Validate tool configuration
+                    validate_tool_config(data)
+                    
                     tools[name] = Tool(
                         name=name,
                         description=data.get("description"),
@@ -219,9 +223,24 @@ class Processor(AgentService):
 
                 await respond(r)
 
+            # Apply tool filtering based on request groups and state
+            filtered_tools = filter_tools_by_group_and_state(
+                tools=self.agent.tools,
+                requested_groups=getattr(request, 'group', None),
+                current_state=getattr(request, 'state', None)
+            )
+            
+            logger.info(f"Filtered from {len(self.agent.tools)} to {len(filtered_tools)} available tools")
+            
+            # Create temporary agent with filtered tools
+            temp_agent = AgentManager(
+                tools=filtered_tools,
+                additional_context=self.agent.additional_context
+            )
+            
             logger.debug("Call React")
 
-            act = await self.agent.react(
+            act = await temp_agent.react(
                 question = request.question,
                 history = history,
                 think = think,
@@ -255,11 +274,17 @@ class Processor(AgentService):
             logger.debug("Send next...")
 
             history.append(act)
+            
+            # Handle state transitions if tool execution was successful
+            next_state = request.state
+            if act.name in filtered_tools:
+                executed_tool = filtered_tools[act.name]
+                next_state = get_next_state(executed_tool, request.state or "undefined")
 
             r = AgentRequest(
                 question=request.question,
-                plan=request.plan,
-                state=request.state,
+                state=next_state,
+                group=getattr(request, 'group', []),
                 history=[
                     AgentStep(
                         thought=h.thought,

trustgraph_flow-1.3.3/trustgraph/agent/tool_filter.py

@@ -0,0 +1,165 @@
+"""
+Tool filtering logic for the TrustGraph tool group system.
+
+Provides functions to filter available tools based on group membership
+and execution state as defined in the tool-group tech spec.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+logger = logging.getLogger(__name__)
+
+
+def filter_tools_by_group_and_state(
+    tools: Dict[str, Any],
+    requested_groups: Optional[List[str]] = None,
+    current_state: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Filter tools based on group membership and execution state.
+    
+    Args:
+        tools: Dictionary of tool_name -> tool_object
+        requested_groups: List of groups requested (defaults to ["default"])
+        current_state: Current execution state (defaults to "undefined")
+        
+    Returns:
+        Dictionary of filtered tools that match group and state criteria
+    """
+    
+    # Apply defaults as specified in tech spec
+    if requested_groups is None:
+        requested_groups = ["default"]
+    if current_state is None:
+        current_state = "undefined"
+        
+    logger.info(f"Filtering tools with groups={requested_groups}, state={current_state}")
+    
+    filtered_tools = {}
+    
+    for tool_name, tool in tools.items():
+        if _is_tool_available(tool, requested_groups, current_state):
+            filtered_tools[tool_name] = tool
+        else:
+            logger.debug(f"Tool {tool_name} filtered out")
+            
+    logger.info(f"Filtered {len(tools)} tools to {len(filtered_tools)} available tools")
+    return filtered_tools
+
+
+def _is_tool_available(
+    tool: Any,
+    requested_groups: List[str],
+    current_state: str
+) -> bool:
+    """
+    Check if a tool is available based on group and state criteria.
+    
+    Args:
+        tool: Tool object with config attribute containing group/state metadata
+        requested_groups: List of requested groups  
+        current_state: Current execution state
+        
+    Returns:
+        True if tool should be available, False otherwise
+    """
+    
+    # Extract tool configuration
+    config = getattr(tool, 'config', {})
+    
+    # Get tool groups (default to ["default"] if not specified)
+    tool_groups = config.get('group', ["default"])
+    if not isinstance(tool_groups, list):
+        tool_groups = [tool_groups]
+        
+    # Get tool applicable states (default to all states if not specified)  
+    applicable_states = config.get('applicable-states', ["*"])
+    if not isinstance(applicable_states, list):
+        applicable_states = [applicable_states]
+    
+    # Apply group filtering logic from tech spec:
+    # Tool is available if intersection(tool_groups, requested_groups) is not empty 
+    # OR "*" is in requested_groups (wildcard access)
+    group_match = (
+        "*" in requested_groups or 
+        bool(set(tool_groups) & set(requested_groups))
+    )
+    
+    # Apply state filtering logic from tech spec:
+    # Tool is available if current_state is in applicable_states 
+    # OR "*" is in applicable_states (available in all states)
+    state_match = (
+        "*" in applicable_states or 
+        current_state in applicable_states
+    )
+    
+    is_available = group_match and state_match
+    
+    if logger.isEnabledFor(logging.DEBUG):
+        logger.debug(
+            f"Tool availability check: tool_groups={tool_groups}, "
+            f"requested_groups={requested_groups}, applicable_states={applicable_states}, "
+            f"current_state={current_state}, group_match={group_match}, "
+            f"state_match={state_match}, is_available={is_available}"
+        )
+    
+    return is_available
+
+
+def get_next_state(tool: Any, current_state: str) -> str:
+    """
+    Get the next state after successful tool execution.
+    
+    Args:
+        tool: Tool object with config attribute
+        current_state: Current execution state
+        
+    Returns:
+        Next state, or current_state if no transition is defined
+    """
+    config = getattr(tool, 'config', {})
+    if config is None:
+        config = {}
+    next_state = config.get('state')
+    
+    if next_state:
+        logger.debug(f"State transition: {current_state} -> {next_state}")
+        return next_state
+    else:
+        logger.debug(f"No state transition defined, staying in {current_state}")
+        return current_state
+
+
+def validate_tool_config(config: Dict[str, Any]) -> None:
+    """
+    Validate tool configuration for group and state fields.
+    
+    Args:
+        config: Tool configuration dictionary
+        
+    Raises:
+        ValueError: If configuration is invalid
+    """
+    
+    # Validate group field
+    if 'group' in config:
+        groups = config['group']
+        if not isinstance(groups, list):
+            raise ValueError("Tool 'group' field must be a list of strings")
+        if not all(isinstance(g, str) for g in groups):
+            raise ValueError("All group names must be strings")
+            
+    # Validate state field
+    if 'state' in config:
+        state = config['state']
+        if not isinstance(state, str):
+            raise ValueError("Tool 'state' field must be a string")
+            
+    # Validate applicable-states field
+    if 'applicable-states' in config:
+        states = config['applicable-states']
+        if not isinstance(states, list):
+            raise ValueError("Tool 'applicable-states' field must be a list of strings")
+        if not all(isinstance(s, str) for s in states):
+            raise ValueError("All state names must be strings")

trustgraph_flow-1.3.3/trustgraph/flow_version.py

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

{trustgraph_flow-1.3.2 → trustgraph_flow-1.3.3}/trustgraph/gateway/dispatch/manager.py

@@ -19,6 +19,7 @@ from . prompt import PromptRequestor
 from . graph_rag import GraphRagRequestor
 from . document_rag import DocumentRagRequestor
 from . triples_query import TriplesQueryRequestor
+from . objects_query import ObjectsQueryRequestor
 from . embeddings import EmbeddingsRequestor
 from . graph_embeddings_query import GraphEmbeddingsQueryRequestor
 from . mcp_tool import McpToolRequestor
@@ -50,6 +51,7 @@ request_response_dispatchers = {
     "embeddings": EmbeddingsRequestor,
     "graph-embeddings": GraphEmbeddingsQueryRequestor,
     "triples": TriplesQueryRequestor,
+    "objects": ObjectsQueryRequestor,
 }
 
 global_dispatchers = {

trustgraph_flow-1.3.3/trustgraph/gateway/dispatch/objects_query.py

@@ -0,0 +1,30 @@
+from ... schema import ObjectsQueryRequest, ObjectsQueryResponse
+from ... messaging import TranslatorRegistry
+
+from . requestor import ServiceRequestor
+
+class ObjectsQueryRequestor(ServiceRequestor):
+    def __init__(
+            self, pulsar_client, request_queue, response_queue, timeout,
+            consumer, subscriber,
+    ):
+
+        super(ObjectsQueryRequestor, self).__init__(
+            pulsar_client=pulsar_client,
+            request_queue=request_queue,
+            response_queue=response_queue,
+            request_schema=ObjectsQueryRequest,
+            response_schema=ObjectsQueryResponse,
+            subscription = subscriber,
+            consumer_name = consumer,
+            timeout=timeout,
+        )
+
+        self.request_translator = TranslatorRegistry.get_request_translator("objects-query")
+        self.response_translator = TranslatorRegistry.get_response_translator("objects-query")
+
+    def to_request(self, body):
+        return self.request_translator.to_pulsar(body)
+
+    def from_response(self, message):
+        return self.response_translator.from_response_with_completion(message)

trustgraph_flow-1.3.3/trustgraph/query/objects/cassandra/__init__.py

@@ -0,0 +1,2 @@
+
+from . service import *

trustgraph_flow-1.3.3/trustgraph/query/objects/cassandra/__main__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+
+from . service import run
+
+run()
+