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

lionagi/session/branch.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr, field_serializer
 
 from lionagi.config import settings
+from lionagi.fields import Instruct
 from lionagi.ln.types import Unset
 from lionagi.models.field_model import FieldModel
 from lionagi.operations.flow import AlcallParams
@@ -38,8 +39,7 @@ from lionagi.protocols.types import (
     SenderRecipient,
     System,
 )
-from lionagi.service.connections.endpoint import Endpoint
-from lionagi.service.types import iModel, iModelManager
+from lionagi.service import Endpoint, iModel, iModelManager
 from lionagi.tools.base import LionTool
 from lionagi.utils import copy
 
@@ -194,11 +194,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,
             )
@@ -502,7 +502,7 @@ class Branch(Element, Communicatable, Relational):
                     raise ValueError(
                         "Invalid message package: The item must be a `RoledMessage`."
                     )
-                new_message = mail.package.item.clone()
+                new_message = mail.package.item.model_copy(deep=True)
                 new_message.sender = mail.sender
                 new_message.recipient = self.id
                 self.msgs.messages.include(new_message)
@@ -632,7 +632,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 +760,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 +810,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 +892,14 @@ 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
+        from lionagi.operations.parse.parse import parse, prepare_parse_kws
 
-        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
+        }
+        return await parse(self, **prepare_parse_kws(self, **_pms))
 
     async def operate(
         self,
@@ -1026,39 +1018,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 +1103,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 +1126,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,17 +1182,21 @@ 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,
+        _pms = {
+            k: v
+            for k, v in locals().items()
+            if k not in ("self", "_pms", "kwargs") and v is not None
+        }
+        _pms.update(kwargs)
+
+        from lionagi.operations.interpret.interpret import (
+            interpret,
+            prepare_interpret_kw,
         )
 
+        return await interpret(self, **prepare_interpret_kw(self, **_pms))
+
     async def instruct(
         self,
         instruct: "Instruct",
@@ -1413,6 +1324,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 +1356,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 +1384,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

lionagi/session/session.py

@@ -22,7 +22,6 @@ from lionagi.protocols.types import (
     Graph,
     IDType,
     MailManager,
-    MessageFlag,
     Node,
     Pile,
     Progression,
@@ -273,17 +272,12 @@ class Session(Node, Communicatable, Relational):
         if any(i not in self.branches for i in branches):
             raise ValueError("Branch does not exist.")
 
-        exclude_flag = []
-        if exclude_clone:
-            exclude_flag.append(MessageFlag.MESSAGE_CLONE)
-        if exclude_load:
-            exclude_flag.append(MessageFlag.MESSAGE_LOAD)
+        # Note: exclude_clone and exclude_load parameters are deprecated
+        # and currently have no effect. They are kept for API compatibility.
 
         messages = lcall(
             branches,
-            lambda x: [
-                i for i in self.branches[x].messages if i not in exclude_flag
-            ],
+            lambda x: list(self.branches[x].messages),
             input_unique=True,
             input_flatten=True,
             input_dropna=True,

lionagi/tools/file/reader.py

@@ -79,8 +79,8 @@ class ReaderRequest(BaseModel):
         ),
     )
 
-    recursive: bool = Field(
-        False,
+    recursive: bool | None = Field(
+        None,
         description=(
             "Whether to recursively list files in subdirectories. Defaults to False."
             "Only used if action='list_dir'."

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.17.11"
+__version__ = "0.18.0"

{lionagi-0.17.11.dist-info → lionagi-0.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.11
+Version: 0.18.0
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -223,7 +223,6 @@ Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
 Requires-Dist: anyio>=4.7.0
 Requires-Dist: backoff>=2.0.0
-Requires-Dist: jinja2>=3.0.0
 Requires-Dist: json-repair>=0.40.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: pydantic-settings>=2.8.0