ursa-ai 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

ursa/agents/execution_agent.py

@@ -6,9 +6,16 @@ from pathlib import Path
 from typing import Annotated, Any, Literal, Optional
 
 import coolname
-from langchain_community.tools import DuckDuckGoSearchResults  # TavilySearchResults,
+from langchain_community.tools import (
+    DuckDuckGoSearchResults,
+)  # TavilySearchResults,
 from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
+from langchain_core.messages import (
+    AIMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
 from langchain_core.tools import InjectedToolCallId, tool
 from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
@@ -49,7 +56,7 @@ class ExecutionAgent(BaseAgent):
     def __init__(
         self,
         llm: str | BaseChatModel = "openai/gpt-4o-mini",
-        agent_memory: Optional [Any | AgentMemory] = None,
+        agent_memory: Optional[Any | AgentMemory] = None,
         log_state: bool = False,
         **kwargs,
     ):
@@ -101,14 +108,17 @@ class ExecutionAgent(BaseAgent):
             new_state["symlinkdir"]["is_linked"] = True
 
         if type(new_state["messages"][0]) == SystemMessage:
-            new_state["messages"][0] = SystemMessage(content=self.executor_prompt)
+            new_state["messages"][0] = SystemMessage(
+                content=self.executor_prompt
+            )
         else:
             new_state["messages"] = [
                 SystemMessage(content=self.executor_prompt)
             ] + state["messages"]
         try:
             response = self.llm.invoke(
-                new_state["messages"], {"configurable": {"thread_id": self.thread_id}}
+                new_state["messages"],
+                {"configurable": {"thread_id": self.thread_id}},
             )
         except ContentPolicyViolationError as e:
             print("Error: ", e, " ", new_state["messages"][-1].content)
@@ -140,7 +150,7 @@ class ExecutionAgent(BaseAgent):
                         tool_strings.append(tool_name)
                         for y in tool["args"]:
                             tool_strings.append(
-                                f'Arg: {str(y)}\nValue: {str(tool["args"][y])}'
+                                f"Arg: {str(y)}\nValue: {str(tool['args'][y])}"
                             )
                     memories.append("\n".join(tool_strings))
             memories.append(response.content)
@@ -188,7 +198,8 @@ class ExecutionAgent(BaseAgent):
                     For reason: {safety_check.content}
                     """
                     console.print(
-                        "[bold red][WARNING][/bold red] Command deemed unsafe:", query
+                        "[bold red][WARNING][/bold red] Command deemed unsafe:",
+                        query,
                     )
                     # and tell the user the reason
                     console.print(
@@ -414,7 +425,9 @@ def edit_code(
     new_code_clean = _strip_fences(new_code)
 
     if old_code_clean not in content:
-        console.print(f"[yellow] ⚠️ 'old_code' not found in file'; no changes made.[/]")
+        console.print(
+            f"[yellow] ⚠️ 'old_code' not found in file'; no changes made.[/]"
+        )
         return f"No changes made to {filename}: 'old_code' not found in file."
 
     updated = content.replace(old_code_clean, new_code_clean, 1)
@@ -482,7 +495,9 @@ def command_safe(state: ExecutionState) -> Literal["safe", "unsafe"]:
 
 def main():
     execution_agent = ExecutionAgent()
-    problem_string = "Write and execute a python script to print the first 10 integers."
+    problem_string = (
+        "Write and execute a python script to print the first 10 integers."
+    )
     inputs = {
         "messages": [HumanMessage(content=problem_string)]
     }  # , "workspace":"dummy_test"}

ursa/agents/hypothesizer_agent.py

@@ -357,7 +357,7 @@ class HypothesizerAgent(BaseAgent):
             You are a system that produces a FULL LaTeX document.
             Here is information about a multi-iteration process:
 
-            Original question: {state['question']}
+            Original question: {state["question"]}
 
             Below are the solutions, critiques, and competitor perspectives from each iteration:
 
@@ -365,7 +365,7 @@ class HypothesizerAgent(BaseAgent):
 
             The final solution we arrived at was:
 
-            {state['final_solution']}
+            {state["final_solution"]}
 
             Now produce a valid LaTeX document.  Be sure to use a table of contents.
             It must start with an Executive Summary (that may be multiple pages) which summarizes
@@ -487,7 +487,7 @@ class HypothesizerAgent(BaseAgent):
 
         self.action = self.graph.compile(checkpointer=self.checkpointer)
         # self.action.get_graph().draw_mermaid_png(output_file_path="hypothesizer_agent_graph.png", draw_method=MermaidDrawMethod.PYPPETEER)
-    
+
     def run(self, prompt, max_iter=3, recursion_limit=99999):
         # Initialize the state
         initial_state = HypothesizerState(
@@ -501,12 +501,15 @@ class HypothesizerAgent(BaseAgent):
         )
         # Run the graph
         result = hypothesizer_agent.action.invoke(
-            initial_state, {"recursion_limit": recursion_limit, "configurable": {"thread_id": self.thread_id}}
+            initial_state,
+            {
+                "recursion_limit": recursion_limit,
+                "configurable": {"thread_id": self.thread_id},
+            },
         )
         return result["final_solution"]
 
 
-
 def should_continue(state: HypothesizerState) -> Literal["continue", "finish"]:
     if state["current_iteration"] >= state["max_iterations"]:
         print(
@@ -583,7 +586,11 @@ if __name__ == "__main__":
     print("[DEBUG] Invoking the graph...")
     # Run the graph
     result = hypothesizer_agent.action.invoke(
-        initial_state, {"recursion_limit": 999999, "configurable": {"thread_id": self.thread_id}}
+        initial_state,
+        {
+            "recursion_limit": 999999,
+            "configurable": {"thread_id": self.thread_id},
+        },
     )
     summary_text = result["summary_report"]
 

ursa/agents/mp_agent.py

@@ -8,7 +8,7 @@ from mp_api.client import MPRester
 from langchain.schema import Document
 
 import os
-import pymupdf  
+import pymupdf
 import requests
 import feedparser
 from PIL import Image
@@ -33,16 +33,16 @@ from openai import OpenAI
 from .base import BaseAgent
 
 
-
-
 client = OpenAI()
 
 embeddings = OpenAIEmbeddings()
 
+
 class PaperMetadata(TypedDict):
     arxiv_id: str
     full_text: str
 
+
 class PaperState(TypedDict, total=False):
     query: str
     context: str
@@ -59,12 +59,23 @@ def describe_image(image: Image.Image) -> str:
     response = client.chat.completions.create(
         model="gpt-4-vision-preview",
         messages=[
-            {"role": "system", "content": "You are a scientific assistant who explains plots and scientific diagrams."},
+            {
+                "role": "system",
+                "content": "You are a scientific assistant who explains plots and scientific diagrams.",
+            },
             {
                 "role": "user",
                 "content": [
-                    {"type": "text", "text": "Describe this scientific image or plot in detail."},
-                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_base64}"}}
+                    {
+                        "type": "text",
+                        "text": "Describe this scientific image or plot in detail.",
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{img_base64}"
+                        },
+                    },
                 ],
             },
         ],
@@ -73,7 +84,9 @@ def describe_image(image: Image.Image) -> str:
     return response.choices[0].message.content.strip()
 
 
-def extract_and_describe_images(pdf_path: str, max_images: int = 5) -> List[str]:
+def extract_and_describe_images(
+    pdf_path: str, max_images: int = 5
+) -> List[str]:
     doc = pymupdf.open(pdf_path)
     descriptions = []
     image_count = 0
@@ -94,16 +107,21 @@ def extract_and_describe_images(pdf_path: str, max_images: int = 5) -> List[str]
 
             try:
                 desc = describe_image(image)
-                descriptions.append(f"Page {page_index + 1}, Image {img_index + 1}: {desc}")
+                descriptions.append(
+                    f"Page {page_index + 1}, Image {img_index + 1}: {desc}"
+                )
             except Exception as e:
-                descriptions.append(f"Page {page_index + 1}, Image {img_index + 1}: [Error: {e}]")
+                descriptions.append(
+                    f"Page {page_index + 1}, Image {img_index + 1}: [Error: {e}]"
+                )
             image_count += 1
 
     return descriptions
 
 
 def remove_surrogates(text: str) -> str:
-    return re.sub(r'[\ud800-\udfff]', '', text)
+    return re.sub(r"[\ud800-\udfff]", "", text)
+
 
 class MaterialsProjectAgent(BaseAgent):
     def __init__(
@@ -111,30 +129,30 @@ class MaterialsProjectAgent(BaseAgent):
         llm="openai/o3-mini",
         summarize: bool = True,
         max_results: int = 3,
-        database_path: str = 'mp_database',
-        summaries_path: str = 'mp_summaries',
-        vectorstore_path: str = 'mp_vectorstores',
-        **kwargs
+        database_path: str = "mp_database",
+        summaries_path: str = "mp_summaries",
+        vectorstore_path: str = "mp_vectorstores",
+        **kwargs,
     ):
         super().__init__(llm, **kwargs)
-        self.summarize        = summarize
-        self.max_results      = max_results
-        self.database_path    = database_path
-        self.summaries_path   = summaries_path
+        self.summarize = summarize
+        self.max_results = max_results
+        self.database_path = database_path
+        self.summaries_path = summaries_path
         self.vectorstore_path = vectorstore_path
-        
-        os.makedirs(self.database_path,    exist_ok=True)
-        os.makedirs(self.summaries_path,   exist_ok=True)
+
+        os.makedirs(self.database_path, exist_ok=True)
+        os.makedirs(self.summaries_path, exist_ok=True)
         os.makedirs(self.vectorstore_path, exist_ok=True)
 
         self.embeddings = OpenAIEmbeddings()  # or your preferred embedding
         self.graph = self._build_graph()
 
     def _fetch_node(self, state: Dict) -> Dict:
-        f   = state["query"]
-        els = f["elements"]                  # e.g. ["Ga","In"]
-        bg  = (f["band_gap_min"], f["band_gap_max"])
-        e_above_hull = (0, 0)                # only on-hull (stable)
+        f = state["query"]
+        els = f["elements"]  # e.g. ["Ga","In"]
+        bg = (f["band_gap_min"], f["band_gap_max"])
+        e_above_hull = (0, 0)  # only on-hull (stable)
         mats = []
         with MPRester() as mpr:
             # get ALL matching materials…
@@ -142,7 +160,7 @@ class MaterialsProjectAgent(BaseAgent):
                 elements=els,
                 band_gap=bg,
                 energy_above_hull=e_above_hull,
-                is_stable=True              # equivalent filter
+                is_stable=True,  # equivalent filter
             )
             # …then take only the first `max_results`
             for doc in all_results[: self.max_results]:
@@ -161,11 +179,18 @@ class MaterialsProjectAgent(BaseAgent):
         """Build or load a Chroma vectorstore for a single material's description."""
         persist_dir = os.path.join(self.vectorstore_path, mid)
         if os.path.exists(persist_dir):
-            store = Chroma(persist_directory=persist_dir, embedding_function=self.embeddings)
+            store = Chroma(
+                persist_directory=persist_dir,
+                embedding_function=self.embeddings,
+            )
         else:
-            splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+            splitter = RecursiveCharacterTextSplitter(
+                chunk_size=500, chunk_overlap=100
+            )
             docs = splitter.create_documents([text])
-            store = Chroma.from_documents(docs, self.embeddings, persist_directory=persist_dir)
+            store = Chroma.from_documents(
+                docs, self.embeddings, persist_directory=persist_dir
+            )
         return store.as_retriever(search_kwargs={"k": 5})
 
     def _summarize_node(self, state: Dict) -> Dict:
@@ -187,18 +212,25 @@ You are a materials-science assistant. Given the following metadata about a mate
             # flatten metadata to text
             text = "\n".join(f"{k}: {v}" for k, v in meta.items())
             # build or load summary
-            summary_file = os.path.join(self.summaries_path, f"{mid}_summary.txt")
+            summary_file = os.path.join(
+                self.summaries_path, f"{mid}_summary.txt"
+            )
             if os.path.exists(summary_file):
                 with open(summary_file) as f:
                     return i, f.read()
             # optional: vectorize & retrieve, but here we just summarize full text
             result = chain.invoke({"metadata": text})
-            with open(summary_file, 'w') as f:
+            with open(summary_file, "w") as f:
                 f.write(result)
             return i, result
 
-        with ThreadPoolExecutor(max_workers=min(8, len(state["materials"]))) as exe:
-            futures = [exe.submit(process, i, m) for i, m in enumerate(state["materials"])]
+        with ThreadPoolExecutor(
+            max_workers=min(8, len(state["materials"]))
+        ) as exe:
+            futures = [
+                exe.submit(process, i, m)
+                for i, m in enumerate(state["materials"])
+            ]
             for future in tqdm(futures, desc="Summarizing materials"):
                 i, summ = future.result()
                 summaries[i] = summ
@@ -208,8 +240,10 @@ You are a materials-science assistant. Given the following metadata about a mate
     def _aggregate_node(self, state: Dict) -> Dict:
         """Combine all summaries into a single, coherent answer."""
         combined = "\n\n----\n\n".join(
-            f"[{i+1}] {m['material_id']}\n\n{summary}"
-            for i, (m, summary) in enumerate(zip(state["materials"], state["summaries"]))
+            f"[{i + 1}] {m['material_id']}\n\n{summary}"
+            for i, (m, summary) in enumerate(
+                zip(state["materials"], state["summaries"])
+            )
         )
 
         prompt = ChatPromptTemplate.from_template("""
@@ -222,7 +256,9 @@ You are a materials-science assistant. Given the following metadata about a mate
         {context}
                 """)
         chain = prompt | self.llm | StrOutputParser()
-        final = chain.invoke({"summaries": combined, "context": state["context"]})
+        final = chain.invoke(
+            {"summaries": combined, "context": state["context"]}
+        )
         return {**state, "final_summary": final}
 
     def _build_graph(self):
@@ -252,6 +288,6 @@ if __name__ == "__main__":
     agent = MaterialsProjectAgent()
     resp = agent.run(
         mp_query="LiFePO4",
-        context="What is its band gap and stability, and any synthesis challenges?"
+        context="What is its band gap and stability, and any synthesis challenges?",
     )
     print(resp)

ursa/agents/planning_agent.py

@@ -44,7 +44,13 @@ class PlanningAgent(BaseAgent):
             messages[0] = SystemMessage(content=self.planner_prompt)
         else:
             messages = [SystemMessage(content=self.planner_prompt)] + messages
-        return {"messages": [self.llm.invoke(messages, {"configurable": {"thread_id": self.thread_id}})]}
+        return {
+            "messages": [
+                self.llm.invoke(
+                    messages, {"configurable": {"thread_id": self.thread_id}}
+                )
+            ]
+        }
 
     def formalize_node(self, state: PlanningState) -> PlanningState:
         cls_map = {"ai": HumanMessage, "human": AIMessage}
@@ -55,7 +61,9 @@ class PlanningAgent(BaseAgent):
         translated = [SystemMessage(content=self.formalize_prompt)] + translated
         for _ in range(10):
             try:
-                res = self.llm.invoke(translated, {"configurable": {"thread_id": self.thread_id}})
+                res = self.llm.invoke(
+                    translated, {"configurable": {"thread_id": self.thread_id}}
+                )
                 json_out = extract_json(res.content)
                 break
             except ValueError:
@@ -76,7 +84,9 @@ class PlanningAgent(BaseAgent):
             for msg in state["messages"][1:]
         ]
         translated = [SystemMessage(content=reflection_prompt)] + translated
-        res = self.llm.invoke(translated, {"configurable": {"thread_id": self.thread_id}})
+        res = self.llm.invoke(
+            translated, {"configurable": {"thread_id": self.thread_id}}
+        )
         return {"messages": [HumanMessage(content=res.content)]}
 
     def _initialize_agent(self):
@@ -99,10 +109,16 @@ class PlanningAgent(BaseAgent):
         # self.action = self.graph.compile(checkpointer=memory)
         self.action = self.graph.compile(checkpointer=self.checkpointer)
         # self.action.get_graph().draw_mermaid_png(output_file_path="planning_agent_graph.png", draw_method=MermaidDrawMethod.PYPPETEER)
-    
-    def run(self, prompt,recursion_limit=100):
+
+    def run(self, prompt, recursion_limit=100):
         initial_state = {"messages": [HumanMessage(content=prompt)]}
-        return self.action.invoke(initial_state, {"recursion_limit":recursion_limit, "configurable": {"thread_id": self.thread_id}})
+        return self.action.invoke(
+            initial_state,
+            {
+                "recursion_limit": recursion_limit,
+                "configurable": {"thread_id": self.thread_id},
+            },
+        )
 
 
 config = {"configurable": {"thread_id": "1"}}

ursa/agents/recall_agent.py

@@ -4,10 +4,9 @@ from .base import BaseAgent
 
 class RecallAgent(BaseAgent):
     def __init__(self, llm, memory, **kwargs):
-        
         super().__init__(llm, **kwargs)
         self.memorydb = memory
-    
+
     def remember(self, query):
         memories = self.memorydb.retrieve(query)
         summarize_query = f"""

ursa/agents/websearch_agent.py

@@ -56,25 +56,45 @@ class WebSearchAgent(BaseAgent):
         self.websearch_prompt = websearch_prompt
         self.reflection_prompt = reflection_prompt
         self.tools = [search_tool, process_content]  # + cb_tools
-        self.has_internet = self._check_for_internet(kwargs.get("url","http://www.lanl.gov"))
+        self.has_internet = self._check_for_internet(
+            kwargs.get("url", "http://www.lanl.gov")
+        )
         self._initialize_agent()
 
     def review_node(self, state: WebSearchState) -> WebSearchState:
         if not self.has_internet:
-            return {"messages":[HumanMessage(content="No internet for WebSearch Agent so no research to review.")], "urls_visited": []}
-        
+            return {
+                "messages": [
+                    HumanMessage(
+                        content="No internet for WebSearch Agent so no research to review."
+                    )
+                ],
+                "urls_visited": [],
+            }
+
         translated = [SystemMessage(content=reflection_prompt)] + state[
             "messages"
         ]
-        res = self.llm.invoke(translated, {"configurable": {"thread_id": self.thread_id}})
+        res = self.llm.invoke(
+            translated, {"configurable": {"thread_id": self.thread_id}}
+        )
         return {"messages": [HumanMessage(content=res.content)]}
 
     def response_node(self, state: WebSearchState) -> WebSearchState:
         if not self.has_internet:
-            return {"messages":[HumanMessage(content="No internet for WebSearch Agent. No research carried out.")], "urls_visited": []}
+            return {
+                "messages": [
+                    HumanMessage(
+                        content="No internet for WebSearch Agent. No research carried out."
+                    )
+                ],
+                "urls_visited": [],
+            }
 
         messages = state["messages"] + [SystemMessage(content=summarize_prompt)]
-        response = self.llm.invoke(messages, {"configurable": {"thread_id": self.thread_id}})
+        response = self.llm.invoke(
+            messages, {"configurable": {"thread_id": self.thread_id}}
+        )
 
         urls_visited = []
         for message in messages:
@@ -82,7 +102,7 @@ class WebSearchAgent(BaseAgent):
                 if "url" in message.tool_calls[0]["args"]:
                     urls_visited.append(message.tool_calls[0]["args"]["url"])
         return {"messages": [response.content], "urls_visited": urls_visited}
-    
+
     def _check_for_internet(self, url, timeout=2):
         """
         Checks for internet connectivity by attempting an HTTP GET request.
@@ -119,15 +139,28 @@ class WebSearchAgent(BaseAgent):
         )
         self.action = self.graph.compile(checkpointer=self.checkpointer)
         # self.action.get_graph().draw_mermaid_png(output_file_path="./websearch_agent_graph.png", draw_method=MermaidDrawMethod.PYPPETEER)
-    
+
     def run(self, prompt, recursion_limit=100):
         if not self.has_internet:
-            return {"messages":[HumanMessage(content="No internet for WebSearch Agent. No research carried out.")]}
+            return {
+                "messages": [
+                    HumanMessage(
+                        content="No internet for WebSearch Agent. No research carried out."
+                    )
+                ]
+            }
         inputs = {
             "messages": [HumanMessage(content=prompt)],
             "model": self.llm,
         }
-        return self.action.invoke(inputs, {"recursion_limit":recursion_limit, "configurable": {"thread_id": self.thread_id}})        
+        return self.action.invoke(
+            inputs,
+            {
+                "recursion_limit": recursion_limit,
+                "configurable": {"thread_id": self.thread_id},
+            },
+        )
+
 
 def process_content(
     url: str, context: str, state: Annotated[dict, InjectedState]
@@ -150,7 +183,11 @@ def process_content(
     Carefully summarize the content in full detail, given the following context:
     {context}
     """
-    summarized_information = state["model"].invoke(content_prompt, {"configurable": {"thread_id": self.thread_id}}).content
+    summarized_information = (
+        state["model"]
+        .invoke(content_prompt, {"configurable": {"thread_id": self.thread_id}})
+        .content
+    )
     return summarized_information
 
 
@@ -176,7 +213,13 @@ def main():
         "messages": [HumanMessage(content=problem_string)],
         "model": model,
     }
-    result = websearcher.action.invoke(inputs, {"recursion_limit": 10000, "configurable": {"thread_id": self.thread_id}})
+    result = websearcher.action.invoke(
+        inputs,
+        {
+            "recursion_limit": 10000,
+            "configurable": {"thread_id": self.thread_id},
+        },
+    )
 
     colors = [BLUE, RED]
     for ii, x in enumerate(result["messages"][:-1]):

ursa/prompt_library/code_review_prompts.py

@@ -1,6 +1,5 @@
-
 def get_code_review_prompt(project_prompt, file_list):
-   return f'''
+    return f"""
    You are a responsible and efficient code review agent tasked with assessing if given files meet the goals of a project description.
 
    The project goals are:
@@ -26,10 +25,11 @@ def get_code_review_prompt(project_prompt, file_list):
    4. Immediately highlight and clearly communicate any steps that appear unclear, unsafe, or impractical before proceeding.
 
    Your goal is to ensure the implemented code addresses the plan accurately, safely, and transparently, maintaining accountability at each step.
-   '''
+   """
+
 
 def get_plan_review_prompt(project_prompt, file_list):
-   return f'''
+    return f"""
    You are a responsible and efficient code review agent tasked with assessing if given files meet the goals of a project description.
 
    The project goals are:
@@ -48,4 +48,4 @@ def get_plan_review_prompt(project_prompt, file_list):
       - Do any files appear dangerous, adversarial, or performing actions detrimental to the plan.
 
    Your goal is to provide that information in a clear, concise way for use by a code reviewer who will look over files in detail.
-   '''
+   """

ursa/prompt_library/execution_prompts.py

@@ -6,7 +6,7 @@
 # You may execute system commands to carry out this plan, as long as they are safe commands.
 # '''
 
-executor_prompt = '''
+executor_prompt = """
 You are a responsible and efficient execution agent tasked with carrying out a provided plan designed to solve a specific problem.
 
 Your responsibilities are as follows:
@@ -23,9 +23,9 @@ Your responsibilities are as follows:
 4. Immediately highlight and clearly communicate any steps that appear unclear, unsafe, or impractical before proceeding.
 
 Your goal is to carry out the provided plan accurately, safely, and transparently, maintaining accountability at each step.
-'''
+"""
 
-summarize_prompt = '''
+summarize_prompt = """
 You are a summarizing agent.  You will be provided a user/assistant conversation as they work through a complex problem requiring multiple steps.
 
 Your responsibilities is to write a condensed summary of the conversation.
@@ -33,4 +33,4 @@ Your responsibilities is to write a condensed summary of the conversation.
     - Ensure the summary responds to the goals of the original query.
     - Summarize all the work that was carried out to meet those goals
     - Highlight any places where those goals were not achieved and why.
-'''
+"""

ursa/prompt_library/literature_prompts.py

@@ -1,11 +1,11 @@
-search_prompt = '''
+search_prompt = """
 You are an agent that is responsible for reviewing the literature to answer a specific question.
 Use the arxiv tool available to carry out this plan.
 You should perform a search through the arxiv database.
-'''
+"""
 
-summarize_prompt = '''
+summarize_prompt = """
 You are a summarizing agent. 
 You should cite all the papers that were used for the arxiv review.
 You should give me the final summary from the literature review.
-'''
+"""

ursa/prompt_library/planning_prompts.py

@@ -37,14 +37,14 @@ Please keep your plan concise yet sufficiently detailed so that it can be execut
 # reflection_prompt = '''
 # You are a critical reviewer being given a series of steps to solve a problem.
 
-# Provide detailed recommendations, including adding missing steps or removing 
+# Provide detailed recommendations, including adding missing steps or removing
 # superfluous steps. Ensure the proposed effort is appropriate for the problem.
 
-# In the end, decide if the current proposal should be approved or revised. 
+# In the end, decide if the current proposal should be approved or revised.
 # Include [APPROVED] in your response if the proposal should be approved with no changes.
 # '''
 
-reflection_prompt = '''
+reflection_prompt = """
 You are acting as a critical reviewer evaluating a series of steps proposed to solve a specific problem.
 
 Carefully review the proposed steps and provide detailed feedback based on the following criteria:
@@ -61,7 +61,7 @@ At the end of your feedback, clearly state your decision:
 
 - If the current proposal requires no changes, include "[APPROVED]" at the end of your response.
 - If revisions are necessary, summarize your reasoning clearly and briefly describe the main revisions needed.
-'''
+"""
 
 formalize_prompt = """
 Now that the step-by-step plan is finalized, format it into a series of steps in the form of a JSON array with objects having the following structure: