langroid 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

langroid/agent/base.py

@@ -344,7 +344,7 @@ class Agent(ABC):
             return results
         if not settings.quiet:
             console.print(f"[red]{self.indent}", end="")
-            print(f"[red]Agent: {results}")
+            print(f"[red]Agent: {escape(results)}")
             maybe_json = len(extract_top_level_json(results)) > 0
             self.callbacks.show_agent_response(
                 content=results,
@@ -409,14 +409,12 @@ class Agent(ABC):
             isinstance(msg, ChatDocument) and msg.metadata.recipient == Entity.USER
         )
 
-        interactive = (
-            self.interactive if self.interactive is not None else settings.interactive
-        )
-        if self.default_human_response is not None and not need_human_response:
-            # useful for automated testing
-            user_msg = self.default_human_response
-        elif not interactive and not need_human_response:
+        interactive = self.interactive or settings.interactive
+
+        if not interactive and not need_human_response:
             return None
+        elif self.default_human_response is not None:
+            user_msg = self.default_human_response
         else:
             if self.callbacks.get_user_response is not None:
                 # ask user with empty prompt: no need for prompt

langroid/agent/chat_agent.py

@@ -857,7 +857,7 @@ class ChatAgent(Agent):
             # we won't have citations yet, so we're done
             return
         if response.metadata.has_citation and not settings.quiet:
-            print("[grey37]SOURCES:\n" + response.metadata.source + "[/grey37]")
+            print("[grey37]SOURCES:\n" + escape(response.metadata.source) + "[/grey37]")
             self.callbacks.show_llm_response(
                 content=str(response.metadata.source),
                 is_tool=False,

langroid/agent/chat_document.py

@@ -36,7 +36,8 @@ class StatusCode(str, Enum):
     STALLED = "STALLED"
     INF_LOOP = "INF_LOOP"
     KILL = "KILL"
-    MAX_TURNS = "MAX_TURNS"
+    FIXED_TURNS = "FIXED_TURNS"  # reached intended number of turns
+    MAX_TURNS = "MAX_TURNS"  # hit max-turns limit
     MAX_COST = "MAX_COST"
     MAX_TOKENS = "MAX_TOKENS"
     TIMEOUT = "TIMEOUT"

langroid/agent/task.py

@@ -5,6 +5,7 @@ import copy
 import logging
 import threading
 from collections import Counter, deque
+from pathlib import Path
 from types import SimpleNamespace
 from typing import (
     Any,
@@ -39,6 +40,7 @@ from langroid.parsing.routing import parse_addressed_message
 from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.utils.constants import (
+    AT,  # regex for start of an addressed recipient e.g. "@"
     DONE,
     NO_ANSWER,
     PASS,
@@ -77,6 +79,7 @@ class TaskConfig(BaseModel):
     inf_loop_dominance_factor: float = 1.5
     inf_loop_wait_factor: int = 5
     restart_as_subtask: bool = False
+    logs_dir: str = "logs"
 
 
 class Task:
@@ -124,13 +127,14 @@ class Task:
         restart: bool = True,
         default_human_response: Optional[str] = None,
         interactive: bool = True,
-        only_user_quits_root: bool = False,
+        only_user_quits_root: bool = True,
         erase_substeps: bool = False,
-        allow_null_result: bool = True,
+        allow_null_result: bool = False,
         max_stalled_steps: int = 5,
         done_if_no_response: List[Responder] = [],
         done_if_response: List[Responder] = [],
         config: TaskConfig = TaskConfig(),
+        **kwargs: Any,  # catch-all for any legacy params, for backwards compatibility
     ):
         """
         A task to be performed by an agent.
@@ -139,23 +143,29 @@ class Task:
             agent (Agent): agent associated with the task
             name (str): name of the task
             llm_delegate (bool):
-                [Deprecated, not used; use `done_if_response`, `done_if_no_response`
-                instead]
-                Whether to delegate control to LLM; conceptually,
+                Whether to delegate "control" to LLM; conceptually,
                 the "controlling entity" is the one "seeking" responses to its queries,
-                and has a goal it is aiming to achieve. The "controlling entity" is
-                either the LLM or the USER. (Note within a Task there is just one
+                and has a goal it is aiming to achieve, and decides when a task is done.
+                The "controlling entity" is either the LLM or the USER.
+                (Note within a Task there is just one
                 LLM, and all other entities are proxies of the "User" entity).
+                See also: `done_if_response`, `done_if_no_response` for more granular
+                control of task termination.
             single_round (bool):
-                [Deprecated: Use `done_if_response`, `done_if_no_response` instead].
-                If true, task runs until one message by controller,
-                and subsequent response by non-controller. If false, runs for the
-                specified number of turns in `run`, or until `done()` is true.
+                If true, task runs until one message by "controller"
+                (i.e. LLM if `llm_delegate` is true, otherwise USER)
+                and subsequent response by non-controller [When a tool is involved,
+                this will not give intended results. See `done_if_response`,
+                `done_if_no_response` below].
+                termination]. If false, runs for the specified number of turns in
+                `run`, or until `done()` is true.
                 One run of step() is considered a "turn".
+                See also: `done_if_response`, `done_if_no_response` for more granular
+                control of task termination.
             system_message (str): if not empty, overrides agent's system_message
             user_message (str): if not empty, overrides agent's user_message
             restart (bool): if true, resets the agent's message history *at every run*.
-            default_human_response (str): default response from user; useful for
+            default_human_response (str|None): default response from user; useful for
                 testing, to avoid interactive input from user.
                 [Instead of this, setting `interactive` usually suffices]
             interactive (bool): if true, wait for human input after each non-human
@@ -166,18 +176,26 @@ class Task:
                 case the system will wait for a user response. In other words, use
                 `interactive=False` when you want a "largely non-interactive"
                 run, with the exception of explicit user addressing.
-            only_user_quits_root (bool): if true, only user can quit the root task.
-                [This param is ignored & deprecated; Keeping for backward compatibility.
-                Instead of this, setting `interactive` suffices]
+            only_user_quits_root (bool): if true, when interactive=True, only user can
+                quit the root task (Ignored when interactive=False).
             erase_substeps (bool): if true, when task completes, erase intermediate
                 conversation with subtasks from this agent's `message_history`, and also
                 erase all subtask agents' `message_history`.
                 Note: erasing can reduce prompt sizes, but results in repetitive
                 sub-task delegation.
-            allow_null_result (bool): [Deprecated, may be removed in future.]
-                If true, allow null (empty or NO_ANSWER)
-                as the result of a step or overall task result.
-                Optional, default is True.
+            allow_null_result (bool):
+                If true, create dummy NO_ANSWER response when no valid response is found
+                in a step.
+                Optional, default is False.
+                *Note:* In non-interactive mode, when this is set to True,
+                you can have a situation where an LLM generates (non-tool) text,
+                and no other responders have valid responses, and a "Null result"
+                is inserted as a dummy response from the User entity, so the LLM
+                will now respond to this Null result, and this will continue
+                until the LLM emits a DONE signal (if instructed to do so),
+                otherwise langroid detects a potential infinite loop after
+                a certain number of such steps (= `TaskConfig.inf_loop_wait_factor`)
+                and will raise an InfiniteLoopException.
             max_stalled_steps (int): task considered done after this many consecutive
                 steps with no progress. Default is 3.
             done_if_no_response (List[Responder]): consider task done if NULL
@@ -234,36 +252,32 @@ class Task:
         self.tsv_logger: None | logging.Logger = None
         self.color_log: bool = False if settings.notebook else True
 
-        self.step_progress = False  # progress in current step?
         self.n_stalled_steps = 0  # how many consecutive steps with no progress?
+        # how many 2-step-apart alternations of no_answer step-result have we had,
+        # i.e. x1, N/A, x2, N/A, x3, N/A ...
+        self.n_no_answer_alternations = 0
+        self._no_answer_step: int = -1
+        self._step_idx = -1  # current step index
         self.max_stalled_steps = max_stalled_steps
         self.done_if_response = [r.value for r in done_if_response]
         self.done_if_no_response = [r.value for r in done_if_no_response]
         self.is_done = False  # is task done (based on response)?
         self.is_pass_thru = False  # is current response a pass-thru?
-        self.task_progress = False  # progress in current task (since run or run_async)?
         if name:
             # task name overrides name in agent config
             agent.config.name = name
         self.name = name or agent.config.name
         self.value: str = self.name
 
-        if default_human_response is not None and default_human_response == "":
-            interactive = False
-        self.interactive = interactive
-        self.agent.interactive = interactive
-        self.message_history_idx = -1
-        if interactive:
-            only_user_quits_root = True
-        else:
-            default_human_response = default_human_response or ""
-            only_user_quits_root = False
+        self.default_human_response = default_human_response
         if default_human_response is not None:
+            # only override agent's default_human_response if it is explicitly set
             self.agent.default_human_response = default_human_response
-        self.default_human_response = default_human_response
-        if self.interactive:
-            self.agent.default_human_response = None
+        self.interactive = interactive
+        self.agent.interactive = interactive
         self.only_user_quits_root = only_user_quits_root
+        self.message_history_idx = -1
+
         # set to True if we want to collapse multi-turn conversation with sub-tasks into
         # just the first outgoing message and last incoming message.
         # Note this also completely erases sub-task agents' message_history.
@@ -300,17 +314,16 @@ class Task:
         self.turns = -1  # no limit
         self.llm_delegate = llm_delegate
         if llm_delegate:
-            self.controller = Entity.LLM
             if self.single_round:
                 # 0: User instructs (delegating to LLM);
-                # 1: LLM asks;
+                # 1: LLM (as the Controller) asks;
                 # 2: user replies.
                 self.turns = 2
         else:
-            self.controller = Entity.USER
             if self.single_round:
-                self.turns = 1  # 0: User asks, 1: LLM replies.
-
+                # 0: User (as Controller) asks,
+                # 1: LLM replies.
+                self.turns = 1
         # other sub_tasks this task can delegate to
         self.sub_tasks: List[Task] = []
         self.caller: Task | None = None  # which task called this task's `run` method
@@ -521,12 +534,18 @@ class Task:
         if self.caller is not None and self.caller.logger is not None:
             self.logger = self.caller.logger
         else:
-            self.logger = RichFileLogger(f"logs/{self.name}.log", color=self.color_log)
+            self.logger = RichFileLogger(
+                str(Path(self.config.logs_dir) / f"{self.name}.log"),
+                color=self.color_log,
+            )
 
         if self.caller is not None and self.caller.tsv_logger is not None:
             self.tsv_logger = self.caller.tsv_logger
         else:
-            self.tsv_logger = setup_file_logger("tsv_logger", f"logs/{self.name}.tsv")
+            self.tsv_logger = setup_file_logger(
+                "tsv_logger",
+                str(Path(self.config.logs_dir) / f"{self.name}.tsv"),
+            )
             header = ChatDocLoggerFields().tsv_header()
             self.tsv_logger.info(f" \tTask\tResponder\t{header}")
 
@@ -559,8 +578,10 @@ class Task:
             # so reset own agent and recursively for all sub-tasks
             self.reset_all_sub_tasks()
 
-        self.task_progress = False
         self.n_stalled_steps = 0
+        self._no_answer_step = -1  # last step where the best explicit response was N/A
+        # how many N/A alternations have we had so far? (for Inf loop detection)
+        self.n_no_answer_alternations = 0
         self.max_cost = max_cost
         self.max_tokens = max_tokens
         self.session_id = session_id
@@ -588,6 +609,7 @@ class Task:
         turns = self.turns if turns < 0 else turns
         i = 0
         while True:
+            self._step_idx = i  # used in step() below
             self.step()
             done, status = self.done()
             if done:
@@ -601,7 +623,17 @@ class Task:
                 else max(turns, settings.max_turns)
             )
             if max_turns > 0 and i >= max_turns:
-                status = StatusCode.MAX_TURNS
+                # Important to distinguish between:
+                # (a) intentional run for a
+                #     fixed number of turns, where we expect the pending message
+                #     at that stage to be the desired result, and
+                # (b) hitting max_turns limit, which is not intentional, and is an
+                #     exception, resulting in a None task result
+                status = (
+                    StatusCode.MAX_TURNS
+                    if i == settings.max_turns
+                    else StatusCode.FIXED_TURNS
+                )
                 break
             if (
                 self.config.inf_loop_cycle_len > 0
@@ -617,9 +649,7 @@ class Task:
                     """
                 )
 
-        final_result = self.result()
-        if final_result is not None:
-            final_result.metadata.status = status
+        final_result = self.result(status)
         self._post_run_loop()
         return final_result
 
@@ -673,8 +703,10 @@ class Task:
             # so reset own agent and recursively for all sub-tasks
             self.reset_all_sub_tasks()
 
-        self.task_progress = False
         self.n_stalled_steps = 0
+        self._no_answer_step = -1  # last step where the best explicit response was N/A
+        # how many N/A alternations have we had so far? (for Inf loop detection)
+        self.n_no_answer_alternations = 0
         self.max_cost = max_cost
         self.max_tokens = max_tokens
         self.session_id = session_id
@@ -698,6 +730,7 @@ class Task:
         turns = self.turns if turns < 0 else turns
         i = 0
         while True:
+            self._step_idx = i  # used in step() below
             await self.step_async()
             await asyncio.sleep(0.01)  # temp yield to avoid blocking
             done, status = self.done()
@@ -712,7 +745,17 @@ class Task:
                 else max(turns, settings.max_turns)
             )
             if max_turns > 0 and i >= max_turns:
-                status = StatusCode.MAX_TURNS
+                # Important to distinguish between:
+                # (a) intentional run for a
+                #     fixed number of turns, where we expect the pending message
+                #     at that stage to be the desired result, and
+                # (b) hitting max_turns limit, which is not intentional, and is an
+                #     exception, resulting in a None task result
+                status = (
+                    StatusCode.MAX_TURNS
+                    if i == settings.max_turns
+                    else StatusCode.FIXED_TURNS
+                )
                 break
             if (
                 self.config.inf_loop_cycle_len > 0
@@ -728,9 +771,7 @@ class Task:
                     """
                 )
 
-        final_result = self.result()
-        if final_result is not None:
-            final_result.metadata.status = status
+        final_result = self.result(status)
         self._post_run_loop()
         return final_result
 
@@ -744,9 +785,6 @@ class Task:
         self.init(msg)
         # sets indentation to be printed prior to any output from agent
         self.agent.indent = self._indent
-        if self.default_human_response is not None:
-            self.agent.default_human_response = self.default_human_response
-
         self.message_history_idx = -1
         if isinstance(self.agent, ChatAgent):
             # mark where we are in the message history, so we can reset to this when
@@ -820,7 +858,6 @@ class Task:
         `step_async()`. Consider refactoring to avoid duplication.
         """
         self.is_done = False
-        self.step_progress = False
         parent = self.pending_message
         recipient = (
             ""
@@ -860,6 +897,8 @@ class Task:
             responders.insert(0, Entity.USER)
 
         found_response = False
+        # (responder, result) from a responder who explicitly said NO_ANSWER
+        no_answer_response: None | Tuple[Responder, ChatDocument] = None
         for r in responders:
             self.is_pass_thru = False
             if not self._can_respond(r):
@@ -879,6 +918,8 @@ class Task:
                 continue
             self.human_tried = r == Entity.USER
             result = self.response(r, turns)
+            if result and NO_ANSWER in result.content:
+                no_answer_response = (r, result)
             self.is_done = self._is_done_response(result, r)
             self.is_pass_thru = PASS in result.content if result else False
             if self.valid(result, r):
@@ -891,8 +932,15 @@ class Task:
             if self.is_done:
                 # skip trying other responders in this step
                 break
-        if not found_response:
-            self._process_invalid_step_result(parent)
+        if not found_response:  # did not find a Non-NO_ANSWER response
+            if no_answer_response:
+                # even though there was no valid response from anyone in this step,
+                # if there was at least one who EXPLICITLY said NO_ANSWER, then
+                # we process that as a valid response.
+                r, result = no_answer_response
+                self._process_valid_responder_result(r, parent, result)
+            else:
+                self._process_invalid_step_result(parent)
         self._show_pending_message_if_debug()
         return self.pending_message
 
@@ -918,7 +966,6 @@ class Task:
                 different context.
         """
         self.is_done = False
-        self.step_progress = False
         parent = self.pending_message
         recipient = (
             ""
@@ -956,6 +1003,8 @@ class Task:
             responders.insert(0, Entity.USER)
 
         found_response = False
+        # (responder, result) from a responder who explicitly said NO_ANSWER
+        no_answer_response: None | Tuple[Responder, ChatDocument] = None
         for r in responders:
             if not self._can_respond(r):
                 # create dummy msg for logging
@@ -974,6 +1023,8 @@ class Task:
                 continue
             self.human_tried = r == Entity.USER
             result = await self.response_async(r, turns)
+            if result and NO_ANSWER in result.content:
+                no_answer_response = (r, result)
             self.is_done = self._is_done_response(result, r)
             self.is_pass_thru = PASS in result.content if result else False
             if self.valid(result, r):
@@ -987,10 +1038,32 @@ class Task:
                 # skip trying other responders in this step
                 break
         if not found_response:
-            self._process_invalid_step_result(parent)
+            if no_answer_response:
+                # even though there was no valid response from anyone in this step,
+                # if there was at least one who EXPLICITLY said NO_ANSWER, then
+                # we process that as a valid response.
+                r, result = no_answer_response
+                self._process_valid_responder_result(r, parent, result)
+            else:
+                self._process_invalid_step_result(parent)
         self._show_pending_message_if_debug()
         return self.pending_message
 
+    def _update_no_answer_vars(self, result: ChatDocument) -> None:
+        """Update variables related to NO_ANSWER responses, to aid
+        in alternating NO_ANSWER infinite-loop detection."""
+
+        if NO_ANSWER in result.content:
+            if self._no_answer_step == self._step_idx - 2:
+                # N/A two steps ago
+                self.n_no_answer_alternations += 1
+            else:
+                # reset alternations counter
+                self.n_no_answer_alternations = 0
+
+            # record the last step where the best explicit response was N/A
+            self._no_answer_step = self._step_idx
+
     def _process_valid_responder_result(
         self,
         r: Responder,
@@ -999,6 +1072,8 @@ class Task:
     ) -> None:
         """Processes valid result from a responder, during a step"""
 
+        self._update_no_answer_vars(result)
+
         # pending_sender is of type Responder,
         # i.e. it is either one of the agent's entities
         # OR a sub-task, that has produced a valid response.
@@ -1026,8 +1101,6 @@ class Task:
             parent.metadata.child_id = result.id()
 
         self.log_message(self.pending_sender, result, mark=True)
-        self.step_progress = True
-        self.task_progress = True
         if self.is_pass_thru:
             self.n_stalled_steps += 1
         else:
@@ -1049,11 +1122,13 @@ class Task:
            parent (ChatDocument|None): parent message of the current message
         """
         self.n_stalled_steps += 1
-        if (not self.task_progress or self.allow_null_result) and not self.is_pass_thru:
-            # There has been no progress at all in this task, so we
-            # update the pending_message to a dummy NO_ANSWER msg
+        if self.allow_null_result and not self.is_pass_thru:
+            # Null step-result is allowed, and we're not in a "pass-thru" situation,
+            # so we update the pending_message to a dummy NO_ANSWER msg
             # from the entity 'opposite' to the current pending_sender,
-            # so we show "progress" and avoid getting stuck in an infinite loop.
+            # so that the task can continue.
+            # CAUTION: unless the LLM is instructed to signal DONE at an appropriate
+            # time, this can result in an infinite loop.
             responder = (
                 Entity.LLM if self.pending_sender == Entity.USER else Entity.USER
             )
@@ -1063,6 +1138,7 @@ class Task:
                 metadata=ChatDocMetaData(sender=responder, parent_id=parent_id),
             )
             self.pending_sender = responder
+            self._update_no_answer_vars(self.pending_message)
         self.log_message(self.pending_sender, self.pending_message, mark=True)
 
     def _show_pending_message_if_debug(self) -> None:
@@ -1092,7 +1168,9 @@ class Task:
                 max_cost=self.max_cost,
                 max_tokens=self.max_tokens,
             )
-            result_str = str(ChatDocument.to_LLMMessage(result))
+            result_str = (  # only used by callback to display content and possible tool
+                "NONE" if result is None else str(ChatDocument.to_LLMMessage(result))
+            )
             maybe_tool = len(extract_top_level_json(result_str)) > 0
             self.callbacks.show_subtask_response(
                 task=e,
@@ -1180,16 +1258,23 @@ class Task:
             result = await response_fn(self.pending_message)
         return self._process_result_routing(result)
 
-    def result(self) -> ChatDocument:
+    def result(self, status: StatusCode | None = None) -> ChatDocument | None:
         """
         Get result of task. This is the default behavior.
         Derived classes can override this.
 
         Note the result of a task is returned as if it is from the User entity.
 
+        Args:
+            status (StatusCode): status of the task when it ended
         Returns:
             ChatDocument: result of task
         """
+        if status in [StatusCode.STALLED, StatusCode.MAX_TURNS, StatusCode.INF_LOOP]:
+            # In these case we don't know (and don't want to try to guess)
+            # what the task result should be, so we return None
+            return None
+
         result_msg = self.pending_message
 
         content = result_msg.content if result_msg else ""
@@ -1201,7 +1286,6 @@ class Task:
         block = result_msg.metadata.block if result_msg else None
         recipient = result_msg.metadata.recipient if result_msg else ""
         tool_ids = result_msg.metadata.tool_ids if result_msg else []
-        status = result_msg.metadata.status if result_msg else None
 
         # regardless of which entity actually produced the result,
         # when we return the result, we set entity to USER
@@ -1214,7 +1298,7 @@ class Task:
                 source=Entity.USER,
                 sender=Entity.USER,
                 block=block,
-                status=status,
+                status=status or (result_msg.metadata.status if result_msg else None),
                 sender_name=self.name,
                 recipient=recipient,
                 tool_ids=tool_ids,
@@ -1270,13 +1354,20 @@ class Task:
     def _maybe_infinite_loop(self) -> bool:
         """
         Detect possible infinite loop based on message frequencies.
-        NOTE: This only (attempts to) detect "exact" loops, i.e. a cycle
-        of messages that repeats exactly, e.g.
+        NOTE: This detects two types of loops:
+        - Alternating NO_ANSWER loops, specifically of the form
+        x1 NO_ANSWER x2 NO_ANSWER x3 NO_ANSWER...
+        (e.g. an LLM repeatedly saying something different, and another responder
+        or sub-task saying NO_ANSWER -- i.e. "DO-NOT-KNOW")
+
+        - "exact" loops, i.e. a cycle of messages that repeats exactly, e.g.
         a r b i t r a t e r a t e r a t e r a t e ...
 
-        [It does not detect "approximate" loops, where the LLM is generating a
-        sequence of messages that are similar, but not exactly the same.]
+        [It does not detect more general "approximate" loops, where two entities are
+        responding to each other potentially forever, with (slightly) different
+        messages each time]
 
+        Here is the logic for the exact-loop detection:
         Intuition: when you look at a sufficiently long sequence with an m-message
         loop, then the frequencies of these m messages will "dominate" those
         of all other messages.
@@ -1294,6 +1385,9 @@ class Task:
            If the set of last (W * m) messages are the same as the
            set of m dominant messages,  then we are likely in a loop.
         """
+        if self.n_no_answer_alternations > self.config.inf_loop_wait_factor:
+            return True
+
         max_cycle_len = self.config.inf_loop_cycle_len
         if max_cycle_len <= 0:
             # no loop detection
@@ -1362,8 +1456,8 @@ class Task:
             and result.content in USER_QUIT_STRINGS
             and result.metadata.sender == Entity.USER
         )
-        if self._level == 0 and self.only_user_quits_root:
-            # for top-level task, only user can quit out
+        if self._level == 0 and self.interactive and self.only_user_quits_root:
+            # for top-level task, in interactive mode, only user can quit out
             return (user_quit, StatusCode.USER_QUIT if user_quit else StatusCode.OK)
 
         if self.is_done:
@@ -1405,11 +1499,6 @@ class Task:
                 and self.caller.name != ""
                 and result.metadata.recipient == self.caller.name
             )
-            # or (
-            #     # Task controller is "stuck", has nothing to say
-            #     NO_ANSWER in result.content
-            #     and result.metadata.sender == self.controller
-            # )
             or user_quit
         )
         return (final, StatusCode.OK)
@@ -1591,7 +1680,6 @@ def parse_routing(
             return True, addressee, None
         else:
             return False, addressee, content_to_send
-    AT = "@"
     if (
         AT in content
         and (addressee_content := parse_addressed_message(content, AT))[0] is not None

langroid/agent/tools/rewind_tool.py

@@ -82,8 +82,9 @@ class RewindTool(ToolMessage):
             cls(n=1, content="What are the 3 major causes of heart disease?"),
             (
                 """
-                I want to change my 2nd message to Bob, to say 
-                'who wrote the book Grime and Banishment?'
+                Based on the conversation so far, I realize I would get a better
+                response from Bob if rephrase my 2nd message to him to: 
+                'Who wrote the book Grime and Banishment?'
                 """,
                 cls(n=2, content="who wrote the book 'Grime and Banishment'?"),
             ),

langroid/language_models/mock_lm.py

@@ -1,12 +1,16 @@
 """Mock Language Model for testing"""
 
-from typing import Dict, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union
 
 import langroid.language_models as lm
 from langroid.language_models import LLMResponse
 from langroid.language_models.base import LanguageModel, LLMConfig
 
 
+def none_fn(x: str) -> None | str:
+    return None
+
+
 class MockLMConfig(LLMConfig):
     """
     Mock Language Model Configuration.
@@ -17,7 +21,9 @@ class MockLMConfig(LLMConfig):
     """
 
     response_dict: Dict[str, str] = {}
+    response_fn: Callable[[str], None | str] = none_fn
     default_response: str = "Mock response"
+
     type: str = "mock"
 
 
@@ -27,6 +33,19 @@ class MockLM(LanguageModel):
         super().__init__(config)
         self.config: MockLMConfig = config
 
+    def _response(self, msg: str) -> LLMResponse:
+        # response is based on this fallback order:
+        # - response_dict
+        # - response_fn
+        # - default_response
+        return lm.LLMResponse(
+            message=self.config.response_dict.get(
+                msg,
+                self.config.response_fn(msg) or self.config.default_response,
+            ),
+            cached=False,
+        )
+
     def chat(
         self,
         messages: Union[str, List[lm.LLMMessage]],
@@ -38,13 +57,7 @@ class MockLM(LanguageModel):
         Mock chat function for testing
         """
         last_msg = messages[-1].content if isinstance(messages, list) else messages
-        return lm.LLMResponse(
-            message=self.config.response_dict.get(
-                last_msg,
-                self.config.default_response,
-            ),
-            cached=False,
-        )
+        return self._response(last_msg)
 
     async def achat(
         self,
@@ -57,37 +70,19 @@ class MockLM(LanguageModel):
         Mock chat function for testing
         """
         last_msg = messages[-1].content if isinstance(messages, list) else messages
-        return lm.LLMResponse(
-            message=self.config.response_dict.get(
-                last_msg,
-                self.config.default_response,
-            ),
-            cached=False,
-        )
+        return self._response(last_msg)
 
     def generate(self, prompt: str, max_tokens: int = 200) -> lm.LLMResponse:
         """
         Mock generate function for testing
         """
-        return lm.LLMResponse(
-            message=self.config.response_dict.get(
-                prompt,
-                self.config.default_response,
-            ),
-            cached=False,
-        )
+        return self._response(prompt)
 
     async def agenerate(self, prompt: str, max_tokens: int = 200) -> LLMResponse:
         """
         Mock generate function for testing
         """
-        return lm.LLMResponse(
-            message=self.config.response_dict.get(
-                prompt,
-                self.config.default_response,
-            ),
-            cached=False,
-        )
+        return self._response(prompt)
 
     def get_stream(self) -> bool:
         return False

langroid/utils/constants.py

@@ -13,10 +13,11 @@ class Colors(BaseModel):
     RESET: str = "\033[0m"
 
 
-USER_QUIT_STRINGS = ["q", "x", "quit", "exit", "bye"]
 NO_ANSWER = "DO-NOT-KNOW"
 DONE = "DONE"
+USER_QUIT_STRINGS = ["q", "x", "quit", "exit", "bye", DONE]
 PASS = "__PASS__"
 PASS_TO = PASS + ":"
 SEND_TO = "SEND:"
 TOOL = "TOOL"
+AT = "@"

{langroid-0.2.0.dist-info → langroid-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.2.0
+Version: 0.2.3
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -36,7 +36,7 @@ Provides-Extra: vecdbs
 Requires-Dist: aiohttp (>=3.9.1,<4.0.0)
 Requires-Dist: async-generator (>=1.10,<2.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.2)
-Requires-Dist: chainlit (>=1.0.400,<2.0.0) ; extra == "all" or extra == "chainlit"
+Requires-Dist: chainlit (==1.1.202) ; extra == "all" or extra == "chainlit"
 Requires-Dist: chromadb (>=0.4.21,<=0.4.23) ; extra == "vecdbs" or extra == "all" or extra == "chromadb"
 Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: docstring-parser (>=0.15,<0.16)
@@ -226,6 +226,10 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Jun 2024:**
+  - **0.2.0:** Improved lineage tracking, granular sub-task configs, and a new tool, `RewindTool`, 
+    that lets an agent "rewind and redo" a past message (and all dependent messages are cleared out 
+    thanks to the lineage tracking). Read notes [here](https://github.com/langroid/langroid/releases/tag/0.2.0).
 - **May 2024:** 
   - **Slimmer langroid**: All document-parsers (i.e. pdf, doc, docx) and most 
     vector-databases (except qdrant) 

{langroid-0.2.0.dist-info → langroid-0.2.3.dist-info}/RECORD

@@ -1,11 +1,11 @@
 langroid/__init__.py,sha256=z_fCOLQJPOw3LLRPBlFB5-2HyCjpPgQa4m4iY5Fvb8Y,1800
 langroid/agent/__init__.py,sha256=ll0Cubd2DZ-fsCMl7e10hf9ZjFGKzphfBco396IKITY,786
-langroid/agent/base.py,sha256=rqkf5FN1jO7IGqa_bvnQc37d8LZRal1RHVJe0Dvtlsc,37680
+langroid/agent/base.py,sha256=eeYZ-NYbrepOjUVQS9K0nDhE8x2gKUNjgxFTA24mook,37560
 langroid/agent/batch.py,sha256=feRA_yRG768ElOQjrKEefcRv6Aefd_yY7qktuYUQDwc,10040
 langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/callbacks/chainlit.py,sha256=UKG2_v4ktfkEaGvdouVRHEqQejEYya2Rli8jrP65TmA,22055
-langroid/agent/chat_agent.py,sha256=eRTrTjGlu36gTbdBLbQ5M5EtBMIcdEc9bjgMLTa40oQ,41506
-langroid/agent/chat_document.py,sha256=8yH7o0aMVtUDHh3InpEErjhlY6t4Lr6KQzBrAKcYsEM,11141
+langroid/agent/chat_agent.py,sha256=nO6Yx5WvFsul5RmTP-HCdzeQPhccmzU_mDcPNdkzQ-s,41514
+langroid/agent/chat_document.py,sha256=MwtNABK28tfSzqCeQlxoauT8uPn8oldU7dlnrX8aQ10,11232
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
 langroid/agent/openai_assistant.py,sha256=rmGJD5n0eE7_O1EkPyXgHFMNGc3vb2GKweZMhzmRWvI,33068
@@ -32,7 +32,7 @@ langroid/agent/special/sql/utils/populate_metadata.py,sha256=1J22UsyEPKzwK0XlJZt
 langroid/agent/special/sql/utils/system_message.py,sha256=qKLHkvQWRQodTtPLPxr1GSLUYUFASZU8x-ybV67cB68,1885
 langroid/agent/special/sql/utils/tools.py,sha256=vFYysk6Vi7HJjII8B4RitA3pt_z3gkSglDNdhNVMiFc,1332
 langroid/agent/special/table_chat_agent.py,sha256=d9v2wsblaRx7oMnKhLV7uO_ujvk9gh59pSGvBXyeyNc,9659
-langroid/agent/task.py,sha256=ZTnG8h214FF3Vm54Eyl37j5OzKIHc313QbiUkMlofwM,67091
+langroid/agent/task.py,sha256=ALqGmqzqUNaZB3u8jReBcsC8rRti3WqsN82EMm4CFAo,72189
 langroid/agent/tool_message.py,sha256=wIyZnUcZpxkiRPvM9O3MO3b5BBAdLEEan9kqPbvtApc,9743
 langroid/agent/tools/__init__.py,sha256=e-63cfwQNk_ftRKQwgDAJQK16QLbRVWDBILeXIc7wLk,402
 langroid/agent/tools/duckduckgo_search_tool.py,sha256=NhsCaGZkdv28nja7yveAhSK_w6l_Ftym8agbrdzqgfo,1935
@@ -42,7 +42,7 @@ langroid/agent/tools/google_search_tool.py,sha256=y7b-3FtgXf0lfF4AYxrZ3K5pH2dhid
 langroid/agent/tools/metaphor_search_tool.py,sha256=qj4gt453cLEX3EGW7nVzVu6X7LCdrwjSlcNY0qJW104,2489
 langroid/agent/tools/recipient_tool.py,sha256=NrLxIeQT-kbMv7AeYX0uqvGeMK4Q3fIDvG15OVzlgk8,9624
 langroid/agent/tools/retrieval_tool.py,sha256=2q2pfoYbZNfbWQ0McxrtmfF0ekGglIgRl-6uF26pa-E,871
-langroid/agent/tools/rewind_tool.py,sha256=aeu35_OjmCDTCgWH6nn8noXIC7ACD7-Rh-qh36wnBOg,5516
+langroid/agent/tools/rewind_tool.py,sha256=G4DiXuOt2nQ2fU7qvtJMdLyyf-rK7RZwLsFxsAUfk-Y,5606
 langroid/agent/tools/run_python_code.py,sha256=BvoxYzzHijU-p4703n2iVlt5BCieR1oMSy50w0tQZAg,1787
 langroid/agent/tools/segment_extract_tool.py,sha256=__srZ_VGYLVOdPrITUM8S0HpmX4q7r5FHWMDdHdEv8w,1440
 langroid/agent_config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -65,7 +65,7 @@ langroid/language_models/__init__.py,sha256=vrBtgR8Cq9UVfoI7nTms0IN7fd4y2JYpUP3G
 langroid/language_models/azure_openai.py,sha256=ncRCbKooqLVOY-PWQUIo9C3yTuKEFbAwyngXT_M4P7k,5989
 langroid/language_models/base.py,sha256=aVptuo_LpymIQFpJh836lcFCUpJNOV3ukxvQAQMCqFc,17426
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
-langroid/language_models/mock_lm.py,sha256=L0YqrrxLCePs_5MrK7rJ5-SajNxDtuVU_VvZVRfs9q4,2834
+langroid/language_models/mock_lm.py,sha256=qdgj-wtbQBXlibo_0rIRfCt0hGTPRoxy1C4VjN6quI4,2707
 langroid/language_models/openai_gpt.py,sha256=RXnLKULuCSeDeUPQvaZ4naqJgMKcMZogCtRDLycd4j8,50714
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
@@ -104,7 +104,7 @@ langroid/utils/__init__.py,sha256=Sruos2tB4G7Tn0vlblvYlX9PEGR0plI2uE0PJ4d_EC4,35
 langroid/utils/algorithms/__init__.py,sha256=WylYoZymA0fnzpB4vrsH_0n7WsoLhmuZq8qxsOCjUpM,41
 langroid/utils/algorithms/graph.py,sha256=JbdpPnUOhw4-D6O7ou101JLA3xPCD0Lr3qaPoFCaRfo,2866
 langroid/utils/configuration.py,sha256=A70LdvdMuunlLSGI1gBmBL5j6Jhz-1syNP8R4AdjqDc,3295
-langroid/utils/constants.py,sha256=eTiXfx8Nq2kmq0WChVLqV9C58UWju0NCIuW28sMgd5g,575
+langroid/utils/constants.py,sha256=5WgyXjhRegNWB_BSYZsEZW-7mm-F_5bJPM4nuZ9qvNo,590
 langroid/utils/docker.py,sha256=kJQOLTgM0x9j9pgIIqp0dZNZCTvoUDhp6i8tYBq1Jr0,1105
 langroid/utils/globals.py,sha256=Az9dOFqR6n9CoTYSqa2kLikQWS0oCQ9DFQIQAnG-2q8,1355
 langroid/utils/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -128,8 +128,8 @@ langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3Hmh
 langroid/vector_store/momento.py,sha256=QaPzUnTwlswoawGB-paLtUPyLRvckFXLfLDfvbTzjNQ,10505
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=wYOuu5c2vIKn9ZgvTXcAiZXMpV8AOXEWFAzI8S8UP-0,16828
-pyproject.toml,sha256=dZYHxf2D_qc8g68xt4KgMoa7tuxbY_JpLn-Pd541kuw,6964
-langroid-0.2.0.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.2.0.dist-info/METADATA,sha256=vcctmhiBgiBI4LlzmbJFMfRG7nwjD4B1IZvnDu0XR_M,52823
-langroid-0.2.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langroid-0.2.0.dist-info/RECORD,,
+pyproject.toml,sha256=MX6Rg0hLOiPlYpb9q4G0H0jLdqAjNWSI_tnKXB8mkuQ,6963
+langroid-0.2.3.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.2.3.dist-info/METADATA,sha256=1GD93aMG3wEtL7pE3NBXM1gxjyjEO0Og5XdtNGb3UGA,53146
+langroid-0.2.3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langroid-0.2.3.dist-info/RECORD,,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.2.0"
+version = "0.2.3"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -23,7 +23,7 @@ pymysql = {version = "^1.1.0", optional = true}
 meilisearch-python-sdk = {version="^2.2.3", optional=true}
 litellm = {version = "^1.30.1", optional = true}
 metaphor-python = {version = "^0.1.23", optional = true}
-chainlit = {version = "^1.0.400", optional = true}
+chainlit = {version = "1.1.202", optional = true}
 python-socketio = {version="^5.11.0", optional=true}
 neo4j = {version = "^5.14.1", optional = true}
 huggingface-hub = {version="^0.21.2", optional=true}