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

lionagi/session/branch.py

@@ -2,52 +2,48 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from collections.abc import AsyncGenerator, Callable
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr, field_serializer
 
 from lionagi.config import settings
+from lionagi.ln import AlcallParams
 from lionagi.ln.types import Unset
 from lionagi.models.field_model import FieldModel
-from lionagi.operations.flow import AlcallParams
+from lionagi.operations.fields import Instruct
 from lionagi.operations.manager import OperationManager
+from lionagi.protocols._concepts import Relational
 from lionagi.protocols.action.manager import ActionManager
 from lionagi.protocols.action.tool import FuncTool, Tool, ToolRef
-from lionagi.protocols.types import (
+from lionagi.protocols.generic import (
     ID,
-    MESSAGE_FIELDS,
+    DataLogger,
+    DataLoggerConfig,
+    Element,
+    Log,
+    Pile,
+    Progression,
+)
+from lionagi.protocols.messages import (
     ActionRequest,
     ActionResponse,
     AssistantResponse,
-    Communicatable,
-    Element,
-    IDType,
     Instruction,
-    Log,
-    LogManager,
-    LogManagerConfig,
-    Mail,
-    Mailbox,
     MessageManager,
     MessageRole,
-    PackageCategory,
-    Pile,
-    Progression,
-    Relational,
     RoledMessage,
     SenderRecipient,
     System,
 )
 from lionagi.service.connections.endpoint import Endpoint
-from lionagi.service.types import iModel, iModelManager
+from lionagi.service.manager import iModel, iModelManager
 from lionagi.tools.base import LionTool
 from lionagi.utils import copy
 
 from .prompts import LION_SYSTEM_MESSAGE
 
 if TYPE_CHECKING:
-    from lionagi.fields import Instruct
-    from lionagi.protocols.operatives.operative import Operative
+    from lionagi.operations.operate.operative import Operative
 
 
 __all__ = ("Branch",)
@@ -56,7 +52,7 @@ __all__ = ("Branch",)
 _DEFAULT_ALCALL_PARAMS = None
 
 
-class Branch(Element, Communicatable, Relational):
+class Branch(Element, Relational):
     """
     Manages a conversation 'branch' with messages, tools, and iModels.
 
@@ -65,20 +61,17 @@ class Branch(Element, Communicatable, Relational):
         - Registers and invokes tools/actions (`ActionManager`).
         - Manages model instances (`iModelManager`).
         - Logs activity (`LogManager`).
-        - Communicates via mailboxes (`Mailbox`).
 
     **Key responsibilities**:
         - Storing and organizing messages, including system instructions, user instructions, and model responses.
         - Handling asynchronous or synchronous execution of LLM calls and tool invocations.
-        - Providing a consistent interface for “operate,” “chat,” “communicate,” “parse,” etc.
+        - Providing a consistent interface for "operate," "chat," "communicate," "parse," etc.
 
     Attributes:
         user (SenderRecipient | None):
             The user or "owner" of this branch (often tied to a session).
         name (str | None):
             A human-readable name for this branch.
-        mailbox (Mailbox):
-            A mailbox for sending and receiving `Package` objects to/from other branches.
 
     Note:
         Actual implementations for chat, parse, operate, etc., are referenced
@@ -101,16 +94,10 @@ class Branch(Element, Communicatable, Relational):
         description="A human-readable name of the branch (optional).",
     )
 
-    mailbox: Mailbox = Field(
-        default_factory=Mailbox,
-        exclude=True,
-        description="Mailbox for cross-branch or external communication.",
-    )
-
     _message_manager: MessageManager | None = PrivateAttr(None)
     _action_manager: ActionManager | None = PrivateAttr(None)
     _imodel_manager: iModelManager | None = PrivateAttr(None)
-    _log_manager: LogManager | None = PrivateAttr(None)
+    _log_manager: DataLogger | None = PrivateAttr(None)
     _operation_manager: OperationManager | None = PrivateAttr(None)
 
     def __init__(
@@ -125,7 +112,7 @@ class Branch(Element, Communicatable, Relational):
         parse_model: iModel | dict = None,
         imodel: iModel = None,  # deprecated, alias of chat_model
         tools: FuncTool | list[FuncTool] = None,  # ActionManager kwargs
-        log_config: LogManagerConfig | dict = None,  # LogManager kwargs
+        log_config: DataLoggerConfig | dict = None,  # LogManager kwargs
         system_datetime: bool | str = None,
         system_template=None,
         system_template_context: dict = None,
@@ -194,11 +181,11 @@ class Branch(Element, Communicatable, Relational):
                 system = f"Developer Prompt: {str(system)}" if system else ""
                 system = (LION_SYSTEM_MESSAGE + "\n\n" + system).strip()
 
+            # Note: system_template and system_template_context are deprecated
+            # Template rendering has been removed from the message system
             self._message_manager.add_message(
                 system=system,
                 system_datetime=system_datetime,
-                template=system_template,
-                template_context=system_template_context,
                 recipient=self.id,
                 sender=system_sender or self.user or MessageRole.SYSTEM,
             )
@@ -229,10 +216,10 @@ class Branch(Element, Communicatable, Relational):
         # --- LogManager ---
         if log_config:
             if isinstance(log_config, dict):
-                log_config = LogManagerConfig(**log_config)
-            self._log_manager = LogManager.from_config(log_config, logs=logs)
+                log_config = DataLoggerConfig(**log_config)
+            self._log_manager = DataLogger.from_config(log_config, logs=logs)
         else:
-            self._log_manager = LogManager(**settings.LOG_CONFIG, logs=logs)
+            self._log_manager = DataLogger(**settings.LOG_CONFIG, logs=logs)
 
         self._operation_manager = OperationManager()
 
@@ -414,6 +401,7 @@ class Branch(Element, Communicatable, Relational):
             pd.DataFrame: Each row represents a message, with columns defined by MESSAGE_FIELDS.
         """
         from lionagi.protocols.generic.pile import Pile
+        from lionagi.protocols.messages.base import MESSAGE_FIELDS
 
         if progression is None:
             progression = self.msgs.progression
@@ -426,170 +414,6 @@ class Branch(Element, Communicatable, Relational):
         p = Pile(collections=msgs)
         return p.to_df(columns=MESSAGE_FIELDS)
 
-    # -------------------------------------------------------------------------
-    # Mailbox Send / Receive
-    # -------------------------------------------------------------------------
-    def send(
-        self,
-        recipient: IDType,
-        category: Optional["PackageCategory"],
-        item: Any,
-        request_source: IDType | None = None,
-    ) -> None:
-        """
-        Sends a `Package` (wrapped in a `Mail` object) to a specified recipient.
-
-        Args:
-            recipient (IDType):
-                ID of the recipient branch or component.
-            category (PackageCategory | None):
-                The category/type of the package (e.g., 'message', 'tool', 'imodel').
-            item (Any):
-                The payload to send (e.g., a message, tool reference, model, etc.).
-            request_source (IDType | None):
-                The ID that prompted or requested this send operation (optional).
-        """
-        from lionagi.protocols.mail.package import Package
-
-        package = Package(
-            category=category,
-            item=item,
-            request_source=request_source,
-        )
-
-        mail = Mail(
-            sender=self.id,
-            recipient=recipient,
-            package=package,
-        )
-        self.mailbox.append_out(mail)
-
-    def receive(
-        self,
-        sender: IDType,
-        message: bool = False,
-        tool: bool = False,
-        imodel: bool = False,
-    ) -> None:
-        """
-        Retrieves and processes mail from a given sender according to the specified flags.
-
-        Args:
-            sender (IDType):
-                The ID of the mail sender.
-            message (bool):
-                If `True`, process packages categorized as "message".
-            tool (bool):
-                If `True`, process packages categorized as "tool".
-            imodel (bool):
-                If `True`, process packages categorized as "imodel".
-
-        Raises:
-            ValueError: If no mail exists from the specified sender,
-                        or if a package is invalid for the chosen category.
-        """
-        sender = ID.get_id(sender)
-        if sender not in self.mailbox.pending_ins.keys():
-            raise ValueError(f"No mail or package found from sender: {sender}")
-
-        skipped_requests = Progression()
-        while self.mailbox.pending_ins[sender]:
-            mail_id = self.mailbox.pending_ins[sender].popleft()
-            mail: Mail = self.mailbox.pile_[mail_id]
-
-            if mail.category == "message" and message:
-                if not isinstance(mail.package.item, RoledMessage):
-                    raise ValueError(
-                        "Invalid message package: The item must be a `RoledMessage`."
-                    )
-                new_message = mail.package.item.clone()
-                new_message.sender = mail.sender
-                new_message.recipient = self.id
-                self.msgs.messages.include(new_message)
-                self.mailbox.pile_.pop(mail_id)
-
-            elif mail.category == "tool" and tool:
-                if not isinstance(mail.package.item, Tool):
-                    raise ValueError(
-                        "Invalid tool package: The item must be a `Tool` instance."
-                    )
-                self._action_manager.register_tools(mail.package.item)
-                self.mailbox.pile_.pop(mail_id)
-
-            elif mail.category == "imodel" and imodel:
-                if not isinstance(mail.package.item, iModel):
-                    raise ValueError(
-                        "Invalid iModel package: The item must be an `iModel` instance."
-                    )
-                self._imodel_manager.register_imodel(
-                    mail.package.item.name or "chat", mail.package.item
-                )
-                self.mailbox.pile_.pop(mail_id)
-
-            else:
-                # If the category doesn't match the flags or is unhandled
-                skipped_requests.append(mail)
-
-        # Requeue any skipped mail
-        self.mailbox.pending_ins[sender] = skipped_requests
-        if len(self.mailbox.pending_ins[sender]) == 0:
-            self.mailbox.pending_ins.pop(sender)
-
-    async def asend(
-        self,
-        recipient: IDType,
-        category: PackageCategory | None,
-        package: Any,
-        request_source: IDType | None = None,
-    ):
-        """
-        Async version of `send()`.
-
-        Args:
-            recipient (IDType):
-                ID of the recipient branch or component.
-            category (PackageCategory | None):
-                The category/type of the package.
-            package (Any):
-                The item(s) to send (message/tool/model).
-            request_source (IDType | None):
-                The origin request ID (if any).
-        """
-        async with self.mailbox.pile_:
-            self.send(recipient, category, package, request_source)
-
-    async def areceive(
-        self,
-        sender: IDType,
-        message: bool = False,
-        tool: bool = False,
-        imodel: bool = False,
-    ) -> None:
-        """
-        Async version of `receive()`.
-
-        Args:
-            sender (IDType):
-                The ID of the mail sender.
-            message (bool):
-                If `True`, process packages categorized as "message".
-            tool (bool):
-                If `True`, process packages categorized as "tool".
-            imodel (bool):
-                If `True`, process packages categorized as "imodel".
-        """
-        async with self.mailbox.pile_:
-            self.receive(sender, message, tool, imodel)
-
-    def receive_all(self) -> None:
-        """
-        Receives mail from all known senders without filtering.
-
-        (Duplicate method included in your snippet; you may unify or remove.)
-        """
-        for key in self.mailbox.pending_ins:
-            self.receive(key)
-
     def connect(
         self,
         provider: str = None,
@@ -632,7 +456,7 @@ class Branch(Element, Communicatable, Relational):
         async def _connect(**kwargs):
             """connect to an api endpoint"""
             api_call = await imodel.invoke(**kwargs)
-            self._log_manager.log(Log.create(api_call))
+            self._log_manager.log(api_call)
             return api_call.response
 
         _connect.__name__ = name or imodel.endpoint.name
@@ -760,6 +584,7 @@ class Branch(Element, Communicatable, Relational):
         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]:
         """
@@ -809,25 +634,27 @@ class Branch(Element, Communicatable, Relational):
             tuple[Instruction, AssistantResponse]:
                 The `Instruction` object and the final `AssistantResponse`.
         """
-        from lionagi.operations.chat.chat import chat
+        from lionagi.operations.chat.chat import ChatParam, chat
 
         return await chat(
             self,
             instruction=instruction,
-            guidance=guidance,
-            context=context,
-            sender=sender,
-            recipient=recipient,
-            request_fields=request_fields,
-            response_format=response_format,
-            progression=progression,
-            imodel=imodel or kwargs.pop("chat_model", None) or self.chat_model,
-            tool_schemas=tool_schemas,
-            images=images,
-            image_detail=image_detail,
-            plain_content=plain_content,
+            chat_param=ChatParam(
+                guidance=guidance,
+                context=context,
+                sender=sender or self.user or "user",
+                recipient=recipient or self.id,
+                response_format=response_format or request_fields,
+                progression=progression,
+                tool_schemas=tool_schemas or [],
+                images=images or [],
+                image_detail=image_detail or "auto",
+                plain_content=plain_content or "",
+                include_token_usage_to_model=include_token_usage_to_model,
+                imodel=imodel or self.chat_model,
+                imodel_kw=kwargs,
+            ),
             return_ins_res_message=return_ins_res_message,
-            **kwargs,
         )
 
     async def parse(
@@ -889,25 +716,15 @@ class Branch(Element, Communicatable, Relational):
             BaseModel | dict | str | None:
                 Parsed model instance, or a fallback based on `handle_validation`.
         """
-        from lionagi.operations.parse.parse import parse
 
-        return await parse(
-            self,
-            text=text,
-            handle_validation=handle_validation,
-            max_retries=max_retries,
-            request_type=request_type,
-            operative=operative,
-            similarity_algo=similarity_algo,
-            similarity_threshold=similarity_threshold,
-            fuzzy_match=fuzzy_match,
-            handle_unmatched=handle_unmatched,
-            fill_value=fill_value,
-            fill_mapping=fill_mapping,
-            strict=strict,
-            suppress_conversion_errors=suppress_conversion_errors,
-            response_format=response_format,
-        )
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms") and v is not None
+        }
+        from lionagi.operations.parse.parse import parse, prepare_parse_kws
+
+        return await parse(self, **prepare_parse_kws(self, **_pms))
 
     async def operate(
         self,
@@ -1026,39 +843,18 @@ class Branch(Element, Communicatable, Relational):
                 - If both `operative_model` and `response_format` or `request_model` are given.
                 - If the LLM's response cannot be parsed into the expected format and `handle_validation='raise'`.
         """
-        from lionagi.operations.operate.operate import operate
-
-        return await operate(
-            self,
-            instruct=instruct,
-            instruction=instruction,
-            guidance=guidance,
-            context=context,
-            sender=sender,
-            recipient=recipient,
-            progression=progression,
-            chat_model=chat_model,
-            invoke_actions=invoke_actions,
-            tool_schemas=tool_schemas,
-            images=images,
-            image_detail=image_detail,
-            parse_model=parse_model,
-            skip_validation=skip_validation,
-            tools=tools,
-            operative=operative,
-            response_format=response_format,
-            actions=actions,
-            reason=reason,
-            call_params=call_params,
-            action_strategy=action_strategy,
-            verbose_action=verbose_action,
-            field_models=field_models,
-            exclude_fields=exclude_fields,
-            handle_validation=handle_validation,
-            include_token_usage_to_model=include_token_usage_to_model,
-            **kwargs,
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms") and v is not None
+        }
+        from lionagi.operations.operate.operate import (
+            operate,
+            prepare_operate_kw,
         )
 
+        return await operate(self, **prepare_operate_kw(self, **_pms))
+
     async def communicate(
         self,
         instruction: Instruction | JsonValue = None,
@@ -1132,44 +928,19 @@ class Branch(Element, Communicatable, Relational):
                 - A dict of the requested fields,
                 - or `None` if parsing fails and `handle_validation='return_none'`.
         """
-        from lionagi.operations.communicate.communicate import communicate
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms", "kwargs") and v is not None
+        }
+        _pms.update(kwargs)
 
-        return await communicate(
-            self,
-            instruction=instruction,
-            guidance=guidance,
-            context=context,
-            plain_content=plain_content,
-            sender=sender,
-            recipient=recipient,
-            progression=progression,
-            response_format=response_format,
-            request_fields=request_fields,
-            chat_model=chat_model,
-            parse_model=parse_model,
-            skip_validation=skip_validation,
-            images=images,
-            image_detail=image_detail,
-            num_parse_retries=num_parse_retries,
-            clear_messages=clear_messages,
-            include_token_usage_to_model=include_token_usage_to_model,
-            **kwargs,
+        from lionagi.operations.communicate.communicate import (
+            communicate,
+            prepare_communicate_kw,
         )
 
-    async def _act(
-        self,
-        action_request: ActionRequest | BaseModel | dict,
-        suppress_errors: bool,
-        verbose_action: bool,
-    ) -> ActionResponse:
-        from lionagi.operations._act.act import _act
-
-        return await _act(
-            branch=self,
-            action_request=action_request,
-            suppress_errors=suppress_errors,
-            verbose_action=verbose_action,
-        )
+        return await communicate(self, **prepare_communicate_kw(self, **_pms))
 
     async def act(
         self,
@@ -1180,54 +951,15 @@ class Branch(Element, Communicatable, Relational):
         suppress_errors: bool = True,
         call_params: AlcallParams = None,
     ) -> list[ActionResponse]:
-        global _DEFAULT_ALCALL_PARAMS
-        if call_params is None:
-            if _DEFAULT_ALCALL_PARAMS is None:
-                _DEFAULT_ALCALL_PARAMS = AlcallParams(output_dropna=True)
-            call_params = _DEFAULT_ALCALL_PARAMS
-
-        kw = {
-            "suppress_errors": suppress_errors,
-            "verbose_action": verbose_action,
-        }
-
-        match strategy:
-            case "concurrent":
-                return await self._concurrent_act(
-                    action_request, call_params, **kw
-                )
-            case "sequential":
-                return await self._sequential_act(action_request, **kw)
-            case _:
-                raise ValueError(
-                    "Invalid strategy. Choose 'concurrent' or 'sequential'."
-                )
 
-    async def _concurrent_act(
-        self,
-        action_request: ActionRequest | BaseModel | dict,
-        call_params: AlcallParams = None,
-        **kwargs,
-    ) -> list:
-        return await call_params(action_request, self._act, **kwargs)
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms") and v is not None
+        }
+        from lionagi.operations.act.act import act, prepare_act_kw
 
-    async def _sequential_act(
-        self,
-        action_request: ActionRequest | BaseModel | dict,
-        suppress_errors: bool = True,
-        verbose_action: bool = False,
-    ) -> list:
-        action_request = (
-            action_request
-            if isinstance(action_request, list)
-            else [action_request]
-        )
-        results = []
-        for req in action_request:
-            results.append(
-                await self._act(req, verbose_action, suppress_errors)
-            )
-        return results
+        return await act(self, **prepare_act_kw(self, **_pms))
 
     async def interpret(
         self,
@@ -1275,43 +1007,20 @@ class Branch(Element, Communicatable, Relational):
             # refined might be "Explain step-by-step how to set up a marketing analytics
             #  pipeline to track campaign performance..."
         """
-        from lionagi.operations.interpret.interpret import interpret
-
-        return await interpret(
-            self,
-            text=text,
-            domain=domain,
-            style=style,
-            interpret_model=interpret_model,
-            **kwargs,
-        )
-
-    async def instruct(
-        self,
-        instruct: "Instruct",
-        /,
-        **kwargs,
-    ):
-        """
-        A convenience method that chooses between `operate()` and `communicate()`
-        based on the contents of an `Instruct` object.
-
-        If the `Instruct` indicates tool usage or advanced response format,
-        `operate()` is used. Otherwise, it defaults to `communicate()`.
 
-        Args:
-            instruct (Instruct):
-                An object containing `instruction`, `guidance`, `context`, etc.
-            **kwargs:
-                Additional args forwarded to `operate()` or `communicate()`.
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms", "kwargs") and v is not None
+        }
+        _pms.update(kwargs)
 
-        Returns:
-            Any:
-                The result of the underlying call (structured object, raw text, etc.).
-        """
-        from lionagi.operations.instruct.instruct import instruct as _ins
+        from lionagi.operations.interpret.interpret import (
+            interpret,
+            prepare_interpret_kw,
+        )
 
-        return await _ins(self, instruct, **kwargs)
+        return await interpret(self, **prepare_interpret_kw(self, **_pms))
 
     async def ReAct(
         self,
@@ -1413,6 +1122,13 @@ class Branch(Element, Communicatable, Relational):
         """
         from lionagi.operations.ReAct.ReAct import ReAct
 
+        # Remove potential duplicate parameters from kwargs
+        kwargs_filtered = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in {"verbose_analysis", "verbose_action"}
+        }
+
         return await ReAct(
             self,
             instruct,
@@ -1438,7 +1154,7 @@ class Branch(Element, Communicatable, Relational):
             reasoning_effort=reasoning_effort,
             display_as=display_as,
             include_token_usage_to_model=include_token_usage_to_model,
-            **kwargs,
+            **kwargs_filtered,
         )
 
     async def ReActStream(
@@ -1466,40 +1182,114 @@ class Branch(Element, Communicatable, Relational):
         include_token_usage_to_model: bool = True,
         **kwargs,
     ) -> AsyncGenerator:
+        from lionagi.ln.fuzzy import FuzzyMatchKeysParams
         from lionagi.operations.ReAct.ReAct import ReActStream
+        from lionagi.operations.ReAct.utils import ReActAnalysis
+        from lionagi.operations.types import (
+            ActionParam,
+            ChatParam,
+            InterpretParam,
+            ParseParam,
+        )
+
+        # Convert Instruct to dict if needed
+        instruct_dict = (
+            instruct.to_dict()
+            if isinstance(instruct, Instruct)
+            else dict(instruct)
+        )
+
+        # Build InterpretContext if interpretation requested
+        intp_param = None
+        if interpret:
+            intp_param = InterpretParam(
+                domain=interpret_domain or "general",
+                style=interpret_style or "concise",
+                sample_writing=interpret_sample or "",
+                imodel=interpret_model or analysis_model or self.chat_model,
+                imodel_kw=interpret_kwargs or {},
+            )
+
+        # Build ChatContext
+        chat_param = ChatParam(
+            guidance=instruct_dict.get("guidance"),
+            context=instruct_dict.get("context"),
+            sender=self.user or "user",
+            recipient=self.id,
+            response_format=None,
+            progression=None,
+            tool_schemas=tool_schemas or [],
+            images=[],
+            image_detail="auto",
+            plain_content="",
+            include_token_usage_to_model=include_token_usage_to_model,
+            imodel=analysis_model or self.chat_model,
+            imodel_kw=kwargs,
+        )
+
+        # Build ActionContext
+        action_param = None
+        if tools is not None or tool_schemas is not None:
+            from lionagi.operations.act.act import _get_default_call_params
+
+            action_param = ActionParam(
+                action_call_params=_get_default_call_params(),
+                tools=tools or True,
+                strategy="concurrent",
+                suppress_errors=True,
+                verbose_action=False,
+            )
+
+        # Build ParseContext
+        from lionagi.operations.parse.parse import get_default_call
+
+        parse_param = ParseParam(
+            response_format=ReActAnalysis,
+            fuzzy_match_params=FuzzyMatchKeysParams(),
+            handle_validation="return_value",
+            alcall_params=get_default_call(),
+            imodel=analysis_model or self.chat_model,
+            imodel_kw={},
+        )
+
+        # Response context for final answer
+        resp_ctx = response_kwargs or {}
+        if response_format:
+            resp_ctx["response_format"] = response_format
 
         async for result in ReActStream(
             self,
-            instruct,
-            interpret=interpret,
-            interpret_domain=interpret_domain,
-            interpret_style=interpret_style,
-            interpret_sample=interpret_sample,
-            interpret_model=interpret_model,
-            interpret_kwargs=interpret_kwargs,
-            tools=tools,
-            tool_schemas=tool_schemas,
-            response_format=response_format,
+            instruction=instruct_dict.get("instruction", str(instruct)),
+            chat_param=chat_param,
+            action_param=action_param,
+            parse_param=parse_param,
+            intp_param=intp_param,
+            resp_ctx=resp_ctx,
+            reasoning_effort=reasoning_effort,
+            reason=True,
+            field_models=None,
+            handle_validation="return_value",
+            invoke_actions=True,
+            clear_messages=False,
             intermediate_response_options=intermediate_response_options,
             intermediate_listable=intermediate_listable,
-            reasoning_effort=reasoning_effort,
-            extension_allowed=extension_allowed,
+            intermediate_nullable=False,
             max_extensions=max_extensions,
-            response_kwargs=response_kwargs,
-            analysis_model=analysis_model,
-            verbose_analysis=True,
+            extension_allowed=extension_allowed,
+            verbose_analysis=verbose,
             display_as=display_as,
             verbose_length=verbose_length,
-            include_token_usage_to_model=include_token_usage_to_model,
-            **kwargs,
+            continue_after_failed_response=False,
         ):
-            analysis, str_ = result
             if verbose:
+                analysis, str_ = result
                 from lionagi.libs.schema.as_readable import as_readable
 
                 str_ += "\n---------\n"
                 as_readable(str_, md=True, display_str=True)
-            yield analysis
+                yield analysis
+            else:
+                yield result
 
 
 # File: lionagi/session/branch.py