lionagi 0.17.11__py3-none-any.whl → 0.18.0__py3-none-any.whl

lionagi/operations/ReAct/utils.py

@@ -101,6 +101,9 @@ class ReActAnalysis(HashableModel):
         ),
     )
 
+    # Note: action_requests and action_responses are added dynamically by Step.request_operative()
+    # when actions=True, so they don't need to be defined here. The operate() function will add them.
+
 
 class Analysis(HashableModel):
     answer: str | None = None

lionagi/operations/act/act.py

@@ -0,0 +1,206 @@
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import BaseModel
+
+from lionagi.fields.action import ActionResponseModel
+from lionagi.ln._async_call import AlcallParams
+from lionagi.protocols.types import ActionRequest, ActionResponse
+
+from ..types import ActionParam
+
+if TYPE_CHECKING:
+    from lionagi.session.branch import Branch
+
+_DEFAULT_ALCALL_PARAMS = None
+
+
+async def _act(
+    branch: "Branch",
+    action_request: BaseModel | dict | ActionRequest,
+    suppress_errors: bool = False,
+    verbose_action: bool = False,
+):
+
+    _request = action_request
+    if isinstance(action_request, ActionRequest):
+        _request = {
+            "function": action_request.function,
+            "arguments": action_request.arguments,
+        }
+    elif isinstance(action_request, BaseModel) and set(
+        action_request.__class__.model_fields.keys()
+    ) >= {"function", "arguments"}:
+        _request = {
+            "function": action_request.function,
+            "arguments": action_request.arguments,
+        }
+    if not isinstance(_request, dict) or not {"function", "arguments"} <= set(
+        _request.keys()
+    ):
+        raise ValueError(
+            "action_request must be an ActionRequest, BaseModel with 'function'"
+            " and 'arguments', or dict with 'function' and 'arguments'."
+        )
+
+    try:
+        if verbose_action:
+            args_ = str(_request["arguments"])
+            args_ = args_[:50] + "..." if len(args_) > 50 else args_
+            print(f"Invoking action {_request['function']} with {args_}.")
+
+        func_call = await branch._action_manager.invoke(_request)
+        if verbose_action:
+            print(
+                f"Action {_request['function']} invoked, status: {func_call.status}."
+            )
+
+    except Exception as e:
+        content = {
+            "error": str(e),
+            "function": _request.get("function"),
+            "arguments": _request.get("arguments"),
+            "branch": str(branch.id),
+        }
+        branch._log_manager.log(content)
+        if verbose_action:
+            print(f"Action {_request['function']} failed, error: {str(e)}.")
+        if suppress_errors:
+            error_msg = f"Error invoking action '{_request['function']}': {e}"
+            logging.error(error_msg)
+
+            # Return error as action response so model knows it failed
+            return ActionResponseModel(
+                function=_request.get("function", "unknown"),
+                arguments=_request.get("arguments", {}),
+                output={"error": str(e), "message": error_msg},
+            )
+        raise e
+
+    branch._log_manager.log(func_call)
+
+    if not isinstance(action_request, ActionRequest):
+        action_request = ActionRequest(
+            content=_request,
+            sender=branch.id,
+            recipient=func_call.func_tool.id,
+        )
+
+    # Add the action request/response to the message manager, if not present
+    if action_request not in branch.messages:
+        branch.msgs.add_message(action_request=action_request)
+
+    branch.msgs.add_message(
+        action_request=action_request,
+        action_output=func_call.response,
+    )
+
+    return ActionResponseModel(
+        function=action_request.function,
+        arguments=action_request.arguments,
+        output=func_call.response,
+    )
+
+
+def prepare_act_kw(
+    branch: "Branch",
+    action_request: list | ActionRequest | BaseModel | dict,
+    *,
+    strategy: Literal["concurrent", "sequential"] = "concurrent",
+    verbose_action: bool = False,
+    suppress_errors: bool = True,
+    call_params: AlcallParams = None,
+):
+
+    action_param = ActionParam(
+        action_call_params=call_params or _get_default_call_params(),
+        tools=None,  # Not used in this context
+        strategy=strategy,
+        suppress_errors=suppress_errors,
+        verbose_action=verbose_action,
+    )
+    return {
+        "action_request": action_request,
+        "action_param": action_param,
+    }
+
+
+async def act(
+    branch: "Branch",
+    action_request: list | ActionRequest | BaseModel | dict,
+    action_param: ActionParam,
+) -> list[ActionResponse]:
+    """Execute action requests with ActionParam."""
+
+    match action_param.strategy:
+        case "concurrent":
+            return await _concurrent_act(
+                branch,
+                action_request,
+                action_param.action_call_params,
+                suppress_errors=action_param.suppress_errors,
+                verbose_action=action_param.verbose_action,
+            )
+        case "sequential":
+            return await _sequential_act(
+                branch,
+                action_request,
+                suppress_errors=action_param.suppress_errors,
+                verbose_action=action_param.verbose_action,
+            )
+        case _:
+            raise ValueError(
+                "Invalid strategy. Choose 'concurrent' or 'sequential'."
+            )
+
+
+async def _concurrent_act(
+    branch: "Branch",
+    action_request: list | ActionRequest | BaseModel | dict,
+    call_params: AlcallParams,
+    suppress_errors: bool = True,
+    verbose_action: bool = False,
+) -> list:
+    """Execute actions concurrently using AlcallParams."""
+
+    async def _wrapper(req):
+        return await _act(branch, req, suppress_errors, verbose_action)
+
+    # AlcallParams expects a list as first argument
+    action_request_list = (
+        action_request
+        if isinstance(action_request, list)
+        else [action_request]
+    )
+
+    return await call_params(action_request_list, _wrapper)
+
+
+async def _sequential_act(
+    branch: "Branch",
+    action_request: list | ActionRequest | BaseModel | dict,
+    suppress_errors: bool = True,
+    verbose_action: bool = False,
+) -> list:
+    """Execute actions sequentially."""
+    action_request = (
+        action_request
+        if isinstance(action_request, list)
+        else [action_request]
+    )
+    results = []
+    for req in action_request:
+        result = await _act(branch, req, suppress_errors, verbose_action)
+        results.append(result)
+    return results
+
+
+def _get_default_call_params() -> AlcallParams:
+    """Get or create default AlcallParams."""
+    global _DEFAULT_ALCALL_PARAMS
+    if _DEFAULT_ALCALL_PARAMS is None:
+        _DEFAULT_ALCALL_PARAMS = AlcallParams(output_dropna=True)
+    return _DEFAULT_ALCALL_PARAMS

lionagi/operations/chat/chat.py

@@ -1,19 +1,18 @@
 # Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING
 
-from pydantic import BaseModel
+from pydantic import JsonValue
 
-from lionagi.protocols.types import (
+from lionagi.ln._to_list import to_list
+from lionagi.protocols.messages import (
     ActionResponse,
     AssistantResponse,
     Instruction,
-    Log,
-    RoledMessage,
 )
-from lionagi.service.imodel import iModel
-from lionagi.utils import copy
+
+from ..types import ChatParam
 
 if TYPE_CHECKING:
     from lionagi.session.branch import Branch
@@ -21,98 +20,94 @@ if TYPE_CHECKING:
 
 async def chat(
     branch: "Branch",
-    instruction=None,
-    guidance=None,
-    context=None,
-    sender=None,
-    recipient=None,
-    request_fields=None,
-    response_format: type[BaseModel] = None,
-    progression=None,
-    imodel: iModel = None,
-    tool_schemas=None,
-    images: list = None,
-    image_detail: Literal["low", "high", "auto"] = None,
-    plain_content: str = None,
+    instruction: JsonValue | Instruction,
+    chat_param: ChatParam,
     return_ins_res_message: bool = False,
-    include_token_usage_to_model: bool = False,
-    **kwargs,
-) -> tuple[Instruction, AssistantResponse]:
-    ins: Instruction = branch.msgs.create_instruction(
-        instruction=instruction,
-        guidance=guidance,
-        context=context,
-        sender=sender or branch.user or "user",
-        recipient=recipient or branch.id,
-        response_format=response_format,
-        request_fields=request_fields,
-        images=images,
-        image_detail=image_detail,
-        tool_schemas=tool_schemas,
-        plain_content=plain_content,
+) -> tuple[Instruction, AssistantResponse] | str:
+    params = chat_param.to_dict(
+        exclude={
+            "imodel",
+            "imodel_kw",
+            "include_token_usage_to_model",
+            "progression",
+        }
     )
+    params["sender"] = chat_param.sender or branch.user or "user"
+    params["recipient"] = chat_param.recipient or branch.id
+    params["instruction"] = instruction
 
-    progression = progression or branch.msgs.progression
-    messages: list[RoledMessage] = [
-        branch.msgs.messages[i] for i in progression
-    ]
-
-    use_ins = None
-    _to_use = []
-    _action_responses: set[ActionResponse] = set()
-
-    for i in messages:
-        if isinstance(i, ActionResponse):
-            _action_responses.add(i)
-        if isinstance(i, AssistantResponse):
-            j = AssistantResponse(
-                role=i.role,
-                content=copy(i.content),
-                sender=i.sender,
-                recipient=i.recipient,
-                template=i.template,
-            )
-            _to_use.append(j)
-        if isinstance(i, Instruction):
-            j = Instruction(
-                role=i.role,
-                content=copy(i.content),
-                sender=i.sender,
-                recipient=i.recipient,
-                template=i.template,
+    ins = branch.msgs.create_instruction(**params)
+
+    _use_ins, _use_msgs, _act_res = None, [], []
+    progression = chat_param.progression or branch.msgs.progression
+
+    for msg in (branch.msgs.messages[j] for j in progression):
+        if isinstance(msg, ActionResponse):
+            _act_res.append(msg)
+
+        if isinstance(msg, AssistantResponse):
+            _use_msgs.append(
+                msg.model_copy(update={"content": msg.content.with_updates()})
             )
-            j.tool_schemas = None
-            j.respond_schema_info = None
-            j.request_response_format = None
-
-            if _action_responses:
-                d_ = [k.content for k in _action_responses]
-                for z in d_:
-                    if z not in j.context:
-                        j.context.append(z)
-
-                _to_use.append(j)
-                _action_responses = set()
-            else:
-                _to_use.append(j)
 
-    messages = _to_use
-    if _action_responses:
-        j = ins.model_copy()
-        d_ = [k.content for k in _action_responses]
-        for z in d_:
-            if z not in j.context:
-                j.context.append(z)
-        use_ins = j
+        if isinstance(msg, Instruction):
+            j = msg.model_copy(update={"content": msg.content.with_updates()})
+            j.content.tool_schemas.clear()
+            j.content.response_format = None
+            j.content._schema_dict = None
+            j.content._model_class = None
+
+            if _act_res:
+                # Convert ActionResponseContent to dicts for proper rendering
+                d_ = []
+                for k in to_list(_act_res, flatten=True, unique=True):
+                    if hasattr(k.content, "function"):  # ActionResponseContent
+                        d_.append(
+                            {
+                                "function": k.content.function,
+                                "arguments": k.content.arguments,
+                                "output": k.content.output,
+                            }
+                        )
+                    else:
+                        d_.append(k.content)
+                j.content.prompt_context.extend(
+                    [z for z in d_ if z not in j.content.prompt_context]
+                )
+                _use_msgs.append(j)
+                _act_res = []
+            else:
+                _use_msgs.append(j)
+
+    if _act_res:
+        j = ins.model_copy(update={"content": ins.content.with_updates()})
+        # Convert ActionResponseContent to dicts for proper rendering
+        d_ = []
+        for k in to_list(_act_res, flatten=True, unique=True):
+            if hasattr(k.content, "function"):  # ActionResponseContent
+                d_.append(
+                    {
+                        "function": k.content.function,
+                        "arguments": k.content.arguments,
+                        "output": k.content.output,
+                    }
+                )
+            else:
+                d_.append(k.content)
+        j.content.prompt_context.extend(
+            [z for z in d_ if z not in j.content.prompt_context]
+        )
+        _use_ins = j
 
-    if messages and len(messages) > 1:
-        _msgs = [messages[0]]
+    messages = _use_msgs
+    if _use_msgs and len(_use_msgs) > 1:
+        _msgs = [_use_msgs[0]]
 
-        for i in messages[1:]:
+        for i in _use_msgs[1:]:
             if isinstance(i, AssistantResponse):
                 if isinstance(_msgs[-1], AssistantResponse):
-                    _msgs[-1].response = (
-                        f"{_msgs[-1].response}\n\n{i.response}"
+                    _msgs[-1].content.assistant_response = (
+                        f"{_msgs[-1].content.assistant_response}\n\n{i.content.assistant_response}"
                     )
                 else:
                     _msgs.append(i)
@@ -125,11 +120,10 @@ async def chat(
     if branch.msgs.system:
         messages = [msg for msg in messages if msg.role != "system"]
         first_instruction = None
-
+        f = lambda x: branch.msgs.system.rendered + (x.content.guidance or "")
         if len(messages) == 0:
-            first_instruction = ins.model_copy()
-            first_instruction.guidance = branch.msgs.system.rendered + (
-                first_instruction.guidance or ""
+            first_instruction = ins.model_copy(
+                update={"content": ins.content.with_updates(guidance=f(ins))}
             )
             messages.append(first_instruction)
         elif len(messages) >= 1:
@@ -138,37 +132,59 @@ async def chat(
                 raise ValueError(
                     "First message in progression must be an Instruction or System"
                 )
-            first_instruction = first_instruction.model_copy()
-            first_instruction.guidance = branch.msgs.system.rendered + (
-                first_instruction.guidance or ""
+            first_instruction = first_instruction.model_copy(
+                update={
+                    "content": first_instruction.content.with_updates(
+                        guidance=f(first_instruction)
+                    )
+                }
             )
             messages[0] = first_instruction
-            messages.append(use_ins or ins)
+            msg_to_append = _use_ins or ins
+            if msg_to_append is not None:
+                messages.append(msg_to_append)
 
     else:
-        messages.append(use_ins or ins)
-
-    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"]:
-        kwargs["include_token_usage_to_model"] = include_token_usage_to_model
-    else:
-        meth = imodel.stream
+        msg_to_append = _use_ins or ins
+        if msg_to_append is not None:
+            messages.append(msg_to_append)
+
+    kw = (chat_param.imodel_kw or {}).copy()
+
+    # Filter out messages with None chat_msg
+    chat_msgs = []
+    for msg in messages:
+        if msg is not None and hasattr(msg, "chat_msg"):
+            chat_msg = msg.chat_msg
+            if chat_msg is not None:
+                chat_msgs.append(chat_msg)
+
+    kw["messages"] = chat_msgs
+
+    imodel = chat_param.imodel or branch.chat_model
+    meth = imodel.stream if "stream" in kw and kw["stream"] else imodel.invoke
+
+    if meth is imodel.invoke:
+        # Only set if it's not the Unset sentinel value
+        if not chat_param._is_sentinel(
+            chat_param.include_token_usage_to_model
+        ):
+            kw["include_token_usage_to_model"] = (
+                chat_param.include_token_usage_to_model
+            )
+    api_call = await meth(**kw)
 
-    api_call = await meth(**kwargs)
-    branch._log_manager.log(Log.create(api_call))
+    branch._log_manager.log(api_call)
 
     if return_ins_res_message:
         # Wrap result in `AssistantResponse` and return
-        return ins, AssistantResponse.create(
-            assistant_response=api_call.response,
+        return ins, AssistantResponse.from_response(
+            api_call.response,
             sender=branch.id,
             recipient=branch.user,
         )
-    return AssistantResponse.create(
-        assistant_response=api_call.response,
+    return AssistantResponse.from_response(
+        api_call.response,
         sender=branch.id,
         recipient=branch.user,
     ).response