langroid 0.6.7__py3-none-any.whl → 0.8.0__py3-none-any.whl

langroid/language_models/openai_gpt.py

@@ -4,6 +4,7 @@ import logging
 import os
 import sys
 import warnings
+from collections import defaultdict
 from enum import Enum
 from functools import cache
 from itertools import chain
@@ -37,7 +38,10 @@ from langroid.language_models.base import (
     LLMMessage,
     LLMResponse,
     LLMTokenUsage,
+    OpenAIToolCall,
+    OpenAIToolSpec,
     Role,
+    ToolChoiceTypes,
 )
 from langroid.language_models.config import HFPromptFormatterConfig
 from langroid.language_models.prompt_formatter.hf_formatter import (
@@ -544,7 +548,7 @@ class OpenAIGPT(LanguageModel):
         Order of priority:
         - (1) Params (mainly max_tokens) in the chat/achat/generate/agenerate call
                 (these are passed in via kwargs)
-        - (2) Params in OpenAIGPTConfi.params (of class OpenAICallParams)
+        - (2) Params in OpenAIGPTConfig.params (of class OpenAICallParams)
         - (3) Specific Params in OpenAIGPTConfig (just temperature for now)
         """
         params = dict(
@@ -614,6 +618,7 @@ class OpenAIGPT(LanguageModel):
         self,
         event,
         chat: bool = False,
+        tool_deltas: List[Dict[str, Any]] = [],
         has_function: bool = False,
         completion: str = "",
         function_args: str = "",
@@ -637,6 +642,7 @@ class OpenAIGPT(LanguageModel):
             choices = [{}]
         event_args = ""
         event_fn_name = ""
+        event_tool_deltas: Optional[List[Dict[str, Any]]] = None
 
         # The first two events in the stream of Azure OpenAI is useless.
         # In the 1st: choices list is empty, in the 2nd: the dict delta has null content
@@ -648,6 +654,10 @@ class OpenAIGPT(LanguageModel):
                     event_fn_name = delta["function_call"]["name"]
                 if "arguments" in delta["function_call"]:
                     event_args = delta["function_call"]["arguments"]
+            if "tool_calls" in delta and delta["tool_calls"] is not None:
+                # it's a list of deltas, usually just one
+                event_tool_deltas = delta["tool_calls"]
+                tool_deltas += event_tool_deltas
         else:
             event_text = choices[0]["text"]
         if event_text:
@@ -670,7 +680,31 @@ class OpenAIGPT(LanguageModel):
                 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"]:
+
+        if event_tool_deltas is not None:
+            # print out streaming tool calls
+            for td in event_tool_deltas:
+                if td["function"]["name"] is not None:
+                    tool_fn_name = td["function"]["name"]
+                    if not is_async:
+                        sys.stdout.write(
+                            Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
+                        )
+                        sys.stdout.flush()
+                        self.config.streamer(tool_fn_name)
+                if td["function"]["arguments"] != "":
+                    tool_fn_args = td["function"]["arguments"]
+                    if not is_async:
+                        sys.stdout.write(Colors().GREEN + tool_fn_args)
+                        sys.stdout.flush()
+                        self.config.streamer(tool_fn_args)
+
+        # show this delta in the stream
+        if choices[0].get("finish_reason", "") in [
+            "stop",
+            "function_call",
+            "tool_calls",
+        ]:
             # for function_call, finish_reason does not necessarily
             # contain "function_call" as mentioned in the docs.
             # So we check for "stop" or "function_call" here.
@@ -699,6 +733,7 @@ class OpenAIGPT(LanguageModel):
         sys.stdout.write(Colors().GREEN)
         sys.stdout.flush()
         has_function = False
+        tool_deltas: List[Dict[str, Any]] = []
         try:
             for event in response:
                 (
@@ -710,6 +745,7 @@ class OpenAIGPT(LanguageModel):
                 ) = self._process_stream_event(
                     event,
                     chat=chat,
+                    tool_deltas=tool_deltas,
                     has_function=has_function,
                     completion=completion,
                     function_args=function_args,
@@ -725,11 +761,11 @@ class OpenAIGPT(LanguageModel):
 
         return self._create_stream_response(
             chat=chat,
+            tool_deltas=tool_deltas,
             has_function=has_function,
             completion=completion,
             function_args=function_args,
             function_name=function_name,
-            is_async=False,
         )
 
     @async_retry_with_exponential_backoff
@@ -754,6 +790,7 @@ class OpenAIGPT(LanguageModel):
         sys.stdout.write(Colors().GREEN)
         sys.stdout.flush()
         has_function = False
+        tool_deltas: List[Dict[str, Any]] = []
         try:
             async for event in response:
                 (
@@ -765,6 +802,7 @@ class OpenAIGPT(LanguageModel):
                 ) = self._process_stream_event(
                     event,
                     chat=chat,
+                    tool_deltas=tool_deltas,
                     has_function=has_function,
                     completion=completion,
                     function_args=function_args,
@@ -780,52 +818,182 @@ class OpenAIGPT(LanguageModel):
 
         return self._create_stream_response(
             chat=chat,
+            tool_deltas=tool_deltas,
             has_function=has_function,
             completion=completion,
             function_args=function_args,
             function_name=function_name,
-            is_async=True,
         )
 
+    @staticmethod
+    def tool_deltas_to_tools(tools: List[Dict[str, Any]]) -> Tuple[
+        str,
+        List[OpenAIToolCall],
+        List[Dict[str, Any]],
+    ]:
+        """
+        Convert accumulated tool-call deltas to OpenAIToolCall objects.
+        Adapted from this excellent code:
+         https://community.openai.com/t/help-for-function-calls-with-streaming/627170/2
+
+        Args:
+            tools: list of tool deltas received from streaming API
+
+        Returns:
+            str: plain text corresponding to tool calls that failed to parse
+            List[OpenAIToolCall]: list of OpenAIToolCall objects
+            List[Dict[str, Any]]: list of tool dicts
+                (to reconstruct OpenAI API response, so it can be cached)
+        """
+        # Initialize a dictionary with default values
+
+        # idx -> dict repr of tool
+        # (used to simulate OpenAIResponse object later, and also to
+        # accumulate function args as strings)
+        idx2tool_dict: Dict[str, Dict[str, Any]] = defaultdict(
+            lambda: {
+                "id": None,
+                "function": {"arguments": "", "name": None},
+                "type": None,
+            }
+        )
+
+        for tool_delta in tools:
+            if tool_delta["id"] is not None:
+                idx2tool_dict[tool_delta["index"]]["id"] = tool_delta["id"]
+
+            if tool_delta["function"]["name"] is not None:
+                idx2tool_dict[tool_delta["index"]]["function"]["name"] = tool_delta[
+                    "function"
+                ]["name"]
+
+            idx2tool_dict[tool_delta["index"]]["function"]["arguments"] += tool_delta[
+                "function"
+            ]["arguments"]
+
+            if tool_delta["type"] is not None:
+                idx2tool_dict[tool_delta["index"]]["type"] = tool_delta["type"]
+
+        # (try to) parse the fn args of each tool
+        contents: List[str] = []
+        good_indices = []
+        id2args: Dict[str, None | Dict[str, Any]] = {}
+        for idx, tool_dict in idx2tool_dict.items():
+            failed_content, args_dict = OpenAIGPT._parse_function_args(
+                tool_dict["function"]["arguments"]
+            )
+            # used to build tool_calls_list below
+            id2args[tool_dict["id"]] = args_dict or None  # if {}, store as None
+            if failed_content != "":
+                contents.append(failed_content)
+            else:
+                good_indices.append(idx)
+
+        # remove the failed tool calls
+        idx2tool_dict = {
+            idx: tool_dict
+            for idx, tool_dict in idx2tool_dict.items()
+            if idx in good_indices
+        }
+
+        # create OpenAIToolCall list
+        tool_calls_list = [
+            OpenAIToolCall(
+                id=tool_dict["id"],
+                function=LLMFunctionCall(
+                    name=tool_dict["function"]["name"],
+                    arguments=id2args.get(tool_dict["id"]),
+                ),
+                type=tool_dict["type"],
+            )
+            for tool_dict in idx2tool_dict.values()
+        ]
+        return "\n".join(contents), tool_calls_list, list(idx2tool_dict.values())
+
+    @staticmethod
+    def _parse_function_args(args: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        Try to parse the `args` string as function args.
+
+        Args:
+            args: string containing function args
+
+        Returns:
+            Tuple of content, function name and args dict.
+            If parsing unsuccessful, returns the original string as content,
+            else returns the args dict.
+        """
+        content = ""
+        args_dict = {}
+        try:
+            stripped_fn_args = args.strip()
+            dict_or_list = parse_imperfect_json(stripped_fn_args)
+            if not isinstance(dict_or_list, dict):
+                raise ValueError(
+                    f"""
+                        Invalid function args: {stripped_fn_args} 
+                        parsed as {dict_or_list},
+                        which is not a valid dict.
+                        """
+                )
+            args_dict = dict_or_list
+        except (SyntaxError, ValueError) as e:
+            logging.warning(
+                f"""
+                    Parsing OpenAI function args failed: {args};
+                    treating args as normal message. Error detail:
+                    {e}
+                    """
+            )
+            content = args
+
+        return content, args_dict
+
     def _create_stream_response(
         self,
         chat: bool = False,
+        tool_deltas: List[Dict[str, Any]] = [],
         has_function: bool = False,
         completion: str = "",
         function_args: str = "",
         function_name: str = "",
-        is_async: bool = False,
     ) -> Tuple[LLMResponse, Dict[str, Any]]:
+        """
+        Create an LLMResponse object from the streaming API response.
+
+        Args:
+            chat: whether in chat-mode (or else completion-mode)
+            tool_deltas: list of tool deltas received from streaming API
+            has_function: whether the response contains a function_call
+            completion: completion text
+            function_args: string representing function args
+            function_name: name of the function
+        Returns:
+            Tuple consisting of:
+                LLMResponse object (with message, usage),
+                Dict version of OpenAIResponse object (with choices, usage)
+                    (this is needed so we can cache the response, as if it were
+                    a non-streaming response)
+        """
         # check if function_call args are valid, if not,
         # treat this as a normal msg, not a function call
-        args = {}
+        args: Dict[str, Any] = {}
         if has_function and function_args != "":
-            try:
-                stripped_fn_args = function_args.strip()
-                dict_or_list = parse_imperfect_json(stripped_fn_args)
-                if not isinstance(dict_or_list, dict):
-                    raise ValueError(
-                        f"""
-                        Invalid function args: {stripped_fn_args} 
-                        parsed as {dict_or_list},
-                        which is not a valid dict.
-                        """
-                    )
-                args = dict_or_list
-            except (SyntaxError, ValueError) as e:
-                logging.warning(
-                    f"""
-                    Parsing OpenAI function args failed: {function_args};
-                    treating args as normal message. Error detail:
-                    {e}
-                    """
-                )
+            content, args = self._parse_function_args(function_args)
+            completion = completion + content
+            if content != "":
                 has_function = False
-                completion = completion + function_args
 
         # mock openai response so we can cache it
         if chat:
+            failed_content, tool_calls, tool_dicts = OpenAIGPT.tool_deltas_to_tools(
+                tool_deltas,
+            )
+            completion = completion + "\n" + failed_content
             msg: Dict[str, Any] = dict(message=dict(content=completion))
+            if len(tool_dicts) > 0:
+                msg["message"]["tool_calls"] = tool_dicts
+
             if has_function:
                 function_call = LLMFunctionCall(name=function_name)
                 function_call_dict = function_call.dict()
@@ -839,6 +1007,8 @@ class OpenAIGPT(LanguageModel):
             # non-chat mode has no function_call
             msg = dict(text=completion)
 
+        # create an OpenAIResponse object so we can cache it as if it were
+        # a non-streaming response
         openai_response = OpenAIResponse(
             choices=[msg],
             usage=dict(total_tokens=0),
@@ -847,6 +1017,7 @@ class OpenAIGPT(LanguageModel):
             LLMResponse(
                 message=completion,
                 cached=False,
+                oai_tool_calls=tool_calls or None,  # don't allow empty list [] here
                 function_call=function_call if has_function else None,
             ),
             openai_response.dict(),
@@ -1061,16 +1232,19 @@ class OpenAIGPT(LanguageModel):
         self,
         messages: Union[str, List[LLMMessage]],
         max_tokens: int = 200,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
         functions: Optional[List[LLMFunctionSpec]] = None,
         function_call: str | Dict[str, str] = "auto",
     ) -> LLMResponse:
         self.run_on_first_use()
 
-        if functions is not None and not self.is_openai_chat_model():
+        if [functions, tools] != [None, None] and not self.is_openai_chat_model():
             raise ValueError(
                 f"""
-                `functions` can only be specified for OpenAI chat models;
-                {self.config.chat_model} does not support function-calling.
+                `functions` and `tools` can only be specified for OpenAI chat LLMs, 
+                or LLMs served via an OpenAI-compatible API.
+                {self.config.chat_model} does not support function-calling or tools.
                 Instead, please use Langroid's ToolMessages, which are equivalent.
                 In the ChatAgentConfig, set `use_functions_api=False` 
                 and `use_tools=True`, this will enable ToolMessages.
@@ -1094,7 +1268,9 @@ class OpenAIGPT(LanguageModel):
             prompt = self.config.hf_formatter.format(messages)
             return self.generate(prompt=prompt, max_tokens=max_tokens)
         try:
-            return self._chat(messages, max_tokens, functions, function_call)
+            return self._chat(
+                messages, max_tokens, tools, tool_choice, functions, function_call
+            )
         except Exception as e:
             # log and re-raise exception
             logging.error(friendly_error(e, "Error in OpenAIGPT.chat: "))
@@ -1104,16 +1280,18 @@ class OpenAIGPT(LanguageModel):
         self,
         messages: Union[str, List[LLMMessage]],
         max_tokens: int = 200,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
         functions: Optional[List[LLMFunctionSpec]] = None,
         function_call: str | Dict[str, str] = "auto",
     ) -> LLMResponse:
         self.run_on_first_use()
 
-        if functions is not None and not self.is_openai_chat_model():
+        if [functions, tools] != [None, None] and not self.is_openai_chat_model():
             raise ValueError(
                 f"""
-                `functions` can only be specified for OpenAI chat models;
-                {self.config.chat_model} does not support function-calling.
+                `functions` and `tools` can only be specified for OpenAI chat models;
+                {self.config.chat_model} does not support function-calling or tools.
                 Instead, please use Langroid's ToolMessages, which are equivalent.
                 In the ChatAgentConfig, set `use_functions_api=False` 
                 and `use_tools=True`, this will enable ToolMessages.
@@ -1146,7 +1324,14 @@ class OpenAIGPT(LanguageModel):
             prompt = formatter.format(messages)
             return await self.agenerate(prompt=prompt, max_tokens=max_tokens)
         try:
-            result = await self._achat(messages, max_tokens, functions, function_call)
+            result = await self._achat(
+                messages,
+                max_tokens,
+                tools,
+                tool_choice,
+                functions,
+                function_call,
+            )
             return result
         except Exception as e:
             # log and re-raise exception
@@ -1209,9 +1394,12 @@ class OpenAIGPT(LanguageModel):
         self,
         messages: Union[str, List[LLMMessage]],
         max_tokens: int,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
         functions: Optional[List[LLMFunctionSpec]] = None,
         function_call: str | Dict[str, str] = "auto",
     ) -> Dict[str, Any]:
+        """Prepare args for LLM chat-completion API call"""
         if isinstance(messages, str):
             llm_messages = [
                 LLMMessage(role=Role.SYSTEM, content="You are a helpful assistant."),
@@ -1243,6 +1431,19 @@ class OpenAIGPT(LanguageModel):
                     function_call=function_call,
                 )
             )
+        if tools is not None:
+            args.update(
+                dict(
+                    tools=[
+                        dict(
+                            type="function",
+                            function=t.function.dict(),
+                        )
+                        for t in tools
+                    ],
+                    tool_choice=tool_choice,
+                )
+            )
         return args
 
     def _process_chat_completion_response(
@@ -1281,6 +1482,7 @@ class OpenAIGPT(LanguageModel):
         """
         message = response["choices"][0]["message"]
         msg = message["content"] or ""
+
         if message.get("function_call") is None:
             fun_call = None
         else:
@@ -1297,10 +1499,24 @@ class OpenAIGPT(LanguageModel):
                 args_str = message["function_call"]["arguments"] or ""
                 msg_str = message["content"] or ""
                 msg = msg_str + args_str
-
+        oai_tool_calls = None
+        if message.get("tool_calls") is not None:
+            oai_tool_calls = []
+            for tool_call_dict in message["tool_calls"]:
+                try:
+                    tool_call = OpenAIToolCall.from_dict(tool_call_dict)
+                    oai_tool_calls.append(tool_call)
+                except (ValueError, SyntaxError):
+                    logging.warning(
+                        "Could not parse tool call: "
+                        f"{json.dumps(tool_call_dict)} "
+                        "treating as normal non-tool message"
+                    )
+                    msg = msg + "\n" + json.dumps(tool_call_dict)
         return LLMResponse(
             message=msg.strip() if msg is not None else "",
             function_call=fun_call,
+            oai_tool_calls=oai_tool_calls or None,  # don't allow empty list [] here
             cached=cached,
             usage=self._get_non_stream_token_usage(cached, response),
         )
@@ -1309,6 +1525,8 @@ class OpenAIGPT(LanguageModel):
         self,
         messages: Union[str, List[LLMMessage]],
         max_tokens: int,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
         functions: Optional[List[LLMFunctionSpec]] = None,
         function_call: str | Dict[str, str] = "auto",
     ) -> LLMResponse:
@@ -1333,6 +1551,8 @@ class OpenAIGPT(LanguageModel):
         args = self._prep_chat_completion(
             messages,
             max_tokens,
+            tools,
+            tool_choice,
             functions,
             function_call,
         )
@@ -1351,6 +1571,8 @@ class OpenAIGPT(LanguageModel):
         self,
         messages: Union[str, List[LLMMessage]],
         max_tokens: int,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
         functions: Optional[List[LLMFunctionSpec]] = None,
         function_call: str | Dict[str, str] = "auto",
     ) -> LLMResponse:
@@ -1360,6 +1582,8 @@ class OpenAIGPT(LanguageModel):
         args = self._prep_chat_completion(
             messages,
             max_tokens,
+            tools,
+            tool_choice,
             functions,
             function_call,
         )

{langroid-0.6.7.dist-info → langroid-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.6.7
+Version: 0.8.0
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -235,6 +235,8 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Aug 2024:** 
+  - **[0.7.0](https://github.com/langroid/langroid/releases/tag/0.7.0)** OpenAI tools API support.
 - **Jul 2024:**
   - **[0.3.0](https://github.com/langroid/langroid/releases/tag/0.3.0)**: Added [FastEmbed](https://qdrant.github.io/fastembed/qdrant/Usage_With_Qdrant/) embeddings from Qdrant
 - **Jun 2024:**

{langroid-0.6.7.dist-info → langroid-0.8.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 langroid/__init__.py,sha256=z_fCOLQJPOw3LLRPBlFB5-2HyCjpPgQa4m4iY5Fvb8Y,1800
 langroid/agent/__init__.py,sha256=ll0Cubd2DZ-fsCMl7e10hf9ZjFGKzphfBco396IKITY,786
-langroid/agent/base.py,sha256=x6SbInDGJUL_kusr-ligYsCwuaid2CmcRkzlucOXyw0,38999
+langroid/agent/base.py,sha256=EOAdZ2K0Yjjdt3zkjNsUhHgRvYZT-eIgRbY4ldjt6hY,46995
 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=M5tdp1HuFthhMChLNd5XKBWxoiMSTkOuXlM8JoRLiUk,41586
-langroid/agent/chat_document.py,sha256=MwtNABK28tfSzqCeQlxoauT8uPn8oldU7dlnrX8aQ10,11232
+langroid/agent/callbacks/chainlit.py,sha256=Qedk1-CBCgo9PdaIa7AboLBFCTgAMg9q5nGmoqpZ378,22050
+langroid/agent/chat_agent.py,sha256=4bgLHBFSxL1dw1UAEF5zfCqnp_ss0MUUTOnjKkfOJRQ,45401
+langroid/agent/chat_document.py,sha256=y3QBdpclTBuqs42c3lLO9HU4s70PyK133HXZxyaxNZ8,16322
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
-langroid/agent/openai_assistant.py,sha256=3saI9PwF8IZNJcjqyUy-rj73TInAzdlk14LiOvT_Dkc,33548
+langroid/agent/openai_assistant.py,sha256=TlMi5QecrxxhZ7TW03wB161elSSQYwL7H0xk8g7HawU,33879
 langroid/agent/special/__init__.py,sha256=gik_Xtm_zV7U9s30Mn8UX3Gyuy4jTjQe9zjiE3HWmEo,1273
 langroid/agent/special/doc_chat_agent.py,sha256=8NPAhMnHkFUolQ8EHos40tz5Vwuz_m33NjUfjheXWXY,54569
 langroid/agent/special/lance_doc_chat_agent.py,sha256=Hjpu6u9UPAFMg5J6K97PRFaLbNrGhInC0N9oGi09CeY,10006
@@ -29,16 +29,16 @@ langroid/agent/special/neo4j/utils/system_message.py,sha256=_2NKX2Sx_7nLGNk_0rUy
 langroid/agent/special/relevance_extractor_agent.py,sha256=zIx8GUdVo1aGW6ASla0NPQjYYIpmriK_TYMijqAx3F8,4796
 langroid/agent/special/retriever_agent.py,sha256=lvMvf-u9rSosg4YASuFdUbGLgkzLPknXAbJZfZ1LZCc,1868
 langroid/agent/special/sql/__init__.py,sha256=mWfmm1QpXCezpFOS2eI57M0L_Ok3q5_ukG8tXBnBrEA,319
-langroid/agent/special/sql/sql_chat_agent.py,sha256=8ZCKjN8GE4I4_G_YkMoZExT6StOWcXZYD95DQ2yI1ro,14436
+langroid/agent/special/sql/sql_chat_agent.py,sha256=PArNz9up0atw0cJet1LOfWlpW6xgofVBDR7Z3xvpzHk,16592
 langroid/agent/special/sql/utils/__init__.py,sha256=JFif6CRTrN-bc91uuAI4K9fe2ndIWSNMVxJ0WA68--M,446
 langroid/agent/special/sql/utils/description_extractors.py,sha256=cX8TIpmTPXZXQTMpIi3OUFwFsPywxFFdurpx717Kq0I,6529
 langroid/agent/special/sql/utils/populate_metadata.py,sha256=1J22UsyEPKzwK0XlJZtYn9r6kYc0FXIr8-lZrndYlhc,3131
 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=vKM2dmRYSH4i_VA0lf2axUtZcTGU44rVHz6EyxI4kG0,73990
+langroid/agent/task.py,sha256=eCA91yr6DSaRRGteTbSki-liMl6nspzRd_5Gin_ZFYw,75176
 langroid/agent/team.py,sha256=88VNRSmK35WEl620GfBzuIrBASXYSeBZ8yDKX-nP_Bo,75778
-langroid/agent/tool_message.py,sha256=ggxmIZO_wi6x5uD-YWml07Bfgms-ohOSKHyQQdJFi4o,9571
+langroid/agent/tool_message.py,sha256=XPM6whazpUOQu_vM2D4Q_L9tV6Vs9OTXNrGchwcqD_o,9768
 langroid/agent/tools/__init__.py,sha256=e-63cfwQNk_ftRKQwgDAJQK16QLbRVWDBILeXIc7wLk,402
 langroid/agent/tools/duckduckgo_search_tool.py,sha256=NhsCaGZkdv28nja7yveAhSK_w6l_Ftym8agbrdzqgfo,1935
 langroid/agent/tools/extract_tool.py,sha256=u5lL9rKBzaLBOrRyLnTAZ97pQ1uxyLP39XsWMnpaZpw,3789
@@ -48,7 +48,7 @@ langroid/agent/tools/metaphor_search_tool.py,sha256=qj4gt453cLEX3EGW7nVzVu6X7LCd
 langroid/agent/tools/note_tool.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=G4DiXuOt2nQ2fU7qvtJMdLyyf-rK7RZwLsFxsAUfk-Y,5606
+langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,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
@@ -67,12 +67,14 @@ langroid/embedding_models/protoc/embeddings_pb2.pyi,sha256=UkNy7BrNsmQm0vLb3NtGX
 langroid/embedding_models/protoc/embeddings_pb2_grpc.py,sha256=9dYQqkW3JPyBpSEjeGXTNpSqAkC-6FPtBHyteVob2Y8,2452
 langroid/embedding_models/remote_embeds.py,sha256=6_kjXByVbqhY9cGwl9R83ZcYC2km-nGieNNAo1McHaY,5151
 langroid/exceptions.py,sha256=w_Cr41nPAmsa6gW5nNFaO9yDcBCWdQqRspL1jYvZf5w,2209
+langroid/language_models/.chainlit/config.toml,sha256=1t5lHORGzc2E6dkaO9P15jYHu2w-4Kl9pYjpDPc84vs,3716
+langroid/language_models/.chainlit/translations/en-US.json,sha256=DAFz2HjOFFfboCStrUfKFg2BpplJPK_OOtixwF_GivY,9931
 langroid/language_models/__init__.py,sha256=1sUGobooTqq77XC7LxKsvME0RgSd5GGmeyrPo9SMh4U,940
 langroid/language_models/azure_openai.py,sha256=G4le3j4YLHV7IwgB2C37hO3MKijZ1KjynbYlEvpIF7Y,6214
-langroid/language_models/base.py,sha256=nhY-AdSkfqaW4hzeIekxxZs29AWLd7X7GYhRygU9L74,17527
+langroid/language_models/base.py,sha256=L76syCytos5IaQ5tpgToYJHThch4gA9uyjeMmjWjZ8E,21757
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
-langroid/language_models/mock_lm.py,sha256=qdgj-wtbQBXlibo_0rIRfCt0hGTPRoxy1C4VjN6quI4,2707
-langroid/language_models/openai_gpt.py,sha256=BI5q9AVEJA-jA0G0Eg60T4NF1AdNLSd1-sOSHXnxaYU,52428
+langroid/language_models/mock_lm.py,sha256=2Ka05SVGSUy096bsa2AyjaqC5jmcFoe7HycpdnICTIw,3031
+langroid/language_models/openai_gpt.py,sha256=Bv-FCva9q0oO85VSqNpaxEYI8zPwVXpHmmfV7O8QRhU,61325
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
 langroid/language_models/prompt_formatter/hf_formatter.py,sha256=TFL6ppmeQWnzr6CKQzRZFYY810zE1mr8DZnhw6i85ok,5217
@@ -134,8 +136,8 @@ langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3Hmh
 langroid/vector_store/momento.py,sha256=qR-zBF1RKVHQZPZQYW_7g-XpTwr46p8HJuYPCkfJbM4,10534
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=v88lqFkepADvlN6lByUj9I4NEKa9X9lWH16uTPPbYrE,17457
-pyproject.toml,sha256=WOkJHLl-xkyt4KNDhhl1B9I5KTg00EuyYcBQ5fgPZa4,7063
-langroid-0.6.7.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.6.7.dist-info/METADATA,sha256=KWqO3AOdYeXoUSIJW3hdTkfnzfHwSanXvqZvAsNrtgQ,54402
-langroid-0.6.7.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langroid-0.6.7.dist-info/RECORD,,
+pyproject.toml,sha256=pK1C4vWrb5-NkREBDkFao-3Pi-xXJXMjh_wjedpjFAk,7063
+langroid-0.8.0.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.8.0.dist-info/METADATA,sha256=i2_aKdjkgYcGAYMXEG2F3NC59yVI1w3uidn3edm5wAY,54518
+langroid-0.8.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langroid-0.8.0.dist-info/RECORD,,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.6.7"
+version = "0.8.0"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"