Merge pull request #555 from lion-agi/update-react2

Various Updates:  check pr

lionagi/operations/ReAct/ReAct.py

@@ -47,6 +47,8 @@ async def ReAct(
     analysis_model: iModel | None = None,
     verbose_analysis: bool = False,
     verbose_length: int = None,
+    include_token_usage_to_model: bool = True,
+    continue_after_failed_response: bool = False,
     **kwargs,
 ):
     outs = []
@@ -73,6 +75,8 @@ async def ReAct(
             verbose_analysis=verbose_analysis,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
+            continue_after_failed_response=continue_after_failed_response,
             **kwargs,
         ):
             analysis, str_ = i
@@ -101,6 +105,8 @@ async def ReAct(
             analysis_model=analysis_model,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
+            continue_after_failed_response=continue_after_failed_response,
             **kwargs,
         ):
             outs.append(i)
@@ -131,6 +137,8 @@ async def ReActStream(
     verbose_analysis: bool = False,
     display_as: Literal["json", "yaml"] = "yaml",
     verbose_length: int = None,
+    include_token_usage_to_model: bool = True,
+    continue_after_failed_response: bool = False,
     **kwargs,
 ) -> AsyncGenerator:
     irfm: FieldModel | None = None
@@ -213,6 +221,9 @@ async def ReActStream(
     kwargs_for_operate = copy(kwargs)
     kwargs_for_operate["actions"] = True
     kwargs_for_operate["reason"] = True
+    kwargs_for_operate["include_token_usage_to_model"] = (
+        include_token_usage_to_model
+    )
 
     # Step 1: Generate initial ReAct analysis
     analysis: ReActAnalysis = await branch.operate(
@@ -255,7 +266,7 @@ async def ReActStream(
             if isinstance(analysis, dict)
             else False
         )
-        and (extensions if max_extensions else 0) > 0
+        and (extensions - 1 if max_extensions else 0) > 0
     ):
         new_instruction = None
         if extensions == max_extensions:
@@ -272,6 +283,9 @@ async def ReActStream(
         operate_kwargs["reason"] = True
         operate_kwargs["response_format"] = ReActAnalysis
         operate_kwargs["action_strategy"] = analysis.action_strategy
+        operate_kwargs["include_token_usage_to_model"] = (
+            include_token_usage_to_model
+        )
         if analysis.action_batch_size:
             operate_kwargs["action_batch_size"] = analysis.action_batch_size
         if irfm:
@@ -289,6 +303,7 @@ async def ReActStream(
             operate_kwargs["guidance"] = guide + operate_kwargs.get(
                 "guidance", ""
             )
+            operate_kwargs["reasoning_effort"] = reasoning_effort
 
         analysis = await branch.operate(
             instruction=new_instruction,
@@ -298,6 +313,16 @@ async def ReActStream(
         )
         round_count += 1
 
+        if isinstance(analysis, dict) and all(
+            i is None for i in analysis.values()
+        ):
+            if not continue_after_failed_response:
+                raise ValueError(
+                    "All values in the response are None. "
+                    "This might be due to a failed response. "
+                    "Set `continue_after_failed_response=True` to ignore this error."
+                )
+
         # If verbose, show round analysis
         if verbose_analysis:
             str_ = f"\n### ReAct Round No.{round_count} Analysis:\n"
@@ -329,6 +354,15 @@ async def ReActStream(
             response_format=response_format,
             **(response_kwargs or {}),
         )
+        if isinstance(analysis, dict) and all(
+            i is None for i in analysis.values()
+        ):
+            if not continue_after_failed_response:
+                raise ValueError(
+                    "All values in the response are None. "
+                    "This might be due to a failed response. "
+                    "Set `continue_after_failed_response=True` to ignore this error."
+                )
     except Exception:
         out = branch.msgs.last_response.response
 

lionagi/operations/ReAct/utils.py

@@ -30,6 +30,8 @@ class ReActAnalysis(BaseModel):
     2) A list of planned actions to perform before finalizing,
     3) Indication whether more expansions/rounds are needed,
     4) Additional tuning knobs: how to handle validation, how to execute actions, etc.
+    Remember do not repeat yourself, and aim to use the most efficient way to achieve
+    the goal to user's satisfaction.
     """
 
     # Standard ReAct strings for controlling expansions:
@@ -38,11 +40,12 @@ class ReActAnalysis(BaseModel):
         "If you are not ready to finalize, set extension_needed to True. "
         "hint: you should set extension_needed to True if the overall goal"
         "is not yet achieved. Do not set it to False, if you are just providing"
-        "an interim answer. You have up to {extensions} expansions. Please continue."
+        "an interim answer. You have up to {extensions} expansions. Please "
+        "strategize accordingly and continue."
     )
     CONTINUE_EXT_PROMPT: ClassVar[str] = (
         "Another round is available. You may do multiple actions if needed. "
-        "You have up to {extensions} expansions. Please continue."
+        "You have up to {extensions} expansions. Please strategize accordingly and continue."
     )
     ANSWER_PROMPT: ClassVar[str] = (
         "Given your reasoning and actions, please now provide the final answer "

lionagi/operations/chat/chat.py

@@ -36,6 +36,7 @@ async def chat(
     image_detail: Literal["low", "high", "auto"] = None,
     plain_content: str = None,
     return_ins_res_message: bool = False,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ) -> tuple[Instruction, AssistantResponse]:
     ins: Instruction = branch.msgs.create_instruction(
@@ -151,11 +152,12 @@ async def chat(
     kwargs["messages"] = [i.chat_msg for i in messages]
     imodel = imodel or branch.chat_model
 
-    meth = (
-        imodel.invoke
-        if ("stream" not in kwargs or not kwargs["stream"])
-        else imodel.stream
-    )
+    meth = imodel.invoke
+    if "stream" not in kwargs or not kwargs["stream"]:
+        kwargs["include_token_usage_to_model"] = include_token_usage_to_model
+    else:
+        meth = imodel.stream
+
     api_call = await meth(**kwargs)
     branch._log_manager.log(Log.create(api_call))
 

lionagi/operations/communicate/communicate.py

@@ -35,6 +35,7 @@ async def communicate(
     fuzzy_match_kwargs=None,
     clear_messages=False,
     operative_model=None,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ):
     if operative_model:
@@ -80,6 +81,7 @@ async def communicate(
         image_detail=image_detail,
         plain_content=plain_content,
         return_ins_res_message=True,
+        include_token_usage_to_model=include_token_usage_to_model,
         **kwargs,
     )
     branch.msgs.add_message(instruction=ins)

lionagi/operations/interpret/interpret.py

@@ -20,7 +20,8 @@ async def interpret(
     instruction = (
         "You are given a user's raw instruction or question. Your task is to rewrite it into a clearer,"
         "more structured prompt for an LLM or system, making any implicit or missing details explicit. "
-        "Return only the re-written prompt."
+        "Return only the re-written prompt. Do not assume any details not mentioned in the input, nor "
+        "give additional instruction than what is explicitly stated."
     )
     guidance = (
         f"Domain hint: {domain or 'general'}. "

lionagi/operations/operate/operate.py

@@ -63,6 +63,7 @@ async def operate(
     ] = "return_value",
     operative_model: type[BaseModel] = None,
     request_model: type[BaseModel] = None,
+    include_token_usage_to_model: bool = False,
     **kwargs,
 ) -> list | BaseModel | None | dict | str:
     if operative_model:
@@ -138,6 +139,7 @@ async def operate(
         image_detail=image_detail,
         tool_schemas=tool_schemas,
         return_ins_res_message=True,
+        include_token_usage_to_model=include_token_usage_to_model,
         **kwargs,
     )
     branch.msgs.add_message(instruction=ins)

lionagi/service/endpoints/base.py

@@ -349,11 +349,37 @@ class APICalling(Event):
     endpoint: EndPoint = Field(exclude=True)
     is_cached: bool = Field(default=False, exclude=True)
     should_invoke_endpoint: bool = Field(default=True, exclude=True)
+    include_token_usage_to_model: bool = Field(
+        default=False,
+        exclude=True,
+        description="Whether to include token usage information into instruction messages",
+    )
 
     @model_validator(mode="after")
     def _validate_streaming(self) -> Self:
         if self.payload.get("stream") is True:
             self.streaming = True
+
+        if self.include_token_usage_to_model:
+            if isinstance(self.payload["messages"][-1], dict):
+                required_tokens = self.required_tokens
+                self.payload["messages"][-1][
+                    "content"
+                ] += f"\n\nEstimated Current Token Usage: {required_tokens}"
+                if "model" in self.payload:
+                    if (
+                        self.payload["model"].startswith("gpt-4")
+                        or "o1mini" in self.payload["model"]
+                        or "o1-preview" in self.payload["model"]
+                    ):
+                        self.payload["messages"][-1]["content"] += "/128_000"
+                    elif "o1" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+                    elif "sonnet" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+                    elif "haiku" in self.payload["model"]:
+                        self.payload["messages"][-1]["content"] += "/200_000"
+
         return self
 
     @property

lionagi/service/imodel.py

@@ -162,7 +162,9 @@ def __init__(
         else:
             self.streaming_process_func = streaming_process_func
 
-    def create_api_calling(self, **kwargs) -> APICalling:
+    def create_api_calling(
+        self, include_token_usage_to_model: bool = False, **kwargs
+    ) -> APICalling:
         """Constructs an `APICalling` object from endpoint-specific payload.
 
         Args:
@@ -183,6 +185,7 @@ def create_api_calling(self, **kwargs) -> APICalling:
             endpoint=self.endpoint,
             is_cached=payload.get("is_cached", False),
             should_invoke_endpoint=self.should_invoke_endpoint,
+            include_token_usage_to_model=include_token_usage_to_model,
         )
 
     async def process_chunk(self, chunk) -> None:
@@ -200,7 +203,12 @@ async def process_chunk(self, chunk) -> None:
                 return await self.streaming_process_func(chunk)
             return self.streaming_process_func(chunk)
 
-    async def stream(self, api_call=None, **kwargs) -> AsyncGenerator:
+    async def stream(
+        self,
+        api_call=None,
+        include_token_usage_to_model: bool = False,
+        **kwargs,
+    ) -> AsyncGenerator:
         """Performs a streaming API call with the given arguments.
 
         Args:
@@ -214,7 +222,10 @@ async def stream(self, api_call=None, **kwargs) -> AsyncGenerator:
         """
         if api_call is None:
             kwargs["stream"] = True
-            api_call = self.create_api_calling(**kwargs)
+            api_call = self.create_api_calling(
+                include_token_usage_to_model=include_token_usage_to_model,
+                **kwargs,
+            )
             await self.executor.append(api_call)
 
         if (

lionagi/service/providers/openai_/chat_completions.py

@@ -89,6 +89,8 @@ def create_payload(self, **kwargs) -> dict:
             payload.pop("top_p", None)
             if payload["messages"][0].get("role") == "system":
                 payload["messages"][0]["role"] = "developer"
+        else:
+            payload.pop("reasoning_effort", None)
 
         return {
             "payload": payload,

lionagi/session/branch.py

@@ -941,6 +941,7 @@ async def operate(
         ] = "return_value",
         operative_model: type[BaseModel] = None,
         request_model: type[BaseModel] = None,
+        include_token_usage_to_model: bool = False,
         **kwargs,
     ) -> list | BaseModel | None | dict | str:
         """
@@ -1028,6 +1029,8 @@ async def operate(
                 Alias for `response_format`.
             request_model (type[BaseModel], optional):
                 Another alias for `response_format`.
+            include_token_usage_to_model:
+                If `True`, includes token usage in the model messages.
             **kwargs:
                 Additional keyword arguments passed to the LLM via `branch.chat()`.
 
@@ -1080,6 +1083,7 @@ async def operate(
             operative_model=operative_model,
             request_model=request_model,
             imodel=imodel,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1106,6 +1110,7 @@ async def communicate(
         fuzzy_match_kwargs: dict = None,
         clear_messages: bool = False,
         operative_model: type[BaseModel] = None,
+        include_token_usage_to_model: bool = False,
         **kwargs,
     ):
         """
@@ -1190,6 +1195,7 @@ async def communicate(
             fuzzy_match_kwargs=fuzzy_match_kwargs,
             clear_messages=clear_messages,
             operative_model=operative_model,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1639,6 +1645,7 @@ async def ReAct(
         analysis_model: iModel | None = None,
         verbose: bool = False,
         verbose_length: int = None,
+        include_token_usage_to_model: bool = True,
         **kwargs,
     ):
         """
@@ -1688,6 +1695,12 @@ async def ReAct(
             analysis_model (iModel | None, optional):
                 A custom LLM model for generating the ReAct analysis steps. If `None`,
                 uses the branch's default `chat_model`.
+            include_token_usage_to_model:
+                If `True`, includes token usage in the model messages.
+            verbose (bool):
+                If `True`, logs detailed information about the process.
+            verbose_length (int):
+                If `verbose=True`, limits the length of logged strings to this value.
             **kwargs:
                 Additional keyword arguments passed into the initial `branch.operate()` call.
 
@@ -1733,6 +1746,7 @@ async def ReAct(
             intermediate_listable=intermediate_listable,
             reasoning_effort=reasoning_effort,
             display_as=display_as,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         )
 
@@ -1758,6 +1772,7 @@ async def ReActStream(
         verbose: bool = False,
         display_as: Literal["json", "yaml"] = "yaml",
         verbose_length: int = None,
+        include_token_usage_to_model: bool = True,
         **kwargs,
     ) -> AsyncGenerator:
         from lionagi.operations.ReAct.ReAct import ReActStream
@@ -1784,6 +1799,7 @@ async def ReActStream(
             verbose_analysis=True,
             display_as=display_as,
             verbose_length=verbose_length,
+            include_token_usage_to_model=include_token_usage_to_model,
             **kwargs,
         ):
             analysis, str_ = result

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.9.4"
+__version__ = "0.9.5"