new: in interactive mode continue after flow complete

Author: evilsocket

nerve/runtime/flow.py

@@ -98,9 +98,11 @@ async def from_path(
 
     async def _setup_if_needed(self, task_override: str | None = None) -> None:
         if self.started_at is None:
+            logger.debug("setting started at")
             self.started_at = time.time()
 
         if self.curr_actor is None:
+            logger.debug(f"setting curr actor to {self.curr_actor_idx}")
             self.curr_actor = self.actors[self.curr_actor_idx]
 
             if task_override:
@@ -112,9 +114,12 @@ async def _setup_if_needed(self, task_override: str | None = None) -> None:
             state.on_task_started(self.curr_actor)
 
     async def step(self) -> None:
+        logger.debug("flow.step")
+
         await self._setup_if_needed()
 
         if self.done():
+            logger.debug("flow done")
             state.on_event("flow_complete", {"steps": self.curr_step, "usage": state.get_usage()})
             return
 
@@ -130,30 +135,39 @@ async def step(self) -> None:
         if state.is_active_task_done():
             logger.debug(f"task {self.curr_actor.runtime.name} complete")  # type: ignore
             self.curr_actor_idx += 1
-            self.curr_actor = None
             state.reset()
 
         self.curr_step += 1
 
     def done(self) -> bool:
         if self.curr_actor_idx >= len(self.actors):
+            logger.debug("all actors done")
             return True
 
         if self.max_steps > 0 and self.curr_step > self.max_steps:
+            logger.debug("max steps reached")
             state.on_max_steps_reached()
             return True
 
         usage = state.get_usage()
         if self.max_cost > 0 and usage.cost is not None and usage.cost > self.max_cost:
+            logger.debug("max cost reached")
             state.on_max_cost_reached()
             return True
 
         if self.timeout is not None and self.started_at is not None and time.time() - self.started_at > self.timeout:
+            logger.debug("timeout reached")
             state.on_timeout()
             return True
 
         return False
 
+    async def _reset(self) -> None:
+        logger.debug("flow reset")
+        state.reset()
+        await self.shell.reset()
+        self.curr_actor_idx = 0
+
     async def run(self, task_override: str | None = None) -> None:
         state.on_event(
             "flow_started",
@@ -165,10 +179,22 @@ async def run(self, task_override: str | None = None) -> None:
 
         while not self.done():
             await self._setup_if_needed(task_override)
+
             if self.curr_actor:
+                logger.debug("interact if needed")
                 await self.shell.interact_if_needed(self.curr_actor)
+            else:
+                logger.debug("no actor, can't interact")
+
             await self.step()
 
+            # in interactive mode, we reset and restart when we're done
+            # to let the user quit or change the task
+            if self.done() and state.is_interactive():
+                await self._reset()
+
+        logger.debug("flow complete")
+
         state.on_event(
             "flow_complete",
             {

nerve/runtime/logging.py

@@ -9,10 +9,6 @@
 from nerve.runtime.events import Event
 
 
-def _log_message_format(record: dict[str, t.Any]) -> str:
-    return "{time} <level>{message}</level>\n"
-
-
 def init(log_path: pathlib.Path | None = None, level: str = "INFO", litellm_debug: bool = False) -> None:
     """
     Initialize the logging system.
@@ -28,7 +24,7 @@ def init(log_path: pathlib.Path | None = None, level: str = "INFO", litellm_debu
         logger.add(
             sys.stdout,
             colorize=True,
-            format=_log_message_format,
+            format="{time} <level>{message}</level>",
             level=level,
         )
 
@@ -142,10 +138,6 @@ def log_event_to_terminal(event: Event) -> None:
         logger.info(f"💬 {colored(data['response'], 'black', 'on_white')}")
 
     elif event.name == "step_started":
-        # avoid logging step usage in interactive mode
-        if state.is_interactive():
-            return
-
         if isinstance(data["usage"], dict):
             data["usage"] = DictWrapper(data["usage"])
 

nerve/runtime/shell.py

@@ -133,15 +133,20 @@ async def _show_welcome(self) -> None:
         print()
         print(colored("👋 Welcome to the interactive shell!", "white", attrs=["bold"]))
         print()
+        await self._handle_view()
         await self._handle_help()
 
-    async def interact_if_needed(self, actor: Agent) -> None:
-        if not state.is_interactive() or self._keep_going:
-            return
+    async def reset(self) -> None:
+        logger.debug("shell reset")
+        self._keep_going = False
 
+    async def interact_if_needed(self, actor: Agent) -> None:
         # wait for all events to be logged
         state.wait_for_events_logs()
 
+        if not state.is_interactive() or self._keep_going:
+            return
+
         # show the welcome message if this is the first step
         if self._first_step:
             self._first_step = False
@@ -157,6 +162,8 @@ async def interact_if_needed(self, actor: Agent) -> None:
             logger.debug(f"unhandled command: {command}")
             # add the command to the conversation
             actor.add_extra_message(command)
+            # continue until complete
+            self._keep_going = True
         elif not done:
             # keep running the interaction shell
             await self.interact_if_needed(actor)

nerve/runtime/state.py

@@ -362,7 +362,6 @@ def reset() -> None:
     global _task_status, _reason, _knowledge
     _task_status = Status.RUNNING
     _reason = None
-    _knowledge = {}
 
 
 def on_user_input_needed(input_name: str, prompt: str) -> str: