Updates to add the web dashboard plus some minor bug fixes (#192)

* Updates to add the web dashboard plus some minor bug fixes

This commit has 3 changes (sorry for putting more than one per PR):

Major:
- Committing the web dashboard into the repo. It can now be launched with:
`ursa_dashboard` or `ursa_dashboard --host 127.0.0.1 --port 8080`

Sessions are stored in `Path.home() / .cache/ursa_dashboard_workspace`
This seems to work well and while a review would be great, there is definitely some extra stuff
around in it that we should clean out later but should commit now to make the working web
interface available to anyone.

Minor:
- Fix to the dangling tool issue
    - There were still rare but possible reasons to get dangling tools in checkpointing or
      around summarization. This is fixed now for the execution agent: Before invoking the LLM
      the message history is checked for dangling tools and if any exist, a ToolMessage is
      inserted to fix it.
- Plan-Execute workflow has checkpointing switched from SQL to InMemory. We should probably
      change this back in the long run but involves handling the swap between Sync and Async
      checkpointing that we should push down the road.
- Small changes about checking for async tools to allow the web dashboard to work properly with
      MCP tools.

* Update the README with basic web dashboard launch commands.

* Changing dashboard default model and max tokens.

* Update src/ursa/workflows/planning_execution_workflow.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update src/ursa_dashboard/adapters.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update src/ursa_dashboard/api_models.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update src/ursa_dashboard/api_models.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update src/ursa_dashboard/artifacts.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update src/ursa_dashboard/artifacts.py

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update pyproject.toml

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update README.md

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Update README.md

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

* Better name for looping index: msg_ind instead of iii

* Updating comment about dangling tool fix

* Remove trailing whitespace failing ruff check

---------

Co-authored-by: Arthur Lui <5297817+luiarthur@users.noreply.github.com>

Author: mikegros

README.md

@@ -119,6 +119,20 @@ You can get a list of available command line options via
 ursa --help
 ```
 
+### Web Dashboard
+
+The URSA web interface can be launched with:
+```
+ursa-dashboard
+```
+
+or with 
+```
+ursa-dashboard --host 127.0.0.1 --port 8080
+```
+
+This requires installing with the optional `[dashboard]` dependencies.
+
 ### Configuring URSA
 
 See the example [configuration file](./configs/example.yaml) and [documentation](./configs/README.md) for more details.

pyproject.toml

@@ -59,6 +59,7 @@ classifiers = [
 
 [project.scripts]
 ursa = "ursa.cli:main"
+ursa-dashboard = "ursa_dashboard.main:app"
 
 [project.urls]
 Homepage = "https://github.com/lanl/ursa"
@@ -67,6 +68,10 @@ Repository = "https://github.com/lanl/ursa"
 Issues = "https://github.com/lanl/ursa/issues"
 
 [project.optional-dependencies]
+dashboard = [
+    "fastapi>=0.120.0",
+    "uvicorn>=0.37.0",
+]
 fm = [
     "torch>=2.9.0",
 ] # Ursa's MCP FM interface

src/ursa/agents/base.py

@@ -15,6 +15,7 @@
 integration capabilities while only needing to implement the core _invoke method.
 """
 
+import asyncio
 import re
 import sqlite3
 from abc import ABC, abstractmethod
@@ -591,11 +592,74 @@ def _finalize_graph(
         """Hook for subclasses to wrap or modify the compiled graph."""
         return graph_app
 
+    def _tool_is_async_only(self, tool: Any) -> bool:
+        """Return True for tools that can only be invoked asynchronously.
+
+        MCP tools are commonly exposed as StructuredTool instances with a
+        coroutine implementation but no synchronous function implementation.
+        Those raise errors like:
+
+            "StructuredTool does not support sync invocation."
+
+        when called via `.invoke()`.
+        """
+
+        func = getattr(tool, "func", None)
+        coroutine = getattr(tool, "coroutine", None)
+        return func is None and coroutine is not None
+
+    def _has_async_only_tools(self) -> bool:
+        tools_obj = getattr(self, "tools", None)
+        if not tools_obj:
+            return False
+
+        try:
+            tool_iter = (
+                tools_obj.values() if isinstance(tools_obj, dict) else tools_obj
+            )
+        except Exception:
+            return False
+
+        return any(self._tool_is_async_only(t) for t in tool_iter)
+
     def _invoke(self, input, **config):
         config = self.build_config(**config)
-        return self.compiled_graph.invoke(
-            input, config=config, context=self.context
-        )
+
+        # If we have async-only tools (e.g. MCP StructuredTools), we must run the
+        # graph via `ainvoke` so ToolNode dispatches tools asynchronously.
+        if self._has_async_only_tools():
+            try:
+                asyncio.get_running_loop()
+            except RuntimeError:
+                return asyncio.run(
+                    self.compiled_graph.ainvoke(
+                        input, config=config, context=self.context
+                    )
+                )
+
+            raise RuntimeError(
+                "This agent has async-only tools, but `.invoke()` was called "
+                "from an async context (a running event loop was detected). "
+                "Use `await agent.ainvoke(...)` instead."
+            )
+
+        try:
+            return self.compiled_graph.invoke(
+                input, config=config, context=self.context
+            )
+        except Exception as e:
+            # Fallback: if a tool raises the canonical sync-invoke error, retry
+            # with ainvoke for backwards compatibility.
+            if "does not support sync invocation" in str(e):
+                try:
+                    asyncio.get_running_loop()
+                except RuntimeError:
+                    return asyncio.run(
+                        self.compiled_graph.ainvoke(
+                            input, config=config, context=self.context
+                        )
+                    )
+            raise
 
     async def _ainvoke(self, input, **config):
         config = self.build_config(**config)

src/ursa/agents/execution_agent.py

@@ -221,6 +221,44 @@ def __init__(
         self.tokens_before_summarize = tokens_before_summarize
         self.messages_to_keep = messages_to_keep
 
+    def _patch_dangling(self, state: ExecutionState) -> ExecutionState:
+        new_state = deepcopy(state)
+        summarized = False
+        dangling_response = (
+            "Response Not Found from tool. "
+            "May have timed out or been forgotten due to summarization."
+        )
+
+        tool_ids = []
+        for msg in new_state["messages"]:
+            if hasattr(msg, "tool_calls"):
+                for call in msg.tool_calls:
+                    tool_ids.append(call["id"])
+            if isinstance(msg, ToolMessage):
+                tool_ids.remove(msg.tool_call_id)
+        if tool_ids:
+            summarized = True
+            print(
+                f"[Dangling Tool Call Warning] The following tool IDs "
+                f"were dangling:\n{tool_ids}\nReplies of missing response applied."
+            )
+            for tool_id in tool_ids:
+                for msg_ind, msg in enumerate(new_state["messages"]):
+                    if hasattr(msg, "tool_calls"):
+                        if any([tc["id"] == tool_id for tc in msg.tool_calls]):
+                            # Inserts tool response one after the dangling tool call
+                            #    Mutates new_state so break afterward to reset loop.
+                            #    Not as efficient as could be but should be correct
+                            new_state["messages"].insert(
+                                msg_ind + 1,
+                                ToolMessage(
+                                    content=dangling_response,
+                                    tool_call_id=tool_id,
+                                ),
+                            )
+                            break
+        return new_state, summarized
+
     # Check message history length and summarize to shorten the token usage:
     def _summarize_context(self, state: ExecutionState) -> ExecutionState:
         new_state = deepcopy(state)
@@ -357,6 +395,8 @@ def query_executor(
             new_state["symlinkdir"]["is_linked"] = True
             full_overwrite = True
 
+        new_state, full_overwrite = self._patch_dangling(new_state)
+
         # 3) Ensure the executor prompt is the first SystemMessage.
         messages = deepcopy(new_state["messages"])
         if isinstance(messages[0], SystemMessage):
@@ -412,6 +452,7 @@ def recap(self, state: ExecutionState) -> ExecutionState:
         new_state["messages"] = new_state["messages"] + [recap_message]
 
         # 2) Invoke the LLM to generate a recap; capture content even on failure.
+        new_state, full_overwrite = self._patch_dangling(new_state)
         try:
             response = self.llm.invoke(
                 input=new_state["messages"],

src/ursa/util/helperFunctions.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import json
 import uuid
 from typing import Any, Callable, Iterable
@@ -76,9 +77,35 @@ def _stringify_output(x: Any) -> str:
 def _invoke_tool(
     tool: Runnable | Callable[..., Any], args: dict[str, Any]
 ) -> Any:
+    """Invoke a tool from a synchronous context.
+
+    Some tool implementations (notably MCP-adapted tools exposed as
+    StructuredTool instances) are *async-only* and will raise an error like
+    "... does not support sync invocation" when `.invoke()` is used.
+
+    For those tools we fall back to running `.ainvoke()` in a fresh event
+    loop when possible.
+    """
+
     # Runnable (LangChain tools & chains)
     if isinstance(tool, Runnable):
-        return tool.invoke(args)
+        try:
+            return tool.invoke(args)
+        except Exception as e:
+            if "does not support sync invocation" in str(e) and hasattr(
+                tool, "ainvoke"
+            ):
+                try:
+                    asyncio.get_running_loop()
+                except RuntimeError:
+                    return asyncio.run(tool.ainvoke(args))
+
+                raise RuntimeError(
+                    "Async-only tool was invoked from within a running event loop. "
+                    "Use `await tool.ainvoke(...)` (or provide an async caller) instead."
+                ) from e
+            raise
+
     # Plain callable
     try:
         return tool(**args)

src/ursa/workflows/planning_execution_workflow.py

@@ -1,7 +1,4 @@
-import sqlite3
-from pathlib import Path
-
-from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.checkpoint.memory import InMemorySaver
 from rich import get_console
 from rich.panel import Panel
 
@@ -24,14 +21,17 @@ def __init__(self, planner, executor, workspace, **kwargs):
         self.executor = executor
         self.workspace = workspace
 
+        # FIXME: DOES NOT CURRENTLY WORK IN WEB INTERFACE WITH
+        # SQL checkpointing
+        # MOVING TO IN MEMORY CHECKPOINTING FOR NOW
         # Setup checkpointing
-        db_path = Path(workspace) / "checkpoint.db"
-        db_path.parent.mkdir(parents=True, exist_ok=True)
-        conn = sqlite3.connect(str(db_path), check_same_thread=False)
-        checkpointer = SqliteSaver(conn)
+        # db_path = Path(workspace) / "checkpoint.db"
+        # db_path.parent.mkdir(parents=True, exist_ok=True)
+        # conn = sqlite3.connect(str(db_path), check_same_thread=False)
+        # checkpointer = SqliteSaver(conn)
 
-        self.planner.checkpointer = checkpointer
-        self.executor.checkpointer = checkpointer
+        self.planner.checkpointer = InMemorySaver()
+        self.executor.checkpointer = InMemorySaver()
 
     def _invoke(self, task: str, **kw):
         with console.status(

src/ursa_dashboard/__init__.py

@@ -0,0 +1,14 @@
+"""URSA Dashboard package.
+
+This package provides web-dashboard plumbing around URSA agents:
+
+- Agent registry with parameter schemas + capability flags.
+- Adapters to execute heterogeneous agents behind a common interface.
+
+Other dashboard subsystems (run orchestration, SSE streaming, artifact serving)
+should build on the contracts defined in prior steps.
+"""
+
+from .registry import REGISTRY
+
+__all__ = ["REGISTRY"]

src/ursa_dashboard/__main__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())