lionagi 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

lionagi/libs/token_transform/synthlang_/resources/frameworks/framework_options.json

@@ -1,52 +1,52 @@
 {
-  "options": {
-    "math": {
-      "name": "Mathematical Framework",
-      "description": "Offers a suite of math glyphs and notation rules.",
-      "glyphs": [
-        {
-          "symbol": "\u21b9",
-          "name": "Focus/Filter",
-          "description": "Used for focusing instructions"
+    "options": {
+        "math": {
+            "name": "Mathematical Framework",
+            "description": "Offers a suite of math glyphs and notation rules.",
+            "glyphs": [
+                {
+                    "symbol": "\u21b9",
+                    "name": "Focus/Filter",
+                    "description": "Used for focusing instructions"
+                },
+                {
+                    "symbol": "\u03a3",
+                    "name": "Summarize",
+                    "description": "Condense large sets of data"
+                },
+                {
+                    "symbol": "\u2295",
+                    "name": "Combine/Merge",
+                    "description": "Merge multiple data sources"
+                },
+                {
+                    "symbol": "\u2022",
+                    "name": "Group Operation",
+                    "description": "Binary operation in group theory"
+                }
+            ]
         },
-        {
-          "symbol": "\u03a3",
-          "name": "Summarize",
-          "description": "Condense large sets of data"
+        "optim": {
+            "name": "Optimization Framework",
+            "description": "Compression and optimization for code/math expressions.",
+            "glyphs": [
+                {
+                    "symbol": "IF",
+                    "name": "Conditional Operator",
+                    "description": "Represents branching logic"
+                }
+            ]
         },
-        {
-          "symbol": "\u2295",
-          "name": "Combine/Merge",
-          "description": "Merge multiple data sources"
-        },
-        {
-          "symbol": "\u2022",
-          "name": "Group Operation",
-          "description": "Binary operation in group theory"
-        }
-      ]
-    },
-    "optim": {
-      "name": "Optimization Framework",
-      "description": "Compression and optimization for code/math expressions.",
-      "glyphs": [
-        {
-          "symbol": "IF",
-          "name": "Conditional Operator",
-          "description": "Represents branching logic"
-        }
-      ]
-    },
-    "custom_algebra": {
-      "name": "Custom Algebraic Framework",
-      "description": "Extra rules for ring, group, field expansions.",
-      "glyphs": [
-        {
-          "symbol": "\u221e",
-          "name": "Infinite Operator",
-          "description": "Represents unbounded algebraic ops"
+        "custom_algebra": {
+            "name": "Custom Algebraic Framework",
+            "description": "Extra rules for ring, group, field expansions.",
+            "glyphs": [
+                {
+                    "symbol": "\u221e",
+                    "name": "Infinite Operator",
+                    "description": "Represents unbounded algebraic ops"
+                }
+            ]
         }
-      ]
     }
-  }
 }

lionagi/libs/token_transform/synthlang_/translate_to_synthlang.py

@@ -93,7 +93,7 @@ async def translate_to_synthlang(
     else:
         branch = Branch(system=final_prompt, chat_model=chat_model)
 
-    from lionagi.service.endpoints.token_calculator import TokenCalculator
+    from lionagi.service.token_calculator import TokenCalculator
 
     calculator = TokenCalculator()
 

lionagi/operations/chat/chat.py

@@ -122,8 +122,8 @@ async def chat(
                     _msgs.append(i)
         messages = _msgs
 
-    imodel = imodel or branch.chat_model
-    if branch.msgs.system and imodel.sequential_exchange:
+    # All endpoints now assume sequential exchange (system message embedded in first user message)
+    if branch.msgs.system:
         messages = [msg for msg in messages if msg.role != "system"]
         first_instruction = None
 

lionagi/operations/communicate/communicate.py

@@ -91,12 +91,27 @@ async def communicate(
         return res.response
 
     if response_format is not None:
-        return await branch.parse(
-            text=res.response,
-            request_type=response_format,
-            max_retries=num_parse_retries,
+        # Default to raising errors unless explicitly set in fuzzy_match_kwargs
+        parse_kwargs = {
+            "handle_validation": "raise",  # Default to raising errors
             **(fuzzy_match_kwargs or {}),
-        )
+        }
+
+        try:
+            return await branch.parse(
+                text=res.response,
+                request_type=response_format,
+                max_retries=num_parse_retries,
+                **parse_kwargs,
+            )
+        except ValueError as e:
+            # Re-raise with more context
+            logging.error(
+                f"Failed to parse response '{res.response}' into {response_format}: {e}"
+            )
+            raise ValueError(
+                f"Failed to parse model response into {response_format.__name__}: {e}"
+            ) from e
 
     if request_fields is not None:
         _d = fuzzy_validate_mapping(

lionagi/operations/parse/parse.py

@@ -35,35 +35,117 @@ async def parse(
     suppress_conversion_errors: bool = False,
     response_format=None,
 ):
-    _should_try = True
-    num_try = 0
-    response_model = text
     if operative is not None:
         max_retries = operative.max_retries
-        response_format = operative.request_type
+        response_format = operative.request_type or response_format
+        request_type = request_type or operative.request_type
 
-    while (
-        _should_try
-        and num_try < max_retries
-        and not isinstance(response_model, BaseModel)
-    ):
-        num_try += 1
-        if num_try == max_retries:
-            _should_try = False
-        _, res = await branch.chat(
-            instruction="reformat text into specified model",
-            guidane="follow the required response format, using the model schema as a guide",
-            context=[{"text_to_format": text}],
-            response_format=response_format or request_type,
-            sender=branch.user,
-            recipient=branch.id,
-            imodel=branch.parse_model,
-            return_ins_res_message=True,
+    if not request_type and not response_format:
+        raise ValueError(
+            "Either request_type or response_format must be provided"
+        )
+
+    request_type = request_type or response_format
+
+    # First attempt: try to parse the text directly
+    import logging
+
+    initial_error = None
+    parsed_data = None  # Initialize to avoid scoping issues
+
+    try:
+        # Try fuzzy validation first
+        parsed_data = fuzzy_validate_mapping(
+            text,
+            breakdown_pydantic_annotation(request_type),
+            similarity_algo=similarity_algo,
+            similarity_threshold=similarity_threshold,
+            fuzzy_match=fuzzy_match,
+            handle_unmatched=handle_unmatched,
+            fill_value=fill_value,
+            fill_mapping=fill_mapping,
+            strict=strict,
+            suppress_conversion_errors=False,  # Don't suppress on first attempt
         )
+
+        logging.debug(f"Parsed data from fuzzy validation: {parsed_data}")
+
+        # Validate with pydantic
         if operative is not None:
-            response_model = operative.update_response_model(res.response)
+            response_model = operative.update_response_model(parsed_data)
         else:
-            response_model = fuzzy_validate_mapping(
+            response_model = request_type.model_validate(parsed_data)
+
+        # If successful, return immediately
+        if isinstance(response_model, BaseModel):
+            return response_model
+
+    except Exception as e:
+        initial_error = e
+        # Log the initial parsing error for debugging
+        logging.debug(
+            f"Initial parsing failed for text '{text[:100]}...': {e}"
+        )
+        logging.debug(
+            f"Parsed data was: {locals().get('parsed_data', 'not set')}"
+        )
+
+        # Only continue if we have retries left
+        if max_retries <= 0:
+            if handle_validation == "raise":
+                raise ValueError(f"Failed to parse response: {e}") from e
+            elif handle_validation == "return_none":
+                return None
+            else:  # return_value
+                return text
+
+    # If direct parsing failed, try using the parse model
+    num_try = 0
+    last_error = initial_error
+
+    # Check if the parsed_data exists but just failed validation
+    # This might mean we have the right structure but wrong values
+    if parsed_data is not None and isinstance(parsed_data, dict):
+        logging.debug(
+            f"Have parsed_data dict, checking if it's close to valid..."
+        )
+        # If we got a dict with the right keys, maybe we just need to clean it up
+        expected_fields = set(request_type.model_fields.keys())
+        parsed_fields = set(parsed_data.keys())
+        if expected_fields == parsed_fields and all(
+            parsed_data.get(k) is not None for k in expected_fields
+        ):
+            # We have the right structure with non-None values, don't retry with parse model
+            logging.debug(
+                "Structure matches with valid values, returning original error"
+            )
+            if handle_validation == "raise":
+                raise ValueError(
+                    f"Failed to parse response: {initial_error}"
+                ) from initial_error
+            elif handle_validation == "return_none":
+                return None
+            else:
+                return text
+
+    while num_try < max_retries:
+        num_try += 1
+
+        try:
+            logging.debug(f"Retry {num_try}: Using parse model to reformat")
+            _, res = await branch.chat(
+                instruction="reformat text into specified model",
+                guidance="follow the required response format, using the model schema as a guide",
+                context=[{"text_to_format": text}],
+                response_format=request_type,
+                sender=branch.user,
+                recipient=branch.id,
+                imodel=branch.parse_model,
+                return_ins_res_message=True,
+            )
+
+            # Try to parse the reformatted response
+            parsed_data = fuzzy_validate_mapping(
                 res.response,
                 breakdown_pydantic_annotation(request_type),
                 similarity_algo=similarity_algo,
@@ -75,25 +157,31 @@ async def parse(
                 strict=strict,
                 suppress_conversion_errors=suppress_conversion_errors,
             )
-            try:
-                response_model = request_type.model_validate(response_model)
-            except InterruptedError as e:
-                raise e
-            except Exception:
-                if _should_try:
-                    continue
-                else:
-                    break
-
-    if not isinstance(response_model, BaseModel):
-        match handle_validation:
-            case "return_value":
+
+            if operative is not None:
+                response_model = operative.update_response_model(parsed_data)
+            else:
+                response_model = request_type.model_validate(parsed_data)
+
+            # If successful, return
+            if isinstance(response_model, BaseModel):
                 return response_model
-            case "return_none":
-                return None
-            case "raise":
-                raise ValueError(
-                    "Failed to parse response into request format"
-                )
 
-    return response_model
+        except InterruptedError as e:
+            raise e
+        except Exception as e:
+            last_error = e
+            # Continue to next retry
+            continue
+
+    # All retries exhausted
+    match handle_validation:
+        case "return_value":
+            return text
+        case "return_none":
+            return None
+        case "raise":
+            error_msg = "Failed to parse response into request format"
+            if last_error:
+                error_msg += f": {last_error}"
+            raise ValueError(error_msg) from last_error

lionagi/protocols/generic/log.py

@@ -11,8 +11,7 @@ from typing import Any
 
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 
-from lionagi.libs.file.create_path import create_path
-from lionagi.utils import to_dict
+from lionagi.utils import create_path, to_dict
 
 from .._concepts import Manager
 from .element import Element

lionagi/protocols/generic/pile.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, ClassVar, Generic, TypeVar
 
 import pandas as pd
-from pydantic import Field, field_serializer
+from pydantic import Field
 from pydantic.fields import FieldInfo
 from typing_extensions import Self, override
 
@@ -910,9 +910,23 @@ class Pile(Element, Collective[E], Generic[E]):
         self.progression.insert(index, item_order)
         self.collections.update(item_dict)
 
-    @field_serializer("collections")
-    def _(self, value: dict[str, T]):
-        return [i.to_dict() for i in value.values()]
+    def to_dict(self) -> dict[str, Any]:
+        """Convert pile to dictionary, properly handling collections."""
+        # Get base dict from parent class
+        dict_ = super().to_dict()
+
+        # Manually serialize collections
+        collections_list = []
+        for item in self.collections.values():
+            if hasattr(item, "to_dict"):
+                collections_list.append(item.to_dict())
+            elif hasattr(item, "model_dump"):
+                collections_list.append(item.model_dump())
+            else:
+                collections_list.append(str(item))
+
+        dict_["collections"] = collections_list
+        return dict_
 
     class AsyncPileIterator:
         def __init__(self, pile: Pile):

lionagi/protocols/messages/assistant_response.py

@@ -46,7 +46,7 @@ def prepare_assistant_response(
                     elif isinstance(j, str):
                         text_contents.append(j)
 
-            # openai standard
+            # openai chat completions standard
             elif "choices" in i:
                 choices = i["choices"]
                 choices = (
@@ -58,6 +58,25 @@ def prepare_assistant_response(
                     elif "delta" in j:
                         text_contents.append(j["delta"]["content"] or "")
 
+            # openai responses API standard
+            elif "output" in i:
+                output = i["output"]
+                output = [output] if not isinstance(output, list) else output
+                for item in output:
+                    if isinstance(item, dict):
+                        if item.get("type") == "message":
+                            # Extract content from message
+                            content = item.get("content", [])
+                            if isinstance(content, list):
+                                for c in content:
+                                    if (
+                                        isinstance(c, dict)
+                                        and c.get("type") == "output_text"
+                                    ):
+                                        text_contents.append(c.get("text", ""))
+                                    elif isinstance(c, str):
+                                        text_contents.append(c)
+
         elif isinstance(i, str):
             text_contents.append(i)
 

lionagi/protocols/messages/templates/README.md

@@ -19,14 +19,10 @@ message_text = template.render(**args)
 print(message_text)
 ```
 
-Benefits and Customization •	You can easily rearrange sections within these
-templates without changing your code logic. •	Each message type is clearly
-separated, making it simpler to maintain or adjust one message format without
-affecting the others. •	If you find that you use some snippet (like rendering a
-schema) in multiple templates, you can factor it out into its own partial
-template (like tool_schemas.jinja2) and include it where needed. •	Over time,
-you can add more templates or split existing ones if certain messages become too
-complex.
+Benefits and Customization
+	•	You can easily rearrange sections within these templates without changing your code logic.
+	•	Each message type is clearly separated, making it simpler to maintain or adjust one message format without affecting the others.
+	•	If you find that you use some snippet (like rendering a schema) in multiple templates, you can factor it out into its own partial template (like tool_schemas.jinja2) and include it where needed.
+	•	Over time, you can add more templates or split existing ones if certain messages become too complex.
 
-By establishing this set of base templates and arguments, you have a starting
-point. You can expand or refine as your requirements evolve.
+By establishing this set of base templates and arguments, you have a starting point. You can expand or refine as your requirements evolve.

lionagi/service/connections/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .endpoint import Endpoint
+from .endpoint_config import EndpointConfig
+from .header_factory import HeaderFactory
+from .match_endpoint import match_endpoint
+
+__all__ = (
+    "Endpoint",
+    "EndpointConfig",
+    "HeaderFactory",
+    "match_endpoint",
+)