Update prompts/prompts.py

prompts/prompts.py

@@ -23,70 +23,116 @@ def load_prompts():
 
     merged_prompts =  {str(k): _to_str(v) for k, v in merged.items()}
     
-    print(merged_prompts)
+    #print(merged_prompts)
     
     return {str(k): _to_str(v) for k, v in merged.items()}
 
 
 
-def print_default_prompt_templates( agent ): 
-    
-    import os, tempfile, pathlib, yaml
-    from smolagents import CodeAgent, InferenceClientModel
+def print_default_prompt_templates(agent):
+    import tempfile, pathlib, yaml, json, inspect
+    from dataclasses import is_dataclass, asdict
 
-    #  agent = CodeAgent(tools=[], model=model)
+    def safe_get(obj, attr, default=None):
+        try:
+            return getattr(obj, attr)
+        except Exception:
+            return default
 
-    # Try to print from the in-memory PromptTemplates object
-    try: 
-        print("Trying to print the in-memory PromptTemplates object")
+    def pick(obj, fields):
+        out = {}
+        for k in fields:
+            v = safe_get(obj, k, None)
+            # keep falsy-but-valid (e.g., ""), just skip None
+            if v is not None:
+                out[k] = v
+        return out
 
+    def normalize_for_yaml(x):
+        # Strings, lists, dicts are safe; other objects → string repr
+        if isinstance(x, (str, int, float, bool)) or x is None:
+            return x
+        if isinstance(x, (list, tuple)):
+            return [normalize_for_yaml(v) for v in x]
+        if isinstance(x, dict):
+            return {str(k): normalize_for_yaml(v) for k, v in x.items()}
+        # Dataclasses emitted upstream should’ve been dict-ified already
+        return str(x)
 
-        print(type(agent))
-        print(hasattr(agent, "prompt_templates"))
-        print(getattr(agent, "prompt_templates", None))
-        print([a for a in dir(agent) if "prompt" in a.lower()])
-    
-        
-        pt = agent.prompt_templates   # <- this is the PromptTemplates object
-
-        # peek at pieces
-        print(pt.system_prompt)
-        print(pt.planning.plan)
-        print(pt.planning.update_plan_pre_messages)
-        print(pt.final_answer.pre_messages)
-
-        print("end of simple code")
-        pt = getattr(agent, "prompt_templates", None)
-        if pt is not None:
-            def pick(obj, fields):
-                return {k: getattr(obj, k) for k in fields if getattr(obj, k, None)}
+    print("Trying to print the in-memory PromptTemplates object")
+    print("agent type:", type(agent))
+    print("has prompt_templates:", hasattr(agent, "prompt_templates"))
+
+    try:
+        pt = safe_get(agent, "prompt_templates", None)
+        print("prompt_templates object:", pt)
+        if pt is None:
+            raise AttributeError("agent.prompt_templates is None or missing")
+
+        # If it’s a dataclass, get a dict in one shot
+        if is_dataclass(pt):
+            out = asdict(pt)
+        else:
             out = {}
+            sp = safe_get(pt, "system_prompt", None)
+            if sp is not None:
+                out["system_prompt"] = sp
+
+            planning = safe_get(pt, "planning", None)
+            if planning is not None:
+                out["planning"] = pick(planning, [
+                    "plan",
+                    "update_plan_pre_messages",
+                    "update_plan_post_messages",
+                ])
+
+            managed = safe_get(pt, "managed_agent", None)
+            if managed is not None:
+                out["managed_agent"] = pick(managed, ["task", "report"])
+
+            final_answer = safe_get(pt, "final_answer", None)
+            if final_answer is not None:
+                out["final_answer"] = pick(final_answer, ["pre_messages", "post_messages"])
+
+        # Normalize any message objects to YAML-safe structures
+        out = normalize_for_yaml(out)
+
+        # Pretty print quick peeks (safe)
+        for path in [
+            ("system_prompt",),
+            ("planning", "plan"),
+            ("planning", "update_plan_pre_messages"),
+            ("planning", "update_plan_post_messages"),
+            ("final_answer", "pre_messages"),
+            ("final_answer", "post_messages"),
+        ]:
+            cur = out
+            for key in path:
+                if isinstance(cur, dict) and key in cur:
+                    cur = cur[key]
+                else:
+                    cur = None
+                    break
+            print(".".join(path)+":", (cur if cur is not None else "<absent>"))
+
+        print("\n---- prompt templates (YAML) ----")
+        print(yaml.safe_dump(out, sort_keys=False, allow_unicode=True))
+        return
 
-            print ("starting filling out")
-            if getattr(pt, "system_prompt", None):
-                out["system_prompt"] = pt.system_prompt
-                print(pt.system_prompt)
-            if getattr(pt, "planning", None):
-                out["planning"] = pick(pt.planning, ["plan", "update_plan_pre_messages", "update_plan_post_messages"])
-            if getattr(pt, "managed_agent", None):
-                out["managed_agent"] = pick(pt.managed_agent, ["task", "report"])
-            if getattr(pt, "final_answer", None):
-                out["final_answer"] = pick(pt.final_answer, ["pre_messages", "post_messages"])
-            print(yaml.safe_dump(out, sort_keys=False, allow_unicode=True))
-            return
     except Exception as e:
         print(f"[warn] couldn't access agent.prompt_templates directly: {e}")
 
-    # Fallback: export prompt.yaml and print it
+    # Fallback: export prompt file and print it
     try:
         with tempfile.TemporaryDirectory() as td:
-            agent.save(td)  # should write prompt.yaml
-            p = pathlib.Path(td) / "prompt.yaml"
-            if p.exists():
-                print(p.read_text(encoding="utf-8"))
-            else:
-                print("[warn] agent.save() produced no prompt.yaml")
+            agent.save(td)  # some builds write prompt.yaml (or prompts.yaml)
+            # try common filenames
+            for fname in ("prompt.yaml", "prompts.yaml", "prompt.yml", "prompts.yml"):
+                p = pathlib.Path(td) / fname
+                if p.exists():
+                    print(f"\n---- exported {fname} ----")
+                    print(p.read_text(encoding="utf-8"))
+                    return
+            print("[warn] agent.save() produced no prompt file I recognize")
     except Exception as e:
         print(f"[error] failed to export defaults: {e}")
-
-