ursa-ai 0.2.12__py3-none-any.whl → 0.3.0__py3-none-any.whl

ursa/agents/__init__.py

@@ -9,6 +9,8 @@ from .execution_agent import ExecutionAgent as ExecutionAgent
 from .execution_agent import ExecutionState as ExecutionState
 from .hypothesizer_agent import HypothesizerAgent as HypothesizerAgent
 from .hypothesizer_agent import HypothesizerState as HypothesizerState
+from .lammps_agent import LammpsAgent as LammpsAgent
+from .lammps_agent import LammpsState as LammpsState
 from .mp_agent import MaterialsProjectAgent as MaterialsProjectAgent
 from .planning_agent import PlanningAgent as PlanningAgent
 from .planning_agent import PlanningState as PlanningState

ursa/agents/arxiv_agent.py

@@ -156,9 +156,29 @@ class ArxivAgent(BaseAgent):
         if self.download_papers:
             encoded_query = quote(query)
             url = f"http://export.arxiv.org/api/query?search_query=all:{encoded_query}&start=0&max_results={self.max_results}"
-            feed = feedparser.parse(url)
+            #            print(f"URL is {url}") # if verbose
+            entries = []
+            try:
+                response = requests.get(url, timeout=10)
+                response.raise_for_status()
+
+                feed = feedparser.parse(response.content)
+                #                print(f"parsed response status is {feed.status}") # if verbose
+                entries = feed.entries
+                if feed.bozo:
+                    raise Exception("Feed from arXiv looks like garbage =(")
+            except requests.exceptions.Timeout:
+                print("Request timed out while fetching papers.")
+            except requests.exceptions.RequestException as e:
+                print(f"Request error encountered while fetching papers: {e}")
+            except ValueError as ve:
+                print(f"Value error occurred while fetching papers: {ve}")
+            except Exception as e:
+                print(
+                    f"An unexpected error occurred while fetching papers: {e}"
+                )
 
-            for i, entry in enumerate(feed.entries):
+            for i, entry in enumerate(entries):
                 full_id = entry.id.split("/abs/")[-1]
                 arxiv_id = full_id.split("/")[-1]
                 title = entry.title.strip()

ursa/agents/execution_agent.py

@@ -5,7 +5,7 @@ import subprocess
 from pathlib import Path
 from typing import Annotated, Any, Literal, Optional
 
-import coolname
+import randomname
 from langchain_community.tools import (
     DuckDuckGoSearchResults,
 )  # TavilySearchResults,
@@ -75,17 +75,15 @@ class ExecutionAgent(BaseAgent):
     def query_executor(self, state: ExecutionState) -> ExecutionState:
         new_state = state.copy()
         if "workspace" not in new_state.keys():
-            new_state["workspace"] = coolname.generate_slug(2)
+            new_state["workspace"] = randomname.get_name()
             print(
                 f"{RED}Creating the folder {BLUE}{BOLD}{new_state['workspace']}{RESET}{RED} for this project.{RESET}"
             )
         os.makedirs(new_state["workspace"], exist_ok=True)
 
         # code related to symlink
-        if (
-            "symlinkdir" in new_state.keys()
-            and "is_linked" not in new_state["symlinkdir"].keys()
-        ):
+        sd = new_state.get("symlinkdir")
+        if isinstance(sd, dict) and "is_linked" not in sd:
             # symlinkdir = {"source": "foo", "dest": "bar"}
             symlinkdir = new_state["symlinkdir"]
             # user provided a symlinkdir key - let's do the linking!

ursa/agents/hypothesizer_agent.py

@@ -35,7 +35,7 @@ class HypothesizerState(TypedDict):
     agent1_solution: List[str]  # List to store each iteration of solutions
     agent2_critiques: List[str]  # List to store critiques
     agent3_perspectives: List[str]  # List to store competitor perspectives
-    final_solution: str  # Final refined solution
+    solution: str  # Refined solution
     summary_report: str  # the final summarized report
     visited_sites: List[str]
 
@@ -262,12 +262,10 @@ class HypothesizerAgent(BaseAgent):
         )
         return new_state
 
-    def generate_final_solution(
-        self, state: HypothesizerState
-    ) -> HypothesizerState:
-        """Generate the final, refined solution based on all iterations."""
+    def generate_solution(self, state: HypothesizerState) -> HypothesizerState:
+        """Generate the overall, refined solution based on all iterations."""
         print(
-            f"[iteration {state['current_iteration']} - DEBUG] Entering generate_final_solution."
+            f"[iteration {state['current_iteration']} - DEBUG] Entering generate_solution."
         )
         prompt = f"Original question: {state['question']}\n\n"
         prompt += "Evolution of solutions:\n"
@@ -280,23 +278,23 @@ class HypothesizerAgent(BaseAgent):
                 f"Competitor perspective: {state['agent3_perspectives'][i]}\n"
             )
 
-        prompt += "\nBased on this iterative process, provide the final, refined solution."
+        prompt += "\nBased on this iterative process, provide the overall, refined solution."
 
         print(
-            f"[iteration {state['current_iteration']} - DEBUG] Generating final solution with LLM..."
+            f"[iteration {state['current_iteration']} - DEBUG] Generating overall solution with LLM..."
         )
-        final_solution = self.llm.invoke(prompt)
+        solution = self.llm.invoke(prompt)
         print(
-            f"[iteration {state['current_iteration']} - DEBUG] Final solution obtained. Preview:",
-            final_solution.content[:200],
+            f"[iteration {state['current_iteration']} - DEBUG] Overall solution obtained. Preview:",
+            solution.content[:200],
             "...",
         )
 
         new_state = state.copy()
-        new_state["final_solution"] = final_solution.content
+        new_state["solution"] = solution.content
 
         print(
-            f"[iteration {state['current_iteration']} - DEBUG] Exiting generate_final_solution."
+            f"[iteration {state['current_iteration']} - DEBUG] Exiting generate_solution."
         )
         return new_state
 
@@ -363,13 +361,13 @@ class HypothesizerAgent(BaseAgent):
 
             {iteration_details}
 
-            The final solution we arrived at was:
+            The solution we arrived at was:
 
-            {state["final_solution"]}
+            {state["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
-            the entire iterative process.  Following that, we should include the final solution in full,
+            the entire iterative process.  Following that, we should include the solution in full,
             not summarized, but reformatted for appropriate LaTeX.  And then, finally (and this will be
             quite long), we must take all the steps - solutions, critiques, and competitor perspectives
             and *NOT SUMMARIZE THEM* but merely reformat them for the reader.  This will be in an Appendix
@@ -387,7 +385,7 @@ class HypothesizerAgent(BaseAgent):
         """
 
         # Now produce a valid LaTeX document that nicely summarizes this entire iterative process.
-        # It must include the final solution in full, not summarized, but reformatted for appropriate
+        # It must include the overall solution in full, not summarized, but reformatted for appropriate
         # LaTeX. The summarization is for the other steps.
 
         all_visited_sites = state.get("visited_sites", [])
@@ -455,7 +453,7 @@ class HypothesizerAgent(BaseAgent):
         self.graph.add_node("agent2", self.agent2_critique)
         self.graph.add_node("agent3", self.agent3_competitor_perspective)
         self.graph.add_node("increment_iteration", self.increment_iteration)
-        self.graph.add_node("finalize", self.generate_final_solution)
+        self.graph.add_node("finalize", self.generate_solution)
         self.graph.add_node("print_sites", self.print_visited_sites)
         self.graph.add_node(
             "summarize_as_latex", self.summarize_process_as_latex
@@ -497,7 +495,7 @@ class HypothesizerAgent(BaseAgent):
             agent1_solution=[],
             agent2_critiques=[],
             agent3_perspectives=[],
-            final_solution="",
+            solution="",
         )
         # Run the graph
         result = self.action.invoke(
@@ -507,7 +505,7 @@ class HypothesizerAgent(BaseAgent):
                 "configurable": {"thread_id": self.thread_id},
             },
         )
-        return result["final_solution"]
+        return result["solution"]
 
 
 def should_continue(state: HypothesizerState) -> Literal["continue", "finish"]:
@@ -580,7 +578,7 @@ if __name__ == "__main__":
         agent1_solution=[],
         agent2_critiques=[],
         agent3_perspectives=[],
-        final_solution="",
+        solution="",
     )
 
     print("[DEBUG] Invoking the graph...")
@@ -596,9 +594,9 @@ if __name__ == "__main__":
 
     print("[DEBUG] Graph invocation complete.")
 
-    # Print the final solution
-    print("Final Solution:")
-    print(result["final_solution"])
+    # Print the overall solution
+    print("Overall Solution:")
+    print(result["solution"])
 
     # print("Summarized Report:")
     # print(summary_text)

ursa/agents/lammps_agent.py

@@ -0,0 +1,392 @@
+import json
+import os
+import subprocess
+from typing import Any, Dict, List, Optional, TypedDict
+
+import atomman as am
+import tiktoken
+import trafilatura
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langgraph.graph import END, StateGraph
+
+from .base import BaseAgent
+
+
+class LammpsState(TypedDict, total=False):
+    simulation_task: str
+    elements: List[str]
+
+    matches: List[Any]
+    db_message: str
+
+    idx: int
+    summaries: List[str]
+    full_texts: List[str]
+
+    summaries_combined: str
+    choice_json: str
+    chosen_index: int
+
+    input_script: str
+    run_returncode: Optional[int]
+    run_stdout: str
+    run_stderr: str
+
+    fix_attempts: int
+
+
+class LammpsAgent(BaseAgent):
+    def __init__(
+        self,
+        llm,
+        max_potentials: int = 5,
+        max_fix_attempts: int = 10,
+        mpi_procs: int = 8,
+        workspace: str = "./workspace",
+        lammps_cmd: str = "lmp_mpi",
+        mpirun_cmd: str = "mpirun",
+        tiktoken_model: str = "o3",
+        max_tokens: int = 200000,
+        **kwargs,
+    ):
+        self.max_potentials = max_potentials
+        self.max_fix_attempts = max_fix_attempts
+        self.mpi_procs = mpi_procs
+        self.lammps_cmd = lammps_cmd
+        self.mpirun_cmd = mpirun_cmd
+        self.tiktoken_model = tiktoken_model
+        self.max_tokens = max_tokens
+
+        self.pair_styles = [
+            "eam",
+            "eam/alloy",
+            "eam/fs",
+            "meam",
+            "adp",  # classical, HEA-relevant
+            "kim",  # OpenKIM models
+            "snap",
+            "quip",
+            "mlip",
+            "pace",
+            "nep",  # ML/ACE families (if available)
+        ]
+
+        self.workspace = workspace
+        os.makedirs(self.workspace, exist_ok=True)
+
+        super().__init__(llm, **kwargs)
+
+        self.str_parser = StrOutputParser()
+
+        self.summ_chain = (
+            ChatPromptTemplate.from_template(
+                "Here is some data about an interatomic potential: {metadata}\n\n"
+                "Briefly summarize why it could be useful for this task: {simulation_task}."
+            )
+            | self.llm
+            | self.str_parser
+        )
+
+        self.choose_chain = (
+            ChatPromptTemplate.from_template(
+                "Here are the summaries of a certain number of interatomic potentials: {summaries_combined}\n\n"
+                "Pick one potential which would be most useful for this task: {simulation_task}.\n\n"
+                "Return your answer **only** as valid JSON, with no extra text or formatting.\n\n"
+                "Use this exact schema:\n"
+                "{{\n"
+                '  "Chosen index": <int>,\n'
+                '  "rationale": "<string>",\n'
+                '  "Potential name": "<string>"\n'
+                "}}\n"
+            )
+            | self.llm
+            | self.str_parser
+        )
+
+        self.author_chain = (
+            ChatPromptTemplate.from_template(
+                "Your task is to write a LAMMPS input file for this purpose: {simulation_task}.\n"
+                "Here is metadata about the interatomic potential that will be used: {metadata}.\n"
+                "Note that all potential files are in the './' directory.\n"
+                "Here is some information about the pair_style and pair_coeff that might be useful in writing the input file: {pair_info}.\n"
+                "Ensure that all output data is written only to the './log.lammps' file. Do not create any other output file.\n"
+                "To create the log, use only the 'log ./log.lammps' command. Do not use any other command like 'echo' or 'screen'.\n"
+                "Return your answer **only** as valid JSON, with no extra text or formatting.\n"
+                "Use this exact schema:\n"
+                "{{\n"
+                '  "input_script": "<string>"\n'
+                "}}\n"
+            )
+            | self.llm
+            | self.str_parser
+        )
+
+        self.fix_chain = (
+            ChatPromptTemplate.from_template(
+                "You are part of a larger scientific workflow whose purpose is to accomplish this task: {simulation_task}\n"
+                "For this purpose, this input file for LAMMPS was written: {input_script}\n"
+                "However, when running the simulation, an error was raised.\n"
+                "Here is the full stdout message that includes the error message: {err_message}\n"
+                "Your task is to write a new input file that resolves the error.\n"
+                "Here is metadata about the interatomic potential that will be used: {metadata}.\n"
+                "Note that all potential files are in the './' directory.\n"
+                "Here is some information about the pair_style and pair_coeff that might be useful in writing the input file: {pair_info}.\n"
+                "Ensure that all output data is written only to the './log.lammps' file. Do not create any other output file.\n"
+                "To create the log, use only the 'log ./log.lammps' command. Do not use any other command like 'echo' or 'screen'.\n"
+                "Return your answer **only** as valid JSON, with no extra text or formatting.\n"
+                "Use this exact schema:\n"
+                "{{\n"
+                '  "input_script": "<string>"\n'
+                "}}\n"
+            )
+            | self.llm
+            | self.str_parser
+        )
+
+        self.graph = self._build_graph().compile()
+
+    @staticmethod
+    def _safe_json_loads(s: str) -> Dict[str, Any]:
+        s = s.strip()
+        if s.startswith("```"):
+            s = s.strip("`")
+            i = s.find("\n")
+            if i != -1:
+                s = s[i + 1 :].strip()
+        return json.loads(s)
+
+    def _fetch_and_trim_text(self, url: str) -> str:
+        downloaded = trafilatura.fetch_url(url)
+        if not downloaded:
+            return "No metadata available"
+        text = trafilatura.extract(
+            downloaded,
+            include_comments=False,
+            include_tables=True,
+            include_links=False,
+            favor_recall=True,
+        )
+        if not text:
+            return "No metadata available"
+        text = text.strip()
+        try:
+            enc = tiktoken.encoding_for_model(self.tiktoken_model)
+            toks = enc.encode(text)
+            if len(toks) > self.max_tokens:
+                toks = toks[: self.max_tokens]
+                text = enc.decode(toks)
+        except Exception:
+            pass
+        return text
+
+    def _find_potentials(self, state: LammpsState) -> LammpsState:
+        db = am.library.Database(remote=True)
+        matches = db.get_lammps_potentials(
+            pair_style=self.pair_styles, elements=state["elements"]
+        )
+        msg_lines = []
+        if not list(matches):
+            msg_lines.append("No potentials found for this task in NIST.")
+        else:
+            msg_lines.append("Found these potentials in NIST:")
+            for rec in matches:
+                msg_lines.append(f"{rec.id}  {rec.pair_style}  {rec.symbols}")
+        return {
+            **state,
+            "matches": list(matches),
+            "db_message": "\n".join(msg_lines),
+            "idx": 0,
+            "summaries": [],
+            "full_texts": [],
+            "fix_attempts": 0,
+        }
+
+    def _should_summarize(self, state: LammpsState) -> str:
+        matches = state.get("matches", [])
+        i = state.get("idx", 0)
+        if not matches:
+            print("No potentials found in NIST for this task. Exiting....")
+            return "done_no_matches"
+        if i < min(self.max_potentials, len(matches)):
+            return "summarize_one"
+        return "summarize_done"
+
+    def _summarize_one(self, state: LammpsState) -> LammpsState:
+        i = state["idx"]
+        print(f"Summarizing potential #{i}")
+        match = state["matches"][i]
+        md = match.metadata()
+
+        if md.get("comments") is None:
+            text = "No metadata available"
+            summary = "No summary available"
+        else:
+            lines = md["comments"].split("\n")
+            url = lines[1] if len(lines) > 1 else ""
+            text = (
+                self._fetch_and_trim_text(url)
+                if url
+                else "No metadata available"
+            )
+            summary = self.summ_chain.invoke({
+                "metadata": text,
+                "simulation_task": state["simulation_task"],
+            })
+
+        return {
+            **state,
+            "idx": i + 1,
+            "summaries": [*state["summaries"], summary],
+            "full_texts": [*state["full_texts"], text],
+        }
+
+    def _build_summaries(self, state: LammpsState) -> LammpsState:
+        parts = []
+        for i, s in enumerate(state["summaries"]):
+            rec = state["matches"][i]
+            parts.append(f"\nSummary of potential #{i}: {rec.id}\n{s}\n")
+        return {**state, "summaries_combined": "".join(parts)}
+
+    def _choose(self, state: LammpsState) -> LammpsState:
+        print("Choosing one potential for this task...")
+        choice = self.choose_chain.invoke({
+            "summaries_combined": state["summaries_combined"],
+            "simulation_task": state["simulation_task"],
+        })
+        choice_dict = self._safe_json_loads(choice)
+        chosen_index = int(choice_dict["Chosen index"])
+        print(f"Chosen potential #{chosen_index}")
+        print("Rationale for choosing this potential:")
+        print(choice_dict["rationale"])
+        return {**state, "choice_json": choice, "chosen_index": chosen_index}
+
+    def _author(self, state: LammpsState) -> LammpsState:
+        print("First attempt at writing LAMMPS input file....")
+        match = state["matches"][state["chosen_index"]]
+        match.download_files(self.workspace)
+        text = state["full_texts"][state["chosen_index"]]
+        pair_info = match.pair_info()
+        authored_json = self.author_chain.invoke({
+            "simulation_task": state["simulation_task"],
+            "metadata": text,
+            "pair_info": pair_info,
+        })
+        script_dict = self._safe_json_loads(authored_json)
+        input_script = script_dict["input_script"]
+        with open(os.path.join(self.workspace, "in.lammps"), "w") as f:
+            f.write(input_script)
+        return {**state, "input_script": input_script}
+
+    def _run_lammps(self, state: LammpsState) -> LammpsState:
+        print("Running LAMMPS....")
+        result = subprocess.run(
+            [
+                self.mpirun_cmd,
+                "-np",
+                str(self.mpi_procs),
+                self.lammps_cmd,
+                "-in",
+                "in.lammps",
+            ],
+            cwd=self.workspace,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False,
+        )
+        return {
+            **state,
+            "run_returncode": result.returncode,
+            "run_stdout": result.stdout,
+            "run_stderr": result.stderr,
+        }
+
+    def _route_run(self, state: LammpsState) -> str:
+        rc = state.get("run_returncode", 0)
+        attempts = state.get("fix_attempts", 0)
+        if rc == 0:
+            print("LAMMPS run successful! Exiting...")
+            return "done_success"
+        if attempts < self.max_fix_attempts:
+            print("LAMMPS run Failed. Attempting to rewrite input file...")
+            return "need_fix"
+        print("LAMMPS run Failed and maximum fix attempts reached. Exiting...")
+        return "done_failed"
+
+    def _fix(self, state: LammpsState) -> LammpsState:
+        match = state["matches"][state["chosen_index"]]
+        text = state["full_texts"][state["chosen_index"]]
+        pair_info = match.pair_info()
+        err_blob = state.get("run_stdout")
+
+        fixed_json = self.fix_chain.invoke({
+            "simulation_task": state["simulation_task"],
+            "input_script": state["input_script"],
+            "err_message": err_blob,
+            "metadata": text,
+            "pair_info": pair_info,
+        })
+        script_dict = self._safe_json_loads(fixed_json)
+        new_input = script_dict["input_script"]
+        with open(os.path.join(self.workspace, "in.lammps"), "w") as f:
+            f.write(new_input)
+        return {
+            **state,
+            "input_script": new_input,
+            "fix_attempts": state.get("fix_attempts", 0) + 1,
+        }
+
+    def _build_graph(self):
+        g = StateGraph(LammpsState)
+
+        g.add_node("find_potentials", self._find_potentials)
+        g.add_node("summarize_one", self._summarize_one)
+        g.add_node("build_summaries", self._build_summaries)
+        g.add_node("choose", self._choose)
+        g.add_node("author", self._author)
+        g.add_node("run_lammps", self._run_lammps)
+        g.add_node("fix", self._fix)
+
+        g.set_entry_point("find_potentials")
+
+        g.add_conditional_edges(
+            "find_potentials",
+            self._should_summarize,
+            {
+                "summarize_one": "summarize_one",
+                "summarize_done": "build_summaries",
+                "done_no_matches": END,
+            },
+        )
+
+        g.add_conditional_edges(
+            "summarize_one",
+            self._should_summarize,
+            {
+                "summarize_one": "summarize_one",
+                "summarize_done": "build_summaries",
+            },
+        )
+
+        g.add_edge("build_summaries", "choose")
+        g.add_edge("choose", "author")
+        g.add_edge("author", "run_lammps")
+
+        g.add_conditional_edges(
+            "run_lammps",
+            self._route_run,
+            {
+                "need_fix": "fix",
+                "done_success": END,
+                "done_failed": END,
+            },
+        )
+        g.add_edge("fix", "run_lammps")
+        return g
+
+    def run(self, simulation_task, elements):
+        return self.graph.invoke(
+            {"simulation_task": simulation_task, "elements": elements},
+            {"recursion_limit": 999_999},
+        )

ursa/agents/planning_agent.py

@@ -39,6 +39,7 @@ class PlanningAgent(BaseAgent):
         self._initialize_agent()
 
     def generation_node(self, state: PlanningState) -> PlanningState:
+        print("PlanningAgent: generating . . .")
         messages = state["messages"]
         if isinstance(messages[0], SystemMessage):
             messages[0] = SystemMessage(content=self.planner_prompt)
@@ -53,6 +54,7 @@ class PlanningAgent(BaseAgent):
         }
 
     def formalize_node(self, state: PlanningState) -> PlanningState:
+        print("PlanningAgent: formalizing . . .")
         cls_map = {"ai": HumanMessage, "human": AIMessage}
         translated = [state["messages"][0]] + [
             cls_map[msg.type](content=msg.content)
@@ -78,6 +80,7 @@ class PlanningAgent(BaseAgent):
         }
 
     def reflection_node(self, state: PlanningState) -> PlanningState:
+        print("PlanningAgent: reflecting . . .")
         cls_map = {"ai": HumanMessage, "human": AIMessage}
         translated = [state["messages"][0]] + [
             cls_map[msg.type](content=msg.content)

{ursa_ai-0.2.12.dist-info → ursa_ai-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ursa-ai
-Version: 0.2.12
+Version: 0.3.0
 Summary: Agents for science at LANL
 Author-email: Mike Grosskopf <mikegros@lanl.gov>, Nathan Debardeleben <ndebard@lanl.gov>, Rahul Somasundaram <rsomasundaram@lanl.gov>, Isaac Michaud <imichaud@lanl.gov>, Avanish Mishra <avanish@lanl.gov>, Arthur Lui <alui@lanl.gov>, Russell Bent <rbent@lanl.gov>, Earl Lawrence <earl@lanl.gov>
 License-Expression: BSD-3-Clause
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: arxiv<3.0,>=2.2.0
 Requires-Dist: beautifulsoup4<5.0,>=4.13.4
-Requires-Dist: coolname<3.0,>=2.2.0
+Requires-Dist: randomname<0.3,>=0.2.1
 Requires-Dist: langchain<0.4,>=0.3.27
 Requires-Dist: langchain-community<0.4,>=0.3.29
 Requires-Dist: langchain-litellm<0.3,>=0.2.2
@@ -38,6 +38,8 @@ Requires-Dist: langchain-anthropic<0.4,>=0.3.19
 Requires-Dist: langgraph-checkpoint-sqlite<3.0,>=2.0.10
 Requires-Dist: langchain-ollama<0.4,>=0.3.6
 Requires-Dist: ddgs>=9.5.5
+Requires-Dist: atomman>=1.5.2
+Requires-Dist: trafilatura>=1.6.1
 Dynamic: license-file
 
 # URSA - The Universal Research and Scientific Agent

{ursa_ai-0.2.12.dist-info → ursa_ai-0.3.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
-ursa/agents/__init__.py,sha256=IdwVBLlz7QydHiFSok06McIfEJed6rxrT01hZgpQig0,1008
-ursa/agents/arxiv_agent.py,sha256=6pycpm1hkUNjwXF6lJ4DCF5CxOiSnS5dvpW2Qes3ZD8,14125
+ursa/agents/__init__.py,sha256=HG95_hMlR0cEAF8Vbr7dF_7I2cWM-rMW1p8ULRXTzTg,1114
+ursa/agents/arxiv_agent.py,sha256=hS6RKqP0fz9KdAyFbXIxl7DuZyuhxpR-jJLfq2tCnlY,15106
 ursa/agents/base.py,sha256=uFhRLVzqhFbTZVA7IePKbUi03ATCXuvga7rzwaHy1B0,1321
 ursa/agents/code_review_agent.py,sha256=aUDq5gT-jdl9Qs-Wewj2oz1d60xov9sN-DOYRfGNTU0,11550
-ursa/agents/execution_agent.py,sha256=-At1EcKRHP9lYQ80jpqTPtQyPuQV-sIpf9J8LlEfWdA,16618
-ursa/agents/hypothesizer_agent.py,sha256=KrOoyM5znZVAIpcflGLO1sybMbyx7S7HERAXvct5zig,23295
+ursa/agents/execution_agent.py,sha256=okVTsZhG0S92evHtmxge3Ymq3pH0QLYY2VqzO39WG5Y,16581
+ursa/agents/hypothesizer_agent.py,sha256=pUwFDWGBJAqL7CDXxWYJrQrknC3DgRe82Poc_Q_OSMg,23193
+ursa/agents/lammps_agent.py,sha256=16eKOtAXEm-clnIZcfEaoxQONqbUJm_1dZhZhm2C2uM,14099
 ursa/agents/mp_agent.py,sha256=UyJSheMGHZpWQJL3EgYgPPqArfv6F8sndN05q4CPtyo,6015
-ursa/agents/planning_agent.py,sha256=AKWQJ848RLPiwQGrvDNdN9lBlf3YI5qWmt2hqXnRGj8,5426
+ursa/agents/planning_agent.py,sha256=ayyNDQifPvYtQ-JYnFk3TaXWZcd_6k8qUheJGariqG8,5574
 ursa/agents/recall_agent.py,sha256=bQk7ZJtiO5pj89A50OBDzAJ4G2F7ZdsMwmKnp1WWR7g,813
 ursa/agents/websearch_agent.py,sha256=rCv4AWbqe5Us4FmuypM6jptri21nKoNg044ncsu9u3E,8014
 ursa/prompt_library/code_review_prompts.py,sha256=-HuhwW9W_p2LDn44bXLntxLADHCOyl-2KIXxRHto66w,2444
@@ -19,8 +20,8 @@ ursa/tools/write_code.py,sha256=DtCsUMZegYm0mk-HMPG5Zo3Ba1gbGfnXHsv1NZTdDs8,1220
 ursa/util/diff_renderer.py,sha256=1L1q2qWWb8gLhR532-LgJn2TrqXDx0gUpPVOWD_sqeU,4086
 ursa/util/memory_logger.py,sha256=9tNPF3Fgth4ImpNbs7Qg5Ci6Hb1ziMWsDTsqjkDi1iY,6096
 ursa/util/parse.py,sha256=M0cjyQWmjatxX4WbVmDRUiirTLyW-t_Aemlrlrsc5nA,2811
-ursa_ai-0.2.12.dist-info/licenses/LICENSE,sha256=4Vr6_u2zTHIUvYjoOBg9ztDbfpV3hyCFv3mTCS87gYU,1482
-ursa_ai-0.2.12.dist-info/METADATA,sha256=Yx4oeE3N7uIaQemsgzHldvOC818Hmo0UNyTnxcHchcQ,6833
-ursa_ai-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ursa_ai-0.2.12.dist-info/top_level.txt,sha256=OjA1gRYSUAeiXGnpqPC8iOOGfcjFO1IlP848qMnYSdY,5
-ursa_ai-0.2.12.dist-info/RECORD,,
+ursa_ai-0.3.0.dist-info/licenses/LICENSE,sha256=4Vr6_u2zTHIUvYjoOBg9ztDbfpV3hyCFv3mTCS87gYU,1482
+ursa_ai-0.3.0.dist-info/METADATA,sha256=utYzFg58XhjGfhs4j-dEO_KDLy2GImgzTKdqdVrasu0,6898
+ursa_ai-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ursa_ai-0.3.0.dist-info/top_level.txt,sha256=OjA1gRYSUAeiXGnpqPC8iOOGfcjFO1IlP848qMnYSdY,5
+ursa_ai-0.3.0.dist-info/RECORD,,