trustgraph-cli 2.2.10__tar.gz → 2.2.12__tar.gz

{trustgraph_cli-2.2.10 → trustgraph_cli-2.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 2.2.10
+Version: 2.2.12
 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_cli-2.2.10 → trustgraph_cli-2.2.12}/trustgraph/cli/dump_queues.py

@@ -19,43 +19,67 @@ import argparse
 from trustgraph.base.subscriber import Subscriber
 from trustgraph.base.pubsub import get_pubsub
 
+def decode_json_strings(obj):
+    """Recursively decode JSON-encoded string values within a dict/list."""
+    if isinstance(obj, dict):
+        return {k: decode_json_strings(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [decode_json_strings(v) for v in obj]
+    if isinstance(obj, str):
+        try:
+            parsed = json.loads(obj)
+            if isinstance(parsed, (dict, list)):
+                return decode_json_strings(parsed)
+        except (json.JSONDecodeError, TypeError):
+            pass
+    return obj
+
+
+def to_dict(value):
+    """Recursively convert a value to a JSON-serialisable structure."""
+
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+
+    if isinstance(value, bytes):
+        value = value.decode('utf-8')
+
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, TypeError):
+            return value
+
+    if isinstance(value, dict):
+        return {k: to_dict(v) for k, v in value.items()}
+
+    if isinstance(value, (list, tuple)):
+        return [to_dict(v) for v in value]
+
+    # Pulsar schema objects expose fields via __dict__
+    if hasattr(value, '__dict__'):
+        return {
+            k: to_dict(v) for k, v in value.__dict__.items()
+            if not k.startswith('_')
+        }
+
+    return str(value)
+
+
 def format_message(queue_name, msg):
     """Format a message with timestamp and queue name."""
     timestamp = datetime.now().isoformat()
 
-    # Try to parse as JSON and pretty-print
     try:
-        # Handle both Message objects and raw bytes
-        if hasattr(msg, 'value'):
-            # Message object with .value() method
-            value = msg.value()
-        else:
-            # Raw bytes from schema-less subscription
-            value = msg
-
-        # If it's bytes, decode it
-        if isinstance(value, bytes):
-            value = value.decode('utf-8')
+        value = msg.value() if hasattr(msg, 'value') else msg
+        parsed = to_dict(value)
 
-        # If it's a string, try to parse as JSON
-        if isinstance(value, str):
-            try:
-                parsed = json.loads(value)
-                body = json.dumps(parsed, indent=2)
-            except (json.JSONDecodeError, TypeError):
-                body = value
+        # Unwrap nested JSON strings (e.g. terms values)
+        if isinstance(parsed, (dict, list)):
+            parsed = decode_json_strings(parsed)
+            body = json.dumps(parsed, indent=2, default=str)
         else:
-            # Try to convert to dict for pretty printing
-            try:
-                # Pulsar schema objects have __dict__ or similar
-                if hasattr(value, '__dict__'):
-                    parsed = {k: v for k, v in value.__dict__.items()
-                             if not k.startswith('_')}
-                else:
-                    parsed = str(value)
-                body = json.dumps(parsed, indent=2, default=str)
-            except (TypeError, AttributeError):
-                body = str(value)
+            body = str(parsed)
 
     except Exception as e:
         body = f"<Error formatting message: {e}>\n{str(msg)}"

{trustgraph_cli-2.2.10 → trustgraph_cli-2.2.12}/trustgraph/cli/invoke_agent.py

@@ -13,6 +13,11 @@ from trustgraph.api import (
     Question,
     Analysis,
     Conclusion,
+    Decomposition,
+    Finding,
+    Plan,
+    StepResult,
+    Synthesis,
     AgentThought,
     AgentObservation,
     AgentAnswer,
@@ -209,6 +214,35 @@ def question_explainable(
                     if entity.observation:
                         print(f"    Observation: {entity.observation}", file=sys.stderr)
 
+                elif isinstance(entity, Decomposition):
+                    print(f"\n  [decompose] {prov_id}", file=sys.stderr)
+                    for i, goal in enumerate(entity.goals):
+                        print(f"    Thread {i}: {goal}", file=sys.stderr)
+
+                elif isinstance(entity, Finding):
+                    print(f"\n  [finding] {prov_id}", file=sys.stderr)
+                    if entity.goal:
+                        print(f"    Goal: {entity.goal}", file=sys.stderr)
+                    if entity.document:
+                        print(f"    Document: {entity.document}", file=sys.stderr)
+
+                elif isinstance(entity, Plan):
+                    print(f"\n  [plan] {prov_id}", file=sys.stderr)
+                    for i, step in enumerate(entity.steps):
+                        print(f"    Step {i}: {step}", file=sys.stderr)
+
+                elif isinstance(entity, StepResult):
+                    print(f"\n  [step-result] {prov_id}", file=sys.stderr)
+                    if entity.step:
+                        print(f"    Step: {entity.step}", file=sys.stderr)
+                    if entity.document:
+                        print(f"    Document: {entity.document}", file=sys.stderr)
+
+                elif isinstance(entity, Synthesis):
+                    print(f"\n  [synthesis] {prov_id}", file=sys.stderr)
+                    if entity.document:
+                        print(f"    Document: {entity.document}", file=sys.stderr)
+
                 elif isinstance(entity, Conclusion):
                     print(f"\n  [conclusion] {prov_id}", file=sys.stderr)
                     if entity.document:
@@ -233,7 +267,8 @@ def question_explainable(
 
 def question(
         url, question, flow_id, user, collection,
-        plan=None, state=None, group=None, verbose=False, streaming=True,
+        plan=None, state=None, group=None, pattern=None,
+        verbose=False, streaming=True,
         token=None, explainable=False, debug=False
 ):
     # Explainable mode uses the API to capture and process provenance events
@@ -273,6 +308,8 @@ def question(
         request_params["state"] = state
     if group is not None:
         request_params["group"] = group
+    if pattern is not None:
+        request_params["pattern"] = pattern
 
     try:
         # Call agent
@@ -396,6 +433,12 @@ def main():
         help=f'Agent plan (default: unspecified)'
     )
 
+    parser.add_argument(
+        '-p', '--pattern',
+        choices=['react', 'plan-then-execute', 'supervisor'],
+        help='Force execution pattern (default: auto-selected by meta-router)'
+    )
+
     parser.add_argument(
         '-s', '--state',
         help=f'Agent initial state (default: unspecified)'
@@ -444,6 +487,7 @@ def main():
             plan = args.plan,
             state = args.state,
             group = args.group,
+            pattern = args.pattern,
             verbose = args.verbose,
             streaming = not args.no_streaming,
             token = args.token,

{trustgraph_cli-2.2.10 → trustgraph_cli-2.2.12}/trustgraph/cli/monitor_prompts.py

@@ -24,7 +24,7 @@ from pulsar.schema import BytesSchema
 
 
 default_flow = "default"
-default_queue_type = "prompt"
+default_queue_type = "prompt-rag"
 default_max_lines = 3
 default_max_width = 80
 

{trustgraph_cli-2.2.10 → trustgraph_cli-2.2.12}/trustgraph/cli/show_explain_trace.py

@@ -27,6 +27,10 @@ from trustgraph.api import (
     Synthesis,
     Analysis,
     Conclusion,
+    Decomposition,
+    Finding,
+    Plan,
+    StepResult,
 )
 
 default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
@@ -297,6 +301,23 @@ def print_docrag_text(trace, explain_client, api, user):
         print("No synthesis data found")
 
 
+def _print_document_content(explain_client, api, user, document_uri, label="Answer"):
+    """Fetch and print document content, or fall back to URI."""
+    if not document_uri:
+        return
+    content = ""
+    if api:
+        content = explain_client.fetch_document_content(
+            document_uri, api, user
+        )
+    if content:
+        print(f"{label}:")
+        for line in content.split("\n"):
+            print(f"  {line}")
+    else:
+        print(f"Document: {document_uri}")
+
+
 def print_agent_text(trace, explain_client, api, user):
     """Print Agent trace in text format."""
     question = trace.get("question")
@@ -310,82 +331,143 @@ def print_agent_text(trace, explain_client, api, user):
             print(f"Time: {question.timestamp}")
     print()
 
-    # Analysis steps
-    print("--- Analysis ---")
-    iterations = trace.get("iterations", [])
-    if iterations:
-        for i, analysis in enumerate(iterations, 1):
-            print(f"Analysis {i}:")
-            print(f"  Thought: {analysis.thought or 'N/A'}")
-            print(f"  Action: {analysis.action or 'N/A'}")
+    # Walk the steps list which contains all entity types
+    steps = trace.get("steps", [])
+
+    for step in steps:
+
+        if isinstance(step, Decomposition):
+            print("--- Decomposition ---")
+            print(f"Decomposed into {len(step.goals)} research threads:")
+            for i, goal in enumerate(step.goals):
+                print(f"  {i}: {goal}")
+            print()
+
+        elif isinstance(step, Finding):
+            print("--- Finding ---")
+            print(f"Goal: {step.goal}")
+            _print_document_content(
+                explain_client, api, user, step.document, "Result",
+            )
+            print()
+
+        elif isinstance(step, Plan):
+            print("--- Plan ---")
+            print(f"Plan with {len(step.steps)} steps:")
+            for i, s in enumerate(step.steps):
+                print(f"  {i}: {s}")
+            print()
+
+        elif isinstance(step, StepResult):
+            print("--- Step Result ---")
+            print(f"Step: {step.step}")
+            _print_document_content(
+                explain_client, api, user, step.document, "Result",
+            )
+            print()
 
+        elif isinstance(step, Analysis):
+            print("--- Analysis ---")
+            print(f"  Action: {step.action or 'N/A'}")
 
-            if analysis.arguments:
-                # Try to pretty-print JSON arguments
+            if step.arguments:
                 try:
-                    args_obj = json.loads(analysis.arguments)
+                    args_obj = json.loads(step.arguments)
                     args_str = json.dumps(args_obj, indent=4)
                     print(f"  Arguments:")
                     for line in args_str.split('\n'):
                         print(f"    {line}")
                 except Exception:
-                    print(f"  Arguments: {analysis.arguments}")
-            else:
-                print(f"  Arguments: N/A")
+                    print(f"  Arguments: {step.arguments}")
 
-            obs = analysis.observation or 'N/A'
+            obs = step.observation or 'N/A'
             if obs and len(obs) > 200:
                 obs = obs[:200] + "... [truncated]"
             print(f"  Observation: {obs}")
             print()
-    else:
-        print("No analysis steps recorded")
-        print()
 
-    # Conclusion
-    print("--- Conclusion ---")
-    conclusion = trace.get("conclusion")
-    if conclusion:
-        content = ""
-        if conclusion.document and api:
-            content = explain_client.fetch_document_content(
-                conclusion.document, api, user
+        elif isinstance(step, Synthesis):
+            print("--- Synthesis ---")
+            _print_document_content(
+                explain_client, api, user, step.document, "Answer",
             )
-        if content:
-            print("Answer:")
-            for line in content.split("\n"):
-                print(f"  {line}")
-        elif conclusion.document:
-            print(f"Document: {conclusion.document}")
-        else:
-            print("No conclusion recorded")
-    else:
-        print("No conclusion recorded")
+            print()
+
+        elif isinstance(step, Conclusion):
+            print("--- Conclusion ---")
+            _print_document_content(
+                explain_client, api, user, step.document, "Answer",
+            )
+            print()
+
+    if not steps:
+        print("No trace steps recorded")
+        print()
 
 
 def trace_to_dict(trace, trace_type):
     """Convert trace entities to JSON-serializable dict."""
     if trace_type == "agent":
         question = trace.get("question")
+
+        def _step_to_dict(step):
+            if isinstance(step, Decomposition):
+                return {
+                    "type": "decomposition",
+                    "id": step.uri,
+                    "goals": step.goals,
+                }
+            elif isinstance(step, Finding):
+                return {
+                    "type": "finding",
+                    "id": step.uri,
+                    "goal": step.goal,
+                    "document": step.document,
+                }
+            elif isinstance(step, Plan):
+                return {
+                    "type": "plan",
+                    "id": step.uri,
+                    "steps": step.steps,
+                }
+            elif isinstance(step, StepResult):
+                return {
+                    "type": "step-result",
+                    "id": step.uri,
+                    "step": step.step,
+                    "document": step.document,
+                }
+            elif isinstance(step, Analysis):
+                return {
+                    "type": "analysis",
+                    "id": step.uri,
+                    "action": step.action,
+                    "arguments": step.arguments,
+                    "thought": step.thought,
+                    "observation": step.observation,
+                }
+            elif isinstance(step, Synthesis):
+                return {
+                    "type": "synthesis",
+                    "id": step.uri,
+                    "document": step.document,
+                }
+            elif isinstance(step, Conclusion):
+                return {
+                    "type": "conclusion",
+                    "id": step.uri,
+                    "document": step.document,
+                }
+            return {"type": step.entity_type, "id": step.uri}
+
+        steps = trace.get("steps", [])
+
         return {
             "type": "agent",
             "session_id": question.uri if question else None,
             "question": question.query if question else None,
             "time": question.timestamp if question else None,
-            "iterations": [
-                {
-                    "id": a.uri,
-                    "thought": a.thought,
-                    "action": a.action,
-                    "arguments": a.arguments,
-                    "observation": a.observation,
-                }
-                for a in trace.get("iterations", [])
-            ],
-            "conclusion": {
-                "id": trace["conclusion"].uri,
-                "document": trace["conclusion"].document,
-            } if trace.get("conclusion") else None,
+            "steps": [_step_to_dict(s) for s in steps],
         }
     elif trace_type == "docrag":
         question = trace.get("question")

trustgraph_cli-2.2.12/trustgraph/cli_version.py

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

{trustgraph_cli-2.2.10 → trustgraph_cli-2.2.12}/trustgraph_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 2.2.10
+Version: 2.2.12
 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_cli-2.2.10/trustgraph/cli_version.py

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