lionagi 0.12.6__py3-none-any.whl → 0.12.7__py3-none-any.whl

lionagi/service/connections/api_calling.py

@@ -4,9 +4,8 @@
 
 import asyncio
 import logging
-from typing import Any
 
-from pydantic import BaseModel, Field, model_validator
+from pydantic import Field, model_validator
 from typing_extensions import Self
 
 from lionagi.protocols.generic.event import Event, EventStatus
@@ -164,10 +163,11 @@ class APICalling(Event):
         try:
             self.execution.status = EventStatus.PROCESSING
 
-            # Make the API call
+            # Make the API call with skip_payload_creation=True since payload is already prepared
             response = await self.endpoint.call(
                 request=self.payload,
                 cache_control=self.cache_control,
+                skip_payload_creation=True,
                 extra_headers=self.headers if self.headers else None,
             )
 

lionagi/service/connections/endpoint.py

@@ -47,9 +47,7 @@ class Endpoint:
         if isinstance(config, dict):
             _config = EndpointConfig(**config, **kwargs)
         elif isinstance(config, EndpointConfig):
-            _config = config.model_copy(
-                deep=True
-            )  # Use deep copy to avoid sharing kwargs dict
+            _config = config.model_copy(deep=True)
             _config.update(**kwargs)
         else:
             raise ValueError(
@@ -72,8 +70,6 @@ class Endpoint:
             **self.config.client_kwargs,
         )
 
-    # Removed old context manager methods - endpoint is now stateless
-
     @property
     def request_options(self):
         return self.config.request_options
@@ -159,8 +155,17 @@ class Endpoint:
 
         return (payload, headers)
 
+    async def _call(self, payload: dict, headers: dict, **kwargs):
+        return await self._call_aiohttp(
+            payload=payload, headers=headers, **kwargs
+        )
+
     async def call(
-        self, request: dict | BaseModel, cache_control: bool = False, **kwargs
+        self,
+        request: dict | BaseModel,
+        cache_control: bool = False,
+        skip_payload_creation: bool = False,
+        **kwargs,
     ):
         """
         Make a call to the endpoint.
@@ -168,6 +173,7 @@ class Endpoint:
         Args:
             request: The request parameters or model.
             cache_control: Whether to use cache control.
+            skip_payload_creation: Whether to skip create_payload and treat request as ready payload.
             **kwargs: Additional keyword arguments for the request.
 
         Returns:
@@ -175,25 +181,28 @@ class Endpoint:
         """
         # Extract extra_headers before passing to create_payload
         extra_headers = kwargs.pop("extra_headers", None)
-        payload, headers = self.create_payload(
-            request, extra_headers=extra_headers, **kwargs
-        )
 
-        async def _call(payload: dict, headers: dict, **kwargs):
-            # Direct call without context manager - each method handles its own resources
-            return await self._call_aiohttp(
-                payload=payload, headers=headers, **kwargs
+        payload, headers = None, None
+        if skip_payload_creation:
+            # Treat request as the ready payload
+            payload = (
+                request if isinstance(request, dict) else request.model_dump()
+            )
+            headers = extra_headers or {}
+        else:
+            payload, headers = self.create_payload(
+                request, extra_headers=extra_headers, **kwargs
             )
 
         # Apply resilience patterns if configured
-        call_func = _call
+        call_func = self._call
 
         # Apply retry if configured
         if self.retry_config:
 
             async def call_func(p, h, **kw):
                 return await retry_with_backoff(
-                    _call, p, h, **kw, **self.retry_config.as_kwargs()
+                    self._call, p, h, **kw, **self.retry_config.as_kwargs()
                 )
 
         # Apply circuit breaker if configured
@@ -208,7 +217,7 @@ class Endpoint:
                 # If only circuit breaker is configured, apply it directly
                 if not cache_control:
                     return await self.circuit_breaker.execute(
-                        _call, payload, headers, **kwargs
+                        self._call, payload, headers, **kwargs
                     )
 
         # Handle caching if requested
@@ -223,12 +232,12 @@ class Endpoint:
                     )
                 if self.circuit_breaker:
                     return await self.circuit_breaker.execute(
-                        _call, payload, headers, **kwargs
+                        self._call, payload, headers, **kwargs
                     )
                 if self.retry_config:
                     return await call_func(payload, headers, **kwargs)
 
-                return await _call(payload, headers, **kwargs)
+                return await self._call(payload, headers, **kwargs)
 
             return await _cached_call(payload, headers, **kwargs)
 
@@ -236,7 +245,7 @@ class Endpoint:
         if self.retry_config:
             return await call_func(payload, headers, **kwargs)
 
-        return await _call(payload, headers, **kwargs)
+        return await self._call(payload, headers, **kwargs)
 
     async def _call_aiohttp(self, payload: dict, headers: dict, **kwargs):
         """

lionagi/service/connections/match_endpoint.py

@@ -45,5 +45,13 @@ def match_endpoint(
         from .providers.perplexity_ import PerplexityChatEndpoint
 
         return PerplexityChatEndpoint(**kwargs)
+    if provider == "claude_code" and (
+        "query" in endpoint or "code" in endpoint
+    ):
+        from lionagi.service.connections.providers.claude_code_ import (
+            ClaudeCodeEndpoint,
+        )
+
+        return ClaudeCodeEndpoint(**kwargs)
 
     return None

lionagi/service/connections/providers/claude_code_.py

@@ -0,0 +1,250 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from pathlib import Path
+from typing import Any
+
+from claude_code_sdk import ClaudeCodeOptions, PermissionMode
+from pydantic import BaseModel, Field
+
+from lionagi.service.connections.endpoint import Endpoint
+from lionagi.service.connections.endpoint_config import EndpointConfig
+from lionagi.utils import to_dict
+
+
+class ClaudeCodeRequest(BaseModel):
+    prompt: str = Field(description="The prompt for Claude Code")
+    allowed_tools: list[str] = Field(
+        default_factory=list, description="List of allowed tools"
+    )
+    max_thinking_tokens: int = 8000
+    mcp_tools: list[str] = list
+    mcp_servers: dict[str, Any] = Field(default_factory=dict)
+    permission_mode: PermissionMode | None = None
+    continue_conversation: bool = False
+    resume: str | None = None
+    max_turns: int | None = None
+    disallowed_tools: list[str] = Field(default_factory=list)
+    model: str | None = None
+    permission_prompt_tool_name: str | None = None
+    cwd: str | Path | None = None
+    system_prompt: str | None = None
+    append_system_prompt: str | None = None
+
+    def as_claude_options(self) -> ClaudeCodeOptions:
+        dict_ = self.model_dump(exclude_unset=True)
+        dict_.pop("prompt")
+        return ClaudeCodeOptions(**dict_)
+
+    @classmethod
+    def create(
+        cls,
+        messages: list[dict],
+        resume: str | None = None,
+        continue_conversation: bool = None,
+        **kwargs,
+    ):
+        prompt = messages[-1]["content"]
+        if isinstance(prompt, dict | list):
+            prompt = json.dumps(prompt)
+
+        # If resume is provided, set continue_conversation to True
+        if resume is not None and continue_conversation is None:
+            continue_conversation = True
+
+        dict_ = dict(
+            prompt=prompt,
+            continue_conversation=continue_conversation,
+            resume=resume,
+        )
+
+        if resume is not None or continue_conversation is not None:
+            if messages[0]["role"] == "system":
+                dict_["system_prompt"] = messages[0]["content"]
+
+        if (a := kwargs.get("system_prompt")) is not None:
+            dict_["append_system_prompt"] = a
+
+        if (a := kwargs.get("append_system_prompt")) is not None:
+            dict_.setdefault("append_system_prompt", "")
+            dict_["append_system_prompt"] += str(a)
+
+        dict_ = {**dict_, **kwargs}
+        dict_ = {k: v for k, v in dict_.items() if v is not None}
+        return cls(**dict_)
+
+
+ENDPOINT_CONFIG = EndpointConfig(
+    name="claude_code",
+    provider="anthropic",
+    base_url="internal",
+    endpoint="query",
+    api_key="dummy",
+    request_options=ClaudeCodeRequest,
+)
+
+
+class ClaudeCodeEndpoint(Endpoint):
+
+    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config=config, **kwargs)
+
+    def create_payload(
+        self,
+        request: dict | BaseModel,
+        **kwargs,
+    ):
+        request_dict = to_dict(request)
+        # Merge stored kwargs from config, then request, then additional kwargs
+        request_dict = {**self.config.kwargs, **request_dict, **kwargs}
+        messages = request_dict.pop("messages", None)
+
+        resume = request_dict.pop("resume", None)
+        continue_conversation = request_dict.pop("continue_conversation", None)
+
+        request_obj = ClaudeCodeRequest.create(
+            messages=messages,
+            resume=resume,
+            continue_conversation=continue_conversation,
+            **{
+                k: v
+                for k, v in request_dict.items()
+                if v is not None and k in ClaudeCodeRequest.model_fields
+            },
+        )
+        request_options = request_obj.as_claude_options()
+        payload = {
+            "prompt": request_obj.prompt,
+            "options": request_options,
+        }
+        return (payload, {})
+
+    def _stream_claude_code(self, prompt: str, options: ClaudeCodeOptions):
+        from claude_code_sdk import query
+
+        return query(prompt=prompt, options=options)
+
+    async def stream(
+        self,
+        request: dict | BaseModel,
+        **kwargs,
+    ):
+        async for chunk in self._stream_claude_code(**request, **kwargs):
+            yield chunk
+
+    def _parse_claude_code_response(self, responses: list) -> dict:
+        """Parse Claude Code responses into a clean chat completions-like format.
+
+        Claude Code returns a list of messages:
+        - SystemMessage: initialization info
+        - AssistantMessage(s): actual assistant responses with content blocks
+        - UserMessage(s): for tool use interactions
+        - ResultMessage: final result with metadata
+
+        When Claude Code uses tools, the ResultMessage.result may be None.
+        In that case, we need to look at the tool results in UserMessages.
+        """
+        result_message = None
+        model = "claude-code"
+        assistant_text_content = []
+        tool_results = []
+
+        # Process all messages
+        for response in responses:
+            class_name = response.__class__.__name__
+
+            if class_name == "SystemMessage" and hasattr(response, "data"):
+                model = response.data.get("model", "claude-code")
+
+            elif class_name == "AssistantMessage":
+                # Extract text content from assistant messages
+                if hasattr(response, "content") and response.content:
+                    for block in response.content:
+                        if hasattr(block, "text"):
+                            assistant_text_content.append(block.text)
+                        elif isinstance(block, dict) and "text" in block:
+                            assistant_text_content.append(block["text"])
+
+            elif class_name == "UserMessage":
+                # Extract tool results from user messages
+                if hasattr(response, "content") and response.content:
+                    for item in response.content:
+                        if (
+                            isinstance(item, dict)
+                            and item.get("type") == "tool_result"
+                        ):
+                            tool_results.append(item.get("content", ""))
+
+            elif class_name == "ResultMessage":
+                result_message = response
+
+        # Determine the final content
+        final_content = ""
+        if (
+            result_message
+            and hasattr(result_message, "result")
+            and result_message.result
+        ):
+            # Use ResultMessage.result if available
+            final_content = result_message.result
+        elif assistant_text_content:
+            # Use assistant text content if available
+            final_content = "\n".join(assistant_text_content)
+        elif tool_results:
+            # If only tool results are available, use a generic summary
+            # (Claude Code typically provides its own summary after tool use)
+            final_content = (
+                "I've completed the requested task using the available tools."
+            )
+
+        # Build the clean chat completions response
+        result = {
+            "model": model,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {"role": "assistant", "content": final_content},
+                    "finish_reason": (
+                        "stop"
+                        if not (
+                            result_message
+                            and hasattr(result_message, "is_error")
+                            and result_message.is_error
+                        )
+                        else "error"
+                    ),
+                }
+            ],
+        }
+
+        # Add usage information if available
+        if result_message and hasattr(result_message, "usage"):
+            result["usage"] = result_message.usage
+
+        # Add only essential Claude Code metadata
+        if result_message:
+            if hasattr(result_message, "cost_usd"):
+                result["usage"]["cost_usd"] = result_message.cost_usd
+            if hasattr(result_message, "session_id"):
+                result["session_id"] = result_message.session_id
+            if hasattr(result_message, "is_error"):
+                result["is_error"] = result_message.is_error
+            if hasattr(result_message, "num_turns"):
+                result["num_turns"] = result_message.num_turns
+
+        return result
+
+    async def _call(
+        self,
+        payload: dict,
+        headers: dict,
+        **kwargs,
+    ):
+        responses = []
+        async for chunk in self._stream_claude_code(**payload):
+            responses.append(chunk)
+
+        # Parse the responses into a consistent format
+        return self._parse_claude_code_response(responses)

lionagi/service/imodel.py

@@ -120,6 +120,9 @@ class iModel:
         # Use provided streaming_process_func or default to None
         self.streaming_process_func = streaming_process_func
 
+        # Provider-specific metadata storage (e.g., session_id for Claude Code)
+        self._provider_metadata = {}
+
     def create_api_calling(
         self, include_token_usage_to_model: bool = False, **kwargs
     ) -> APICalling:
@@ -134,6 +137,15 @@ class iModel:
                 An `APICalling` instance with the constructed payload,
                 headers, and the selected endpoint.
         """
+        # For Claude Code, auto-inject session_id for resume if available and not explicitly provided
+        if (
+            self.endpoint.config.provider == "claude_code"
+            and "resume" not in kwargs
+            and "session_id" not in kwargs
+            and self._provider_metadata.get("session_id")
+        ):
+            kwargs["resume"] = self._provider_metadata["session_id"]
+
         # The new Endpoint.create_payload returns (payload, headers)
         payload, headers = self.endpoint.create_payload(request=kwargs)
 
@@ -256,7 +268,23 @@ class iModel:
                 await self.executor.forward()
                 ctr += 1
                 await asyncio.sleep(0.1)
-            return self.executor.pile.pop(api_call.id)
+
+            # Get the completed API call
+            completed_call = self.executor.pile.pop(api_call.id)
+
+            # Store session_id for Claude Code provider
+            if (
+                self.endpoint.config.provider == "claude_code"
+                and completed_call
+                and completed_call.response
+            ):
+                response = completed_call.response
+                if isinstance(response, dict) and "session_id" in response:
+                    self._provider_metadata["session_id"] = response[
+                        "session_id"
+                    ]
+
+            return completed_call
         except Exception as e:
             raise ValueError(f"Failed to invoke API call: {e}")
 
@@ -300,12 +328,13 @@ class iModel:
     def from_dict(cls, data: dict):
         endpoint = Endpoint.from_dict(data.get("endpoint", {}))
 
-        e1 = match_endpoint(
+        if e1 := match_endpoint(
             provider=endpoint.config.provider,
             endpoint=endpoint.config.endpoint,
-        )
-
-        e1.config = endpoint.config
+        ):
+            e1.config = endpoint.config
+        else:
+            e1 = endpoint
 
         return cls(
             endpoint=e1,

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.12.6"
+__version__ = "0.12.7"

{lionagi-0.12.6.dist-info → lionagi-0.12.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.12.6
+Version: 0.12.7
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -225,13 +225,16 @@ Requires-Dist: backoff>=2.2.1
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: pydantic-settings>=2.8.0
-Requires-Dist: pydapter[pandas]>=0.3.0
+Requires-Dist: pydapter[pandas]>=0.3.2
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: all
+Requires-Dist: claude-code-sdk>=0.0.10; extra == 'all'
 Requires-Dist: docling>=2.15.1; extra == 'all'
 Requires-Dist: ollama>=0.5.0; extra == 'all'
+Provides-Extra: claude-code
+Requires-Dist: claude-code-sdk>=0.0.10; extra == 'claude-code'
 Provides-Extra: docs
 Requires-Dist: furo>=2024.8.6; extra == 'docs'
 Requires-Dist: sphinx-autobuild>=2024.10.3; extra == 'docs'
@@ -389,11 +392,41 @@ analysis = await branch.communicate("Analyze these stats", imodel=sonnet)
 
 Seamlessly route to different models in the same workflow.
 
+### Claude Code Integration
+
+LionAGI now supports Anthropic's [Claude Code SDK](https://github.com/anthropics/claude-code-sdk), enabling autonomous coding capabilities with persistent session management:
+
+```python
+from lionagi import iModel, Branch
+
+# Create a Claude Code model
+coder = iModel(
+    provider="claude_code",
+    endpoint="code",
+    model="claude-sonnet-4-20250514",
+    allowed_tools=["Write", "Read", "Edit"],  # Control which tools Claude can use
+)
+
+# Start a coding session
+branch = Branch(chat_model=coder)
+response = await branch.chat("Create a Python function to calculate fibonacci numbers")
+
+# Claude Code maintains session context automatically
+response2 = await branch.chat("Now optimize it for performance")
+```
+
+Key features:
+- **Auto-Resume Sessions**: Conversations automatically continue from where they left off
+- **Tool Permissions**: Fine-grained control over which tools Claude can access
+- **Streaming Support**: Real-time feedback during code generation
+- **Seamless Integration**: Works with existing LionAGI workflows
+
 ### optional dependencies
 
 ```
 pip install "lionagi[reader]"
 pip install "lionagi[ollama]"
+pip install "lionagi[claude-code]"
 ```
 
 ## Community & Contributing

{lionagi-0.12.6.dist-info → lionagi-0.12.7.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=vb8hPdq1CrFlRl6aBYGOWE4MPv-N84JJm1f3KFvG8o4,23
+lionagi/version.py,sha256=WvcWmk-c-I-XXiq6oM9Y1VYwNWFe64tXpnG_RI47HhE,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
@@ -163,20 +163,21 @@ lionagi/protocols/operatives/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5Z
 lionagi/protocols/operatives/operative.py,sha256=PXEMzD6tFM5PPK9kkPaSb7DBIzy7TNC3f2evuGhWhpg,6677
 lionagi/protocols/operatives/step.py,sha256=AXXRhjsbWqkoMDQ_JyqsfQItQsjBJmldugJz36mA4N0,9772
 lionagi/service/__init__.py,sha256=DMGXIqPsmut9H5GT0ZeSzQIzYzzPwI-2gLXydpbwiV8,21
-lionagi/service/imodel.py,sha256=ho5vINb0xQVOmUsZj1TR4hfXsfNPqsyW1tfDH2Us-nU,11211
+lionagi/service/imodel.py,sha256=LAlU6orAAZr7B-_3upZng8OvMVz0FadWLRawwdqfBGY,12346
 lionagi/service/manager.py,sha256=9-dIE4ZftI94RLLLPXH-yB4E3zfnbTs3yppdFDPNchM,1165
 lionagi/service/rate_limited_processor.py,sha256=PnO0rBf9ObKhD3vtl6pYZX3nHVDvMPdOww59zCWgslQ,5230
 lionagi/service/resilience.py,sha256=uYJYZQ9M-tje8ME3vJmYabXwKHF1c3Ij4-WrdCwogcs,18742
 lionagi/service/token_calculator.py,sha256=zpbk1YlFW5M_e-vs9YJyhDThMm3U3IaZ7hKm-_6XrDU,6460
 lionagi/service/types.py,sha256=6zavqBxK1Fj0nB9eZgJn3JICxmdT-n0nn8YWZFzM5LU,508
 lionagi/service/connections/__init__.py,sha256=yHQZ7OJpCftd6CStYR8inbxjJydYdmv9kCvbUBhJ2zU,362
-lionagi/service/connections/api_calling.py,sha256=KMO4BQf3z-WM2-pG2lhoNzxMb-zzCMKMhbrQPOPIwgI,7929
-lionagi/service/connections/endpoint.py,sha256=HqeLUP0XvUrPpsHraYbKXO9EUIuoivChWju30dVgFrs,14494
+lionagi/service/connections/api_calling.py,sha256=XetCrjMhOHNKGGv-NzHhBhVS7XjKPalrS_iExzU-4S4,8005
+lionagi/service/connections/endpoint.py,sha256=yNIjq9wETMnytynGbq3qY_dkyaMlaHrcfiZjS-tnmLg,14756
 lionagi/service/connections/endpoint_config.py,sha256=jCgMOujN5KzQ2miOrfEqKrVZW3jlZEgBp2R3_2sXynI,4380
 lionagi/service/connections/header_factory.py,sha256=22sG4ian3MiNklF6SdQqkEYgtWKOZik_yDE0Lna6BiE,1754
-lionagi/service/connections/match_endpoint.py,sha256=lwFFpiEfkaMuznjQcqfJlvDLm5EVUs9scAnthVghPuY,1571
+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=1kCLHjc-bqjCsG6HieaJQWy6SCV6PzBZGjTneLPhCY0,8845
 lionagi/service/connections/providers/exa_.py,sha256=GGWaD9jd5gKM257OfUaIBBKIqR1NrNcBE67p_7JbK7g,938
 lionagi/service/connections/providers/oai_.py,sha256=rKZdGufX4vpj88rr98KqoOHzHa7HgH_pCVWjCqAq-XU,4971
 lionagi/service/connections/providers/ollama_.py,sha256=jdx6dGeChwVk5TFfFRbpnrpKzj8YQZw6D5iWJ6zYmfk,4096
@@ -197,7 +198,7 @@ lionagi/tools/types.py,sha256=XtJLY0m-Yi_ZLWhm0KycayvqMCZd--HxfQ0x9vFUYDE,230
 lionagi/tools/file/__init__.py,sha256=5y5joOZzfFWERl75auAcNcKC3lImVJ5ZZGvvHZUFCJM,112
 lionagi/tools/file/reader.py,sha256=0TdnfVGVCKuM58MmGM-NyVjhU9BFoitkNYEepdc0z_Y,9529
 lionagi/tools/memory/tools.py,sha256=zTGBenVsF8Wuh303kWntmQSGlAFKonHNdh5ePuQ26KE,15948
-lionagi-0.12.6.dist-info/METADATA,sha256=GzAVxOdrugSbx9eoSdf85DAfU1fW7VAjMwFH79-2G54,18960
-lionagi-0.12.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lionagi-0.12.6.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.12.6.dist-info/RECORD,,
+lionagi-0.12.7.dist-info/METADATA,sha256=6cpK8bMdHTYDG78vn9Gl09ENET3A4vYkfaot81uoAa0,20200
+lionagi-0.12.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.12.7.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.12.7.dist-info/RECORD,,