ursa-ai 0.7.0rc1__py3-none-any.whl → 0.7.1__py3-none-any.whl

ursa/agents/lammps_agent.py

@@ -21,17 +21,14 @@ except Exception:
 class LammpsState(TypedDict, total=False):
     simulation_task: str
     elements: List[str]
+    template: Optional[str]
+    chosen_potential: Optional[Any]
 
     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]
@@ -47,6 +44,7 @@ class LammpsAgent(BaseAgent):
         llm,
         max_potentials: int = 5,
         max_fix_attempts: int = 10,
+        find_potential_only: bool = False,
         mpi_procs: int = 8,
         workspace: str = "./workspace",
         lammps_cmd: str = "lmp_mpi",
@@ -61,6 +59,7 @@ class LammpsAgent(BaseAgent):
             )
         self.max_potentials = max_potentials
         self.max_fix_attempts = max_fix_attempts
+        self.find_potential_only = find_potential_only
         self.mpi_procs = mpi_procs
         self.lammps_cmd = lammps_cmd
         self.mpirun_cmd = mpirun_cmd
@@ -72,13 +71,13 @@ class LammpsAgent(BaseAgent):
             "eam/alloy",
             "eam/fs",
             "meam",
-            "adp",  # classical, HEA-relevant
-            "kim",  # OpenKIM models
+            "adp",
+            "kim",
             "snap",
             "quip",
             "mlip",
             "pace",
-            "nep",  # ML/ACE families (if available)
+            "nep",
         ]
 
         self.workspace = workspace
@@ -116,9 +115,10 @@ class LammpsAgent(BaseAgent):
         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"
+                "If a template for the input file is provided, you should adapt it appropriately to meet the task requirements.\n"
+                "Template provided (if any): {template}\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"
@@ -138,9 +138,10 @@ class LammpsAgent(BaseAgent):
                 "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"
+                "If a template for the input file is provided, you should adapt it appropriately to meet the task requirements.\n"
+                "Template provided (if any): {template}\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"
@@ -189,22 +190,28 @@ class LammpsAgent(BaseAgent):
             pass
         return text
 
+    def _entry_router(self, state: LammpsState) -> dict:
+        if self.find_potential_only and state.get("chosen_potential"):
+            raise Exception(
+                "You cannot set find_potential_only=True and also specify your own potential!"
+            )
+
+        if not state.get("chosen_potential"):
+            self.potential_summaries_dir = os.path.join(
+                self.workspace, "potential_summaries"
+            )
+            os.makedirs(self.potential_summaries_dir, exist_ok=True)
+        return {}
+
     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": [],
@@ -243,6 +250,12 @@ class LammpsAgent(BaseAgent):
                 "simulation_task": state["simulation_task"],
             })
 
+        summary_file = os.path.join(
+            self.potential_summaries_dir, "potential_" + str(i) + ".txt"
+        )
+        with open(summary_file, "w") as f:
+            f.write(summary)
+
         return {
             **state,
             "idx": i + 1,
@@ -265,21 +278,36 @@ class LammpsAgent(BaseAgent):
         })
         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}
+
+        chosen_potential = state["matches"][chosen_index]
+
+        out_file = os.path.join(self.potential_summaries_dir, "Rationale.txt")
+        with open(out_file, "w") as f:
+            f.write(f"Chosen potential #{chosen_index}")
+            f.write("\n")
+            f.write("Rationale for choosing this potential:")
+            f.write("\n")
+            f.write(choice_dict["rationale"])
+
+        return {**state, "chosen_potential": chosen_potential}
+
+    def _route_after_summarization(self, state: LammpsState) -> str:
+        if self.find_potential_only:
+            return "Exit"
+        return "continue_author"
 
     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()
+        state["chosen_potential"].download_files(self.workspace)
+        pair_info = state["chosen_potential"].pair_info()
         authored_json = self.author_chain.invoke({
             "simulation_task": state["simulation_task"],
-            "metadata": text,
             "pair_info": pair_info,
+            "template": state["template"],
         })
         script_dict = self._safe_json_loads(authored_json)
         input_script = script_dict["input_script"]
@@ -324,17 +352,15 @@ class LammpsAgent(BaseAgent):
         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()
+        pair_info = state["chosen_potential"].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,
+            "template": state["template"],
         })
         script_dict = self._safe_json_loads(fixed_json)
         new_input = script_dict["input_script"]
@@ -349,6 +375,7 @@ class LammpsAgent(BaseAgent):
     def _build_graph(self):
         g = StateGraph(LammpsState)
 
+        self.add_node(g, self._entry_router)
         self.add_node(g, self._find_potentials)
         self.add_node(g, self._summarize_one)
         self.add_node(g, self._build_summaries)
@@ -357,7 +384,18 @@ class LammpsAgent(BaseAgent):
         self.add_node(g, self._run_lammps)
         self.add_node(g, self._fix)
 
-        g.set_entry_point("_find_potentials")
+        g.set_entry_point("_entry_router")
+
+        g.add_conditional_edges(
+            "_entry_router",
+            lambda state: "user_choice"
+            if state.get("chosen_potential")
+            else "agent_choice",
+            {
+                "user_choice": "_author",
+                "agent_choice": "_find_potentials",
+            },
+        )
 
         g.add_conditional_edges(
             "_find_potentials",
@@ -379,7 +417,16 @@ class LammpsAgent(BaseAgent):
         )
 
         g.add_edge("_build_summaries", "_choose")
-        g.add_edge("_choose", "_author")
+
+        g.add_conditional_edges(
+            "_choose",
+            self._route_after_summarization,
+            {
+                "continue_author": "_author",
+                "Exit": END,
+            },
+        )
+
         g.add_edge("_author", "_run_lammps")
 
         g.add_conditional_edges(
@@ -399,7 +446,7 @@ class LammpsAgent(BaseAgent):
         inputs: Mapping[str, Any],
         *,
         summarize: bool | None = None,
-        recursion_limit: int = 1000,
+        recursion_limit: int = 999_999,
         **_,
     ) -> str:
         config = self.build_config(
@@ -411,4 +458,7 @@ class LammpsAgent(BaseAgent):
                 "'simulation_task' and 'elements' are required arguments"
             )
 
+        if "template" not in inputs:
+            inputs = {**inputs, "template": "No template provided."}
+
         return self._action.invoke(inputs, config)

ursa/agents/planning_agent.py

@@ -163,10 +163,35 @@ config = {"configurable": {"thread_id": "1"}}
 
 
 def should_continue(state: PlanningState):
-    if len(state["messages"]) > (state.get("reflection_steps", 3) + 3):
+    reviewMaxLength = 0  # 0 = no limit, else some character limit like 300
+
+    # Latest reviewer output (if present)
+    last_content = (
+        state["messages"][-1].content if state.get("messages") else ""
+    )
+
+    max_reflections = state.get("reflection_steps", 3)
+
+    # Hit the reflection cap?
+    if len(state["messages"]) > (max_reflections + 3):
+        print(
+            f"PlanningAgent: reached reflection limit ({max_reflections}); formalizing . . ."
+        )
         return "formalize"
-    if "[APPROVED]" in state["messages"][-1].content:
+
+    # Approved?
+    if "[APPROVED]" in last_content:
+        print("PlanningAgent: [APPROVED] — formalizing . . .")
         return "formalize"
+
+    # Not approved — print a concise reason before another cycle
+    reason = " ".join(last_content.strip().split())  # collapse whitespace
+    if reviewMaxLength > 0 and len(reason) > reviewMaxLength:
+        reason = reason[:reviewMaxLength] + ". . ."
+    print(
+        f"PlanningAgent: not approved — iterating again. Reviewer notes: {reason}"
+    )
+
     return "generate"
 
 

ursa/agents/websearch_agent.py

@@ -46,7 +46,7 @@ class WebSearchState(TypedDict):
 # all the tokens of all the sources.
 
 
-class WebSearchAgent(BaseAgent):
+class WebSearchAgentLegacy(BaseAgent):
     def __init__(
         self, llm: str | BaseChatModel = "openai/gpt-4o-mini", **kwargs
     ):
@@ -204,7 +204,7 @@ def main():
     model = ChatOpenAI(
         model="gpt-4o", max_tokens=10000, timeout=None, max_retries=2
     )
-    websearcher = WebSearchAgent(llm=model)
+    websearcher = WebSearchAgentLegacy(llm=model)
     problem_string = "Who are the 2025 Detroit Tigers top 10 prospects and what year were they born?"
     inputs = {
         "messages": [HumanMessage(content=problem_string)],

ursa/cli/__init__.py

@@ -12,7 +12,7 @@ app = Typer()
 def run(
     workspace: Annotated[
         Path, Option(help="Directory to store ursa ouput")
-    ] = Path(".ursa"),
+    ] = Path("ursa_workspace"),
     llm_model_name: Annotated[
         str,
         Option(
@@ -48,6 +48,9 @@ def run(
             )
         ),
     ] = False,
+    thread_id: Annotated[
+        str, Option(help="Thread ID for persistance", envvar="URSA_THREAD_ID")
+    ] = "ursa_cli",
     arxiv_summarize: Annotated[
         bool,
         Option(
@@ -104,6 +107,7 @@ def run(
         emb_base_url=emb_base_url,
         emb_api_key=emb_api_key,
         share_key=share_key,
+        thread_id=thread_id,
         arxiv_summarize=arxiv_summarize,
         arxiv_process_images=arxiv_process_images,
         arxiv_max_results=arxiv_max_results,

ursa/cli/hitl.py

@@ -19,6 +19,7 @@ from typer import Typer
 
 from ursa.agents import (
     ArxivAgent,
+    ChatAgent,
     ExecutionAgent,
     PlanningAgent,
     RecallAgent,
@@ -63,6 +64,7 @@ class HITL:
     emb_base_url: str
     emb_api_key: Optional[str]
     share_key: bool
+    thread_id: str
     arxiv_summarize: bool
     arxiv_process_images: bool
     arxiv_max_results: int
@@ -122,9 +124,10 @@ class HITL:
 
         self.last_agent_result = ""
         self.arxiv_state = []
+        self.chatter_state = {"messages": []}
         self.executor_state = {}
         self.planner_state = {}
-        self.websearcher_state = {}
+        self.websearcher_state = []
 
     def update_last_agent_result(self, result: str):
         self.last_agent_result = result
@@ -149,9 +152,21 @@ class HITL:
             download_papers=self.arxiv_download_papers,
         )
 
+    @cached_property
+    def chatter(self) -> ChatAgent:
+        edb_path = self.workspace / "checkpoint.db"
+        edb_path.parent.mkdir(parents=True, exist_ok=True)
+        econn = sqlite3.connect(str(edb_path), check_same_thread=False)
+        self.chatter_checkpointer = SqliteSaver(econn)
+        return ChatAgent(
+            llm=self.model,
+            checkpointer=self.chatter_checkpointer,
+            thread_id=self.thread_id + "_chatter",
+        )
+
     @cached_property
     def executor(self) -> ExecutionAgent:
-        edb_path = self.workspace / "executor_checkpoint.db"
+        edb_path = self.workspace / "checkpoint.db"
         edb_path.parent.mkdir(parents=True, exist_ok=True)
         econn = sqlite3.connect(str(edb_path), check_same_thread=False)
         self.executor_checkpointer = SqliteSaver(econn)
@@ -159,29 +174,35 @@ class HITL:
             llm=self.model,
             checkpointer=self.executor_checkpointer,
             agent_memory=self.memory,
+            thread_id=self.thread_id + "_executor",
         )
 
     @cached_property
     def planner(self) -> PlanningAgent:
-        pdb_path = Path(self.workspace) / "planner_checkpoint.db"
+        pdb_path = Path(self.workspace) / "checkpoint.db"
         pdb_path.parent.mkdir(parents=True, exist_ok=True)
         pconn = sqlite3.connect(str(pdb_path), check_same_thread=False)
         self.planner_checkpointer = SqliteSaver(pconn)
         return PlanningAgent(
             llm=self.model,
             checkpointer=self.planner_checkpointer,
+            thread_id=self.thread_id + "_planner",
         )
 
     @cached_property
     def websearcher(self) -> WebSearchAgent:
-        rdb_path = Path(self.workspace) / "websearcher_checkpoint.db"
+        rdb_path = Path(self.workspace) / "checkpoint.db"
         rdb_path.parent.mkdir(parents=True, exist_ok=True)
         rconn = sqlite3.connect(str(rdb_path), check_same_thread=False)
         self.websearcher_checkpointer = SqliteSaver(rconn)
 
         return WebSearchAgent(
             llm=self.model,
+            max_results=10,
+            database_path="web_db",
+            summaries_path="web_summaries",
             checkpointer=self.websearcher_checkpointer,
+            thread_id=self.thread_id + "_websearch",
         )
 
     @cached_property
@@ -249,13 +270,19 @@ class HITL:
         return f"[Rememberer Output]:\n {memory_output}"
 
     def run_chatter(self, prompt: str) -> str:
-        chat_output = self.model.invoke(
-            f"The last agent output was: {self.last_agent_result}\n The user stated: {prompt}"
+        self.chatter_state["messages"].append(
+            HumanMessage(
+                content=f"The last agent output was: {self.last_agent_result}\n The user stated: {prompt}"
+            )
+        )
+        self.chatter_state = self.chatter.invoke(
+            self.chatter_state,
         )
+        chat_output = self.chatter_state["messages"][-1]
 
         if not isinstance(chat_output.content, str):
             raise TypeError(
-                f"chat_output is not a str! Instead, it is: {chat_output}."
+                f"chat_output is not a str! Instead, it is: {type(chat_output.content)}."
             )
 
         self.update_last_agent_result(chat_output.content)
@@ -285,35 +312,20 @@ class HITL:
         return f"[Planner Agent Output]:\n {self.last_agent_result}"
 
     def run_websearcher(self, prompt: str) -> str:
-        if self.websearcher_state:
-            self.websearcher_state["messages"].append(
-                HumanMessage(
-                    f"The last agent output was: {self.last_agent_result}\n"
-                    f"The user stated: {prompt}"
-                )
-            )
-            self.websearcher_state = self.websearcher.invoke(
-                self.websearcher_state,
-            )
-            self.update_last_agent_result(
-                self.websearcher_state["messages"][-1].content
+        llm_search_query = self.model.invoke(
+            f"The user stated {prompt}. Generate between 1 and 8 words for a search query to address the users need. Return only the words to search."
+        ).content
+        print("Searching Web for ", llm_search_query)
+        if isinstance(llm_search_query, str):
+            web_result = self.websearcher.invoke(
+                query=llm_search_query,
+                context=prompt,
             )
+            self.websearcher_state.append(web_result)
+            self.update_last_agent_result(web_result)
+            return f"[WebSearch Agent Output]:\n {self.last_agent_result}"
         else:
-            self.websearcher_state = {
-                "messages": [
-                    HumanMessage(
-                        f"The last agent output was: {self.last_agent_result}\n"
-                        f"The user stated: {prompt}"
-                    )
-                ]
-            }
-            self.websearcher_state = self.websearcher.invoke(
-                self.websearcher_state,
-            )
-            self.update_last_agent_result(
-                self.websearcher_state["messages"][-1].content
-            )
-        return f"[Planner Agent Output]:\n {self.last_agent_result}"
+            raise RuntimeError("Unexpected error while running WebSearchAgent!")
 
 
 class UrsaRepl(Cmd):

ursa/observability/pricing.json

@@ -0,0 +1,85 @@
+{
+  "_note": "Prices are per 1K tokens; derived from OpenAI's table (originally per 1M). Source: https://platform.openai.com/docs/pricing",
+  "local/*": { "input_per_1k": 0.0, "output_per_1k": 0.0, "cached_input_multiplier": 1.0 },
+
+  "gpt-5":                       { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+  "openai/gpt-5":                { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+
+  "gpt-5-mini":                  { "input_per_1k": 0.00025, "output_per_1k": 0.002,  "cached_input_multiplier": 0.1 },
+  "openai/gpt-5-mini":           { "input_per_1k": 0.00025, "output_per_1k": 0.002,  "cached_input_multiplier": 0.1 },
+
+  "gpt-5-nano":                  { "input_per_1k": 0.00005, "output_per_1k": 0.0004, "cached_input_multiplier": 0.1 },
+  "openai/gpt-5-nano":           { "input_per_1k": 0.00005, "output_per_1k": 0.0004, "cached_input_multiplier": 0.1 },
+
+  "gpt-5-chat-latest":           { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+  "openai/gpt-5-chat-latest":    { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+
+  "gpt-5-codex":                 { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+  "openai/gpt-5-codex":          { "input_per_1k": 0.00125, "output_per_1k": 0.01,   "cached_input_multiplier": 0.1 },
+
+  "gpt-4.1":                     { "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+  "openai/gpt-4.1":              { "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+
+  "gpt-4.1-mini":                { "input_per_1k": 0.0004,  "output_per_1k": 0.0016, "cached_input_multiplier": 0.25 },
+  "openai/gpt-4.1-mini":         { "input_per_1k": 0.0004,  "output_per_1k": 0.0016, "cached_input_multiplier": 0.25 },
+
+  "gpt-4.1-nano":                { "input_per_1k": 0.0001,  "output_per_1k": 0.0004, "cached_input_multiplier": 0.25 },
+  "openai/gpt-4.1-nano":         { "input_per_1k": 0.0001,  "output_per_1k": 0.0004, "cached_input_multiplier": 0.25 },
+
+  "gpt-4o":                      { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 0.5 },
+  "openai/gpt-4o":               { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 0.5 },
+
+  "gpt-4o-2024-05-13":           { "input_per_1k": 0.005,   "output_per_1k": 0.015,  "cached_input_multiplier": 1.0 },
+  "openai/gpt-4o-2024-05-13":    { "input_per_1k": 0.005,   "output_per_1k": 0.015,  "cached_input_multiplier": 1.0 },
+
+  "gpt-4o-mini":                 { "input_per_1k": 0.00015, "output_per_1k": 0.0006, "cached_input_multiplier": 0.5 },
+  "openai/gpt-4o-mini":          { "input_per_1k": 0.00015, "output_per_1k": 0.0006, "cached_input_multiplier": 0.5 },
+
+  "gpt-realtime":                { "input_per_1k": 0.004,   "output_per_1k": 0.016,  "cached_input_multiplier": 0.1 },
+  "openai/gpt-realtime":         { "input_per_1k": 0.004,   "output_per_1k": 0.016,  "cached_input_multiplier": 0.1 },
+
+  "gpt-4o-realtime-preview":     { "input_per_1k": 0.005,   "output_per_1k": 0.02,   "cached_input_multiplier": 0.5 },
+  "openai/gpt-4o-realtime-preview": { "input_per_1k": 0.005, "output_per_1k": 0.02,  "cached_input_multiplier": 0.5 },
+
+  "gpt-4o-mini-realtime-preview":{ "input_per_1k": 0.0006,  "output_per_1k": 0.0024, "cached_input_multiplier": 0.5 },
+  "openai/gpt-4o-mini-realtime-preview": { "input_per_1k": 0.0006, "output_per_1k": 0.0024, "cached_input_multiplier": 0.5 },
+
+  "gpt-audio":                   { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 1.0 },
+  "openai/gpt-audio":            { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 1.0 },
+
+  "gpt-4o-audio-preview":        { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 1.0 },
+  "openai/gpt-4o-audio-preview": { "input_per_1k": 0.0025,  "output_per_1k": 0.01,   "cached_input_multiplier": 1.0 },
+
+  "gpt-4o-mini-audio-preview":   { "input_per_1k": 0.00015, "output_per_1k": 0.0006, "cached_input_multiplier": 1.0 },
+  "openai/gpt-4o-mini-audio-preview": { "input_per_1k": 0.00015, "output_per_1k": 0.0006, "cached_input_multiplier": 1.0 },
+
+  "o1":                          { "input_per_1k": 0.015,   "output_per_1k": 0.06,   "cached_input_multiplier": 0.5 },
+  "openai/o1":                   { "input_per_1k": 0.015,   "output_per_1k": 0.06,   "cached_input_multiplier": 0.5 },
+
+  "o1-pro":                      { "input_per_1k": 0.15,    "output_per_1k": 0.6,    "cached_input_multiplier": 1.0 },
+  "openai/o1-pro":               { "input_per_1k": 0.15,    "output_per_1k": 0.6,    "cached_input_multiplier": 1.0 },
+
+  "o3-pro":                      { "input_per_1k": 0.02,    "output_per_1k": 0.08,   "cached_input_multiplier": 1.0 },
+  "openai/o3-pro":               { "input_per_1k": 0.02,    "output_per_1k": 0.08,   "cached_input_multiplier": 1.0 },
+
+  "o3":                          { "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+  "openai/o3":                   { "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+
+  "o3-deep-research":            { "input_per_1k": 0.01,    "output_per_1k": 0.04,   "cached_input_multiplier": 0.25 },
+  "openai/o3-deep-research":     { "input_per_1k": 0.01,    "output_per_1k": 0.04,   "cached_input_multiplier": 0.25 },
+
+  "o4-mini":                     { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.25 },
+  "openai/o4-mini":              { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.25 },
+
+  "o4-mini-deep-research":       { "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+  "openai/o4-mini-deep-research":{ "input_per_1k": 0.002,   "output_per_1k": 0.008,  "cached_input_multiplier": 0.25 },
+
+  "o3-mini":                     { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.5 },
+  "openai/o3-mini":              { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.5 },
+
+  "o1-mini":                     { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.5 },
+  "openai/o1-mini":              { "input_per_1k": 0.0011,  "output_per_1k": 0.0044, "cached_input_multiplier": 0.5 },
+
+  "codex-mini-latest":           { "input_per_1k": 0.0015,  "output_per_1k": 0.006,  "cached_input_multiplier": 0.25 },
+  "openai/codex-mini-latest":    { "input_per_1k": 0.0015,  "output_per_1k": 0.006,  "cached_input_multiplier": 0.25 }
+}