fix: Loading of competency questions

Author: Dr0p42

docker-compose.yml

@@ -162,7 +162,7 @@ services:
     ports:
       - 3000:80  # YasGUI SPARQL editor - http://localhost:3000
     environment:
-      - DEFAULT_SPARQL_ENDPOINT=http://oxigraph:7878/query  # Points to Oxigraph via Docker network
+      - DEFAULT_SPARQL_ENDPOINT=http://localhost:7878/query  # Points to Oxigraph via Docker network
     depends_on:
       - oxigraph
     networks:

lib/abi/services/agent/Agent.py

@@ -424,9 +424,12 @@ def list_tools_available() -> str:
                 return "I don't have any tools available to help you at the moment."
 
             tools_text = "Here are the tools I can use to help you:\n\n"
-            for t in self._structured_tools:
-                if not t.name.startswith("transfer_to"):
-                    tools_text += f"- `{t.name}`: {t.description.splitlines()[0]}\n"
+            # Filter out tools that start with "transfer_to"
+            filtered_tools = [t for t in self._structured_tools if not t.name.startswith("transfer_to")]
+            # Sort tools alphabetically by name
+            filtered_tools_sorted = sorted(filtered_tools, key=lambda t: t.name)
+            for t in filtered_tools_sorted:
+                tools_text += f"- `{t.name}`: {t.description.splitlines()[0]}\n"
             return tools_text.rstrip()
 
         @tool(return_direct=True)

src/core/templatablesparqlquery/workflows/GenericWorkflow.py

@@ -1,18 +1,20 @@
-from typing import TypeVar, Generic, Type
+from typing import TypeVar, Generic, Type, Optional
 from langchain_core.tools import StructuredTool, BaseTool
 from abi.utils.SPARQL import results_to_list
 from pydantic import BaseModel
 
 T = TypeVar("T", bound=BaseModel)
 
+class NoArgumentsModel(BaseModel):
+    pass
 
 class GenericWorkflow(Generic[T]):
     def __init__(
         self,
         name: str,
         description: str,
         sparql_template: str,
-        arguments_model: Type[T],
+        arguments_model: Optional[Type[T]] = None,
     ):
         self.name = name
         self.description = description
@@ -25,7 +27,7 @@ def run(self, parameters: T):
             from jinja2 import Template
 
             template = Template(self.sparql_template)
-            sparql_query = template.render(parameters.model_dump())
+            sparql_query = template.render(parameters.model_dump() if parameters else {})
             # print(sparql_query)
             from src import services
 
@@ -34,12 +36,12 @@ def run(self, parameters: T):
         except Exception as e:
             return [{'error': str(e)}]
 
-    def as_tools(self) -> list[BaseTool]:
+    def as_tools(self) -> list[BaseTool]:        
         return [
             StructuredTool(
                 name=self.name,
                 description=self.description,
-                func=lambda **kwargs: self.run(self.arguments_model(**kwargs)),
-                args_schema=self.arguments_model,
+                func=lambda **kwargs: self.run(self.arguments_model(**kwargs)) if self.arguments_model else self.run(None),
+                args_schema=self.arguments_model if self.arguments_model else NoArgumentsModel,
             )
         ]

src/core/templatablesparqlquery/workflows/TemplatableSparqlQuery.py

@@ -21,16 +21,16 @@ def templatable_queries():
     from src import services
 
     results = services.triple_store_service.query("""
-        PREFIX intentMapping: <http://ontology.naas.ai/intentMapping/>
-        PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
-        SELECT ?query ?label ?description ?sparqlTemplate ?hasArgument
-        WHERE {
-            ?query a intentMapping:TemplatableSparqlQuery ;
-                intentMapping:intentDescription ?description ;
-                intentMapping:sparqlTemplate ?sparqlTemplate ;
-                intentMapping:hasArgument ?hasArgument ;
-                rdfs:label ?label .
-        }
+PREFIX intentMapping: <http://ontology.naas.ai/intentMapping/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+SELECT ?query ?label ?description ?sparqlTemplate ?hasArgument
+WHERE {
+  ?query a intentMapping:TemplatableSparqlQuery ;
+         intentMapping:intentDescription ?description ;
+         intentMapping:sparqlTemplate ?sparqlTemplate ;
+         rdfs:label ?label ;
+         OPTIONAL {?query intentMapping:hasArgument ?hasArgument } .
+}
     """)
 
     queries = {}
@@ -121,32 +121,38 @@ def load_workflows():
         try:
             query = queries[_query]
 
-            # Arguments Model with validation patterns
-            arguments_model = create_model(
-                f"{str(query['label']).capitalize()}Arguments",
-                **{
-                    str(arguments[argument]["name"]): (
-                        str,
-                        Field(
-                            ...,
-                            description=str(arguments[argument]["description"]),
-                            pattern=str(arguments[argument]["validationPattern"]),
-                            # You could also add additional metadata from validationFormat if needed
-                            example=str(arguments[argument]["validationFormat"]),
-                        ),
-                    )
-                    for argument in query.get("hasArgument")
-                },
-            )
+            arguments_model = None
+            if query.get("hasArgument") and len(query.get("hasArgument")) > 0 and all(query.get("hasArgument")):
+                logger.debug(f"Arguments: {query.get('hasArgument')}")
+                # Arguments Model with validation patterns
+                arguments_model = create_model(
+                    f"{str(query['label']).capitalize()}Arguments",
+                    **{
+                        str(arguments[argument]["name"]): (
+                            str,
+                            Field(
+                                ...,
+                                description=str(arguments[argument]["description"]),
+                                pattern=str(arguments[argument]["validationPattern"]),
+                                # You could also add additional metadata from validationFormat if needed
+                                example=str(arguments[argument]["validationFormat"]),
+                            ),
+                        )
+                        for argument in query.get("hasArgument")
+                    },
+                )
 
             p = GenericWorkflow[arguments_model](
                 str(query["label"]),
                 str(query["description"]),
                 str(query["sparqlTemplate"]),
-                arguments_model,
+                arguments_model if arguments_model else None,
             )
             workflows.append(p)
+            
         except Exception as e:
             logger.error(f"Error loading workflow: {e}")
+            import traceback
+            traceback.print_exc()
 
     return workflows

src/marketplace/domains/cyber-security-analyst/agents/CyberSecurityAgent.py

@@ -99,9 +99,6 @@ def create_agent(
         )
         logger.info("Using OpenAI model: gpt-4o")
 
-    if agent_shared_state is None:
-        agent_shared_state = AgentSharedState()
-    
     # Load all 22 competency question tools from CyberSecurityQueries.ttl
     # The TTL is auto-loaded from /ontologies directory into triplestore
     from src.core.templatablesparqlquery import get_tools
@@ -139,9 +136,9 @@ def create_agent(
     # Create intents - map all CQ tools to TOOL intent type
     intents = [
         Intent(
-            name=tool_name,
-            type=IntentType.TOOL,
-            description=f"Answer competency question {tool_name}",
+            intent_value=tool_name,
+            intent_type=IntentType.TOOL,
+            intent_target=tool_name,
         )
         for tool_name in cq_tools
     ]