lionagi 0.0.315__py3-none-any.whl → 0.1.0__py3-none-any.whl

lionagi/core/branch/{branch_flow_mixin.py → flow_mixin.py}

@@ -1,9 +1,9 @@
 from abc import ABC
 from typing import Any, Optional, Union, TypeVar
 
-from ..schema import TOOL_TYPE, Tool
-from ..messages import Instruction, System
-from ..flow.monoflow import MonoChat, MonoFollowup, MonoReAct
+from lionagi.core.tool import Tool, TOOL_TYPE
+from lionagi.core.messages.schema import Instruction, System
+from lionagi.core.flow.monoflow import MonoChat, MonoFollowup, MonoReAct
 
 T = TypeVar("T", bound=Tool)
 
@@ -20,7 +20,7 @@ class BranchFlowMixin(ABC):
         out: bool = True,
         invoke: bool = True,
         output_fields=None,
-        prompt_template=None,
+        form=None,
         **kwargs,
     ) -> Any:
         flow = MonoChat(self)
@@ -33,7 +33,7 @@ class BranchFlowMixin(ABC):
             out=out,
             invoke=invoke,
             output_fields=output_fields,
-            prompt_template=prompt_template,
+            form=form,
             **kwargs,
         )
 
@@ -93,4 +93,4 @@ class BranchFlowMixin(ABC):
             output_prompt=output_prompt,
             out=out,
             **kwargs,
-        )
+        )

lionagi/core/branch/util.py

@@ -320,4 +320,4 @@ class MessageUtil:
             else:
                 with contextlib.suppress(Exception):
                     answers.append(nested.nget(content, ["system_info"]))
-        return "\n".join(answers)
+        return "\n".join(answers)

lionagi/core/direct/__init__.py

@@ -3,5 +3,17 @@ from .select import select
 from .score import score
 from .react import react
 from .vote import vote
+from .plan import plan
+from .cot import chain_of_thoughts, chain_of_react
 
-__all__ = ["predict", "select", "score", "vote", "react"]
+
+__all__ = [
+    "predict",
+    "select",
+    "score",
+    "vote",
+    "react",
+    "plan",
+    "chain_of_thoughts",
+    "chain_of_react",
+]

lionagi/core/direct/cot.py

@@ -1 +1,123 @@
-# TODO: chain of thoughts
+from lionagi.libs import convert
+
+from lionagi.core.direct.predict import predict
+from lionagi.core.direct.plan import plan
+from lionagi.core.direct.react import react
+
+from .utils import _process_tools
+
+
+async def chain_of_thoughts(
+    sentence=None,
+    branch=None,
+    instruction=None,
+    reason=False,
+    confidence_score=False,
+    num_steps=3,
+    directive_kwargs={},
+    return_branch=False,
+    **kwargs,
+):
+
+    out_, outs, answer, reasons, confidence_score = "", [], "", [], 0
+    if branch is not None:
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
+    else:
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
+    for i in range(len(out_.plan)):
+        _out = await predict(
+            branch=branch,
+            instruction=out_.plan[f"step_{i+1}"],
+            reason=reason,
+            confidence_score=confidence_score,
+            **directive_kwargs,
+        )
+        answer += _out.answer
+        if reason:
+            reasons.append(_out.reason)
+        if confidence_score:
+            confidence_score += _out.confidence_score
+        outs.append(_out)
+
+    setattr(out_, "chain_output", outs)
+    setattr(out_, "chain_answer", answer)
+
+    if reason:
+        setattr(out_, "chain_reasons", reasons)
+    if confidence_score:
+        setattr(out_, "chain_confidence_score", confidence_score / len(outs))
+
+    if return_branch:
+        return out_, branch
+
+    return out_
+
+
+async def chain_of_react(
+    sentence=None,
+    branch=None,
+    instruction=None,
+    num_steps=3,
+    tools=None,
+    directive_system=None,
+    directive_kwargs={},
+    return_branch=False,
+    **kwargs,
+):
+    out_, outs, reasons, actions, action_responses = "", [], [], [], []
+    if branch is not None:
+        out_ = await plan(
+            sentence,
+            branch=branch,
+            instruction=instruction,
+            num_steps=num_steps,
+            **kwargs,
+        )
+    else:
+        out_, branch = await plan(
+            sentence,
+            instruction=instruction,
+            branch=branch,
+            num_steps=num_steps,
+            return_branch=True,
+            **kwargs,
+        )
+
+    _process_tools(tools, branch)
+
+    for i in range(len(out_.plan)):
+        _out = await react(
+            branch=branch,
+            system=directive_system,
+            instruction=out_.plan[f"step_{i+1}"],
+            **directive_kwargs,
+        )
+        outs.append(_out)
+        reasons.append(_out.reason)
+        actions.append(_out.actions)
+        if _out.action_needed:
+            action_responses.append(_out.action_response)
+
+    setattr(out_, "chain_output", convert.to_list(outs))
+    setattr(out_, "chain_reason", convert.to_list(reasons))
+    setattr(out_, "chain_actions", convert.to_list(actions))
+    setattr(out_, "chain_action_response", convert.to_list(action_responses))
+
+    if return_branch:
+        return out_, branch
+
+    return out_

lionagi/core/direct/plan.py

@@ -0,0 +1,164 @@
+# plan.py
+
+from lionagi.libs import func_call, ParseUtil
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
+
+
+class PlanTemplate(ScoredForm):
+    template_name: str = "default_plan"
+    sentence: str | list | dict = Field(
+        default_factory=str,
+        description="the given sentence(s) or context to generate a plan for",
+    )
+    plan: dict | str = Field(
+        default_factory=dict,
+        description="the generated step by step plan, return as a dictionary following {step_n: {plan: ..., reason: ...}} format",
+    )
+    signature: str = "sentence -> plan"
+
+    def __init__(
+        self,
+        sentence=None,
+        instruction=None,
+        confidence_score=False,
+        reason=False,
+        num_step=3,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.sentence = sentence
+        self.task = f"Generate a {num_step}_step plan based on the given context. Instruction: {instruction}."
+
+        if reason:
+            self.output_fields.append("reason")
+
+        if confidence_score:
+            self.output_fields.append("confidence_score")
+
+
+async def _plan(
+    sentence,
+    *,
+    instruction=None,
+    branch=None,
+    confidence_score=False,
+    reason=False,
+    retries=2,
+    delay=0.5,
+    backoff_factor=2,
+    default_value=None,
+    timeout=None,
+    branch_name=None,
+    system=None,
+    messages=None,
+    service=None,
+    sender=None,
+    llmconfig=None,
+    tools=None,
+    datalogger=None,
+    persist_path=None,
+    tool_manager=None,
+    return_branch=False,
+    **kwargs,
+):
+    if "temperature" not in kwargs:
+        kwargs["temperature"] = 0.1
+
+    instruction = instruction or ""
+
+    branch = branch or Branch(
+        name=branch_name,
+        system=system,
+        messages=messages,
+        service=service,
+        sender=sender,
+        llmconfig=llmconfig,
+        tools=tools,
+        datalogger=datalogger,
+        persist_path=persist_path,
+        tool_manager=tool_manager,
+    )
+
+    _template = PlanTemplate(
+        sentence=sentence,
+        instruction=instruction,
+        confidence_score=confidence_score,
+        reason=reason,
+    )
+
+    await func_call.rcall(
+        branch.chat,
+        form=_template,
+        retries=retries,
+        delay=delay,
+        backoff_factor=backoff_factor,
+        default=default_value,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    _template.plan = ParseUtil.fuzzy_parse_json(_template.plan)
+
+    return (_template, branch) if return_branch else _template
+
+
+async def plan(
+    sentence,
+    *,
+    instruction=None,
+    num_instances=1,
+    branch=None,
+    confidence_score=False,
+    reason=False,
+    retries=2,
+    delay=0.5,
+    backoff_factor=2,
+    default_value=None,
+    timeout=None,
+    branch_name=None,
+    system=None,
+    messages=None,
+    service=None,
+    sender=None,
+    llmconfig=None,
+    tools=None,
+    datalogger=None,
+    persist_path=None,
+    tool_manager=None,
+    return_branch=False,
+    **kwargs,
+):
+    async def _inner(i=0):
+        return await _plan(
+            sentence=sentence,
+            instruction=instruction,
+            branch=branch,
+            confidence_score=confidence_score,
+            reason=reason,
+            retries=retries,
+            delay=delay,
+            backoff_factor=backoff_factor,
+            default_value=default_value,
+            timeout=timeout,
+            branch_name=branch_name,
+            system=system,
+            messages=messages,
+            service=service,
+            sender=sender,
+            llmconfig=llmconfig,
+            tools=tools,
+            datalogger=datalogger,
+            persist_path=persist_path,
+            tool_manager=tool_manager,
+            return_branch=return_branch,
+            **kwargs,
+        )
+
+    if num_instances == 1:
+        return await _inner()
+
+    elif num_instances > 1:
+        return await func_call.alcall(range(num_instances), _inner)

lionagi/core/direct/predict.py

@@ -9,11 +9,11 @@ confidence score, and reason for the prediction.
 from lionagi.libs import func_call
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
 
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class PredictTemplate(ScoredTemplate):
+class PredictTemplate(ScoredForm):
     """
     A class for predicting the next sentence(s) based on a given sentence.
 
@@ -43,14 +43,15 @@ class PredictTemplate(ScoredTemplate):
         default_factory=int, description="the number of sentences to predict"
     )
     answer: str | list = Field(
-        default_factory=str, description="the predicted sentence(s)"
+        default_factory=str, description="the predicted sentence(s) or desired output"
     )
     signature: str = "sentence -> answer"
 
     def __init__(
         self,
         sentence=None,
-        num_sentences=None,
+        instruction=None,
+        num_sentences=1,
         confidence_score=False,
         reason=False,
         **kwargs,
@@ -67,9 +68,9 @@ class PredictTemplate(ScoredTemplate):
         """
         super().__init__(**kwargs)
 
-        self.sentence = sentence
+        self.sentence = sentence or ""
         self.num_sentences = num_sentences
-        self.task = f"predict the next {self.num_sentences} sentence(s)"
+        self.task = f"follow instruction to predict the next {self.num_sentences} sentence(s). Instruction: {instruction}."
 
         if reason:
             self.output_fields.append("reason")
@@ -82,6 +83,8 @@ async def predict(
     sentence=None,
     num_sentences=1,
     confidence_score=False,
+    instruction=None,
+    branch=None,
     reason=False,
     retries=2,
     delay=0.5,
@@ -128,7 +131,7 @@ async def predict(
     Returns:
         PredictTemplate: The predict template with the predicted sentence(s).
     """
-    branch = Branch(
+    branch = branch or Branch(
         name=branch_name,
         system=system,
         messages=messages,
@@ -142,6 +145,7 @@ async def predict(
     )
 
     predict_template = PredictTemplate(
+        instruction=instruction,
         sentence=sentence,
         num_sentences=num_sentences,
         confidence_score=confidence_score,
@@ -150,7 +154,7 @@ async def predict(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=predict_template,
+        form=predict_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/react.py

@@ -1,13 +1,14 @@
-from lionagi.libs import func_call, convert, AsyncUtil
+from lionagi.libs import func_call, AsyncUtil
 
 from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
-from ..prompt.action_template import ActionedTemplate
-from ..branch import Branch
+from lionagi.core.form.action_form import ActionForm
+from lionagi.core.branch.branch import Branch
+from lionagi.core.direct.utils import _process_tools
 
 
-class ReactTemplate(ActionedTemplate):
+class ReactTemplate(ActionForm):
     template_name: str = "default_react"
-    sentence: str | list | dict = Field(
+    sentence: str | list | dict | None = Field(
         default_factory=str,
         description="the given sentence(s) to reason and take actions on",
     )
@@ -29,7 +30,7 @@ class ReactTemplate(ActionedTemplate):
 
 
 async def _react(
-    sentence,
+    sentence=None,
     *,
     instruction=None,
     branch=None,
@@ -58,6 +59,9 @@ async def _react(
 
     instruction = instruction or ""
 
+    if branch and tools:
+        _process_tools(tools, branch)
+
     branch = branch or Branch(
         name=branch_name,
         system=system,
@@ -79,7 +83,7 @@ async def _react(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,
@@ -109,7 +113,7 @@ async def _react(
 
 
 async def react(
-    sentence,
+    sentence=None,
     *,
     instruction=None,
     num_instances=1,

lionagi/core/direct/score.py

@@ -12,11 +12,11 @@ ScoreTemplate class and a language model.
 from pydantic import Field
 import numpy as np
 from lionagi.libs import func_call, convert
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class ScoreTemplate(ScoredTemplate):
+class ScoreTemplate(ScoredForm):
     """
     A class for scoring a given context using a language model.
 
@@ -169,7 +169,7 @@ async def _score(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/select.py

@@ -13,11 +13,11 @@ from enum import Enum
 from pydantic import Field
 
 from lionagi.libs import func_call, StringMatch
-from ..prompt.scored_template import ScoredTemplate
-from ..branch import Branch
+from lionagi.core.form.scored_form import ScoredForm
+from lionagi.core.branch.branch import Branch
 
 
-class SelectTemplate(ScoredTemplate):
+class SelectTemplate(ScoredForm):
     """
     A class for selecting an item from given choices based on a given context.
 
@@ -153,7 +153,7 @@ async def select(
 
     await func_call.rcall(
         branch.chat,
-        prompt_template=_template,
+        form=_template,
         retries=retries,
         delay=delay,
         backoff_factor=backoff_factor,

lionagi/core/direct/utils.py

@@ -1,3 +1,6 @@
+from typing import Callable
+from lionagi.core.tool import func_to_tool, Tool
+
 # import contextlib
 # from lionagi.libs import ParseUtil, StringMatch, convert, func_call
 
@@ -85,3 +88,23 @@
 #         return _out
 
 #     return out_ if len(out_) > 1 else out_[0]
+
+
+def _process_tools(tool_obj, branch):
+    if isinstance(tool_obj, Callable):
+        _process_tool(tool_obj, branch)
+    else:
+        for i in tool_obj:
+            _process_tool(i, branch)
+
+
+def _process_tool(tool_obj, branch):
+    if (
+        isinstance(tool_obj, Tool)
+        and tool_obj.schema_["function"]["name"] not in branch.tool_manager.registry
+    ):
+        branch.register_tools(tool_obj)
+    if isinstance(tool_obj, Callable):
+        tool = func_to_tool(tool_obj)[0]
+        if tool.schema_["function"]["name"] not in branch.tool_manager.registry:
+            branch.register_tools(tool)

lionagi/core/direct/vote.py

@@ -8,8 +8,8 @@ number of generations, number of outputs to return, number of scorers, score ran
 
 from lionagi.libs import func_call
 import numpy as np
-from .predict import predict
-from .score import score
+from lionagi.core.direct.predict import predict
+from lionagi.core.direct.score import score
 
 
 async def vote(

lionagi/core/execute/base_executor.py

@@ -0,0 +1,50 @@
+from collections import deque
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import Field
+
+from lionagi.core.generic import BaseComponent
+from lionagi.core.mail.schema import BaseMail
+
+
+class BaseExecutor(BaseComponent, ABC):
+    pending_ins: dict = Field(
+        default_factory=dict, description="The pending incoming mails."
+    )
+    pending_outs: deque = Field(
+        default_factory=deque, description="The pending outgoing mails."
+    )
+    execute_stop: bool = Field(
+        False, description="A flag indicating whether to stop execution."
+    )
+    context: dict | str | None = Field(
+        None, description="The context buffer for the next instruction."
+    )
+    execution_responses: list = Field(
+        default_factory=list, description="The list of responses."
+    )
+    context_log: list = Field(default_factory=list, description="The context log.")
+    verbose: bool = Field(
+        True, description="A flag indicating whether to provide verbose output."
+    )
+    execute_stop: bool = Field(
+        False, description="A flag indicating whether to stop execution."
+    )
+
+    def send(self, recipient_id: str, category: str, package: Any) -> None:
+        """
+        Sends a mail to a recipient.
+
+        Args:
+            recipient_id (str): The ID of the recipient.
+            category (str): The category of the mail.
+            package (Any): The package to send in the mail.
+        """
+        mail = BaseMail(
+            sender_id=self.id_,
+            recipient_id=recipient_id,
+            category=category,
+            package=package,
+        )
+        self.pending_outs.append(mail)