lionagi 0.6.0__tar.gz → 0.7.0__tar.gz

lionagi-0.7.0/.github/workflows/docs.yml

@@ -0,0 +1,34 @@
+name: Build and Deploy Docs
+
+on:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  build-deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install dependencies
+        run: |
+          pip install --upgrade pip
+          pip install sphinx furo  # or your theme
+          # plus any other dependencies needed
+
+      - name: Build Sphinx docs
+        run: |
+          cd docs
+          make html
+
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GH_TOKEN }}
+          publish_dir: docs/_build/html

{lionagi-0.6.0 → lionagi-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.6.0
+Version: 0.7.0
 Summary: An AGentic Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -217,13 +217,13 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
+Requires-Python: >=3.10
 Requires-Dist: aiocache>=0.12.0
 Requires-Dist: aiohttp>=3.11.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: litellm>=1.55.3
 Requires-Dist: pandas>=2.0.0
-Requires-Dist: pillow>=11.0.0
+Requires-Dist: pillow>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.1
 Description-Content-Type: text/markdown
@@ -232,7 +232,7 @@ Description-Content-Type: text/markdown
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
 
-[Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+[Documentation](https://lion-agi.github.io/lionagi/) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
 
 # LION Framework
 ### Language InterOperable Network - The Future of Controlled AI Operations

{lionagi-0.6.0 → lionagi-0.7.0}/README.md

@@ -2,7 +2,7 @@
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/lionagi?color=blue)
 ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
 
-[Documentation](https://ocean-lion.com/Welcome) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
+[Documentation](https://lion-agi.github.io/lionagi/) | [Discord](https://discord.gg/aqSJ2v46vu) | [PyPI](https://pypi.org/project/lionagi/) | [Roadmap](https://trello.com/b/3seomsrI/lionagi)
 
 # LION Framework
 ### Language InterOperable Network - The Future of Controlled AI Operations

lionagi-0.7.0/docs/Makefile

@@ -0,0 +1,20 @@
+# Makefile — On Linux/macOS, run "make html" or "make latexpdf"
+
+SHELL = /bin/sh
+
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+.PHONY: help clean html
+
+help:
+	@echo "Please use 'make <target>' where <target> is one of:"
+	@echo "  html   to build the HTML documentation"
+	@echo "  clean  to remove build artifacts"
+
+clean:
+	rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -M html "$(SOURCEDIR)" "$(BUILDDIR)"

lionagi-0.7.0/docs/_static/custom.css

@@ -0,0 +1,59 @@
+/* Container for the custom link */
+.my-custom-header {
+    /* If you prefer to separate from theme content: */
+    margin: 0.75rem 1rem 0 1rem;
+    display: flex;
+    justify-content: flex-end; /* Right align */
+    align-items: center;
+    /* Optional border or bottom line: */
+    border-bottom: 1px solid var(--color-border-muted, #ccc);
+    padding-bottom: 0.5rem;
+  }
+  
+  .my-custom-header .header-link {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.4rem;
+    text-decoration: none;
+    color: var(--color-text-primary, #222); /* fallback if CSS vars not set */
+    background: var(--color-background-accent, #f5f5f5);
+    padding: 0.4rem 0.75rem;
+    border-radius: 6px;
+    font-weight: 500;
+    transition: background-color 0.2s ease, color 0.2s ease;
+  }
+  
+  .my-custom-header .header-link:hover {
+    background: var(--color-background-accent-hover, #e6e6e6);
+    color: var(--color-text-primary-hover, #111);
+  }
+  
+  /* The GitHub icon: ensures it scales well with text size */
+  .my-custom-header .gh-icon {
+    width: 1.2em;
+    height: 1.2em;
+    flex-shrink: 0;
+    opacity: 0.8;
+    transition: opacity 0.2s ease;
+  }
+  
+  .my-custom-header .header-link:hover .gh-icon {
+    opacity: 1.0;
+  }
+  
+  /* Example support for dark mode if your theme doesn't handle it automatically. */
+  @media (prefers-color-scheme: dark) {
+    .my-custom-header .header-link {
+      background: var(--color-background-accent-dark, #333);
+      color: var(--color-text-primary-dark, #eee);
+    }
+    .my-custom-header .header-link:hover {
+      background: var(--color-background-accent-hover-dark, #444);
+    }
+    .my-custom-header .gh-icon {
+      opacity: 0.8;
+    }
+    .my-custom-header .header-link:hover .gh-icon {
+      opacity: 1.0;
+    }
+  }

lionagi-0.7.0/docs/_templates/layout.html

@@ -0,0 +1,34 @@
+{% extends "!layout.html" %}
+
+{% block header %}
+  <!-- Our custom header container -->
+  <div class="my-custom-header">
+    <!-- A sleek "View on GitHub" link with an icon -->
+    <a class="header-link" 
+       href="https://github.com/lion-agi/lionagi" 
+       target="_blank" 
+       rel="noopener noreferrer"
+       title="View this project on GitHub">
+      <!-- Optional: embed an inline GitHub icon using an SVG -->
+      <svg class="gh-icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor">
+        <path
+          d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 
+             3.438 9.8 8.205 11.387.6.113.82-.258.82-.577 
+             0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61 
+             -.546-1.387-1.333-1.758-1.333-1.758-1.089-.744.083-.729.083-.729 
+             1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.304 
+             3.495.998.108-.776.418-1.304.76-1.604-2.665-.3-5.466-1.332-5.466-5.93 
+             0-1.31.47-2.381 1.236-3.221-.123-.303-.54-1.523.117-3.176 0 0 
+             1.008-.322 3.301 1.23.96-.267 1.98-.399 3-.405 1.02.006 
+             2.04.138 3 .405 2.291-1.552 3.299-1.23 
+             3.299-1.23 .657 1.653.24 2.873.117 3.176.77.84 
+             1.236 1.911 1.236 3.221 0 4.61-2.804 5.625-5.475 
+             5.92.43.372.81 1.102.81 2.221 0 1.604-.015 
+             2.896-.015 3.286 0 .319.22.694.825.576C20.565 
+             22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12"/>
+      </svg>
+      <span>View on GitHub</span>
+    </a>
+  </div>
+  {{ super() }}
+{% endblock %}

lionagi-0.7.0/docs/conf.py

@@ -0,0 +1,56 @@
+# conf.py — Sphinx configuration for your docs
+
+import os
+import sys
+
+# Insert the path to your main package so autodoc can find it
+# (Adjust the relative path to match your repo's layout)
+sys.path.insert(0, os.path.abspath(".."))
+
+project = "LionAGI"
+author = "Haiyang Li"
+copyright = "2025"
+release = "0.6"  # or version from your package
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",  # Google/NumPy style docstrings
+    "sphinx.ext.todo",
+    "sphinx.ext.viewcode",
+    # "sphinx.ext.autosummary",  # optional
+]
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+# -- Options for HTML output ----------------------------------------------
+html_theme = "furo"
+html_static_path = ["_static"]
+
+html_theme_options = {
+    "sidebar_hide_name": True,
+    "navigation_with_keys": True,
+    # Hide the “On This Page” panel if you want to rely solely on your local TOC
+    "hide_pages_index": True,
+    "light_css_variables": {
+        "color-brand-primary": "#007ACC",
+        "color-brand-content": "#006699",
+    },
+    "dark_css_variables": {
+        "color-brand-primary": "#4DC1FF",
+        "color-brand-content": "#99C2FF",
+    },
+}
+
+# Tells Sphinx to include custom.css after the theme's CSS
+html_css_files = [
+    "custom.css",
+]
+
+# (Optional) a custom title for the entire site:
+html_title = "LionAGI Documentation"
+
+
+# -- Custom / Additional config options -----------------------------------
+# e.g., napoleon_use_param = True
+# or todo_include_todos = True

lionagi-0.7.0/docs/index.rst

@@ -0,0 +1,35 @@
+.. _lionagi-docs-index:
+
+=================================
+LionAGI — Documentation Home Page
+=================================
+
+Welcome to LionAGI's documentation!
+
+Here you'll find:
+
+* Core messages system (actions, etc.)
+* Adapters (tools for conversions)
+* Operatives (instruct, plans, etc.)
+* Additional modules references
+* High-level operations and strategies
+* And more...
+
+Contents
+========
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Table of Contents:
+
+   tutorials/index
+   modules/index
+   operations/index
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

lionagi-0.7.0/docs/modules/action.rst

@@ -0,0 +1,339 @@
+.. _lionagi-action:
+
+===========================
+Action
+===========================
+
+This module provides a **flexible event-driven framework** for creating and managing
+**callable “tools”** in LionAGI, validating their inputs/outputs, and invoking them
+asynchronously with optional pre/post-processing steps. It integrates with the LionAGI
+**event system** (see :class:`~lionagi.protocols.types.Event`), allowing each function call
+to be tracked as an event—complete with execution duration, status, and error handling.
+
+The primary components are:
+
+- **Tool**: A wrapper for a Python callable function with validation.
+- **ActionManager**: A registry that orchestrates tools.
+- **FunctionCalling**: An :class:`~lionagi.protocols.types.Event` that tracks
+  asynchronous function execution.
+- **ActionRequestModel** / **ActionResponseModel**: Pydantic models for structuring
+  inputs/outputs.
+
+These classes can be combined with LionAGI's concurrency architecture—such as
+:class:`~lionagi.protocols.generic.processor.Processor` and
+:class:`~lionagi.protocols.generic.processor.Executor`—to manage multiple function calls
+as events in a queue or stored in a :class:`~lionagi.protocols.generic.pile.Pile`
+(ordered by a :class:`~lionagi.protocols.generic.progression.Progression`).
+
+
+---------------------------
+Module Organization & Files
+---------------------------
+
+The ``lionagi.action`` package comprises:
+
+- **function_calling.py**:
+
+  Contains :class:`FunctionCalling`, which is an event class for executing a
+  single tool call asynchronously, handling optional pre/post processing,
+  and storing timing/status in its :attr:`execution`.
+
+- **manager.py**:
+
+  Implements :class:`ActionManager`, a central registry to:
+
+  - Register tools (functions).
+  - Match incoming requests (function name + arguments) to a registered tool.
+  - Create and run :class:`FunctionCalling` events, returning outcomes or errors.
+
+- **request_response_model.py**:
+
+  Defines the data schemas for requests/responses:
+
+  - :class:`ActionRequestModel` — capturing the function name and arguments.
+  - :class:`ActionResponseModel` — capturing output after the call.
+
+- **tool.py**:
+
+  Provides the :class:`Tool` class, wrapping a Python function with optional
+  **preprocessor** / **postprocessor** steps, plus an auto-generated argument schema.
+
+.. module:: lionagi.action
+
+
+Tool
+~~~~
+.. class:: Tool
+
+   A ``Tool`` wraps a Python callable (function) with metadata and (optionally)
+   preprocessing/postprocessing. It can **strictly validate** the function's parameters,
+   preventing extraneous or missing arguments.
+
+   **Key Attributes**:
+
+   .. py:attribute:: func_callable
+      :type: Callable[..., Any]
+
+      The underlying Python function. This may be sync or async.
+
+   .. py:attribute:: tool_schema
+      :type: dict[str, Any] | None
+
+      An auto-generated JSON schema for the function's parameters (unless provided explicitly).
+
+   .. py:attribute:: preprocessor
+      :type: Callable[[dict[str, Any]], dict[str, Any]] | None
+
+      Optional function that modifies/validates the incoming arguments.
+
+   .. py:attribute:: postprocessor
+      :type: Callable[[Any], Any] | None
+
+      Optional function that modifies/validates the function's output.
+
+   .. py:attribute:: strict_func_call
+      :type: bool
+
+      If ``True``, only the function's exact parameters are allowed during invocation.
+
+   **Properties**:
+
+   .. py:attribute:: function
+      :type: str
+
+      The function's name, inferred from the callable unless overridden.
+
+   .. py:attribute:: required_fields
+      :type: set[str]
+
+      The parameter names that have no default in the function signature.
+
+   .. py:attribute:: minimum_acceptable_fields
+      :type: set[str]
+
+      A less strict subset of required fields, determined by analyzing
+      arguments vs. defaults.
+
+   **Example**::
+
+      from lionagi.action.tool import Tool
+
+      def add(x: int, y: int) -> int:
+          return x + y
+
+      # Wrap 'add' with strict validation
+      add_tool = Tool(
+          func_callable=add,
+          strict_func_call=True
+      )
+
+
+FunctionCalling
+~~~~~~~~~~~~~~~
+.. class:: FunctionCalling
+   :noindex:
+
+   An **event** class representing a single function invocation. It tracks:
+
+   - **Which tool** to call (:attr:`func_tool`).
+   - **Arguments** to pass (:attr:`arguments`).
+   - **Execution** metadata (duration, status, response, error) via
+     :attr:`execution`.
+
+   **Methods**:
+
+   .. method:: invoke() -> None
+      :async:
+
+      1. Optionally run :attr:`func_tool.preprocessor` on :attr:`arguments`.
+      2. Call the function (``await`` if async).
+      3. Optionally run :attr:`func_tool.postprocessor` on the result.
+      4. Set the execution status to COMPLETED or FAILED, plus store
+         the output or error message.
+
+   **Usage Example**::
+
+      from lionagi.action.function_calling import FunctionCalling
+      from lionagi.action.tool import Tool
+
+      def greet(name: str) -> str:
+          return f"Hello, {name}!"
+
+      tool = Tool(greet)
+      call_event = FunctionCalling(func_tool=tool, arguments={"name": "Alice"})
+
+      # In an async context:
+      await call_event.invoke()
+      print(call_event.execution.response)  # "Hello, Alice!"
+      print(call_event.status)              # COMPLETED
+
+
+ActionRequestModel
+~~~~~~~~~~~~~~~~~
+.. class:: ActionRequestModel
+   :noindex:
+
+   Pydantic model that describes a requested function call. Typically used
+   to parse inbound data that specifies which function to call and what
+   arguments to provide.
+
+   **Fields**:
+
+   .. py:attribute:: function
+      :type: str | None
+
+      The name of the function/tool to invoke. If None, no function is selected.
+
+   .. py:attribute:: arguments
+      :type: dict[str, Any] | None
+
+      The dictionary of arguments for the function call.
+
+   **Class Methods**:
+
+   .. method:: create(content: str) -> list[ActionRequestModel]
+
+      Attempts to parse a JSON string (or similar) into one or more
+      :class:`ActionRequestModel` objects. Returns an empty list on failure.
+
+
+ActionResponseModel
+~~~~~~~~~~~~~~~~~~
+.. class:: ActionResponseModel
+   :noindex:
+
+   Pydantic model describing the **result** of a function call. Includes:
+
+   - :attr:`function`: The function name.
+   - :attr:`arguments`: The passed arguments.
+   - :attr:`output`: The function's return value, if any.
+
+
+ActionManager
+~~~~~~~~~~~~~
+.. class:: ActionManager
+   :noindex:
+
+   The **central registry** for function tools. You can register Python callables
+   (or pre-wrapped :class:`Tool` objects) and invoke them by name with the correct
+   arguments.
+
+   **Core Usage**:
+
+   1) Instantiate :class:`ActionManager`.
+
+   2) Use :meth:`register_tool` or :meth:`register_tools` to add functions.
+
+   3) Call :meth:`invoke` with a dictionary or :class:`ActionRequestModel` specifying
+   ``{"function": "...", "arguments": {...}}``.
+
+   Under the hood, :meth:`invoke` creates a :class:`FunctionCalling` event and
+   runs :meth:`FunctionCalling.invoke`. The final or error outcome is contained
+   in the event's execution.
+
+   **Key Methods**:
+
+   .. method:: __init__(*args, **kwargs)
+
+      Collect any tools provided via args/kwargs and register them.
+
+   .. method:: register_tool(tool: FuncTool, update: bool = False) -> None
+
+      Register a single function or :class:`Tool`. If the function name is already
+      taken and ``update=False``, raises ``ValueError``.
+
+   .. method:: register_tools(tools: list[FuncTool] | FuncTool, update: bool = False) -> None
+
+      Register multiple functions or tools at once.
+
+   .. method:: invoke(func_call: ActionRequestModel | dict) -> FunctionCalling | None
+      :async:
+
+      Matches the function name, builds a :class:`FunctionCalling`, invokes it,
+      and returns the event (or logs an error). The event’s :attr:`execution` tracks
+      success/failure.
+
+      **Example**::
+
+         from lionagi.action.manager import ActionManager
+
+         manager = ActionManager()
+
+         def multiply(a: int, b: int) -> int:
+             return a * b
+
+         manager.register_tool(multiply)
+         req = {"function": "multiply", "arguments": {"a": 3, "b": 5}}
+
+         result = await manager.invoke(req)
+         print(result.execution.response)  # 15
+
+
+----------------------------
+Integration with Event System
+----------------------------
+Because **FunctionCalling** can inherit from :class:`~lionagi.protocols.types.Event`, it
+may be queued or stored in LionAGI's concurrency structures. For instance, you could:
+
+1. Create a :class:`FunctionCalling` event for each function call you need.
+2. Add these events to a :class:`~lionagi.protocols.generic.processor.Executor`, which
+   uses a :class:`~lionagi.protocols.generic.processor.Processor` to manage concurrency.
+3. The events might be stored in a :class:`~lionagi.protocols.generic.pile.Pile` and
+   ordered by a :class:`~lionagi.protocols.generic.progression.Progression`.
+4. As the Processor runs, it calls :meth:`FunctionCalling.invoke()` for each event,
+   gathering results or errors in the :attr:`execution` field.
+
+This unifies local function calls under LionAGI’s broader **event-driven** design,
+ensuring consistent logging, status tracking, and integration with other event types
+(like advanced scheduling).
+
+-----------------
+Additional Examples
+-----------------
+
+**Strict Validation**:
+
+If ``strict_func_call=True`` on a :class:`Tool`, the arguments **must** match the
+function's signature exactly. Any extra or missing parameters raise a
+``ValueError``:
+
+.. code-block:: python
+
+   from lionagi.action.tool import Tool
+
+   def greet(person: str, punctuation: str = "!") -> str:
+       return f"Hello, {person}{punctuation}"
+
+   greet_tool = Tool(
+       func_callable=greet,
+       strict_func_call=True
+   )
+
+   # This fails if 'punctuation' is missing but required, or if you add any unknown keys.
+
+**Pre/Post Processing**:
+
+You can attach a preprocessor and postprocessor to the :class:`Tool`:
+
+.. code-block:: python
+
+   def pre_check(args, **kwargs):
+       if args.get("x", 0) < 0:
+           raise ValueError("x must be >= 0")
+       return args
+
+   def format_result(result, **kwargs):
+       return f"Computed: {result}"
+
+   from lionagi.action.tool import Tool
+
+   def add(x: int, y: int) -> int:
+       return x + y
+
+   add_tool = Tool(
+       func_callable=add,
+       preprocessor=pre_check,
+       postprocessor=format_result
+   )
+
+   # The final result in FunctionCalling.execution.response will be "Computed: <int>"