lionagi 0.13.1__py3-none-any.whl → 0.13.2__py3-none-any.whl

lionagi/libs/schema/as_readable.py

@@ -3,10 +3,90 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import json
+import sys
 from typing import Any
 
 from lionagi.utils import to_dict
 
+# Try to import rich for enhanced console output
+try:
+    from rich.align import Align
+    from rich.box import ROUNDED
+    from rich.console import Console
+    from rich.padding import Padding
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    from rich.theme import Theme
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+# Custom themes for dark and light modes
+DARK_THEME = Theme(
+    {
+        "info": "bright_cyan",
+        "warning": "bright_yellow",
+        "error": "bold bright_red",
+        "success": "bold bright_green",
+        "panel.border": "bright_blue",
+        "panel.title": "bold bright_cyan",
+        "markdown.h1": "bold bright_magenta",
+        "markdown.h2": "bold bright_blue",
+        "markdown.h3": "bold bright_cyan",
+        "markdown.h4": "bold bright_green",
+        "markdown.code": "bright_yellow on grey23",
+        "markdown.code_block": "bright_white on grey15",
+        "markdown.paragraph": "bright_white",
+        "markdown.text": "bright_white",
+        "markdown.emph": "italic bright_yellow",
+        "markdown.strong": "bold bright_white",
+        "markdown.item": "bright_cyan",
+        "markdown.item.bullet": "bright_blue",
+        "json.key": "bright_cyan",
+        "json.string": "bright_green",
+        "json.number": "bright_yellow",
+        "json.boolean": "bright_magenta",
+        "json.null": "bright_red",
+        "yaml.key": "bright_cyan",
+        "yaml.string": "bright_green",
+        "yaml.number": "bright_yellow",
+        "yaml.boolean": "bright_magenta",
+    }
+)
+
+LIGHT_THEME = Theme(
+    {
+        "info": "blue",
+        "warning": "dark_orange",
+        "error": "bold red",
+        "success": "bold green4",
+        "panel.border": "blue",
+        "panel.title": "bold blue",
+        "markdown.h1": "bold dark_magenta",
+        "markdown.h2": "bold dark_blue",
+        "markdown.h3": "bold dark_cyan",
+        "markdown.h4": "bold dark_green",
+        "markdown.code": "dark_orange on grey93",
+        "markdown.code_block": "black on grey82",
+        "markdown.paragraph": "black",
+        "markdown.text": "black",
+        "markdown.emph": "italic dark_orange",
+        "markdown.strong": "bold black",
+        "markdown.item": "dark_blue",
+        "markdown.item.bullet": "blue",
+        "json.key": "dark_blue",
+        "json.string": "dark_green",
+        "json.number": "dark_orange",
+        "json.boolean": "dark_magenta",
+        "json.null": "dark_red",
+        "yaml.key": "dark_blue",
+        "yaml.string": "dark_green",
+        "yaml.number": "dark_orange",
+        "yaml.boolean": "dark_magenta",
+    }
+)
+
 
 def in_notebook() -> bool:
     """
@@ -22,6 +102,18 @@ def in_notebook() -> bool:
         return False
 
 
+def in_console() -> bool:
+    """
+    Checks if we're running in a console/terminal environment.
+    Returns True if stdout is a TTY and not in a notebook.
+    """
+    return (
+        hasattr(sys.stdout, "isatty")
+        and sys.stdout.isatty()
+        and not in_notebook()
+    )
+
+
 def format_dict(data: Any, indent: int = 0) -> str:
     """
     Recursively format Python data (dicts, lists, strings, etc.) into a
@@ -77,6 +169,9 @@ def as_readable(
     format_curly: bool = False,
     display_str: bool = False,
     max_chars: int | None = None,
+    use_rich: bool = True,
+    theme: str = "dark",
+    max_panel_width: int = 140,
 ) -> str:
     """
     Convert `input_` into a human-readable string. If `format_curly=True`, uses
@@ -84,14 +179,21 @@ def as_readable(
 
     - For Pydantic models or nested data, uses `to_dict` to get a dictionary.
     - If the result is a list of items, each is processed and concatenated.
+    - When in console and rich is available, provides syntax highlighting.
 
     Args:
         input_: The data to convert (could be a single item or list).
         md: If True, wraps the final output in code fences for Markdown display.
         format_curly: If True, use `format_dict`. Otherwise, produce JSON text.
+        display_str: If True, prints the output instead of returning it.
+        max_chars: If set, truncates output to this many characters.
+        use_rich: If True and rich is available, uses rich for console output.
+        theme: Color theme - "dark" (default) or "light". Dark uses GitHub Dark Dimmed,
+               light uses Solarized Light inspired colors.
+        max_panel_width: Maximum width for panels and code blocks in characters.
 
     Returns:
-        A formatted string representation of `input_`.
+        A formatted string representation of `input_` (unless display_str=True).
     """
 
     # 1) Convert the input to a Python dict/list structure
@@ -108,6 +210,7 @@ def as_readable(
         return to_dict(obj, **to_dict_kwargs)
 
     def _inner(i_: Any) -> Any:
+        items = []
         try:
             if isinstance(i_, list):
                 # Already a list. Convert each item
@@ -167,8 +270,127 @@ def as_readable(
             from IPython.display import Markdown, display
 
             display(Markdown(str_))
+        elif RICH_AVAILABLE and in_console() and use_rich:
+            # Use rich for enhanced console output
+            # Select theme and syntax highlighting based on user preference
+            console_theme = DARK_THEME if theme == "dark" else LIGHT_THEME
+            syntax_theme = (
+                "github-dark" if theme == "dark" else "solarized-light"
+            )
+            panel_style = "bright_blue" if theme == "dark" else "blue"
+
+            console = Console(theme=console_theme)
+
+            # Check if content looks like markdown prose (not code)
+            is_markdown_prose = isinstance(str_, str) and (
+                str_.startswith("#")
+                or str_.startswith("**")
+                or str_.startswith("- ")
+                or str_.startswith("1.")
+                or "<multi_reasoning>" in str_
+                or "\n### " in str_
+                or "\n## " in str_
+                or "\n# " in str_
+                or "│" in str_  # Rich table content
+            )
+
+            if md and is_markdown_prose:
+                # Display as formatted markdown
+                # Create markdown with max width
+                from rich.markdown import Markdown as RichMarkdown
+
+                md_content = RichMarkdown(str_, code_theme=syntax_theme)
+
+                # Calculate appropriate width
+                console_width = console.width
+                panel_width = min(console_width - 4, max_panel_width)
+
+                # Add left margin padding for better alignment
+                panel = Panel(
+                    Padding(md_content, (0, 2)),
+                    border_style=panel_style,
+                    box=ROUNDED,
+                    width=panel_width,
+                    expand=False,
+                )
+
+                # Left align with margin
+                aligned_panel = Align.left(panel, pad=True)
+                console.print(Padding(aligned_panel, (0, 0, 0, 4)))
+
+            elif md:
+                # Extract content from markdown code blocks if present
+                content = str_
+                if content.startswith("```") and content.endswith("```"):
+                    # Remove code fences
+                    lines = content.split("\n")
+                    if len(lines) > 2:
+                        lang = lines[0][3:].strip() or "json"
+                        content = "\n".join(lines[1:-1])
+                    else:
+                        lang = "json"
+                else:
+                    lang = "yaml" if format_curly else "json"
+
+                # Calculate appropriate width
+                console_width = console.width
+                panel_width = min(console_width - 4, max_panel_width)
+
+                # Create syntax highlighted output
+                syntax = Syntax(
+                    content,
+                    lang,
+                    theme=syntax_theme,
+                    line_numbers=True,
+                    background_color="default",
+                    word_wrap=True,
+                )
+
+                # Add left margin padding for better alignment
+                panel = Panel(
+                    syntax,
+                    border_style=panel_style,
+                    box=ROUNDED,
+                    width=panel_width,
+                    expand=False,
+                )
+
+                # Left align with margin
+                aligned_panel = Align.left(panel, pad=True)
+                console.print(Padding(aligned_panel, (0, 0, 0, 4)))
+
+            else:
+                # Plain text output with rich formatting
+                if format_curly:
+                    syntax = Syntax(
+                        str_,
+                        "yaml",
+                        theme=syntax_theme,
+                        background_color="default",
+                        word_wrap=True,
+                    )
+                else:
+                    syntax = Syntax(
+                        str_,
+                        "json",
+                        theme=syntax_theme,
+                        background_color="default",
+                        word_wrap=True,
+                    )
+
+                # For plain syntax, add left margin
+                # Create a constrained width container if console is too wide
+                if console.width > max_panel_width:
+                    content = Align.left(
+                        syntax, width=max_panel_width, pad=False
+                    )
+                    # Add left margin
+                    console.print(Padding(content, (0, 0, 0, 4)))
+                else:
+                    # Just add left margin
+                    console.print(Padding(syntax, (0, 0, 0, 4)))
         else:
-            # Otherwise, just print the string
+            # Fallback to regular print
             print(str_)
     else:
         return str_

lionagi/service/connections/providers/claude_code_.py

@@ -10,11 +10,13 @@ from typing import Any, Literal
 
 from claude_code_sdk import ClaudeCodeOptions
 from claude_code_sdk import query as sdk_query
+from claude_code_sdk import types as cc_types
 from pydantic import BaseModel, Field, field_validator, model_validator
 
+from lionagi.libs.schema.as_readable import as_readable
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.utils import to_dict
+from lionagi.utils import to_dict, to_list
 
 # --------------------------------------------------------------------------- constants
 ClaudePermission = Literal[
@@ -67,6 +69,14 @@ class ClaudeCodeRequest(BaseModel):
     permission_prompt_tool_name: str | None = None
     disallowed_tools: list[str] = Field(default_factory=list)
 
+    # -- internal use --------------------------------------------------------
+    auto_finish: bool = Field(
+        default=True,
+        exclude=True,
+        description="Automatically finish the conversation after the first response",
+    )
+    verbose_output: bool = Field(default=False, exclude=True)
+
     # ------------------------ validators & helpers --------------------------
     @field_validator("permission_mode", mode="before")
     def _norm_perm(cls, v):
@@ -182,27 +192,46 @@ class ClaudeCodeRequest(BaseModel):
         if not messages:
             raise ValueError("messages may not be empty")
 
-        prompt = messages[-1]["content"]
-        if isinstance(prompt, (dict, list)):
-            prompt = json.dumps(prompt)
+        prompt = ""
 
-        if resume and continue_conversation is None:
+        # 1. if resume or continue_conversation, use the last message
+        if resume or continue_conversation:
             continue_conversation = True
-
+            prompt = messages[-1]["content"]
+            if isinstance(prompt, (dict, list)):
+                prompt = json.dumps(prompt)
+
+        # 2. else, use entire messages except system message
+        else:
+            prompts = []
+            continue_conversation = False
+            for message in messages:
+                if message["role"] != "system":
+                    content = message["content"]
+                    prompts.append(
+                        json.dumps(content)
+                        if isinstance(content, (dict, list))
+                        else content
+                    )
+
+            prompt = "\n".join(prompts)
+
+        # 3. assemble the request data
         data: dict[str, Any] = dict(
             prompt=prompt,
             resume=resume,
             continue_conversation=bool(continue_conversation),
         )
 
+        # 4. extract system prompt if available
         if (messages[0]["role"] == "system") and (
             resume or continue_conversation
         ):
             data["system_prompt"] = messages[0]["content"]
-
-        if (a := kwargs.get("append_system_prompt")) is not None:
-            data.setdefault("append_system_prompt", "")
-            data["append_system_prompt"] += str(a)
+        if kwargs.get("append_system_prompt"):
+            data["append_system_prompt"] = str(
+                kwargs.get("append_system_prompt")
+            )
 
         data.update(kwargs)
         return cls.model_validate(data, strict=False)
@@ -238,7 +267,7 @@ class ClaudeCodeEndpoint(Endpoint):
         )
 
     async def stream(self, request: dict | BaseModel, **kwargs):
-        payload = self.create_payload(request, **kwargs)["request"]
+        payload, _ = self.create_payload(request, **kwargs)["request"]
         async for chunk in self._stream_claude_code(payload):
             yield chunk
 
@@ -258,6 +287,7 @@ class ClaudeCodeEndpoint(Endpoint):
             "session_id": None,
             "model": "claude-code",
             "result": "",
+            "tool_uses": [],
             "tool_results": [],
             "is_error": False,
             "num_turns": None,
@@ -269,17 +299,31 @@ class ClaudeCodeEndpoint(Endpoint):
             },
         }
 
-        from claude_code_sdk import types
-
         for response in responses:
-            if isinstance(response, types.SystemMessage):
+            if isinstance(response, cc_types.SystemMessage):
                 results["session_id"] = response.data.get("session_id")
                 results["model"] = response.data.get("model", "claude-code")
-            if isinstance(response, types.AssistantMessage):
-                for block in response.content:
-                    if isinstance(block, types.TextBlock):
+            if isinstance(
+                response, cc_types.AssistantMessage | cc_types.UserMessage
+            ):
+                for block in to_list(
+                    response.content,
+                    flatten=True,
+                    flatten_tuple_set=True,
+                    dropna=True,
+                ):
+                    if isinstance(block, cc_types.TextBlock):
                         results["result"] += block.text.strip() + "\n"
-                    if isinstance(block, types.ToolResultBlock):
+
+                    if isinstance(block, cc_types.ToolUseBlock):
+                        entry = {
+                            "id": block.id,
+                            "name": block.name,
+                            "input": block.input,
+                        }
+                        results["tool_uses"].append(entry)
+
+                    if isinstance(block, cc_types.ToolResultBlock):
                         results["tool_results"].append(
                             {
                                 "tool_use_id": block.tool_use_id,
@@ -287,8 +331,10 @@ class ClaudeCodeEndpoint(Endpoint):
                                 "is_error": block.is_error,
                             }
                         )
-            if isinstance(response, types.ResultMessage):
-                results["result"] += response.result.strip() or ""
+
+            if isinstance(response, cc_types.ResultMessage):
+                if response.result:
+                    results["result"] = str(response.result).strip()
                 results["usage"] = response.usage
                 results["is_error"] = response.is_error
                 results["total_cost_usd"] = response.total_cost_usd
@@ -305,7 +351,135 @@ class ClaudeCodeEndpoint(Endpoint):
         **kwargs,
     ):
         responses = []
+        request: ClaudeCodeRequest = payload["request"]
+        system: cc_types.SystemMessage = None
+
+        # 1. stream the Claude Code response
         async for chunk in self._stream_claude_code(**payload):
+
+            if request.verbose_output:
+                _display_message(chunk)
+
+            if isinstance(chunk, cc_types.SystemMessage):
+                system = chunk
             responses.append(chunk)
 
+        # 2. If the last response is not a ResultMessage and auto_finish is True,
+        #   we need to query Claude Code again to get the final result message.
+        if request.auto_finish and not isinstance(
+            responses[-1], cc_types.ResultMessage
+        ):
+            options = request.as_claude_options()
+            options.continue_conversation = True
+            options.max_turns = 1
+            if system:
+                options.resume = (
+                    system.data.get("session_id", None) if system else None
+                )
+
+            async for chunk in sdk_query(
+                prompt="Please provide a the final result message only",
+                options=options,
+            ):
+                if isinstance(chunk, cc_types.ResultMessage):
+                    if request.verbose_output:
+                        str_ = _verbose_output(chunk)
+                        if str_:
+                            as_readable(
+                                str_,
+                                md=True,
+                                display_str=True,
+                                format_curly=True,
+                                max_panel_width=100,
+                                theme="light",
+                            )
+
+                    responses.append(chunk)
+
+        # 3. Parse the responses into a clean format
         return self._parse_claude_code_response(responses)
+
+
+def _display_message(chunk):
+    if isinstance(
+        chunk,
+        cc_types.SystemMessage
+        | cc_types.AssistantMessage
+        | cc_types.UserMessage,
+    ):
+        str_ = _verbose_output(chunk)
+        if str_:
+            if str_.startswith("Claude:"):
+                as_readable(
+                    str_,
+                    md=True,
+                    display_str=True,
+                    max_panel_width=100,
+                    theme="light",
+                )
+            else:
+                as_readable(
+                    str_,
+                    format_curly=True,
+                    display_str=True,
+                    max_panel_width=100,
+                    theme="light",
+                )
+
+    if isinstance(chunk, cc_types.ResultMessage):
+        str_ = _verbose_output(chunk)
+        as_readable(
+            str_,
+            md=True,
+            display_str=True,
+            format_curly=True,
+            max_panel_width=100,
+            theme="light",
+        )
+
+
+def _verbose_output(res: cc_types.Message) -> str:
+    str_ = ""
+    if isinstance(res, cc_types.SystemMessage):
+        str_ = f"Claude Code Session Started: {res.data.get('session_id', 'unknown')}"
+        str_ += f"\nModel: {res.data.get('model', 'claude-code')}\n---"
+        return str_
+
+    if isinstance(res, cc_types.AssistantMessage | cc_types.UserMessage):
+        for block in to_list(
+            res.content, flatten=True, flatten_tuple_set=True, dropna=True
+        ):
+            if isinstance(block, cc_types.TextBlock):
+                text = (
+                    block.text.strip() if isinstance(block.text, str) else ""
+                )
+                str_ += f"Claude:\n{text}"
+
+            if isinstance(block, cc_types.ToolUseBlock):
+                input = (
+                    json.dumps(block.input, indent=2)
+                    if isinstance(block.input, dict)
+                    else str(block.input)
+                )
+                input = input[:200] + "..." if len(input) > 200 else input
+                str_ += (
+                    f"Tool Use: {block.name} - {block.id}\n  - Input: {input}"
+                )
+
+            if isinstance(block, cc_types.ToolResultBlock):
+                content = str(block.content)
+                content = (
+                    content[:200] + "..." if len(content) > 200 else content
+                )
+                str_ += (
+                    f"Tool Result: {block.tool_use_id}\n  - Content: {content}"
+                )
+        return str_
+
+    if isinstance(res, cc_types.ResultMessage):
+        str_ += f"Session Completion - {res.session_id}"
+        str_ += f"\nResult: {res.result or 'No result'}"
+        str_ += f"\n- Cost: ${res.total_cost_usd:.4f} USD"
+        str_ += f"\n- Duration: {res.duration_ms} ms (API: {res.duration_api_ms} ms)"
+        str_ += f"\n- Turns: {res.num_turns}"
+        return str_

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.13.1"
+__version__ = "0.13.2"

{lionagi-0.13.1.dist-info → lionagi-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.13.1
+Version: 0.13.2
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -235,6 +235,7 @@ Requires-Dist: claude-code-sdk>=0.0.14; extra == 'all'
 Requires-Dist: docling>=2.15.1; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
 Requires-Dist: ollama>=0.5.0; extra == 'all'
+Requires-Dist: rich>=13.0.0; extra == 'all'
 Provides-Extra: claude-code
 Requires-Dist: claude-code-sdk>=0.0.14; extra == 'claude-code'
 Provides-Extra: docs
@@ -251,6 +252,8 @@ Provides-Extra: ollama
 Requires-Dist: ollama>=0.5.0; extra == 'ollama'
 Provides-Extra: reader
 Requires-Dist: docling>=2.15.1; extra == 'reader'
+Provides-Extra: rich
+Requires-Dist: rich>=13.0.0; extra == 'rich'
 Provides-Extra: test
 Requires-Dist: pytest-asyncio>=1.0.0; extra == 'test'
 Requires-Dist: pytest>=8.3.4; extra == 'test'

{lionagi-0.13.1.dist-info → lionagi-0.13.2.dist-info}/RECORD

@@ -6,7 +6,7 @@ lionagi/config.py,sha256=dAhDFKtaaSfn6WT9dwX9Vd4TWWs6-Su1FgYIrFgYcgc,3709
 lionagi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/settings.py,sha256=W52mM34E6jXF3GyqCFzVREKZrmnUqtZm_BVDsUiDI_s,1627
 lionagi/utils.py,sha256=uLTJKl7aTnFXV6ehA6zwiwEB7G2nQYKsO2pZ6mqFzUk,78908
-lionagi/version.py,sha256=Zg3oo58_HXe_ieb_PwWnYkKGH2zTvu6G2jly-7GnPGo,23
+lionagi/version.py,sha256=blu6md2c3Nnj5gDBi8U36sYO3k8HcND8s7UoQBjfn3g,23
 lionagi/fields/__init__.py,sha256=8oU7Vfk-fKiULFKqhM6VpJMqdZcVXPTM7twVfNDN_SQ,603
 lionagi/fields/action.py,sha256=iWSApCM77jS0Oc28lb7G601Etkp-yjx5U1hfI_FQgfA,5792
 lionagi/fields/base.py,sha256=5CJc7j8kTTWzXwpYzkSAFzx4BglABfx3AElIATKB7bg,3857
@@ -41,7 +41,7 @@ lionagi/libs/package/management.py,sha256=zgzZ1lNpUhunu_QExiobSYWlvBbR0EORXW4jrt
 lionagi/libs/package/params.py,sha256=4dJiuaTlnhho6OHmBv-02cHx89XRCjnKqpMhVRvTse8,1056
 lionagi/libs/package/system.py,sha256=UW8Y6tEPRCy_pBv_Q8CXJAIbuo7CJDDoWEDdnP0ixp4,564
 lionagi/libs/schema/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
-lionagi/libs/schema/as_readable.py,sha256=W4fi98WVkP5rfZ6A-iWqP5YFJexYCjt9Hf-l0iNs-2Q,5916
+lionagi/libs/schema/as_readable.py,sha256=Sd-SBxOwHaEPw2fBuY0vpAoYqUvatDYnoPWsJO6S8BE,14160
 lionagi/libs/schema/extract_code_block.py,sha256=PuJbJj1JnqR5fSZudowPcVPpEoKISLr0MjTOOVXSzwY,2394
 lionagi/libs/schema/extract_docstring.py,sha256=aYyLSRlB8lTH9QF9-6a56uph3AAkNuTyZ0S_duf5-fw,5729
 lionagi/libs/schema/function_to_schema.py,sha256=XAB031WbYu3a7eFJyYjXVMAjmtWYSYr5kC_DYgjiuyM,5604
@@ -177,7 +177,7 @@ lionagi/service/connections/header_factory.py,sha256=22sG4ian3MiNklF6SdQqkEYgtWK
 lionagi/service/connections/match_endpoint.py,sha256=mEZPDkK1qtvjTGN9-PZsK7w_yB7642nZiJsb0l5QUx4,1827
 lionagi/service/connections/providers/__init__.py,sha256=3lzOakDoBWmMaNnT2g-YwktPKa_Wme4lnPRSmOQfayY,105
 lionagi/service/connections/providers/anthropic_.py,sha256=SUPnw2UqjY5wuHXLHas6snMTzhQ-UuixvPYbkVnXn34,3083
-lionagi/service/connections/providers/claude_code_.py,sha256=TLoNC_iYsdUGFdevX_0GaNtHKldUokNXOdDQnCcbp8E,11111
+lionagi/service/connections/providers/claude_code_.py,sha256=pqi_CfWdAnDnKt2ktTMn_62TZ0vgXv6ey4wxbGh-jjU,17393
 lionagi/service/connections/providers/exa_.py,sha256=GGWaD9jd5gKM257OfUaIBBKIqR1NrNcBE67p_7JbK7g,938
 lionagi/service/connections/providers/oai_.py,sha256=cUI5En8irtKnEbwApgkyg2cPReS8c4Gxtcv65WnGhas,4776
 lionagi/service/connections/providers/ollama_.py,sha256=jdx6dGeChwVk5TFfFRbpnrpKzj8YQZw6D5iWJ6zYmfk,4096
@@ -203,7 +203,7 @@ lionagi/traits/base.py,sha256=ww1qOTrKz6p0rf52OFSWluUNldhs8_S2O-ers4KEUqQ,7114
 lionagi/traits/composer.py,sha256=7qqISOhN3ZhtL0J6fvU3Ic1vHXS2-SSI6kuwQn2tF3E,12780
 lionagi/traits/protocols.py,sha256=S4-EwTjpQwAZJcBbROn9QtJyXw4srnyMGOfabzqMh34,12210
 lionagi/traits/registry.py,sha256=hsQaDE4INsHTwD2ZvYpmPZ92k0i-grgC6PQXbscF5Qc,38465
-lionagi-0.13.1.dist-info/METADATA,sha256=u2Q5qp1TIJ0K5muCksoFrX4I35Aqeno2UhYSbPSUP9Y,20347
-lionagi-0.13.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.13.1.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.13.1.dist-info/RECORD,,
+lionagi-0.13.2.dist-info/METADATA,sha256=OSa_9xutEW5Eb8UhrMmMoV247VDjVtJHX2ay0QJI4VA,20457
+lionagi-0.13.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.13.2.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.13.2.dist-info/RECORD,,