langroid 0.1.181__py3-none-any.whl → 0.1.183__py3-none-any.whl

langroid/__init__.py

@@ -20,6 +20,15 @@ from .agent.base import (
     AgentConfig,
 )
 
+from .agent.chat_document import (
+    ChatDocument,
+    ChatDocMetaData,
+)
+
+from .agent.tool_message import (
+    ToolMessage,
+)
+
 from .agent.chat_agent import (
     ChatAgent,
     ChatAgentConfig,
@@ -27,6 +36,19 @@ from .agent.chat_agent import (
 
 from .agent.task import Task
 
+try:
+    from .agent.callbacks.chainlit import (
+        ChainlitAgentCallbacks,
+        ChainlitTaskCallbacks,
+    )
+
+    chainlit_available = True
+    ChainlitAgentCallbacks
+    ChainlitTaskCallbacks
+except ImportError:
+    chainlit_available = False
+
+
 from .mytypes import (
     DocMetaData,
     Document,
@@ -47,8 +69,18 @@ __all__ = [
     "AgentConfig",
     "ChatAgent",
     "ChatAgentConfig",
+    "ChatDocument",
+    "ChatDocMetaData",
     "Task",
     "DocMetaData",
     "Document",
     "Entity",
+    "ToolMessage",
 ]
+if chainlit_available:
+    __all__.extend(
+        [
+            "ChainlitAgentCallbacks",
+            "ChainlitTaskCallbacks",
+        ]
+    )

langroid/agent/base.py

@@ -4,6 +4,7 @@ import json
 import logging
 from abc import ABC
 from contextlib import ExitStack
+from types import SimpleNamespace
 from typing import (
     Any,
     Callable,
@@ -63,6 +64,10 @@ class AgentConfig(BaseSettings):
     show_stats: bool = True  # show token usage/cost stats?
 
 
+def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
+    pass
+
+
 class Agent(ABC):
     """
     An Agent is an abstraction that encapsulates mainly two components:
@@ -91,6 +96,16 @@ class Agent(ABC):
         self.parser: Optional[Parser] = (
             Parser(config.parsing) if config.parsing else None
         )
+        self.callbacks = SimpleNamespace(
+            start_llm_stream=lambda: noop_fn,
+            cancel_llm_stream=noop_fn,
+            finish_llm_stream=noop_fn,
+            show_llm_response=noop_fn,
+            show_agent_response=noop_fn,
+            get_user_response=None,
+            get_last_step=noop_fn,
+            set_parent_agent=noop_fn,
+        )
 
     def entity_responders(
         self,
@@ -295,6 +310,7 @@ class Agent(ABC):
         if not settings.quiet:
             console.print(f"[red]{self.indent}", end="")
             print(f"[red]Agent: {results}")
+            self.callbacks.show_agent_response(content=results)
         sender_name = self.config.name
         if isinstance(msg, ChatDocument) and msg.function_call is not None:
             # if result was from handling an LLM `function_call`,
@@ -353,11 +369,18 @@ class Agent(ABC):
         elif not settings.interactive:
             user_msg = ""
         else:
-            user_msg = Prompt.ask(
-                f"[blue]{self.indent}Human "
-                "(respond or q, x to exit current level, "
-                f"or hit enter to continue)\n{self.indent}",
-            ).strip()
+            if self.callbacks.get_user_response is not None:
+                # ask user with empty prompt: no need for prompt
+                # since user has seen the conversation so far.
+                # But non-empty prompt can be useful when Agent
+                # uses a tool that requires user input, or in other scenarios.
+                user_msg = self.callbacks.get_user_response(prompt="")
+            else:
+                user_msg = Prompt.ask(
+                    f"[blue]{self.indent}Human "
+                    "(respond or q, x to exit current level, "
+                    f"or hit enter to continue)\n{self.indent}",
+                ).strip()
 
         tool_ids = []
         if msg is not None and isinstance(msg, ChatDocument):

langroid/agent/callbacks/chainlit.py

@@ -0,0 +1,450 @@
+"""
+Callbacks for Chainlit integration.
+"""
+
+import json
+import logging
+import textwrap
+from typing import Any, Callable, Dict, List, Literal, Optional, no_type_check
+
+try:
+    import chainlit as cl
+except ImportError:
+    raise ImportError(
+        """
+        You are attempting to use `chainlit`, which is not installed 
+        by default with `langroid`.
+        Please install langroid with the `chainlit` extra using:
+        `pip install langroid[chainlit]` or 
+        `poetry install -E chainlit`
+        depending on your scenario
+        """
+    )
+
+from chainlit import run_sync
+from chainlit.config import config
+from chainlit.logger import logger
+
+import langroid as lr
+import langroid.language_models as lm
+from langroid.utils.configuration import settings
+from langroid.utils.constants import NO_ANSWER
+
+# Attempt to reconfigure the root logger to your desired settings
+log_level = logging.INFO if settings.debug else logging.WARNING
+logger.setLevel(log_level)
+
+USER_TIMEOUT = 60_000
+
+
+@no_type_check
+async def ask_helper(func, **kwargs):
+    res = await func(**kwargs).send()
+    while not res:
+        res = await func(**kwargs).send()
+    return res
+
+
+@no_type_check
+async def setup_llm() -> None:
+    llm_settings = cl.user_session.get("llm_settings", {})
+    model = llm_settings.get("chat_model")
+    context_length = llm_settings.get("context_length", 16_000)
+    temperature = llm_settings.get("temperature", 0.2)
+    timeout = llm_settings.get("timeout", 90)
+    print(f"Using model: {model}")
+    llm_config = lm.OpenAIGPTConfig(
+        chat_model=model or lm.OpenAIChatModel.GPT4_TURBO,
+        # or, other possibilities for example:
+        # "litellm/ollama_chat/mistral"
+        # "litellm/ollama_chat/mistral:7b-instruct-v0.2-q8_0"
+        # "litellm/ollama/llama2"
+        # "local/localhost:8000/v1"
+        # "local/localhost:8000"
+        chat_context_length=context_length,  # adjust based on model
+        temperature=temperature,
+        timeout=timeout,
+    )
+    llm = lm.OpenAIGPT(llm_config)
+    cl.user_session.set("llm_config", llm_config)
+    cl.user_session.set("llm", llm)
+
+
+@no_type_check
+async def update_agent(settings: Dict[str, Any], agent="agent") -> None:
+    cl.user_session.set("llm_settings", settings)
+    await inform_llm_settings()
+    await setup_llm()
+    agent = cl.user_session.get(agent)
+    if agent is None:
+        raise ValueError(f"Agent {agent} not found in user session")
+    agent.llm = cl.user_session.get("llm")
+    agent.config.llm = cl.user_session.get("llm_config")
+
+
+async def make_llm_settings_widgets() -> None:
+    await cl.ChatSettings(
+        [
+            cl.input_widget.TextInput(
+                id="chat_model",
+                label="Model Name (Default GPT4-Turbo)",
+                initial="",
+                placeholder="E.g. litellm/ollama_chat/mistral or "
+                "local/localhost:8000/v1",
+            ),
+            cl.input_widget.NumberInput(
+                id="context_length",
+                label="Chat Context Length",
+                initial=16_000,
+                placeholder="E.g. 16000",
+            ),
+            cl.input_widget.Slider(
+                id="temperature",
+                label="LLM temperature",
+                min=0.0,
+                max=1.0,
+                step=0.1,
+                initial=0.2,
+                tooltip="Adjust based on model",
+            ),
+            cl.input_widget.Slider(
+                id="timeout",
+                label="Timeout (seconds)",
+                min=10,
+                max=200,
+                step=10,
+                initial=90,
+                tooltip="Timeout for LLM response, in seconds.",
+            ),
+        ]
+    ).send()  # type: ignore
+
+
+@no_type_check
+async def inform_llm_settings() -> None:
+    llm_settings: Dict[str, Any] = cl.user_session.get("llm_settings", {})
+    settings_dict = dict(
+        model=llm_settings.get("chat_model"),
+        context_length=llm_settings.get("context_length"),
+        temperature=llm_settings.get("temperature"),
+        timeout=llm_settings.get("timeout"),
+    )
+    await cl.Message(
+        author="System",
+        content="LLM settings updated",
+        elements=[
+            cl.Text(
+                name="settings",
+                display="side",
+                content=json.dumps(settings_dict, indent=4),
+                language="json",
+            )
+        ],
+    ).send()
+
+
+async def add_instructions(
+    title: str = "Instructions",
+    content: str = "Enter your question/response in the dialog box below.",
+    display: Literal["side", "inline", "page"] = "inline",
+) -> None:
+    await cl.Message(
+        author="",
+        content=title if display == "side" else "",
+        elements=[
+            cl.Text(
+                name=title,
+                content=content,
+                display=display,
+            )
+        ],
+    ).send()
+
+
+async def ask_user_step(
+    name: str,
+    prompt: str,
+    parent_id: str | None = None,
+    timeout: int = USER_TIMEOUT,
+    suppress_values: List[str] = ["c"],
+) -> str:
+    """
+    Ask user for input, as a step nested under parent_id.
+    Rather than rely entirely on AskUserMessage (which doesn't let us
+    nest the question + answer under a step), we instead create fake
+    steps for the question and answer, and only rely on AskUserMessage
+    with an empty prompt to await user response.
+
+    Args:
+        name (str): Name of the agent
+        prompt (str): Prompt to display to user
+        parent_id (str): Id of the parent step under which this step should be nested
+            (If None, the step will be shown at root level)
+        timeout (int): Timeout in seconds
+        suppress_values (List[str]): List of values to suppress from display
+            (e.g. "c" for continue)
+
+    Returns:
+        str: User response
+    """
+
+    # save hide_cot status to restore later
+    # (We should probably use a ctx mgr for this)
+    hide_cot = config.ui.hide_cot
+
+    # force hide_cot to False so that the user question + response is visible
+    config.ui.hide_cot = False
+
+    if prompt != "":
+        # Create a question step to ask user
+        question_step = cl.Step(
+            name=f"{name} (AskUser ❓)",
+            type="run",
+            parent_id=parent_id,
+        )
+        question_step.output = prompt
+        await question_step.send()  # type: ignore
+
+    # Use AskUserMessage to await user response,
+    # but with an empty prompt so the question is not visible,
+    # but still pauses for user input in the input box.
+    res = await cl.AskUserMessage(
+        content="",
+        timeout=timeout,
+    ).send()
+
+    if res is None:
+        run_sync(
+            cl.Message(
+                content=f"Timed out after {USER_TIMEOUT} seconds. Exiting."
+            ).send()
+        )
+        return "x"
+
+    # The above will try to display user response in res
+    # but we create fake step with same id as res and
+    # erase it using empty output so it's not displayed
+    step = cl.Step(
+        id=res["id"], name="TempUserResponse", type="run", parent_id=parent_id
+    )
+    step.output = ""
+    await step.update()  # type: ignore
+
+    # Finally, reproduce the user response at right nesting level
+    if res["output"] in suppress_values:
+        config.ui.hide_cot = hide_cot  # restore original value
+        return ""
+
+    step = cl.Step(
+        name=f"{name}(You 😃)",
+        type="run",
+        parent_id=parent_id,
+    )
+    step.output = res["output"]
+    await step.send()  # type: ignore
+    config.ui.hide_cot = hide_cot  # restore original value
+    return res["output"]
+
+
+def wrap_text_preserving_structure(text: str, width: int = 90) -> str:
+    """Wrap text preserving paragraph breaks. Typically used to
+    format an agent_response output, which may have long lines
+    with no newlines or paragraph breaks."""
+
+    paragraphs = text.split("\n\n")  # Split the text into paragraphs
+    wrapped_text = []
+
+    for para in paragraphs:
+        if para.strip():  # If the paragraph is not just whitespace
+            # Wrap this paragraph and add it to the result
+            wrapped_paragraph = textwrap.fill(para, width=width)
+            wrapped_text.append(wrapped_paragraph)
+        else:
+            # Preserve paragraph breaks
+            wrapped_text.append("")
+
+    return "\n\n".join(wrapped_text)
+
+
+class ChainlitAgentCallbacks:
+    """Inject Chainlit callbacks into a Langroid Agent"""
+
+    last_step: Optional[cl.Step] = None  # used to display sub-steps under this
+    stream: Optional[cl.Step] = None  # pushed into openai_gpt.py to stream tokens
+    parent_agent: Optional[lr.Agent] = None  # used to get parent id, for step nesting
+
+    def __init__(self, agent: lr.Agent):
+        agent.callbacks.start_llm_stream = self.start_llm_stream
+        agent.callbacks.cancel_llm_stream = self.cancel_llm_stream
+        agent.callbacks.finish_llm_stream = self.finish_llm_stream
+        agent.callbacks.show_llm_response = self.show_llm_response
+        agent.callbacks.show_agent_response = self.show_agent_response
+        agent.callbacks.get_user_response = self.get_user_response
+        agent.callbacks.get_last_step = self.get_last_step
+        agent.callbacks.set_parent_agent = self.set_parent_agent
+        self.agent: lr.Agent = agent
+        self.name = agent.config.name
+
+    def _get_parent_id(self) -> str | None:
+        """Get step id under which we need to nest the current step:
+        This should be the parent Agent's last_step.
+        """
+        if self.parent_agent is None:
+            logger.info(f"No parent agent found for {self.name}")
+            return None
+        logger.info(
+            f"Parent agent found for {self.name} = {self.parent_agent.config.name}"
+        )
+        last_step = self.parent_agent.callbacks.get_last_step()
+        if last_step is None:
+            logger.info(f"No last step found for {self.parent_agent.config.name}")
+            return None
+        logger.info(
+            f"Last step found for {self.parent_agent.config.name} = {last_step.id}"
+        )
+        return last_step.id  # type: ignore
+
+    def set_parent_agent(self, parent: lr.Agent) -> None:
+        self.parent_agent = parent
+
+    def get_last_step(self) -> Optional[cl.Step]:
+        return self.last_step
+
+    def start_llm_stream(self) -> Callable[[str], None]:
+        """Returns a streaming fn that can be passed to the LLM class"""
+        logger.info(
+            f"""
+            Starting LLM stream for {self.agent.config.name} 
+            under parent {self._get_parent_id()}
+        """
+        )
+        self.stream = cl.Step(
+            name=self.agent.config.name + "(LLM 🧠)",
+            type="llm",
+            parent_id=self._get_parent_id(),
+        )
+        self.last_step = self.stream
+        run_sync(self.stream.send())  # type: ignore
+
+        def stream_token(t: str) -> None:
+            if self.stream is None:
+                raise ValueError("Stream not initialized")
+            run_sync(self.stream.stream_token(t))
+
+        return stream_token
+
+    def cancel_llm_stream(self) -> None:
+        """Called when cached response found."""
+        self.last_step = None
+        if self.stream is not None:
+            run_sync(self.stream.remove())  # type: ignore
+
+    def finish_llm_stream(self, content: str, is_tool: bool = False) -> None:
+        """Update the stream, and display entire response in the right language."""
+        tool_indicator = " =>  🛠️" if is_tool else ""
+        if self.agent.llm is None or self.stream is None:
+            raise ValueError("LLM or stream not initialized")
+        model = self.agent.llm.config.chat_model
+        if content == "":
+            run_sync(self.stream.remove())  # type: ignore
+        else:
+            run_sync(self.stream.update())  # type: ignore
+        stream_id = self.stream.id if content else None
+        step = cl.Step(
+            id=stream_id,
+            name=self.agent.config.name + f"(LLM {model} 🧠{tool_indicator})",
+            type="llm",
+            parent_id=self._get_parent_id(),
+            language="json" if is_tool else None,
+        )
+        step.output = content or NO_ANSWER
+        run_sync(step.update())  # type: ignore
+
+    def show_llm_response(self, content: str, is_tool: bool = False) -> None:
+        """Show non-streaming LLM response."""
+        model = self.agent.llm is not None and self.agent.llm.config.chat_model
+        tool_indicator = " =>  🛠️" if is_tool else ""
+        step = cl.Step(
+            name=self.agent.config.name + f"(LLM {model} 🧠{tool_indicator})",
+            type="llm",
+            parent_id=self._get_parent_id(),
+            language="json" if is_tool else None,
+        )
+        self.last_step = step
+        step.output = content or NO_ANSWER
+        run_sync(step.send())  # type: ignore
+
+    def show_agent_response(self, content: str) -> None:
+        """Show message from agent (typically tool handler).
+        Agent response can be considered as a "step"
+        between LLM response and user response
+        """
+        step = cl.Step(
+            name=self.agent.config.name + "(Agent <>)",
+            type="tool",
+            parent_id=self._get_parent_id(),
+            language="text",
+        )
+        self.last_step = step
+        step.output = wrap_text_preserving_structure(content, width=90)
+        run_sync(step.send())  # type: ignore
+
+    def _get_user_response_buttons(self, prompt: str) -> str:
+        """Not used. Save for future reference"""
+        res = run_sync(
+            ask_helper(
+                cl.AskActionMessage,
+                content="Continue, exit or say something?",
+                actions=[
+                    cl.Action(
+                        name="continue",
+                        value="continue",
+                        label="✅ Continue",
+                    ),
+                    cl.Action(
+                        name="feedback",
+                        value="feedback",
+                        label="💬 Say something",
+                    ),
+                    cl.Action(name="exit", value="exit", label="🔚 Exit Conversation"),
+                ],
+            )
+        )
+        if res.get("value") == "continue":
+            return ""
+        if res.get("value") == "exit":
+            return "x"
+        if res.get("value") == "feedback":
+            return self.get_user_response(prompt)
+        return ""  # process the "feedback" case here
+
+    def get_user_response(self, prompt: str) -> str:
+        """Ask for user response, wait for it, and return it,
+        as a cl.Step rather than as a cl.Message so we can nest it
+        under the parent step.
+        """
+        return run_sync(
+            ask_user_step(
+                name=self.agent.config.name,
+                prompt=prompt,
+                parent_id=self._get_parent_id(),
+                suppress_values=["c"],
+            )
+        )
+
+
+class ChainlitTaskCallbacks:
+    """
+    Inject ChainlitCallbacks into a Langroid Task's agent and
+    agents of sub-tasks.
+    """
+
+    def __init__(self, task: lr.Task):
+        ChainlitTaskCallbacks._inject_callbacks(task)
+
+    @staticmethod
+    def _inject_callbacks(task: lr.Task) -> None:
+        # recursively apply ChainlitCallbacks to agents of sub-tasks
+        ChainlitAgentCallbacks(task.agent)
+        for t in task.sub_tasks:
+            ChainlitTaskCallbacks._inject_callbacks(t)

langroid/agent/chat_agent.py

@@ -1,3 +1,4 @@
+import copy
 import inspect
 import logging
 import textwrap
@@ -8,7 +9,7 @@ from rich import print
 from rich.console import Console
 from rich.markup import escape
 
-from langroid.agent.base import Agent, AgentConfig
+from langroid.agent.base import Agent, AgentConfig, noop_fn
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.tool_message import ToolMessage
 from langroid.language_models.base import (
@@ -134,6 +135,27 @@ class ChatAgent(Agent):
         self.llm_functions_usable: Set[str] = set()
         self.llm_function_force: Optional[Dict[str, str]] = None
 
+    def clone(self, i: int = 0) -> "ChatAgent":
+        """Create i'th clone of this agent, ensuring tool use/handling is cloned.
+        Important: We assume all member variables are in the __init__ method here
+        and in the Agent class.
+        TODO: We are attempting to close an agent after its state has been
+        changed in possibly many ways. Below is an imperfect solution. Caution advised.
+        Revisit later.
+        """
+        agent_cls = type(self)
+        config_copy = copy.deepcopy(self.config)
+        config_copy.name = f"{config_copy.name}-{i}"
+        new_agent = agent_cls(config_copy)
+        new_agent.system_tool_instructions = self.system_tool_instructions
+        new_agent.system_json_tool_instructions = self.system_json_tool_instructions
+        new_agent.llm_tools_map = self.llm_tools_map
+        new_agent.llm_functions_map = self.llm_functions_map
+        new_agent.llm_functions_handled = self.llm_functions_handled
+        new_agent.llm_functions_usable = self.llm_functions_usable
+        new_agent.llm_function_force = self.llm_function_force
+        return new_agent
+
     def _fn_call_available(self) -> bool:
         """Does this agent's LLM support function calling?"""
         return (
@@ -644,6 +666,10 @@ class ChatAgent(Agent):
         """
         assert self.config.llm is not None and self.llm is not None
         output_len = output_len or self.config.llm.max_output_tokens
+        streamer = noop_fn
+        if self.llm.get_stream():
+            streamer = self.callbacks.start_llm_stream()
+        self.llm.config.streamer = streamer
         with ExitStack() as stack:  # for conditionally using rich spinner
             if not self.llm.get_stream() and not settings.quiet:
                 # show rich spinner only if not streaming!
@@ -659,17 +685,31 @@ class ChatAgent(Agent):
                 functions=functions,
                 function_call=fun_call,
             )
+        if self.llm.get_stream():
+            self.callbacks.finish_llm_stream(
+                content=str(response),
+                is_tool=self.has_tool_message_attempt(
+                    ChatDocument.from_LLMResponse(response, displayed=True)
+                ),
+            )
+        self.llm.config.streamer = noop_fn
+        if response.cached:
+            self.callbacks.cancel_llm_stream()
+
         if not self.llm.get_stream() or response.cached:
             # We would have already displayed the msg "live" ONLY if
             # streaming was enabled, AND we did not find a cached response.
             # If we are here, it means the response has not yet been displayed.
             cached = f"[red]{self.indent}(cached)[/red]" if response.cached else ""
-            if response.function_call is not None:
-                response_str = str(response.function_call)
-            else:
-                response_str = response.message
             if not settings.quiet:
-                print(cached + "[green]" + escape(response_str))
+                print(cached + "[green]" + escape(str(response)))
+                cached = "[cached] " if response.cached else ""
+                self.callbacks.show_llm_response(
+                    content=cached + " " + str(response),
+                    is_tool=self.has_tool_message_attempt(
+                        ChatDocument.from_LLMResponse(response, displayed=True)
+                    ),
+                )
         self.update_token_usage(
             response,
             messages,
@@ -695,24 +735,42 @@ class ChatAgent(Agent):
                 "auto" if self.llm_function_force is None else self.llm_function_force
             )
         assert self.llm is not None
+
+        streamer = noop_fn
+        if self.llm.get_stream():
+            streamer = self.callbacks.start_llm_stream()
+        self.llm.config.streamer = streamer
+
         response = await self.llm.achat(
             messages,
             output_len,
             functions=functions,
             function_call=fun_call,
         )
-
+        if self.llm.get_stream():
+            self.callbacks.finish_llm_stream(
+                content=str(response),
+                is_tool=self.has_tool_message_attempt(
+                    ChatDocument.from_LLMResponse(response, displayed=True)
+                ),
+            )
+        self.llm.config.streamer = noop_fn
+        if response.cached:
+            self.callbacks.cancel_llm_stream()
         if not self.llm.get_stream() or response.cached:
             # We would have already displayed the msg "live" ONLY if
             # streaming was enabled, AND we did not find a cached response.
             # If we are here, it means the response has not yet been displayed.
             cached = f"[red]{self.indent}(cached)[/red]" if response.cached else ""
-            if response.function_call is not None:
-                response_str = str(response.function_call)
-            else:
-                response_str = response.message
             if not settings.quiet:
-                print(cached + "[green]" + escape(response_str))
+                print(cached + "[green]" + escape(str(response)))
+                cached = "[cached] " if response.cached else ""
+                self.callbacks.show_llm_response(
+                    content=cached + " " + str(response),
+                    is_tool=self.has_tool_message_attempt(
+                        ChatDocument.from_LLMResponse(response, displayed=True)
+                    ),
+                )
 
         self.update_token_usage(
             response,

langroid/agent/task.py

@@ -77,7 +77,7 @@ class Task:
         restart: bool = True,
         default_human_response: Optional[str] = None,
         interactive: bool = True,
-        only_user_quits_root: bool = True,
+        only_user_quits_root: bool = False,
         erase_substeps: bool = False,
         allow_null_result: bool = True,
         max_stalled_steps: int = 5,
@@ -114,7 +114,8 @@ class Task:
                 response (prevents infinite loop of non-human responses).
                 Default is true. If false, then `default_human_response` is set to ""
             only_user_quits_root (bool): if true, only user can quit the root task.
-                [Instead of this, setting `interactive` usually suffices]
+                [This param is ignored & deprecated; Keeping for backward compatibility.
+                Instead of this, setting `interactive` suffices]
             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`.
@@ -134,6 +135,20 @@ class Task:
         if agent is None:
             agent = ChatAgent()
 
+        # copy the agent's config, so that we don't modify the original agent's config,
+        # which may be shared by other agents.
+        try:
+            config_copy = copy.deepcopy(agent.config)
+            agent.config = config_copy
+        except Exception:
+            logger.warning(
+                """
+                Failed to deep-copy Agent config during task creation, 
+                proceeding with original config. Be aware that changes to 
+                the config may affect other agents using the same config.
+                """
+            )
+
         if isinstance(agent, ChatAgent) and len(agent.message_history) == 0 or restart:
             agent = cast(ChatAgent, agent)
             agent.clear_history(0)
@@ -157,6 +172,9 @@ class Task:
         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
         self.default_human_response = default_human_response
@@ -229,11 +247,7 @@ class Task:
         Returns a copy of this task, with a new agent.
         """
         assert isinstance(self.agent, ChatAgent), "Task clone only works for ChatAgent"
-
-        agent_cls = type(self.agent)
-        config_copy = copy.deepcopy(self.agent.config)
-        config_copy.name = f"{config_copy.name}-{i}"
-        agent: ChatAgent = agent_cls(config_copy)
+        agent: ChatAgent = self.agent.clone(i)
         return Task(
             agent,
             name=self.name + f"-{i}",
@@ -244,7 +258,6 @@ class Task:
             restart=False,
             default_human_response=self.default_human_response,
             interactive=self.interactive,
-            only_user_quits_root=self.only_user_quits_root,
             erase_substeps=self.erase_substeps,
             allow_null_result=self.allow_null_result,
             max_stalled_steps=self.max_stalled_steps,
@@ -784,6 +797,8 @@ class Task:
         """
         if isinstance(e, Task):
             actual_turns = e.turns if e.turns > 0 else turns
+            if e.agent.callbacks.set_parent_agent is not None:
+                e.agent.callbacks.set_parent_agent(self.agent)
             result = e.run(
                 self.pending_message,
                 turns=actual_turns,
@@ -846,6 +861,8 @@ class Task:
         """
         if isinstance(e, Task):
             actual_turns = e.turns if e.turns > 0 else turns
+            if e.agent.callbacks.set_parent_agent is not None:
+                e.agent.callbacks.set_parent_agent(self.agent)
             result = await e.run_async(
                 self.pending_message,
                 turns=actual_turns,

langroid/language_models/base.py

@@ -5,7 +5,7 @@ import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
 
 import aiohttp
 from pydantic import BaseModel, BaseSettings, Field
@@ -26,8 +26,13 @@ from langroid.utils.output.printing import show_if_debug
 logger = logging.getLogger(__name__)
 
 
+def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
+    pass
+
+
 class LLMConfig(BaseSettings):
     type: str = "openai"
+    streamer: Optional[Callable[[Any], None]] = noop_fn
     api_base: str | None = None
     formatter: None | str = None
     timeout: int = 20  # timeout for API requests
@@ -72,8 +77,11 @@ class LLMFunctionCall(BaseModel):
         fun_args_str = message["arguments"]
         # sometimes may be malformed with invalid indents,
         # so we try to be safe by removing newlines.
-        fun_args_str = fun_args_str.replace("\n", "").strip()
-        fun_args = ast.literal_eval(fun_args_str)
+        if fun_args_str is not None:
+            fun_args_str = fun_args_str.replace("\n", "").strip()
+            fun_args = ast.literal_eval(fun_args_str)
+        else:
+            fun_args = None
         fun_call.arguments = fun_args
 
         return fun_call
@@ -181,6 +189,12 @@ class LLMResponse(BaseModel):
     usage: Optional[LLMTokenUsage]
     cached: bool = False
 
+    def __str__(self) -> str:
+        if self.function_call is not None:
+            return str(self.function_call)
+        else:
+            return self.message
+
     def to_LLMMessage(self) -> LLMMessage:
         content = self.message
         role = Role.ASSISTANT if self.function_call is None else Role.FUNCTION

langroid/language_models/openai_gpt.py

@@ -580,17 +580,21 @@ class OpenAIGPT(LanguageModel):
             if not is_async:
                 sys.stdout.write(Colors().GREEN + event_text)
                 sys.stdout.flush()
+                self.config.streamer(event_text)
         if event_fn_name:
             function_name = event_fn_name
             has_function = True
             if not is_async:
                 sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
                 sys.stdout.flush()
+                self.config.streamer(event_fn_name)
+
         if event_args:
             function_args += event_args
             if not is_async:
                 sys.stdout.write(Colors().GREEN + event_args)
                 sys.stdout.flush()
+                self.config.streamer(event_args)
         if choices[0].get("finish_reason", "") in ["stop", "function_call"]:
             # for function_call, finish_reason does not necessarily
             # contain "function_call" as mentioned in the docs.

langroid/language_models/prompt_formatter/hf_formatter.py

@@ -6,7 +6,7 @@ models will have the same tokenizer, so we just use the first one.
 """
 import logging
 import re
-from typing import List
+from typing import List, Set
 
 from huggingface_hub import HfApi, ModelFilter
 from jinja2.exceptions import TemplateError
@@ -44,6 +44,8 @@ def find_hf_formatter(model_name: str) -> str:
 
 
 class HFFormatter(PromptFormatter):
+    models: Set[str] = set()  # which models have been used for formatting
+
     def __init__(self, config: HFPromptFormatterConfig):
         super().__init__(config)
         self.config: HFPromptFormatterConfig = config
@@ -63,7 +65,8 @@ class HFFormatter(PromptFormatter):
             raise ValueError(
                 f"Model {config.model_name} does not support chat template"
             )
-        else:
+        elif mdl.id not in HFFormatter.models:
+            # only warn if this is the first time we've used this mdl.id
             logger.warning(
                 f"""
             Using HuggingFace {mdl.id} for prompt formatting: 
@@ -73,6 +76,7 @@ class HFFormatter(PromptFormatter):
             {self.tokenizer.chat_template}
             """
             )
+        HFFormatter.models.add(mdl.id)
 
     def format(self, messages: List[LLMMessage]) -> str:
         sys_msg, chat_msgs, user_msg = LanguageModel.get_chat_history_components(

langroid/prompts/chat-gpt4-system-prompt.md

@@ -0,0 +1,68 @@
+Image input capabilities: Enabled
+
+Tools
+python
+When you send a message containing Python code to python, it will be executed in a
+stateful Jupyter notebook environment. python will respond with the output of the execution or time out after 60.0
+seconds. The drive at '/mnt/data' can be used to save and persist user files. Internet access for this session is disabled. Do not make external web requests or API calls as they will fail.
+
+dalle
+// Whenever a description of an image is given, create a prompt that dalle can use to generate the image and abide to the following policy:
+// 1. The prompt must be in English. Translate to English if needed.
+// 2. DO NOT ask for permission to generate the image, just do it!
+// 3. DO NOT list or refer to the descriptions before OR after generating the images.
+// 4. Do not create more than 1 image, even if the user requests more.
+// 5. Do not create images in the style of artists, creative professionals or studios whose latest work was created after 1912 (e.g. Picasso, Kahlo).
+// - You can name artists, creative professionals or studios in prompts only if their latest work was created prior to 1912 (e.g. Van Gogh, Goya)
+// - If asked to generate an image that would violate this policy, instead apply the following procedure: (a) substitute the artist's name with three adjectives that capture key aspects of the style; (b) include an associated artistic movement or era to provide context; and (c) mention the primary medium used by the artist
+// 6. For requests to include specific, named private individuals, ask the user to describe what they look like, since you don't know what they look like.
+// 7. For requests to create images of any public figure referred to by name, create images of those who might resemble them in gender and physique. But they shouldn't look like them. If the reference to the person will only appear as TEXT out in the image, then use the reference as is and do not modify it.
+// 8. Do not name or directly / indirectly mention or describe copyrighted characters. Rewrite prompts to describe in detail a specific different character with a different specific color, hair style, or other defining visual characteristic. Do not discuss copyright policies in responses.
+// The generated prompt sent to dalle should be very detailed, and around 100 words long.
+// Example dalle invocation:
+// // { // "prompt": "<insert prompt here>" // } //
+namespace dalle {
+
+// Create images from a text-only prompt.
+type text2im = (_: {
+// The size of the requested image. Use 1024x1024 (square) as the default, 1792x1024 if the user requests a wide image, and 1024x1792 for full-body portraits. Always include this parameter in the request.
+size?: "1792x1024" | "1024x1024" | "1024x1792",
+// The number of images to generate. If the user does not specify a number, generate 1 image.
+n?: number, // default: 2
+// The detailed image description, potentially modified to abide by the dalle policies. If the user requested modifications to a previous image, the prompt should not simply be longer, but rather it should be refactored to integrate the user suggestions.
+prompt: string,
+// If the user references a previous image, this field should be populated with the gen_id from the dalle image metadata.
+referenced_image_ids?: string[],
+}) => any;
+
+} // namespace dalle
+
+voice_mode
+// Voice mode functions are not available in text conversations.
+namespace voice_mode {
+
+} // namespace voice_mode
+
+browser
+You have the tool browser. Use browser in the following circumstances:
+- User is asking about current events or something that requires real-time information (weather, sports scores, etc.)
+- User is asking about some term you are totally unfamiliar with (it might be new)
+- User explicitly asks you to browse or provide links to references
+
+Given a query that requires retrieval, your turn will consist of three steps:
+
+Call the search function to get a list of results.
+Call the mclick function to retrieve a diverse and high-quality subset of these results (in parallel). Remember to SELECT AT LEAST 3 sources when using mclick.
+Write a response to the user based on these results. In your response, cite sources using the citation format below.
+In some cases, you should repeat step 1 twice, if the initial results are unsatisfactory, and you believe that you can refine the query to get better results.
+
+You can also open a url directly if one is provided by the user. Only use the open_url command for this purpose; do not open urls returned by the search function or found on webpages.
+
+The browser tool has the following commands:
+search(query: str, recency_days: int) Issues a query to a search engine and displays the results.
+mclick(ids: list[str]). Retrieves the contents of the webpages with provided IDs (indices). You should ALWAYS SELECT AT LEAST 3 and at most 10 pages. Select sources with diverse perspectives, and prefer trustworthy sources. Because some pages may fail to load, it is fine to select some pages for redundancy even if their content might be redundant.
+open_url(url: str) Opens the given URL and displays it.
+
+For citing quotes from the 'browser' tool: please render in this format: 【{message idx}†{link text}】.
+For long citations: please render in this format: [link text](message idx).
+Otherwise do not render links.

{langroid-0.1.181.dist-info → langroid-0.1.183.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.181
+Version: 0.1.183
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -10,6 +10,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Provides-Extra: chainlit
 Provides-Extra: hf-embeddings
 Provides-Extra: litellm
 Provides-Extra: metaphor
@@ -23,6 +24,7 @@ Requires-Dist: async-generator (>=1.10,<2.0)
 Requires-Dist: autopep8 (>=2.0.2,<3.0.0)
 Requires-Dist: black[jupyter] (>=23.3.0,<24.0.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.2)
+Requires-Dist: chainlit (>=1.0.200,<2.0.0) ; extra == "chainlit"
 Requires-Dist: chromadb (==0.3.21)
 Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: docstring-parser (>=0.15,<0.16)
@@ -35,7 +37,7 @@ Requires-Dist: google-api-python-client (>=2.95.0,<3.0.0)
 Requires-Dist: halo (>=0.0.31,<0.0.32)
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: lancedb (>=0.4.1,<0.5.0)
-Requires-Dist: litellm (>=1.20.6,<2.0.0) ; extra == "litellm"
+Requires-Dist: litellm (>=1.22.3,<2.0.0) ; extra == "litellm"
 Requires-Dist: lxml (>=4.9.3,<5.0.0)
 Requires-Dist: meilisearch (>=0.28.3,<0.29.0)
 Requires-Dist: meilisearch-python-sdk (>=2.2.3,<3.0.0)

{langroid-0.1.181.dist-info → langroid-0.1.183.dist-info}/RECORD

@@ -1,8 +1,10 @@
-langroid/__init__.py,sha256=I9edNDkpmfd5C4WvTONaGaTFzIlvFyp5GpFEaMCAKMk,778
+langroid/__init__.py,sha256=nj2Cj9VOdy4WUqsoCUix5dhNAJbocBwgXyW41SjKBcs,1370
 langroid/agent/__init__.py,sha256=w2pap-rHrp41gMzdtzur2YY_m62LqQhF2Du-AmoIQi4,752
-langroid/agent/base.py,sha256=dzPuQ0R1AH7fYQ9cM2gslJ0-dhOeDjXv_P2UP0u9oRs,33803
+langroid/agent/base.py,sha256=Fjja2BFd_F8QxqnW7KYr3vs8YCNDFPfi_qUyoq_hwgA,34783
 langroid/agent/batch.py,sha256=8zHdM-863pRD3UoCXUPKEQ4Z4iqjkNVD2xXu1WspBak,6464
-langroid/agent/chat_agent.py,sha256=Rp2a_KZA58U8zexQuTUkVjzTsQmyG4qT3Vya-jSDTCQ,35374
+langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langroid/agent/callbacks/chainlit.py,sha256=LG3b_YkCi0f_Wi86SpOU_hMur6pfukHpg3K5gaAtDDY,15466
+langroid/agent/chat_agent.py,sha256=V7dtTFSVL6MWhz3iUE0RP-VJvK_zCCUE5If_XAiXEyk,37994
 langroid/agent/chat_document.py,sha256=MRp2YCy5f3Q_yPoFXVyr1vGu48wz33UGxAUtMn7MJpo,7958
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
@@ -30,7 +32,7 @@ langroid/agent/special/sql/utils/populate_metadata.py,sha256=zRjw31a1ZXvpx9bcmbt
 langroid/agent/special/sql/utils/system_message.py,sha256=qKLHkvQWRQodTtPLPxr1GSLUYUFASZU8x-ybV67cB68,1885
 langroid/agent/special/sql/utils/tools.py,sha256=6uB2424SLtmapui9ggcEr0ZTiB6_dL1-JRGgN8RK9Js,1332
 langroid/agent/special/table_chat_agent.py,sha256=GEUTP-VdtMXq4CcPV80gDQrCEn-ZFb9IhuRMtLN5I1o,9030
-langroid/agent/task.py,sha256=V2cagppWMwpMy6d3o_0ljoo4k86cho3YpTHHonhMuDI,47589
+langroid/agent/task.py,sha256=GmHultMZHmWXQBbnX6QDMyDsGwb9uzSVQkr5Tf_n7Ig,48393
 langroid/agent/tool_message.py,sha256=ngmWdiqMYbjF4Am0hsLyA9zK0Q9QF2ziec6FW0lPD90,7399
 langroid/agent/tools/__init__.py,sha256=q-maq3k2BXhPAU99G0H6-j_ozoRvx15I1RFpPVicQIU,304
 langroid/agent/tools/extract_tool.py,sha256=u5lL9rKBzaLBOrRyLnTAZ97pQ1uxyLP39XsWMnpaZpw,3789
@@ -52,13 +54,13 @@ langroid/embedding_models/clustering.py,sha256=tZWElUqXl9Etqla0FAa7og96iDKgjqWju
 langroid/embedding_models/models.py,sha256=0bQ8u2ee2ODcopGPusz9WYWI_PjR5Gbdy47qcSU8gCo,4603
 langroid/language_models/__init__.py,sha256=5L9ndEEC8iLJHjDJmYFTnv6-2-3xsxWUMHcugR8IeDs,821
 langroid/language_models/azure_openai.py,sha256=ncRCbKooqLVOY-PWQUIo9C3yTuKEFbAwyngXT_M4P7k,5989
-langroid/language_models/base.py,sha256=N9Jn-veKBCd_ky9mhHVSmf1iRQ1RBdaxm45yrY9Njl0,20616
+langroid/language_models/base.py,sha256=RdXH-BnkFGS8xZTiukdxHTFxqELVSmf546itp9Fa8fs,21008
 langroid/language_models/config.py,sha256=5UF3DzO1a-Dfsc3vghE0XGq7g9t_xDsRCsuRiU4dgBg,366
 langroid/language_models/openai_assistants.py,sha256=9K-DEAL2aSWHeXj2hwCo2RAlK9_1oCPtqX2u1wISCj8,36
-langroid/language_models/openai_gpt.py,sha256=vpAYgfo-Ezo9eqZa0ymy-e5hJ_XdtFFENYIOEI3Q7kQ,48101
+langroid/language_models/openai_gpt.py,sha256=9gm6URAIh2-katOQGl8BTpDp0JtE20JJptPRR_-HfWY,48252
 langroid/language_models/prompt_formatter/__init__.py,sha256=9JXFF22QNMmbQV1q4nrIeQVTtA3Tx8tEZABLtLBdFyc,352
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
-langroid/language_models/prompt_formatter/hf_formatter.py,sha256=iO2OVfRnq7iRxxXdD1T-_TcINt_4oHVQsWAm7fyKYcc,3951
+langroid/language_models/prompt_formatter/hf_formatter.py,sha256=3MQhu8--p168qPWXqlp_nK4phi-SuAUMqahSVyLHIkA,4177
 langroid/language_models/prompt_formatter/llama2_formatter.py,sha256=YdcO88qyBeuMENVIVvVqSYuEpvYSTndUe_jd6hVTko4,2899
 langroid/language_models/utils.py,sha256=3stQOt3sAdbGT70thurlxfnQ4xPxH75YjFm-jaRuXlg,4474
 langroid/mytypes.py,sha256=-0q-SyicLbdjFSIEcwt5u-EwhRcMWllSoWYE3OWk78M,2501
@@ -81,6 +83,7 @@ langroid/parsing/urls.py,sha256=Nv4yCWQLLBEjaiRdaZZVQNBEl_cfK_V6cVuPm91wGtU,7686
 langroid/parsing/utils.py,sha256=Ft0YytDQh2-S1xjk3FDA4IZI9Qp1odrIYm8cuK8H81s,11642
 langroid/parsing/web_search.py,sha256=sS6UPeVB_KSsIUNlv4VHHvc0uFywMExEbQ15k40TLcc,3951
 langroid/prompts/__init__.py,sha256=B0vpJzIJlMR3mFRtoQwyALsFzBHvLp9f92acD8xJA_0,185
+langroid/prompts/chat-gpt4-system-prompt.md,sha256=Q3uLCJTPQvmUkZN2XDnkBC7M2K3X0F3C3GIQBaFvYvw,5329
 langroid/prompts/dialog.py,sha256=SpfiSyofSgy2pwD1YboHR_yHO3LEEMbv6j2sm874jKo,331
 langroid/prompts/prompts_config.py,sha256=XRQHzod7KBnoKn3B_V878jZiqBA7rcn-CtGPkuAe_yM,131
 langroid/prompts/templates.py,sha256=4X-07tnmUQ8Z_zaWRQAUUyKiErGztp3tERujqnG8sGA,6369
@@ -111,7 +114,7 @@ langroid/vector_store/meilisearch.py,sha256=d2huA9P-NoYRuAQ9ZeXJmMKr7ry8u90RUSR2
 langroid/vector_store/momento.py,sha256=j6Eo6oIDN2fe7lsBOlCXJn3uvvERHHTFL5QJfeREeOM,10044
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=_egbsP9SWBwmI827EDYSSOqfIQSmwNsmJfFTxrLpWYE,13457
-langroid-0.1.181.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.1.181.dist-info/METADATA,sha256=K5aL_WW9QSsuTt-XKslR2WhBNxwj6LNwLnKbhhk6X8U,45219
-langroid-0.1.181.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langroid-0.1.181.dist-info/RECORD,,
+langroid-0.1.183.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.1.183.dist-info/METADATA,sha256=s5Vo5vx5oF3UEmswpHY-cJVmu6HTmk_aFva6hQCzoQY,45309
+langroid-0.1.183.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langroid-0.1.183.dist-info/RECORD,,