trustgraph-base 2.2.10__tar.gz → 2.2.11__tar.gz

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 2.2.10
+Version: 2.2.11
 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-2.2.10 → trustgraph_base-2.2.11}/trustgraph/api/__init__.py

@@ -82,6 +82,10 @@ from .explainability import (
     Reflection,
     Analysis,
     Conclusion,
+    Decomposition,
+    Finding,
+    Plan,
+    StepResult,
     EdgeSelection,
     wire_triples_to_tuples,
     extract_term_value,

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/api/explainability.py

@@ -44,6 +44,16 @@ TG_GRAPH_RAG_QUESTION = TG + "GraphRagQuestion"
 TG_DOC_RAG_QUESTION = TG + "DocRagQuestion"
 TG_AGENT_QUESTION = TG + "AgentQuestion"
 
+# Orchestrator entity types
+TG_DECOMPOSITION = TG + "Decomposition"
+TG_FINDING = TG + "Finding"
+TG_PLAN_TYPE = TG + "Plan"
+TG_STEP_RESULT = TG + "StepResult"
+
+# Orchestrator predicates
+TG_SUBAGENT_GOAL = TG + "subagentGoal"
+TG_PLAN_STEP = TG + "planStep"
+
 # PROV-O predicates
 PROV = "http://www.w3.org/ns/prov#"
 PROV_STARTED_AT_TIME = PROV + "startedAtTime"
@@ -82,6 +92,14 @@ class ExplainEntity:
             return Exploration.from_triples(uri, triples)
         elif TG_FOCUS in types:
             return Focus.from_triples(uri, triples)
+        elif TG_DECOMPOSITION in types:
+            return Decomposition.from_triples(uri, triples)
+        elif TG_FINDING in types:
+            return Finding.from_triples(uri, triples)
+        elif TG_PLAN_TYPE in types:
+            return Plan.from_triples(uri, triples)
+        elif TG_STEP_RESULT in types:
+            return StepResult.from_triples(uri, triples)
         elif TG_SYNTHESIS in types:
             return Synthesis.from_triples(uri, triples)
         elif TG_REFLECTION_TYPE in types:
@@ -314,6 +332,70 @@ class Conclusion(ExplainEntity):
         )
 
 
+@dataclass
+class Decomposition(ExplainEntity):
+    """Decomposition entity - supervisor broke question into sub-goals."""
+    goals: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_triples(cls, uri: str, triples: List[Tuple[str, str, Any]]) -> "Decomposition":
+        goals = []
+        for s, p, o in triples:
+            if p == TG_SUBAGENT_GOAL:
+                goals.append(o)
+        return cls(uri=uri, entity_type="decomposition", goals=goals)
+
+
+@dataclass
+class Finding(ExplainEntity):
+    """Finding entity - a subagent's result."""
+    goal: str = ""
+    document: str = ""
+
+    @classmethod
+    def from_triples(cls, uri: str, triples: List[Tuple[str, str, Any]]) -> "Finding":
+        goal = ""
+        document = ""
+        for s, p, o in triples:
+            if p == TG_SUBAGENT_GOAL:
+                goal = o
+            elif p == TG_DOCUMENT:
+                document = o
+        return cls(uri=uri, entity_type="finding", goal=goal, document=document)
+
+
+@dataclass
+class Plan(ExplainEntity):
+    """Plan entity - a structured plan of steps."""
+    steps: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_triples(cls, uri: str, triples: List[Tuple[str, str, Any]]) -> "Plan":
+        steps = []
+        for s, p, o in triples:
+            if p == TG_PLAN_STEP:
+                steps.append(o)
+        return cls(uri=uri, entity_type="plan", steps=steps)
+
+
+@dataclass
+class StepResult(ExplainEntity):
+    """StepResult entity - a plan step's result."""
+    step: str = ""
+    document: str = ""
+
+    @classmethod
+    def from_triples(cls, uri: str, triples: List[Tuple[str, str, Any]]) -> "StepResult":
+        step = ""
+        document = ""
+        for s, p, o in triples:
+            if p == TG_PLAN_STEP:
+                step = o
+            elif p == TG_DOCUMENT:
+                document = o
+        return cls(uri=uri, entity_type="step-result", step=step, document=document)
+
+
 def parse_edge_selection_triples(triples: List[Tuple[str, str, Any]]) -> EdgeSelection:
     """Parse triples for an edge selection entity."""
     uri = triples[0][0] if triples else ""
@@ -895,7 +977,10 @@ class ExplainabilityClient:
         """
         Fetch the complete Agent trace starting from a session URI.
 
-        Follows the provenance chain: Question -> Analysis(s) -> Conclusion
+        Follows the provenance chain for all patterns:
+        - ReAct: Question -> Analysis(s) -> Conclusion
+        - Supervisor: Question -> Decomposition -> Finding(s) -> Synthesis
+        - Plan-then-Execute: Question -> Plan -> StepResult(s) -> Synthesis
 
         Args:
             session_uri: The agent session/question URI
@@ -906,14 +991,15 @@ class ExplainabilityClient:
             max_content: Maximum content length for conclusion
 
         Returns:
-            Dict with question, iterations (Analysis list), conclusion entities
+            Dict with question, steps (mixed entity list), conclusion/synthesis
         """
         if graph is None:
             graph = "urn:graph:retrieval"
 
         trace = {
             "question": None,
-            "iterations": [],
+            "steps": [],
+            "iterations": [],  # Backwards compatibility for ReAct
             "conclusion": None,
         }
 
@@ -923,64 +1009,79 @@ class ExplainabilityClient:
             return trace
         trace["question"] = question
 
-        # Follow the chain: wasGeneratedBy for first hop, wasDerivedFrom after
-        current_uri = session_uri
-        is_first = True
-        max_iterations = 50  # Safety limit
+        # Follow the provenance chain from the question
+        self._follow_provenance_chain(
+            session_uri, trace, graph, user, collection,
+            is_first=True, max_depth=50,
+        )
 
-        for _ in range(max_iterations):
-            # First hop uses wasGeneratedBy (entity←activity),
-            # subsequent hops use wasDerivedFrom (entity←entity)
-            if is_first:
-                derived_triples = self.flow.triples_query(
-                    p=PROV_WAS_GENERATED_BY,
-                    o=current_uri,
-                    g=graph,
-                    user=user,
-                    collection=collection,
-                    limit=10
-                )
-                # Fall back to wasDerivedFrom for backwards compatibility
-                if not derived_triples:
-                    derived_triples = self.flow.triples_query(
-                        p=PROV_WAS_DERIVED_FROM,
-                        o=current_uri,
-                        g=graph,
-                        user=user,
-                        collection=collection,
-                        limit=10
-                    )
-                is_first = False
-            else:
+        # Backwards compat: populate iterations from steps
+        trace["iterations"] = [
+            s for s in trace["steps"] if isinstance(s, Analysis)
+        ]
+
+        return trace
+
+    def _follow_provenance_chain(
+        self, current_uri, trace, graph, user, collection,
+        is_first=False, max_depth=50,
+    ):
+        """Recursively follow the provenance chain, handling branches."""
+        if max_depth <= 0:
+            return
+
+        # Find entities derived from current_uri
+        if is_first:
+            derived_triples = self.flow.triples_query(
+                p=PROV_WAS_GENERATED_BY,
+                o=current_uri,
+                g=graph, user=user, collection=collection,
+                limit=20
+            )
+            if not derived_triples:
                 derived_triples = self.flow.triples_query(
                     p=PROV_WAS_DERIVED_FROM,
                     o=current_uri,
-                    g=graph,
-                    user=user,
-                    collection=collection,
-                    limit=10
+                    g=graph, user=user, collection=collection,
+                    limit=20
                 )
+        else:
+            derived_triples = self.flow.triples_query(
+                p=PROV_WAS_DERIVED_FROM,
+                o=current_uri,
+                g=graph, user=user, collection=collection,
+                limit=20
+            )
 
-            if not derived_triples:
-                break
+        if not derived_triples:
+            return
 
-            derived_uri = extract_term_value(derived_triples[0].get("s", {}))
+        derived_uris = [
+            extract_term_value(t.get("s", {}))
+            for t in derived_triples
+        ]
+
+        for derived_uri in derived_uris:
             if not derived_uri:
-                break
+                continue
 
             entity = self.fetch_entity(derived_uri, graph, user, collection)
+            if entity is None:
+                continue
 
-            if isinstance(entity, Analysis):
-                trace["iterations"].append(entity)
-                current_uri = derived_uri
-            elif isinstance(entity, Conclusion):
-                trace["conclusion"] = entity
-                break
-            else:
-                # Unknown entity type, stop
-                break
+            if isinstance(entity, (Analysis, Decomposition, Finding,
+                                   Plan, StepResult)):
+                trace["steps"].append(entity)
 
-        return trace
+                # Continue following from this entity
+                self._follow_provenance_chain(
+                    derived_uri, trace, graph, user, collection,
+                    max_depth=max_depth - 1,
+                )
+
+            elif isinstance(entity, (Conclusion, Synthesis)):
+                trace["steps"].append(entity)
+                trace["conclusion"] = entity
 
     def list_sessions(
         self,
@@ -1082,7 +1183,7 @@ class ExplainabilityClient:
 
         for child_uri in all_child_uris:
             entity = self.fetch_entity(child_uri, graph, user, collection)
-            if isinstance(entity, Analysis):
+            if isinstance(entity, (Analysis, Decomposition, Plan)):
                 return "agent"
             if isinstance(entity, Exploration):
                 return "graphrag"

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/base/prompt_client.py

@@ -1,21 +1,16 @@
 
 import json
 import asyncio
-import logging
 
 from . request_response_spec import RequestResponse, RequestResponseSpec
 from .. schema import PromptRequest, PromptResponse
 
-logger = logging.getLogger(__name__)
-
 class PromptClient(RequestResponse):
 
     async def prompt(self, id, variables, timeout=600, streaming=False, chunk_callback=None):
-        logger.info(f"DEBUG prompt_client: prompt called, id={id}, streaming={streaming}, chunk_callback={chunk_callback is not None}")
 
         if not streaming:
-            logger.info("DEBUG prompt_client: Non-streaming path")
-            # Non-streaming path
+
             resp = await self.request(
                 PromptRequest(
                     id = id,
@@ -36,39 +31,30 @@ class PromptClient(RequestResponse):
             return json.loads(resp.object)
 
         else:
-            logger.info("DEBUG prompt_client: Streaming path")
-            # Streaming path - just forward chunks, don't accumulate
+
             last_text = ""
             last_object = None
 
             async def forward_chunks(resp):
                 nonlocal last_text, last_object
-                logger.info(f"DEBUG prompt_client: forward_chunks called, resp.text={resp.text[:50] if resp.text else None}, end_of_stream={getattr(resp, 'end_of_stream', False)}")
 
                 if resp.error:
-                    logger.error(f"DEBUG prompt_client: Error in response: {resp.error.message}")
                     raise RuntimeError(resp.error.message)
 
                 end_stream = getattr(resp, 'end_of_stream', False)
 
-                # Always call callback if there's text OR if it's the final message
                 if resp.text is not None:
                     last_text = resp.text
-                    # Call chunk callback if provided with both chunk and end_of_stream flag
                     if chunk_callback:
-                        logger.info(f"DEBUG prompt_client: Calling chunk_callback with end_of_stream={end_stream}")
                         if asyncio.iscoroutinefunction(chunk_callback):
                             await chunk_callback(resp.text, end_stream)
                         else:
                             chunk_callback(resp.text, end_stream)
                 elif resp.object:
-                    logger.info(f"DEBUG prompt_client: Got object response")
                     last_object = resp.object
 
-                logger.info(f"DEBUG prompt_client: Returning end_of_stream={end_stream}")
                 return end_stream
 
-            logger.info("DEBUG prompt_client: Creating PromptRequest")
             req = PromptRequest(
                 id = id,
                 terms = {
@@ -77,19 +63,16 @@ class PromptClient(RequestResponse):
                 },
                 streaming = True
             )
-            logger.info(f"DEBUG prompt_client: About to call self.request with recipient, timeout={timeout}")
+
             await self.request(
                 req,
                 recipient=forward_chunks,
                 timeout=timeout
             )
-            logger.info(f"DEBUG prompt_client: self.request returned, last_text={last_text[:50] if last_text else None}")
 
             if last_text:
-                logger.info("DEBUG prompt_client: Returning last_text")
                 return last_text
 
-            logger.info("DEBUG prompt_client: Returning parsed last_object")
             return json.loads(last_object) if last_object else None
 
     async def extract_definitions(self, text, timeout=600):

trustgraph_base-2.2.11/trustgraph/base_version.py

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

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/provenance/__init__.py

@@ -53,6 +53,12 @@ from . uris import (
     agent_thought_uri,
     agent_observation_uri,
     agent_final_uri,
+    # Orchestrator provenance URIs
+    agent_decomposition_uri,
+    agent_finding_uri,
+    agent_plan_uri,
+    agent_step_result_uri,
+    agent_synthesis_uri,
     # Document RAG provenance URIs
     docrag_question_uri,
     docrag_grounding_uri,
@@ -94,6 +100,9 @@ from . namespaces import (
     TG_GRAPH_RAG_QUESTION, TG_DOC_RAG_QUESTION, TG_AGENT_QUESTION,
     # Agent provenance predicates
     TG_THOUGHT, TG_ACTION, TG_ARGUMENTS, TG_OBSERVATION,
+    TG_SUBAGENT_GOAL, TG_PLAN_STEP,
+    # Orchestrator entity types
+    TG_DECOMPOSITION, TG_FINDING, TG_PLAN_TYPE, TG_STEP_RESULT,
     # Document reference predicate
     TG_DOCUMENT,
     # Named graphs
@@ -124,6 +133,12 @@ from . agent import (
     agent_session_triples,
     agent_iteration_triples,
     agent_final_triples,
+    # Orchestrator provenance triple builders
+    agent_decomposition_triples,
+    agent_finding_triples,
+    agent_plan_triples,
+    agent_step_result_triples,
+    agent_synthesis_triples,
 )
 
 # Vocabulary bootstrap
@@ -159,6 +174,12 @@ __all__ = [
     "agent_thought_uri",
     "agent_observation_uri",
     "agent_final_uri",
+    # Orchestrator provenance URIs
+    "agent_decomposition_uri",
+    "agent_finding_uri",
+    "agent_plan_uri",
+    "agent_step_result_uri",
+    "agent_synthesis_uri",
     # Document RAG provenance URIs
     "docrag_question_uri",
     "docrag_grounding_uri",
@@ -193,6 +214,9 @@ __all__ = [
     "TG_GRAPH_RAG_QUESTION", "TG_DOC_RAG_QUESTION", "TG_AGENT_QUESTION",
     # Agent provenance predicates
     "TG_THOUGHT", "TG_ACTION", "TG_ARGUMENTS", "TG_OBSERVATION",
+    "TG_SUBAGENT_GOAL", "TG_PLAN_STEP",
+    # Orchestrator entity types
+    "TG_DECOMPOSITION", "TG_FINDING", "TG_PLAN_TYPE", "TG_STEP_RESULT",
     # Document reference predicate
     "TG_DOCUMENT",
     # Named graphs
@@ -215,6 +239,12 @@ __all__ = [
     "agent_session_triples",
     "agent_iteration_triples",
     "agent_final_triples",
+    # Orchestrator provenance triple builders
+    "agent_decomposition_triples",
+    "agent_finding_triples",
+    "agent_plan_triples",
+    "agent_step_result_triples",
+    "agent_synthesis_triples",
     # Utility
     "set_graph",
     # Vocabulary

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/provenance/agent.py

@@ -1,10 +1,15 @@
 """
 Helper functions to build PROV-O triples for agent provenance.
 
-Agent provenance tracks the reasoning trace of ReAct agent sessions:
+Agent provenance tracks the reasoning trace of agent sessions:
 - Question: The root activity with query and timestamp
-- Analysis: Each think/act/observe cycle
-- Conclusion: The final answer
+- Analysis: Each think/act/observe cycle (ReAct)
+- Conclusion: The final answer (ReAct)
+- Decomposition: Supervisor broke question into sub-goals
+- Finding: A subagent's result (Supervisor)
+- Plan: Structured plan of steps (Plan-then-Execute)
+- StepResult: A plan step's result (Plan-then-Execute)
+- Synthesis: Final synthesised answer (Supervisor, Plan-then-Execute)
 """
 
 import json
@@ -21,6 +26,8 @@ from . namespaces import (
     TG_QUESTION, TG_ANALYSIS, TG_CONCLUSION, TG_DOCUMENT,
     TG_ANSWER_TYPE, TG_REFLECTION_TYPE, TG_THOUGHT_TYPE, TG_OBSERVATION_TYPE,
     TG_AGENT_QUESTION,
+    TG_DECOMPOSITION, TG_FINDING, TG_PLAN_TYPE, TG_STEP_RESULT,
+    TG_SYNTHESIS, TG_SUBAGENT_GOAL, TG_PLAN_STEP,
 )
 
 
@@ -203,3 +210,97 @@ def agent_final_triples(
         triples.append(_triple(final_uri, TG_DOCUMENT, _iri(document_id)))
 
     return triples
+
+
+def agent_decomposition_triples(
+    uri: str,
+    session_uri: str,
+    goals: List[str],
+) -> List[Triple]:
+    """Build triples for a supervisor decomposition step."""
+    triples = [
+        _triple(uri, RDF_TYPE, _iri(PROV_ENTITY)),
+        _triple(uri, RDF_TYPE, _iri(TG_DECOMPOSITION)),
+        _triple(uri, RDFS_LABEL,
+                _literal(f"Decomposed into {len(goals)} research threads")),
+        _triple(uri, PROV_WAS_GENERATED_BY, _iri(session_uri)),
+    ]
+    for goal in goals:
+        triples.append(_triple(uri, TG_SUBAGENT_GOAL, _literal(goal)))
+    return triples
+
+
+def agent_finding_triples(
+    uri: str,
+    decomposition_uri: str,
+    goal: str,
+    document_id: Optional[str] = None,
+) -> List[Triple]:
+    """Build triples for a subagent finding."""
+    triples = [
+        _triple(uri, RDF_TYPE, _iri(PROV_ENTITY)),
+        _triple(uri, RDF_TYPE, _iri(TG_FINDING)),
+        _triple(uri, RDF_TYPE, _iri(TG_ANSWER_TYPE)),
+        _triple(uri, RDFS_LABEL, _literal(f"Finding: {goal[:60]}")),
+        _triple(uri, PROV_WAS_DERIVED_FROM, _iri(decomposition_uri)),
+        _triple(uri, TG_SUBAGENT_GOAL, _literal(goal)),
+    ]
+    if document_id:
+        triples.append(_triple(uri, TG_DOCUMENT, _iri(document_id)))
+    return triples
+
+
+def agent_plan_triples(
+    uri: str,
+    session_uri: str,
+    steps: List[str],
+) -> List[Triple]:
+    """Build triples for a plan-then-execute plan."""
+    triples = [
+        _triple(uri, RDF_TYPE, _iri(PROV_ENTITY)),
+        _triple(uri, RDF_TYPE, _iri(TG_PLAN_TYPE)),
+        _triple(uri, RDFS_LABEL,
+                _literal(f"Plan with {len(steps)} steps")),
+        _triple(uri, PROV_WAS_GENERATED_BY, _iri(session_uri)),
+    ]
+    for step in steps:
+        triples.append(_triple(uri, TG_PLAN_STEP, _literal(step)))
+    return triples
+
+
+def agent_step_result_triples(
+    uri: str,
+    plan_uri: str,
+    goal: str,
+    document_id: Optional[str] = None,
+) -> List[Triple]:
+    """Build triples for a plan step result."""
+    triples = [
+        _triple(uri, RDF_TYPE, _iri(PROV_ENTITY)),
+        _triple(uri, RDF_TYPE, _iri(TG_STEP_RESULT)),
+        _triple(uri, RDF_TYPE, _iri(TG_ANSWER_TYPE)),
+        _triple(uri, RDFS_LABEL, _literal(f"Step result: {goal[:60]}")),
+        _triple(uri, PROV_WAS_DERIVED_FROM, _iri(plan_uri)),
+        _triple(uri, TG_PLAN_STEP, _literal(goal)),
+    ]
+    if document_id:
+        triples.append(_triple(uri, TG_DOCUMENT, _iri(document_id)))
+    return triples
+
+
+def agent_synthesis_triples(
+    uri: str,
+    previous_uri: str,
+    document_id: Optional[str] = None,
+) -> List[Triple]:
+    """Build triples for a synthesis answer."""
+    triples = [
+        _triple(uri, RDF_TYPE, _iri(PROV_ENTITY)),
+        _triple(uri, RDF_TYPE, _iri(TG_SYNTHESIS)),
+        _triple(uri, RDF_TYPE, _iri(TG_ANSWER_TYPE)),
+        _triple(uri, RDFS_LABEL, _literal("Synthesis")),
+        _triple(uri, PROV_WAS_DERIVED_FROM, _iri(previous_uri)),
+    ]
+    if document_id:
+        triples.append(_triple(uri, TG_DOCUMENT, _iri(document_id)))
+    return triples

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/provenance/namespaces.py

@@ -94,8 +94,14 @@ TG_SYNTHESIS = TG + "Synthesis"
 TG_ANALYSIS = TG + "Analysis"
 TG_CONCLUSION = TG + "Conclusion"
 
+# Orchestrator entity types
+TG_DECOMPOSITION = TG + "Decomposition"  # Supervisor decomposed into sub-goals
+TG_FINDING = TG + "Finding"              # Subagent result
+TG_PLAN_TYPE = TG + "Plan"               # Plan-then-execute plan
+TG_STEP_RESULT = TG + "StepResult"       # Plan step result
+
 # Unifying types for answer and intermediate commentary
-TG_ANSWER_TYPE = TG + "Answer"          # Final answer (Synthesis, Conclusion)
+TG_ANSWER_TYPE = TG + "Answer"          # Final answer (Synthesis, Conclusion, Finding, StepResult)
 TG_REFLECTION_TYPE = TG + "Reflection"  # Intermediate commentary (Thought, Observation)
 TG_THOUGHT_TYPE = TG + "Thought"        # Agent reasoning
 TG_OBSERVATION_TYPE = TG + "Observation" # Agent tool result
@@ -110,6 +116,8 @@ TG_THOUGHT = TG + "thought"        # Links iteration to thought sub-entity
 TG_ACTION = TG + "action"
 TG_ARGUMENTS = TG + "arguments"
 TG_OBSERVATION = TG + "observation" # Links iteration to observation sub-entity
+TG_SUBAGENT_GOAL = TG + "subagentGoal"  # Goal string on Decomposition/Finding
+TG_PLAN_STEP = TG + "planStep"          # Step goal string on Plan/StepResult
 
 # Named graph URIs for RDF datasets
 # These separate different types of data while keeping them in the same collection

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/provenance/uris.py

@@ -234,6 +234,31 @@ def agent_final_uri(session_id: str) -> str:
     return f"urn:trustgraph:agent:{session_id}/final"
 
 
+def agent_decomposition_uri(session_id: str) -> str:
+    """Generate URI for a supervisor decomposition step."""
+    return f"urn:trustgraph:agent:{session_id}/decompose"
+
+
+def agent_finding_uri(session_id: str, index: int) -> str:
+    """Generate URI for a subagent finding."""
+    return f"urn:trustgraph:agent:{session_id}/finding/{index}"
+
+
+def agent_plan_uri(session_id: str) -> str:
+    """Generate URI for a plan-then-execute plan."""
+    return f"urn:trustgraph:agent:{session_id}/plan"
+
+
+def agent_step_result_uri(session_id: str, index: int) -> str:
+    """Generate URI for a plan step result."""
+    return f"urn:trustgraph:agent:{session_id}/step/{index}"
+
+
+def agent_synthesis_uri(session_id: str) -> str:
+    """Generate URI for a synthesis answer."""
+    return f"urn:trustgraph:agent:{session_id}/synthesis"
+
+
 # Document RAG provenance URIs
 # These URIs use the urn:trustgraph:docrag: namespace to distinguish
 # document RAG provenance from graph RAG provenance

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph/provenance/vocabulary.py

@@ -27,6 +27,8 @@ from . namespaces import (
     TG_DOCUMENT_TYPE, TG_PAGE_TYPE, TG_CHUNK_TYPE, TG_SUBGRAPH_TYPE,
     TG_CONCEPT, TG_ENTITY, TG_GROUNDING,
     TG_ANSWER_TYPE, TG_REFLECTION_TYPE, TG_THOUGHT_TYPE, TG_OBSERVATION_TYPE,
+    TG_DECOMPOSITION, TG_FINDING, TG_PLAN_TYPE, TG_STEP_RESULT,
+    TG_SUBAGENT_GOAL, TG_PLAN_STEP,
 )
 
 
@@ -87,6 +89,10 @@ TG_CLASS_LABELS = [
     _label_triple(TG_REFLECTION_TYPE, "Reflection"),
     _label_triple(TG_THOUGHT_TYPE, "Thought"),
     _label_triple(TG_OBSERVATION_TYPE, "Observation"),
+    _label_triple(TG_DECOMPOSITION, "Decomposition"),
+    _label_triple(TG_FINDING, "Finding"),
+    _label_triple(TG_PLAN_TYPE, "Plan"),
+    _label_triple(TG_STEP_RESULT, "Step Result"),
 ]
 
 # TrustGraph predicate labels
@@ -109,6 +115,8 @@ TG_PREDICATE_LABELS = [
     _label_triple(TG_SOURCE_CHAR_LENGTH, "source character length"),
     _label_triple(TG_CONCEPT, "concept"),
     _label_triple(TG_ENTITY, "entity"),
+    _label_triple(TG_SUBAGENT_GOAL, "subagent goal"),
+    _label_triple(TG_PLAN_STEP, "plan step"),
 ]
 
 

{trustgraph_base-2.2.10 → trustgraph_base-2.2.11}/trustgraph_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 2.2.10
+Version: 2.2.11
 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-2.2.10/trustgraph/base_version.py

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