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

lionagi/__init__.py

@@ -8,6 +8,9 @@ from dotenv import load_dotenv
 
 from .core import direct, Branch, Session, func_to_tool
 from .integrations.provider.services import Services
+from .integrations.chunker.chunk import chunk
+from .integrations.loader.load import load
+
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)

lionagi/core/direct/__init__.py

@@ -1,6 +1,7 @@
 from .predict import predict
 from .select import select
 from .score import score
+from .react import react
 from .vote import vote
 
-__all__ = ["predict", "select", "score", "vote"]
+__all__ = ["predict", "select", "score", "vote", "react"]

lionagi/core/direct/cot.py

@@ -0,0 +1 @@
+# TODO: chain of thoughts

lionagi/core/direct/predict.py

@@ -6,9 +6,10 @@ using a language model. It includes fields for the input sentence, number of sen
 confidence score, and reason for the prediction.
 """
 
-from pydantic import Field
 from lionagi.libs import func_call
-from ..prompt.prompt_template import ScoredTemplate
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+
+from ..prompt.scored_template import ScoredTemplate
 from ..branch import Branch
 
 

lionagi/core/direct/react.py

@@ -0,0 +1,167 @@
+from lionagi.libs import func_call, convert, AsyncUtil
+
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+from ..prompt.action_template import ActionedTemplate
+from ..branch import Branch
+
+
+class ReactTemplate(ActionedTemplate):
+    template_name: str = "default_react"
+    sentence: str | list | dict = Field(
+        default_factory=str,
+        description="the given sentence(s) to reason and take actions on",
+    )
+
+    def __init__(
+        self,
+        sentence=None,
+        instruction=None,
+        confidence_score=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.sentence = sentence
+        self.task = f"Think step by step. Perform reasoning and prepare actions with given tools only.Instruction: {instruction}. Absolutely DO NOT MAKE UP FUNCTIONS !!!"
+
+        if confidence_score:
+            self.output_fields.append("confidence_score")
+
+
+async def _react(
+    sentence,
+    *,
+    instruction=None,
+    branch=None,
+    confidence_score=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 = ReactTemplate(
+        sentence=sentence,
+        instruction=instruction,
+        confidence_score=confidence_score,
+    )
+
+    await func_call.rcall(
+        branch.chat,
+        prompt_template=_template,
+        retries=retries,
+        delay=delay,
+        backoff_factor=backoff_factor,
+        default=default_value,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    if _template.action_needed:
+        actions = _template.actions
+        tasks = [branch.tool_manager.invoke(i.values()) for i in actions]
+        results = await AsyncUtil.execute_tasks(*tasks)
+
+        a = []
+        for idx, item in enumerate(actions):
+            res = {
+                "function": item["function"],
+                "arguments": item["arguments"],
+                "output": results[idx],
+            }
+            branch.add_message(response=res)
+            a.append(res)
+
+        _template.__setattr__("action_response", a)
+
+    return (_template, branch) if return_branch else _template
+
+
+async def react(
+    sentence,
+    *,
+    instruction=None,
+    num_instances=1,
+    branch=None,
+    confidence_score=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 _react(
+            sentence=sentence,
+            instruction=instruction,
+            num_instances=num_instances,
+            branch=branch,
+            confidence_score=confidence_score,
+            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/score.py

@@ -12,7 +12,7 @@ ScoreTemplate class and a language model.
 from pydantic import Field
 import numpy as np
 from lionagi.libs import func_call, convert
-from ..prompt.prompt_template import ScoredTemplate
+from ..prompt.scored_template import ScoredTemplate
 from ..branch import Branch
 
 
@@ -183,6 +183,7 @@ async def _score(
 
 async def score(
     sentence,
+    *,
     num_instances=1,
     instruction=None,
     score_range=(1, 10),

lionagi/core/direct/select.py

@@ -13,7 +13,7 @@ from enum import Enum
 from pydantic import Field
 
 from lionagi.libs import func_call, StringMatch
-from ..prompt.prompt_template import ScoredTemplate
+from ..prompt.scored_template import ScoredTemplate
 from ..branch import Branch
 
 
@@ -39,6 +39,7 @@ class SelectTemplate(ScoredTemplate):
     answer: Enum | str = Field(
         default_factory=str, description="selection from given choices"
     )
+    choices: list = Field(default_factory=list, description="the given choices")
 
     signature: str = "sentence -> answer"
 

lionagi/core/direct/sentiment.py

@@ -0,0 +1 @@
+# TODO: sentiment analysis

lionagi/core/messages/schema.py

@@ -173,7 +173,7 @@ class Instruction(BaseMessage):
 
         if output_fields:
             format_ = f"""
-            Follow the following response format.
+            MUST EXACTLY Follow the following response format. NO ADDITIONAL COMMENTS ALLOWED!
             ```json
             {output_fields}
             ```

lionagi/core/prompt/action_template.py

@@ -0,0 +1,26 @@
+from typing import Any
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+
+from .scored_template import ScoredTemplate
+
+
+class ActionRequest: ...
+
+
+class ActionedTemplate(ScoredTemplate):
+
+    action_needed: bool | None = Field(
+        False, description="true if actions are needed else false"
+    )
+
+    actions: list[dict | ActionRequest | Any] | None = Field(
+        default_factory=list,
+        description="""provide The list of action(s) to take, each action in {"function": function_name, "arguments": {param1:..., param2:..., ...}}. Leave blank if no further actions are needed, you must use provided parameters for each action, DO NOT MAKE UP KWARG NAME!!!""",
+    )
+
+    answer: str | dict | Any | None = Field(
+        default_factory=str,
+        description="output answer to the questions asked if further actions are not needed, leave blank if an accurate answer cannot be provided from context during this step",
+    )
+
+    signature: str = "sentence -> reason, action_needed, actions, answer"

lionagi/core/prompt/field_validator.py

@@ -6,7 +6,45 @@ including numeric, boolean, string, and enum. It also provides a dictionary `val
 maps data types to their corresponding validation functions.
 """
 
-from lionagi.libs import convert, StringMatch
+from lionagi.libs import convert, StringMatch, ParseUtil
+
+
+def _has_action_keys(dict_):
+    return list(dict_.keys()) >= ["function", "arguments"]
+
+
+def check_action_field(x, fix_=True, **kwargs):
+    if (
+        isinstance(x, list)
+        and convert.is_same_dtype(x, dict)
+        and all(_has_action_keys(y) for y in x)
+    ):
+        return x
+    try:
+        x = _fix_action_field(x, fix_)
+        return x
+    except Exception as e:
+        raise ValueError("Invalid action field type.") from e
+
+
+def _fix_action_field(x, discard_=True):
+    corrected = []
+    if isinstance(x, str):
+        x = ParseUtil.fuzzy_parse_json(x)
+
+    try:
+        x = convert.to_list(x)
+
+        for i in x:
+            i = convert.to_dict(i)
+            if _has_action_keys(i):
+                corrected.append(i)
+            elif not discard_:
+                raise ValueError(f"Invalid action field: {i}")
+    except Exception as e:
+        raise ValueError(f"Invalid action field: {e}") from e
+
+    return corrected
 
 
 def check_number_field(x, fix_=True, **kwargs):
@@ -236,4 +274,5 @@ validation_funcs = {
     "bool": check_bool_field,
     "str": check_str_field,
     "enum": check_enum_field,
+    "action": check_action_field,
 }

lionagi/core/prompt/prompt_template.py

@@ -207,6 +207,10 @@ class PromptTemplate(BaseComponent):
             setattr(self, k, v_)
             return True
 
+        if "lionagi.core.prompt.action_template.actionrequest" in str_:
+            self.__setattr__(k, validation_funcs["action"](v))
+            return True
+
         elif "bool" in str_:
             self.__setattr__(k, validation_funcs["bool"](v, fix_=fix_, **kwargs))
             return True
@@ -227,48 +231,50 @@ class PromptTemplate(BaseComponent):
             if k not in kwargs:
                 kwargs = {k: {}}
 
-            try:
-                if (
-                    self.model_fields[k].json_schema_extra["choices"] is not None
-                    and "choices" in self.model_fields[k].json_schema_extra
+            if self._field_has_choices(k):
+                self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
+                if self._validate_field(
+                    k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
                 ):
-                    self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
-                    if self._validate_field(
-                        k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
-                    ):
-                        continue
-                    else:
-                        raise ValueError(f"{k} has no choices")
-
-            except Exception as e:
-                if self._validate_field(k, v, fix_=fix_, **kwargs[k]):
                     continue
                 else:
-                    raise ValueError(f"failed to validate field {k}") from e
+                    raise ValueError(f"{k} has no choices")
+
+            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
+                continue
+            else:
+                raise ValueError(f"failed to validate field {k}")
+
+    def _field_has_choices(self, k):
+        try:
+            a = (
+                self.model_fields[k].json_schema_extra["choices"] is not None
+                and "choices" in self.model_fields[k].json_schema_extra
+            )
+            return a if isinstance(a, bool) else False
+        except Exception:
+            return False
 
     def _process_response(self, out_, fix_=True):
         kwargs = self.out_validation_kwargs.copy()
         for k, v in out_.items():
             if k not in kwargs:
                 kwargs = {k: {}}
-            try:
-                if (
-                    self.model_fields[k].json_schema_extra["choices"] is not None
-                    and "choices" in self.model_fields[k].json_schema_extra
+
+            if self._field_has_choices(k):
+                self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
+                if self._validate_field(
+                    k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
                 ):
-                    self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
-                    if self._validate_field(
-                        k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
-                    ):
-                        continue
-                    else:
-                        raise ValueError(f"{k} has no choices")
-
-            except Exception as e:
-                if self._validate_field(k, v, fix_=fix_, **kwargs[k]):
                     continue
                 else:
-                    raise ValueError(f"failed to validate field {k}") from e
+                    raise ValueError(f"{k} has no choices")
+
+            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
+                continue
+
+            else:
+                raise ValueError(f"failed to validate field {k} with value {v}")
 
     @property
     def in_(self):
@@ -288,16 +294,6 @@ class PromptTemplate(BaseComponent):
         return self
 
 
-class ScoredTemplate(PromptTemplate):
-    confidence_score: float | None = Field(
-        -1,
-        description="a numeric score between 0 to 1 formatted in num:0.2f",
-    )
-    reason: str | None = Field(
-        default_factory=str, description="brief reason for the given output"
-    )
-
-
 # class Weather(PromptTemplate):
 #     sunny: bool = Field(True, description="true if the weather is sunny outside else false")
 #     rainy: bool = Field(False, description="true if it is raining outside else false")

lionagi/core/prompt/scored_template.py

@@ -0,0 +1,13 @@
+from lionagi.integrations.bridge.pydantic_.pydantic_bridge import Field
+
+from .prompt_template import PromptTemplate
+
+
+class ScoredTemplate(PromptTemplate):
+    confidence_score: float | None = Field(
+        -1,
+        description="a numeric score between 0 to 1 formatted in num:0.2f",
+    )
+    reason: str | None = Field(
+        default_factory=str, description="brief reason for the given output"
+    )

lionagi/core/tool/manual.py

@@ -0,0 +1 @@
+# TODO: tool manual, instruction on how to use the tool for LLM

lionagi/core/tool/tool_manager.py

@@ -38,7 +38,7 @@ class ToolManager:
     def has_tools(self):
         return self.registry != {}
 
-    def _register_tool(self, tool: Tool) -> None:
+    def _register_tool(self, tool: Tool | Callable) -> None:
         """
         Registers a tool in the registry. Raises a TypeError if the object is not an instance of Tool.
 
@@ -48,6 +48,8 @@ class ToolManager:
         Raises:
                 TypeError: If the provided object is not an instance of Tool.
         """
+        if isinstance(tool, Callable):
+            tool = func_to_tool(tool)[0]
         if not isinstance(tool, Tool):
             raise TypeError("Please register a Tool object.")
         name = tool.schema_["function"]["name"]

lionagi/integrations/bridge/llamaindex_/node_parser.py

@@ -29,19 +29,18 @@ def get_llama_index_node_parser(node_parser: Any):
     import llama_index.core.node_parser
 
     if not isinstance(node_parser, str) and not issubclass(node_parser, NodeParser):
-        raise TypeError(f"node_parser must be a string or NodeParser.")
+        raise TypeError("node_parser must be a string or NodeParser.")
 
     if isinstance(node_parser, str):
         if node_parser == "CodeSplitter":
             SysUtil.check_import("tree_sitter_languages")
 
         try:
-            parser = getattr(llama_index.core.node_parser, node_parser)
-            return parser
+            return getattr(llama_index.core.node_parser, node_parser)
         except Exception as e:
             raise AttributeError(
                 f"llama_index_core has no such attribute:" f" {node_parser}, Error: {e}"
-            )
+            ) from e
 
     elif isinstance(node_parser, NodeParser):
         return node_parser
@@ -75,10 +74,8 @@ def llama_index_parse_node(
         parser = get_llama_index_node_parser(node_parser)
         try:
             parser = parser(*parser_args, **parser_kwargs)
-        except:
+        except Exception:
             parser = parser.from_defaults(*parser_args, **parser_kwargs)
-        nodes = parser.get_nodes_from_documents(documents)
-        return nodes
-
+        return parser.get_nodes_from_documents(documents)
     except Exception as e:
-        raise ValueError(f"Failed to parse. Error: {e}")
+        raise ValueError(f"Failed to parse. Error: {e}") from e

lionagi/integrations/bridge/pydantic_/pydantic_bridge.py

@@ -0,0 +1 @@
+from pydantic import BaseModel, Field, ValidationError, AliasChoices, field_serializer

lionagi/integrations/chunker/chunk.py

@@ -0,0 +1,175 @@
+from typing import Union, Callable
+
+from lionagi.libs import func_call
+from lionagi.core.schema import DataNode
+from ..bridge.langchain_.langchain_bridge import LangchainBridge
+from ..bridge.llamaindex_.llama_index_bridge import LlamaIndexBridge
+
+
+from ..loader.load_util import ChunkerType, file_to_chunks, _datanode_parser
+
+
+def datanodes_convert(documents, chunker_type):
+
+    for i in range(len(documents)):
+        if type(documents[i]) == DataNode:
+            if chunker_type == ChunkerType.LLAMAINDEX:
+                documents[i] = documents[i].to_llama_index()
+            elif chunker_type == ChunkerType.LANGCHAIN:
+                documents[i] = documents[i].to_langchain()
+    return documents
+
+
+def text_chunker(documents, args, kwargs):
+
+    def chunk_node(node):
+        chunks = file_to_chunks(node.to_dict(), *args, **kwargs)
+        func_call.lcall(chunks, lambda chunk: chunk.pop("node_id"))
+        return [DataNode.from_obj({**chunk}) for chunk in chunks]
+
+    return [chunk_node(doc) for doc in documents]
+
+
+def chunk(
+    documents,
+    chunker,
+    chunker_type=ChunkerType.PLAIN,
+    chunker_args=None,
+    chunker_kwargs=None,
+    chunking_kwargs=None,
+    documents_convert_func=None,
+    to_datanode: bool | Callable = True,
+):
+
+    if chunker_args is None:
+        chunker_args = []
+    if chunker_kwargs is None:
+        chunker_kwargs = {}
+    if chunking_kwargs is None:
+        chunking_kwargs = {}
+
+    if chunker_type == ChunkerType.PLAIN:
+        return chunk_funcs[ChunkerType.PLAIN](
+            documents, chunker, chunker_args, chunker_kwargs
+        )
+
+    elif chunker_type == ChunkerType.LANGCHAIN:
+        return chunk_funcs[ChunkerType.LANGCHAIN](
+            documents,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_datanode,
+        )
+
+    elif chunker_type == ChunkerType.LLAMAINDEX:
+        return chunk_funcs[ChunkerType.LLAMAINDEX](
+            documents,
+            documents_convert_func,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            to_datanode,
+        )
+
+    elif chunker_type == ChunkerType.SELFDEFINED:
+        return chunk_funcs[ChunkerType.SELFDEFINED](
+            documents,
+            chunker,
+            chunker_args,
+            chunker_kwargs,
+            chunking_kwargs,
+            to_datanode,
+        )
+
+    else:
+        raise ValueError(
+            f"{chunker_type} is not supported. Please choose from {list(ChunkerType)}"
+        )
+
+
+def _self_defined_chunker(
+    documents,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    chunking_kwargs,
+    to_datanode: bool | Callable,
+):
+    try:
+        splitter = chunker(*chunker_args, **chunker_kwargs)
+        nodes = splitter.split(documents, **chunking_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Self defined chunker {chunker} is not valid. Error: {e}"
+        ) from e
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        raise ValueError("Please define a valid parser to DataNode.")
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _llama_index_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_datanode: bool | Callable,
+):
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "llama_index")
+    nodes = LlamaIndexBridge.llama_index_parse_node(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_llama_index(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _langchain_chunker(
+    documents,
+    documents_convert_func,
+    chunker,
+    chunker_args,
+    chunker_kwargs,
+    to_datanode: bool | Callable,
+):
+    if documents_convert_func:
+        documents = documents_convert_func(documents, "langchain")
+    nodes = LangchainBridge.langchain_text_splitter(
+        documents, chunker, chunker_args, chunker_kwargs
+    )
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        if isinstance(documents, str):
+            nodes = [DataNode(content=i) for i in nodes]
+        else:
+            nodes = [DataNode.from_langchain(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _plain_chunker(documents, chunker, chunker_args, chunker_kwargs):
+    try:
+        if chunker == "text_chunker":
+            chunker = text_chunker
+        return chunker(documents, chunker_args, chunker_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Reader {chunker} is currently not supported. Error: {e}"
+        ) from e
+
+
+chunk_funcs = {
+    ChunkerType.PLAIN: _plain_chunker,
+    ChunkerType.LANGCHAIN: _langchain_chunker,
+    ChunkerType.LLAMAINDEX: _llama_index_chunker,
+    ChunkerType.SELFDEFINED: _self_defined_chunker,
+}

lionagi/integrations/loader/load.py

@@ -0,0 +1,152 @@
+from typing import Callable
+
+from lionagi.core.schema import DataNode
+from ..bridge.langchain_.langchain_bridge import LangchainBridge
+from ..bridge.llamaindex_.llama_index_bridge import LlamaIndexBridge
+
+from .load_util import dir_to_nodes, ReaderType, _datanode_parser
+
+
+def text_reader(args, kwargs):
+    """
+    Reads text files from a directory and converts them to DataNode instances.
+
+    Args:
+        args: Positional arguments for the dir_to_nodes function.
+        kwargs: Keyword arguments for the dir_to_nodes function.
+
+    Returns:
+        A list of DataNode instances.
+
+    Example usage:
+        >>> args = ['path/to/text/files']
+        >>> kwargs = {'file_extension': 'txt'}
+        >>> nodes = text_reader(args, kwargs)
+    """
+    return dir_to_nodes(*args, **kwargs)
+
+
+def load(
+    reader: str | Callable = "SimpleDirectoryReader",
+    input_dir=None,
+    input_files=None,
+    recursive: bool = False,
+    required_exts: list[str] = None,
+    reader_type=ReaderType.LLAMAINDEX,
+    reader_args=None,
+    reader_kwargs=None,
+    load_args=None,
+    load_kwargs=None,
+    to_datanode: bool | Callable = True,
+):
+
+    if reader_args is None:
+        reader_args = []
+    if reader_kwargs is None:
+        reader_kwargs = {}
+    if load_args is None:
+        load_args = []
+    if load_kwargs is None:
+        load_kwargs = {}
+
+    if reader_type == ReaderType.PLAIN:
+        return read_funcs[ReaderType.PLAIN](reader, reader_args, reader_kwargs)
+
+    if reader_type == ReaderType.LANGCHAIN:
+        return read_funcs[ReaderType.LANGCHAIN](
+            reader, reader_args, reader_kwargs, to_datanode
+        )
+
+    elif reader_type == ReaderType.LLAMAINDEX:
+        if input_dir is not None:
+            reader_kwargs["input_dir"] = input_dir
+        if input_files is not None:
+            reader_kwargs["input_files"] = input_files
+        if recursive:
+            reader_kwargs["recursive"] = True
+        if required_exts is not None:
+            reader_kwargs["required_exts"] = required_exts
+
+        return read_funcs[ReaderType.LLAMAINDEX](
+            reader, reader_args, reader_kwargs, load_args, load_kwargs, to_datanode
+        )
+
+    elif reader_type == ReaderType.SELFDEFINED:
+        return read_funcs[ReaderType.SELFDEFINED](
+            reader, reader_args, reader_kwargs, load_args, load_kwargs, to_datanode
+        )
+
+    else:
+        raise ValueError(
+            f"{reader_type} is not supported. Please choose from {list(ReaderType)}"
+        )
+
+
+def _plain_reader(reader, reader_args, reader_kwargs):
+    try:
+        if reader == "text_reader":
+            reader = text_reader
+        return reader(reader_args, reader_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Reader {reader} is currently not supported. Error: {e}"
+        ) from e
+
+
+def _langchain_reader(reader, reader_args, reader_kwargs, to_datanode: bool | Callable):
+    nodes = LangchainBridge.langchain_loader(reader, reader_args, reader_kwargs)
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_langchain(i) for i in nodes]
+
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _llama_index_reader(
+    reader,
+    reader_args,
+    reader_kwargs,
+    load_args,
+    load_kwargs,
+    to_datanode: bool | Callable,
+):
+    nodes = LlamaIndexBridge.llama_index_read_data(
+        reader, reader_args, reader_kwargs, load_args, load_kwargs
+    )
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        nodes = [DataNode.from_llama_index(i) for i in nodes]
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+def _self_defined_reader(
+    reader,
+    reader_args,
+    reader_kwargs,
+    load_args,
+    load_kwargs,
+    to_datanode: bool | Callable,
+):
+    try:
+        loader = reader(*reader_args, **reader_kwargs)
+        nodes = loader.load(*load_args, **load_kwargs)
+    except Exception as e:
+        raise ValueError(
+            f"Self defined reader {reader} is not valid. Error: {e}"
+        ) from e
+
+    if isinstance(to_datanode, bool) and to_datanode is True:
+        raise ValueError("Please define a valid parser to DataNode.")
+    elif isinstance(to_datanode, Callable):
+        nodes = _datanode_parser(nodes, to_datanode)
+    return nodes
+
+
+read_funcs = {
+    ReaderType.PLAIN: _plain_reader,
+    ReaderType.LANGCHAIN: _langchain_reader,
+    ReaderType.LLAMAINDEX: _llama_index_reader,
+    ReaderType.SELFDEFINED: _self_defined_reader,
+}

lionagi/integrations/loader/load_util.py

@@ -0,0 +1,266 @@
+# use utils and schema
+import math
+from enum import Enum
+from pathlib import Path
+from typing import List, Union, Dict, Any, Tuple
+
+from lionagi.libs import convert, func_call
+from lionagi.core.schema import DataNode
+
+
+class ReaderType(str, Enum):
+    PLAIN = "plain"
+    LANGCHAIN = "langchain"
+    LLAMAINDEX = "llama_index"
+    SELFDEFINED = "self_defined"
+
+
+class ChunkerType(str, Enum):
+    PLAIN = "plain"  # default
+    LANGCHAIN = "langchain"  # using langchain functions
+    LLAMAINDEX = "llama_index"  # using llamaindex functions
+    SELFDEFINED = "self_defined"  # create custom functions
+
+
+def dir_to_path(
+    dir: str, ext: str, recursive: bool = False, flatten: bool = True
+) -> List[Path]:
+    """
+    Generates a list of file paths from a directory with the given file extension.
+
+    Parameters:
+        dir (str): The directory to search for files.
+
+        ext (str): The file extension to filter by.
+
+        recursive (bool): Whether to search subdirectories recursively. Defaults to False.
+
+        flatten (bool): Whether to flatten the list. Defaults to True.
+
+    Returns:
+        List[Path]: A list of Paths to the files.
+
+    Raises:
+        ValueError: If the directory or extension is invalid.
+    """
+
+    def _dir_to_path(ext):
+        tem = "**/*" if recursive else "*"
+        return list(Path(dir).glob(tem + ext))
+
+    try:
+        return convert.to_list(
+            func_call.lcall(ext, _dir_to_path, flatten=True), flatten=flatten
+        )
+    except:
+        raise ValueError("Invalid directory or extension, please check the path")
+
+
+def dir_to_nodes(
+    dir: str,
+    ext: Union[List[str], str],
+    recursive: bool = False,
+    flatten: bool = True,
+    clean_text: bool = True,
+) -> List[DataNode]:
+    """
+    Converts directory contents into DataNode objects based on specified file extensions.
+
+    This function first retrieves a list of file paths from the specified directory, matching the given file extension. It then reads the content of these files, optionally cleaning the text, and converts each file's content into a DataNode object.
+
+    Parameters:
+        dir (str): The directory path from which to read files.
+        ext: The file extension(s) to include. Can be a single string or a list/tuple of strings.
+        recursive (bool, optional): If True, the function searches for files recursively in subdirectories. Defaults to False.
+        flatten (bool, optional): If True, flattens the directory structure in the returned paths. Defaults to True.
+        clean_text (bool, optional): If True, cleans the text read from files. Defaults to True.
+
+    Returns:
+        list: A list of DataNode objects created from the files in the specified directory.
+
+    Example:
+        nodes = dir_to_nodes("/path/to/dir", ".txt", recursive=True)
+        # This would read all .txt files in /path/to/dir and its subdirectories,
+        # converting them into DataNode objects.
+    """
+
+    path_list = dir_to_path(dir, ext, recursive, flatten)
+    files_info = func_call.lcall(path_list, read_text, clean=clean_text)
+    return func_call.lcall(files_info, lambda x: DataNode(content=x[0], metadata=x[1]))
+
+
+def chunk_text(
+    input: str, chunk_size: int, overlap: float, threshold: int
+) -> List[Union[str, None]]:
+    """
+    Chunks the input text into smaller parts, with optional overlap and threshold for final chunk.
+
+    Parameters:
+        input (str): The input text to chunk.
+
+        chunk_size (int): The size of each chunk.
+
+        overlap (float): The amount of overlap between chunks.
+
+        threshold (int): The minimum size of the final chunk.
+
+    Returns:
+        List[Union[str, None]]: A list of text chunks.
+
+    Raises:
+        ValueError: If an error occurs during chunking.
+    """
+
+    def _chunk_n1():
+        return [input]
+
+    def _chunk_n2():
+        chunks = []
+        chunks.append(input[: chunk_size + overlap_size])
+
+        if len(input) - chunk_size > threshold:
+            chunks.append(input[chunk_size - overlap_size :])
+        else:
+            return _chunk_n1()
+
+        return chunks
+
+    def _chunk_n3():
+        chunks = []
+        chunks.append(input[: chunk_size + overlap_size])
+        for i in range(1, n_chunks - 1):
+            start_idx = chunk_size * i - overlap_size
+            end_idx = chunk_size * (i + 1) + overlap_size
+            chunks.append(input[start_idx:end_idx])
+
+        if len(input) - chunk_size * (n_chunks - 1) > threshold:
+            chunks.append(input[chunk_size * (n_chunks - 1) - overlap_size :])
+        else:
+            chunks[-1] += input[chunk_size * (n_chunks - 1) + overlap_size :]
+
+        return chunks
+
+    try:
+        if not isinstance(input, str):
+            input = convert.to_str(input)
+
+        n_chunks = math.ceil(len(input) / chunk_size)
+        overlap_size = int(overlap / 2)
+
+        if n_chunks == 1:
+            return _chunk_n1()
+
+        elif n_chunks == 2:
+            return _chunk_n2()
+
+        elif n_chunks > 2:
+            return _chunk_n3()
+
+    except Exception as e:
+        raise ValueError(f"An error occurred while chunking the text. {e}")
+
+
+def read_text(filepath: str, clean: bool = True) -> Tuple[str, dict]:
+    """
+    Reads text from a file and optionally cleans it, returning the content and metadata.
+
+    Parameters:
+        filepath (str): The path to the file to read.
+
+        clean (bool): Whether to clean the text by replacing certain characters. Defaults to True.
+
+    Returns:
+        Tuple[str, dict]: A tuple containing the content and metadata of the file.
+
+    Raises:
+        FileNotFoundError: If the file cannot be found.
+
+        PermissionError: If there are permissions issues.
+
+        OSError: For other OS-related errors.
+    """
+
+    def _get_metadata():
+        import os
+        from datetime import datetime
+
+        file = filepath
+        size = os.path.getsize(filepath)
+        creation_date = datetime.fromtimestamp(os.path.getctime(filepath)).date()
+        modified_date = datetime.fromtimestamp(os.path.getmtime(filepath)).date()
+        last_accessed_date = datetime.fromtimestamp(os.path.getatime(filepath)).date()
+        return {
+            "file": convert.to_str(file),
+            "size": size,
+            "creation_date": str(creation_date),
+            "modified_date": str(modified_date),
+            "last_accessed_date": str(last_accessed_date),
+        }
+
+    try:
+        with open(filepath, "r") as f:
+            content = f.read()
+            if clean:
+                # Define characters to replace and their replacements
+                replacements = {"\\": " ", "\n": " ", "\t": " ", "  ": " ", "'": " "}
+                for old, new in replacements.items():
+                    content = content.replace(old, new)
+            metadata = _get_metadata()
+            return content, metadata
+    except Exception as e:
+        raise e
+
+
+def _file_to_chunks(
+    input: Dict[str, Any],
+    field: str = "content",
+    chunk_size: int = 1500,
+    overlap: float = 0.1,
+    threshold: int = 200,
+) -> List[Dict[str, Any]]:
+    try:
+        out = {key: value for key, value in input.items() if key != field} | {
+            "chunk_overlap": overlap,
+            "chunk_threshold": threshold,
+        }
+        chunks = chunk_text(
+            input[field], chunk_size=chunk_size, overlap=overlap, threshold=threshold
+        )
+        logs = []
+        for i, chunk in enumerate(chunks):
+            chunk_dict = out | {
+                "file_chunks": len(chunks),
+                "chunk_id": i + 1,
+                "chunk_size": len(chunk),
+                f"chunk_{field}": chunk,
+            }
+            logs.append(chunk_dict)
+
+        return logs
+
+    except Exception as e:
+        raise ValueError(f"An error occurred while chunking the file. {e}") from e
+
+
+# needs doing TODO
+def file_to_chunks(
+    input,
+    #    project='project',
+    #    output_dir='data/logs/sources/',
+    chunk_func=_file_to_chunks,
+    **kwargs,
+):
+    #    out_to_csv=False,
+    #    filename=None,
+    #    verbose=True,
+    #    timestamp=True,
+    #    logger=None,
+    return convert.to_list(func_call.lcall(input, chunk_func, **kwargs), flatten=True)
+
+
+def _datanode_parser(nodes, parser):
+
+    try:
+        return parser(nodes)
+    except Exception as e:
+        raise ValueError(f"DataNode parser {parser} failed. Error:{e}") from e

lionagi/integrations/provider/ollama.py

@@ -11,7 +11,7 @@ allowed_kwargs = [
     "seed",
     "stop",
     "stream",
-    "temperature",
+    # "temperature",
     "top_p",
     "tools",
     "tool_choice",

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.0.313"
+__version__ = "0.0.315"

{lionagi-0.0.313.dist-info → lionagi-0.0.315.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.0.313
+Version: 0.0.315
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: Haiyang Li <ocean@lionagi.ai>
@@ -43,39 +43,35 @@ To contribute, you need to make a fork first, and then make pull request from yo
   
 # LionAGI
 
-
-**LionAGI is undergoing major transformation.**
+**Powerful Intelligent Workflow Automation**
 
 It is an intelligent agentic workflow automation framework. It introduces advanced ML models into any existing workflows and data infrastructure.
 
-#### Currently, it can
 
-- generate inferences from almost all models including local
-- run most model inferencing in parallel
-- produce structured pydantic outputs with flexible usage
+### Currently, it can
+
+- interact with almost any models including local*
+- run interactions in parallel for most models (OpenRouter, OpenAI, Ollama, litellm...)
+- produce structured pydantic outputs with flexible usage\*\*
 - automate workflow via graph based agents
 - use advanced prompting techniques, i.e. ReAct (reason-action)
 - …
-  
-#### It aims to:
 
-- provide a centralized agent-managed framework for ML-powered tools coordination.
+### It aims to:
+
+- provide a centralized agent-managed framework for, "ML-powered tools coordination".
+- The ways of coordination and possible path can occur among nodes is what we also refers to as `workflow` (the concept of workflow is still in design).
 - such that, people can utilize intelligence to solve their problems in real life.
 - achieve the goal by dramatically lowering the barrier of entries for creating use-case/domain specific tools.
 
-#### Why?
 
-- To better the human experience for more.
-
----
-
-
-**Powerful Intelligent Workflow Automation**
+All notebooks should run, as of 0.0.313,
 
-LionAGI is an **intelligent agent framework**. Tailored for **big data analysis** in conjunction with advanced **machine learning** tools, designed for data-centric, production-level projects. Lionagi provides a set of robust tools, enabling flexible and rapid design of agentic workflow, for your own data.  
+\* if there are models on providers that have not been configured, you can do so by configuring your own AI providers, and endpoints. 
 
+\*\* Structured Input/Output, Graph based agent system, as well as more advanced prompting techniques are undergoing fast interations...
 
-## Why Automating Workflows?
+### Why Automating Workflows?
 
 Intelligent AI models such as [Large Language Model (LLM)](https://en.wikipedia.org/wiki/Large_language_model), introduced new possibilities of human-computer interaction. LLMs is drawing a lot of attention worldwide due to its “one model fits all”, and incredible performance. One way of using LLM is to use as search engine, however, this usage is complicated by the fact that LLMs [hallucinate](https://arxiv.org/abs/2311.05232).
 

{lionagi-0.0.313.dist-info → lionagi-0.0.315.dist-info}/RECORD

@@ -1,5 +1,5 @@
-lionagi/__init__.py,sha256=xIFCHZZwgI_CCwZTmwkDpw05NkyZHDiD4M_bOmat3Gs,328
-lionagi/version.py,sha256=_WLoEoWoGNQQBzISpn7KBUmEoUC581liJ4vQvxr0-Ac,24
+lionagi/__init__.py,sha256=i6Ci7FebU2s4EVVnBFj1Dsi5RvP80JqeSqW-iripRPg,418
+lionagi/version.py,sha256=Zazlk4sxt5cxFTrUeqVNVrVkGcIAkFTm-b9a6VLDqkw,24
 lionagi/core/__init__.py,sha256=M5YXmJJiLcR5QB1VRmYvec14cHT6pKvxZOEs737BmP8,322
 lionagi/core/agent/__init__.py,sha256=IVcw9yn_QMBJGBou1Atck98Us9uwPGFs-gERTv0RWew,59
 lionagi/core/agent/base_agent.py,sha256=CRUpl7Zc5d2H9uCa17nMiFAnhKM_UH5Ujo1NHo3JAxg,3371
@@ -10,10 +10,14 @@ lionagi/core/branch/branch_flow_mixin.py,sha256=yXEfpxTaJ1aoDQQnCBYx5wShn9zt1ki8
 lionagi/core/branch/executable_branch.py,sha256=Yi0t4fDNMa5UaHo15sX-zBchr5auvXOtSc0RnSpG2a8,12151
 lionagi/core/branch/util.py,sha256=os7Qp7HpDfyyCvdkbBTyIQ3AYHfzUP0M684W4XMDHN4,11813
 lionagi/core/branch/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/core/direct/__init__.py,sha256=MeIVmdOYLsDWX2ipC8H76DeDqHRlmPz1o1kMPDxnQM0,154
-lionagi/core/direct/predict.py,sha256=hzWsPiVxHEePQssJoUiJsFDpGZzjdWgM2uOynCIqR3U,6309
-lionagi/core/direct/score.py,sha256=R7lwYuqUFb3YGWDeiX_CTsp_NcBjaaBx5K0m8DK0xy0,10321
-lionagi/core/direct/select.py,sha256=jDR-M--3iMMk3PUqu_fdIsO3gAYiXA4LbaS9dF-QHCc,6046
+lionagi/core/direct/__init__.py,sha256=P17UfY3tLFgu0ncxMy4FRoVDlvOGUc7jzeowN41akBk,188
+lionagi/core/direct/cot.py,sha256=3hz0CjFN2Bw5IW1tOh26fzd1UVrV_41KKIS7pzCd6ok,26
+lionagi/core/direct/plan.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/core/direct/predict.py,sha256=tkxvN9m_XOf3SW8xTi5yanXylV8xVNRn9a8DeGd9xgs,6355
+lionagi/core/direct/react.py,sha256=IJ6sKgajCjhQ_UpJHf-j71tnVehEtIXFnyeB6bNlZwk,4196
+lionagi/core/direct/score.py,sha256=QHO11WtAUfMEdfa1K-SRyn5uqf6_N0UmyCbEJsiqcQw,10328
+lionagi/core/direct/select.py,sha256=pPwesq29C3JZ5J3piwjBHqjOCsEM4uChPKMGBRxtSTE,6127
+lionagi/core/direct/sentiment.py,sha256=rNwBs-I2XICOwsXxFvfM1Tlc_afsVcRCNCXCxfxm_2k,27
 lionagi/core/direct/utils.py,sha256=yqu4qv9aaU4qzUD9QovtN2m21QySzdMLmcBp5recWC0,2333
 lionagi/core/direct/vote.py,sha256=tjs-EYDGlGB3J6d_nSl1oIuJYHtxncjustBbU_pXDqQ,2449
 lionagi/core/flow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,10 +34,12 @@ lionagi/core/mail/__init__.py,sha256=FTMSvImGo3dQVnY1FYC_K0Ido9VwJa0DDJogR3nqSeM
 lionagi/core/mail/mail_manager.py,sha256=M1l0eWdSj0oMLBeKIVqCJQ1Vn4GdIyf8tABagrsgwxc,3866
 lionagi/core/mail/schema.py,sha256=qA5MsjJGeXQodEWOnKNF3l0_xnssNU3lroorUYuHq0Y,1625
 lionagi/core/messages/__init__.py,sha256=NmK1xeR7xMgsbWxW-wm7d82QXKrRu6t7PKO5REpwO_k,99
-lionagi/core/messages/schema.py,sha256=GEg8FAi4u1R9uG-GVvuE27_H2CLP1Z8SbhKzyOI4BZo,19145
+lionagi/core/messages/schema.py,sha256=BCT9sv3I2CiYkqXlGyvQmKb4xoL5xvhInR8RYWxeIiI,19190
 lionagi/core/prompt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/core/prompt/field_validator.py,sha256=ukjyKvfB6YbHp6kaUNXGmV3pjH2H4W3pWqPFglgsRUU,7094
-lionagi/core/prompt/prompt_template.py,sha256=pSvrnN6lAQrVZAD8lifiNfkRqTAn4frQRvjcQDsK5xY,12044
+lionagi/core/prompt/action_template.py,sha256=B_lpTUeAL1x_hwhsvj5EEFU5hxi5Om7Gjtom4qVKtPo,1035
+lionagi/core/prompt/field_validator.py,sha256=QqeINioagGh4Qj-guZaFX2exFezTTGUCfQLnrnWPEsQ,8090
+lionagi/core/prompt/prompt_template.py,sha256=W6CRXW7fwaSNbj7f7V9Az7yXEtHcLcCZonuMqJmzL8s,11755
+lionagi/core/prompt/scored_template.py,sha256=jrnMEB22eItERmunTPJbmJdgSMoh0pdHMXfJUAUa_S4,410
 lionagi/core/schema/__init__.py,sha256=C2dNOGQdI0c8vISFTG0h_7jhVnCpcY9kJbPEBmPMJO8,521
 lionagi/core/schema/action_node.py,sha256=uTjHLe-GmR1p_9rT_BCF0JC4FB9Dd1Rr5c_2pAL01o8,736
 lionagi/core/schema/base_mixin.py,sha256=c4YAxN5pOvmBZqvL-0bBGrJ7T9LPItVqPNrTwkP0FHk,11059
@@ -46,8 +52,8 @@ lionagi/core/schema/structure.py,sha256=9BFKpkvrBGgZ88Zim7HqsK3AC8qserwN3FdzJyvJ
 lionagi/core/session/__init__.py,sha256=A1W67UXOGAIRuSmFZPtGRqoPq0spTkjSiGCucOEEhTE,52
 lionagi/core/session/session.py,sha256=vNqq5DbEEGfVaMPG8x8LAVnOXlZZ7jUeHgWnQtCRbqY,37975
 lionagi/core/tool/__init__.py,sha256=hpv1NzjiPtpng2Ie_fXgIP-lVCSG1fTub-gO9Q41ee0,95
-lionagi/core/tool/manual.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/core/tool/tool_manager.py,sha256=KKFPZj9qCILJIc2k1UPiHWbRwejQnOAP42NcMT8Z0DQ,11215
+lionagi/core/tool/manual.py,sha256=75XhIkEkVoscu5qKBm3cTWmSWDFN-uRmK-e26lbSEso,64
+lionagi/core/tool/tool_manager.py,sha256=RcF4ktKC_3Ft3xgyr8tj4HuFwKOArJsM7uxK6GWVewY,11306
 lionagi/integrations/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
 lionagi/integrations/bridge/__init__.py,sha256=ee5IeCkDOD2uhbzqxg_xDxaG-Q3BPPZCYltBjzg2gSs,169
 lionagi/integrations/bridge/langchain_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,23 +62,27 @@ lionagi/integrations/bridge/langchain_/langchain_bridge.py,sha256=-lnJtyf4iJEwHK
 lionagi/integrations/bridge/llamaindex_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/bridge/llamaindex_/index.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/integrations/bridge/llamaindex_/llama_index_bridge.py,sha256=SSnLSIu06xVsghTios01QKGrc2xCq3oC8fVNGO4QkF8,5064
-lionagi/integrations/bridge/llamaindex_/node_parser.py,sha256=cDbMqPT9cAXGVPCOPE5HrXxtTZ5ko2Wiw6m8hIaWoGA,3486
+lionagi/integrations/bridge/llamaindex_/node_parser.py,sha256=d8SPD6EMf9bZ6824jjeZOWmwm7BHBZQ0qGq1JnsKh9k,3458
 lionagi/integrations/bridge/llamaindex_/reader.py,sha256=VxdTk5h3a3_5RQzN15q75XGli52umhz9gLUrKk1Sg90,8235
 lionagi/integrations/bridge/llamaindex_/textnode.py,sha256=OszGitHZ36zbG4DCGWUnSV6EO7wChEH2VA5M50iBojs,2322
 lionagi/integrations/bridge/pydantic_/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/integrations/bridge/pydantic_/base_model.py,sha256=leAJmpNTFIOUgTe0nawCSW9V5oTecCsCPr_K6C4MSBM,237
-lionagi/integrations/bridge/pydantic_/pydantic_bridge.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/integrations/bridge/pydantic_/pydantic_bridge.py,sha256=TVh7sQX_LKERUvv1nxsA2JICY1S6ptPr3qFqzgHfGCY,87
+lionagi/integrations/chunker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/integrations/chunker/chunk.py,sha256=huLtaLVzs2Py6F9tFHdU0o67JncOiX4WfmmmFccbcgI,5107
 lionagi/integrations/config/__init__.py,sha256=zzQGZe3H5vofcNWSjjoqe_gqHpCO8Yl7FefmrUpLqnw,133
 lionagi/integrations/config/mlx_configs.py,sha256=xbostqjnk3aAN-qKyC54YBprHPA38C8YDevXMMEHXWY,44
 lionagi/integrations/config/oai_configs.py,sha256=aoKx91Nv5eQU2F8v8EsALXQCEEfy3sfCgUYjCYEGJPU,2754
 lionagi/integrations/config/ollama_configs.py,sha256=Np73p86bTJtxYwAj3lr5l8V9IMu7rHJPdyzHEqyzI2Q,17
 lionagi/integrations/config/openrouter_configs.py,sha256=Sz4IHrriXoB8RQ0Pj23Q13Ps4AnZ0BWrh5DhL18NLwQ,1379
+lionagi/integrations/loader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/integrations/loader/load.py,sha256=XYG93HzxKvnWIrPq-MotY6JTiuB_11rSADjOq_OdeiM,4582
+lionagi/integrations/loader/load_util.py,sha256=7VyoQ3z4kYscjqOGFYrhPq1U0yPIR9NHWCESfv2gmp4,8369
 lionagi/integrations/provider/__init__.py,sha256=MJhnq2tkBRcMH-3utc0G-Co20MmsxLBbp3fUwHrJGQ8,198
 lionagi/integrations/provider/litellm.py,sha256=l3sTtIPDeM_9soTLj9gpVfFWWDzFfIZ7rbVcuzeql2w,1181
 lionagi/integrations/provider/mistralai.py,sha256=G-StbfrnUcWZvl0eRby6CZYXxmJf6BRMFzDaix-brmU,7
 lionagi/integrations/provider/mlx_service.py,sha256=ilbBupRs3HeOeO2iwW0prVq57krPu9db8aYLgq_cN0A,1325
 lionagi/integrations/provider/oai.py,sha256=ZxfVz-ZdpeYqXQFq_1_Lqlz4sG8zmp48MosGIpV5ggU,4222
-lionagi/integrations/provider/ollama.py,sha256=1oQ9B3GAIqjG79KKA1rL6oD7qGwdZZbAlVqBe_jAnGM,1312
+lionagi/integrations/provider/ollama.py,sha256=dOKqzqjpwYYGw9vGKDVzVh9PAem7oFG09cfKEEB__oc,1314
 lionagi/integrations/provider/openrouter.py,sha256=ZEG2lLbp-qb7r95CFAuPz7EqAdsMuJxMJXfgWhaBHsk,1856
 lionagi/integrations/provider/services.py,sha256=zLX_C0p1eI5cfxkxlxIVEsU0k_fknhV1-LoXPJZFE4w,5388
 lionagi/integrations/provider/transformers.py,sha256=E6CTtm7pa3aa0IqYklWvhXz9YWlh3p_lgKaJXYfXeyA,3397
@@ -104,8 +114,8 @@ lionagi/tests/test_libs/test_func_call.py,sha256=xvs19YBNxqh3RbWLjQXY19L06b1_uZY
 lionagi/tests/test_libs/test_nested.py,sha256=eEcE4BXJEkjoPZsd9-0rUxOJHjmu8W2hgVClUTwXEFY,13106
 lionagi/tests/test_libs/test_parse.py,sha256=aa74kfOoJwDU7L7-59EcgBGYc5-OtafPIP2oGTI3Zrk,6814
 lionagi/tests/test_libs/test_sys_util.py,sha256=Y-9jxLGxgbFNp78Z0PJyGUjRROMuRAG3Vo3i5LAH8Hs,7849
-lionagi-0.0.313.dist-info/LICENSE,sha256=vfczrx-xFNkybZ7Ef-lGUnA1Vorky6wL4kwb1Fd5o3I,1089
-lionagi-0.0.313.dist-info/METADATA,sha256=y02OPxTnkFJKv5-uNtc4jueHle7PErVy4hHA4zXAgME,7849
-lionagi-0.0.313.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-lionagi-0.0.313.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
-lionagi-0.0.313.dist-info/RECORD,,
+lionagi-0.0.315.dist-info/LICENSE,sha256=vfczrx-xFNkybZ7Ef-lGUnA1Vorky6wL4kwb1Fd5o3I,1089
+lionagi-0.0.315.dist-info/METADATA,sha256=FVnSivifINUlYoYjEh7s01WKZ3h1Hn1AW_uKW3KfdLg,7934
+lionagi-0.0.315.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+lionagi-0.0.315.dist-info/top_level.txt,sha256=szvch_d2jE1Lu9ZIKsl26Ll6BGfYfbOgt5lm-UpFSo4,8
+lionagi-0.0.315.dist-info/RECORD,,

lionagi/integrations/bridge/pydantic_/base_model.py

@@ -1,7 +0,0 @@
-from pydantic import BaseModel, Field, ValidationError, AliasChoices, field_serializer
-
-ln_BaseModel = BaseModel
-ln_Field = Field
-ln_field_serializer = field_serializer
-ln_AliasChoices = AliasChoices
-ln_ValidationError = ValidationError