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

lionagi/libs/schema/load_pydantic_model_from_schema.py

@@ -151,9 +151,6 @@ def load_pydantic_model_from_schema(
                 base_class="pydantic.BaseModel",
             )
         except Exception as e:
-            # Optional: Print generated code on failure for debugging
-            # if output_file.exists():
-            #     print(f"--- Generated Code (Error) ---\n{output_file.read_text()}\n--------------------------")
             error_msg = "Failed to generate model code"
             raise RuntimeError(error_msg) from e
 
@@ -175,15 +172,9 @@ def load_pydantic_model_from_schema(
         # --- 3. Import the Generated Module Dynamically ---
         try:
             spec, generated_module = get_modules()
-            # Important: Make pydantic available within the executed module's globals
-            # if it's not explicitly imported by the generated code for some reason.
-            # Usually, datamodel-code-generator handles imports well.
-            # generated_module.__dict__['BaseModel'] = BaseModel
             spec.loader.exec_module(generated_module)
 
         except Exception as e:
-            # Optional: Print generated code on failure for debugging
-            # print(f"--- Generated Code (Import Error) ---\n{output_file.read_text()}\n--------------------------")
             error_msg = f"Failed to load generated module ({output_file})"
             raise RuntimeError(error_msg) from e
 

lionagi/service/connections/endpoint_config.py

@@ -53,7 +53,6 @@ class EndpointConfig(BaseModel):
 
     @model_validator(mode="after")
     def _validate_api_key(self):
-
         if self.api_key is not None:
             if isinstance(self.api_key, SecretStr):
                 self._api_key = self.api_key.get_secret_value()
@@ -61,6 +60,9 @@ class EndpointConfig(BaseModel):
                 # Skip settings lookup for ollama special case
                 if self.provider == "ollama" and self.api_key == "ollama_key":
                     self._api_key = "ollama_key"
+                if self.provider == "claude_code":
+                    self._api_key = "dummy"
+
                 else:
                     from lionagi.config import settings
 
@@ -89,9 +91,11 @@ class EndpointConfig(BaseModel):
             if isinstance(v, BaseModel):
                 return v.__class__
             if isinstance(v, dict | str):
-                from lionagi.libs.schema import SchemaUtil
+                from lionagi.libs.schema.load_pydantic_model_from_schema import (
+                    load_pydantic_model_from_schema,
+                )
 
-                return SchemaUtil.load_pydantic_model_from_schema(v)
+                return load_pydantic_model_from_schema(v)
         except Exception as e:
             raise ValueError("Invalid request options") from e
         raise ValueError(

lionagi/service/connections/providers/claude_code_.py

@@ -2,136 +2,244 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from __future__ import annotations
+
 import json
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
-from claude_code_sdk import ClaudeCodeOptions, PermissionMode
-from pydantic import BaseModel, Field
+from claude_code_sdk import ClaudeCodeOptions
+from claude_code_sdk import query as sdk_query
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
 from lionagi.utils import to_dict
 
-
+# --------------------------------------------------------------------------- constants
+ClaudePermission = Literal[
+    "default",
+    "acceptEdits",
+    "bypassPermissions",
+    "dangerously-skip-permissions",
+]
+
+CLAUDE_CODE_OPTION_PARAMS = {
+    "allowed_tools",
+    "max_thinking_tokens",
+    "mcp_tools",
+    "mcp_servers",
+    "permission_mode",
+    "continue_conversation",
+    "resume",
+    "max_turns",
+    "disallowed_tools",
+    "model",
+    "permission_prompt_tool_name",
+    "cwd",
+    "system_prompt",
+    "append_system_prompt",
+}
+
+
+# --------------------------------------------------------------------------- request model
 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
+    # -- conversational bits -------------------------------------------------
+    prompt: str = Field(description="The prompt for Claude Code")
+    system_prompt: str | None = None
+    append_system_prompt: str | None = None
+    max_turns: int | 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
+
+    # -- repo / workspace ----------------------------------------------------
+    repo: Path = Field(default_factory=Path.cwd, exclude=True)
+    ws: str | None = None  # sub-directory under repo
+    add_dir: str | None = None  # extra read-only mount
+    allowed_tools: list[str] | None = None
+
+    # -- runtime & safety ----------------------------------------------------
+    model: Literal["sonnet", "opus"] | str | None = "sonnet"
+    max_thinking_tokens: int | None = None
+    mcp_tools: list[str] = Field(default_factory=list)
+    mcp_servers: dict[str, Any] = Field(default_factory=dict)
+    permission_mode: ClaudePermission | 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
+    disallowed_tools: list[str] = Field(default_factory=list)
+
+    # ------------------------ validators & helpers --------------------------
+    @field_validator("permission_mode", mode="before")
+    def _norm_perm(cls, v):
+        if v in {
+            "dangerously-skip-permissions",
+            "--dangerously-skip-permissions",
+        }:
+            return "bypassPermissions"
+        return v
+
+    # Workspace path derived from repo + ws
+    def cwd(self) -> Path:
+        if not self.ws:
+            return self.repo
+
+        # Convert to Path object for proper validation
+        ws_path = Path(self.ws)
+
+        # Check for absolute paths or directory traversal attempts
+        if ws_path.is_absolute():
+            raise ValueError(
+                f"Workspace path must be relative, got absolute: {self.ws}"
+            )
+
+        if ".." in ws_path.parts:
+            raise ValueError(
+                f"Directory traversal detected in workspace path: {self.ws}"
+            )
 
+        # Resolve paths to handle symlinks and normalize
+        repo_resolved = self.repo.resolve()
+        result = (self.repo / ws_path).resolve()
+
+        # Ensure the resolved path is within the repository bounds
+        try:
+            result.relative_to(repo_resolved)
+        except ValueError:
+            raise ValueError(
+                f"Workspace path escapes repository bounds. "
+                f"Repository: {repo_resolved}, Workspace: {result}"
+            )
+
+        return result
+
+    @model_validator(mode="after")
+    def _check_perm_workspace(self):
+        if self.permission_mode == "bypassPermissions":
+            # Use secure path validation with resolved paths
+            repo_resolved = self.repo.resolve()
+            cwd_resolved = self.cwd().resolve()
+
+            # Check if cwd is within repo bounds using proper path methods
+            try:
+                cwd_resolved.relative_to(repo_resolved)
+            except ValueError:
+                raise ValueError(
+                    f"With bypassPermissions, workspace must be within repository bounds. "
+                    f"Repository: {repo_resolved}, Workspace: {cwd_resolved}"
+                )
+        return self
+
+    # ------------------------ CLI helpers -----------------------------------
+    def as_cmd_args(self) -> list[str]:
+        """Build argument list for the *Node* `claude` CLI."""
+        full_prompt = f"Human User: {self.prompt}\n\nAssistant:"
+        args: list[str] = ["-p", full_prompt, "--output-format", "stream-json"]
+        if self.allowed_tools:
+            args.append("--allowedTools")
+            for tool in self.allowed_tools:
+                args.append(f'"{tool}"')
+
+        if self.disallowed_tools:
+            args.append("--disallowedTools")
+            for tool in self.disallowed_tools:
+                args.append(f'"{tool}"')
+
+        if self.resume:
+            args += ["--resume", self.resume]
+        elif self.continue_conversation:
+            args.append("--continue")
+
+        if self.max_turns:
+            # +1 because CLI counts *pairs*
+            args += ["--max-turns", str(self.max_turns + 1)]
+
+        if self.permission_mode == "bypassPermissions":
+            args += ["--dangerously-skip-permissions"]
+
+        if self.add_dir:
+            args += ["--add-dir", self.add_dir]
+
+        args += ["--model", self.model or "sonnet", "--verbose"]
+        return args
+
+    # ------------------------ SDK helpers -----------------------------------
     def as_claude_options(self) -> ClaudeCodeOptions:
-        dict_ = self.model_dump(exclude_unset=True)
-        dict_.pop("prompt")
-        return ClaudeCodeOptions(**dict_)
+        data = {
+            k: v
+            for k, v in self.model_dump(exclude_none=True).items()
+            if k in CLAUDE_CODE_OPTION_PARAMS
+        }
+        return ClaudeCodeOptions(**data)
 
+    # ------------------------ convenience constructor -----------------------
     @classmethod
     def create(
         cls,
-        messages: list[dict],
+        messages: list[dict[str, Any]],
         resume: str | None = None,
-        continue_conversation: bool = None,
+        continue_conversation: bool | None = None,
         **kwargs,
     ):
+        if not messages:
+            raise ValueError("messages may not be empty")
+
         prompt = messages[-1]["content"]
-        if isinstance(prompt, dict | list):
+        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:
+        if resume and continue_conversation is None:
             continue_conversation = True
 
-        dict_ = dict(
+        data: dict[str, Any] = dict(
             prompt=prompt,
-            continue_conversation=continue_conversation,
             resume=resume,
+            continue_conversation=bool(continue_conversation),
         )
 
-        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 (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:
-            dict_.setdefault("append_system_prompt", "")
-            dict_["append_system_prompt"] += str(a)
+        # Merge optional system prompts
+        if kwargs.get("system_prompt"):
+            data["append_system_prompt"] = kwargs.pop("system_prompt")
 
-        dict_ = {**dict_, **kwargs}
-        dict_ = {k: v for k, v in dict_.items() if v is not None}
-        return cls(**dict_)
+        data.update(kwargs)
+        return cls.model_validate(data, strict=False)
 
 
+# --------------------------------------------------------------------------- SDK endpoint
 ENDPOINT_CONFIG = EndpointConfig(
     name="claude_code",
-    provider="anthropic",
+    provider="claude_code",
     base_url="internal",
     endpoint="query",
     api_key="dummy",
     request_options=ClaudeCodeRequest,
+    timeout=3000,
 )
 
 
 class ClaudeCodeEndpoint(Endpoint):
+    """Direct Python-SDK (non-CLI) endpoint - unchanged except for bug-fixes."""
 
-    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config: EndpointConfig = 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)
+    def create_payload(self, request: dict | BaseModel, **kwargs):
+        req_dict = {**self.config.kwargs, **to_dict(request), **kwargs}
+        messages = req_dict.pop("messages")
+        req_obj = ClaudeCodeRequest.create(messages=messages, **req_dict)
+        return {"request": req_obj}, {}
 
-        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
-            },
+    def _stream_claude_code(self, request: ClaudeCodeRequest):
+        return sdk_query(
+            prompt=request.prompt, options=request.as_claude_options()
         )
-        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):
+    async def stream(self, request: dict | BaseModel, **kwargs):
+        payload = self.create_payload(request, **kwargs)["request"]
+        async for chunk in self._stream_claude_code(payload):
             yield chunk
 
     def _parse_claude_code_response(self, responses: list) -> dict:
@@ -146,95 +254,49 @@ class ClaudeCodeEndpoint(Endpoint):
         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 = []
+        results = {
+            "session_id": None,
+            "model": "claude-code",
+            "result": "",
+            "tool_results": [],
+            "is_error": False,
+            "num_turns": None,
+            "total_cost_usd": None,
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0,
+            },
+        }
 
-        # 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."
-            )
+        from claude_code_sdk import types
 
-        # 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
+        for response in responses:
+            if isinstance(response, 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):
+                        results["result"] += block.text.strip() + "\n"
+                    if isinstance(block, types.ToolResultBlock):
+                        results["tool_results"].append(
+                            {
+                                "tool_use_id": block.tool_use_id,
+                                "content": block.content,
+                                "is_error": block.is_error,
+                            }
                         )
-                        else "error"
-                    ),
-                }
-            ],
-        }
+            if isinstance(response, types.ResultMessage):
+                results["result"] += response.result.strip() or ""
+                results["usage"] = response.usage
+                results["is_error"] = response.is_error
+                results["total_cost_usd"] = response.total_cost_usd
+                results["num_turns"] = response.num_turns
+                results["duration_ms"] = response.duration_ms
+                results["duration_api_ms"] = response.duration_api_ms
 
-        # 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
+        return results
 
     async def _call(
         self,
@@ -246,5 +308,4 @@ class ClaudeCodeEndpoint(Endpoint):
         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/connections/providers/oai_.py

@@ -98,10 +98,21 @@ GROQ_CHAT_ENDPOINT_CONFIG = EndpointConfig(
 
 
 REASONING_MODELS = (
-    "o3-mini-2025-01-31",
-    "o3-mini",
     "o1",
     "o1-2024-12-17",
+    "o1-preview-2024-09-12",
+    "o1-pro",
+    "o1-pro-2025-03-19",
+    "o3-pro",
+    "o3-pro-2025-06-10",
+    "o3",
+    "o3-2025-04-16",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+    "o3-mini",
+    "o3-mini-2025-01-31",
+    "o1-mini",
+    "o1-mini-2024-09-12",
 )
 
 REASONING_NOT_SUPPORT_PARAMS = (

lionagi/service/imodel.py

@@ -46,6 +46,7 @@ class iModel:
         limit_tokens: int = None,
         concurrency_limit: int | None = None,
         streaming_process_func: Callable = None,
+        provider_metadata: dict | None = None,
         **kwargs,
     ) -> None:
         """Initializes the iModel instance.
@@ -79,6 +80,8 @@ class iModel:
             concurrency_limit (int | None, optional):
                 Maximum number of streaming concurrent requests allowed.
                 only applies to streaming requests.
+            provider_metadata (dict | None, optional):
+                Provider-specific metadata, such as session IDs for
             **kwargs:
                 Additional keyword arguments, such as `model`, or any other
                 provider-specific fields.
@@ -121,7 +124,7 @@ class iModel:
         self.streaming_process_func = streaming_process_func
 
         # Provider-specific metadata storage (e.g., session_id for Claude Code)
-        self._provider_metadata = {}
+        self.provider_metadata = provider_metadata or {}
 
     def create_api_calling(
         self, include_token_usage_to_model: bool = False, **kwargs
@@ -142,9 +145,9 @@ class iModel:
             self.endpoint.config.provider == "claude_code"
             and "resume" not in kwargs
             and "session_id" not in kwargs
-            and self._provider_metadata.get("session_id")
+            and self.provider_metadata.get("session_id")
         ):
-            kwargs["resume"] = self._provider_metadata["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)
@@ -280,7 +283,7 @@ class iModel:
             ):
                 response = completed_call.response
                 if isinstance(response, dict) and "session_id" in response:
-                    self._provider_metadata["session_id"] = response[
+                    self.provider_metadata["session_id"] = response[
                         "session_id"
                     ]
 
@@ -322,6 +325,7 @@ class iModel:
         return {
             "endpoint": self.endpoint.to_dict(),
             "processor_config": self.executor.config,
+            "provider_metadata": self.provider_metadata,
         }
 
     @classmethod
@@ -338,5 +342,6 @@ class iModel:
 
         return cls(
             endpoint=e1,
+            provider_metadata=data.get("provider_metadata"),
             **data.get("processor_config", {}),
         )

lionagi/service/third_party/anthropic_models.py

@@ -6,7 +6,7 @@
 
 from __future__ import annotations
 
-from typing import Literal, Optional, Union
+from typing import Literal, Union
 
 from pydantic import BaseModel, Field, field_validator
 

lionagi/service/token_calculator.py

@@ -121,7 +121,7 @@ class TokenCalculator:
         return num_tokens  # buffer for chat
 
     @staticmethod
-    def calcualte_embed_token(inputs: list[str], /, **kwargs) -> int:
+    def calculate_embed_token(inputs: list[str], /, **kwargs) -> int:
         try:
             if not "inputs" in kwargs:
                 raise ValueError("Missing 'inputs' field in payload")

lionagi/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.12.7
+Version: 0.13.0
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -230,11 +230,11 @@ 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: claude-code-sdk>=0.0.14; 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'
+Requires-Dist: claude-code-sdk>=0.0.14; extra == 'claude-code'
 Provides-Extra: docs
 Requires-Dist: furo>=2024.8.6; extra == 'docs'
 Requires-Dist: sphinx-autobuild>=2024.10.3; extra == 'docs'

{lionagi-0.12.7.dist-info → lionagi-0.13.0.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=WvcWmk-c-I-XXiq6oM9Y1VYwNWFe64tXpnG_RI47HhE,23
+lionagi/version.py,sha256=DgpLNbv0e1LIEOOe54Db8_390i9pelMEFEnsBsNmyhA,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
@@ -46,7 +46,7 @@ lionagi/libs/schema/extract_code_block.py,sha256=PuJbJj1JnqR5fSZudowPcVPpEoKISLr
 lionagi/libs/schema/extract_docstring.py,sha256=aYyLSRlB8lTH9QF9-6a56uph3AAkNuTyZ0S_duf5-fw,5729
 lionagi/libs/schema/function_to_schema.py,sha256=XAB031WbYu3a7eFJyYjXVMAjmtWYSYr5kC_DYgjiuyM,5604
 lionagi/libs/schema/json_schema.py,sha256=cuHcaMr748O9g6suNGmRx4tRXcidd5-c7AMGjTIZyHM,7670
-lionagi/libs/schema/load_pydantic_model_from_schema.py,sha256=WwmOqo4mlSjClYb8s0jOr4PODeFz777TxfeyBnzZ3rc,10899
+lionagi/libs/schema/load_pydantic_model_from_schema.py,sha256=VGrmnMb26JNcB9LaQcqTwW--sUljqqlqqsPD69zjcEc,10183
 lionagi/libs/token_transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/libs/token_transform/base.py,sha256=LBnaDgi4HNgaJJGwIzWcQjVMdu49i_93rRvOvMU22Rw,1545
 lionagi/libs/token_transform/llmlingua.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
@@ -163,28 +163,28 @@ 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=LAlU6orAAZr7B-_3upZng8OvMVz0FadWLRawwdqfBGY,12346
+lionagi/service/imodel.py,sha256=jE1Y3JzGwJZesHQtRSadVTAHA2TGdBAwfmzQoOA5Meg,12651
 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/token_calculator.py,sha256=FysR31hpv4QPVsbZBVPR60LSW_xCQpwXx89zOJJ73LQ,6460
 lionagi/service/types.py,sha256=6zavqBxK1Fj0nB9eZgJn3JICxmdT-n0nn8YWZFzM5LU,508
 lionagi/service/connections/__init__.py,sha256=yHQZ7OJpCftd6CStYR8inbxjJydYdmv9kCvbUBhJ2zU,362
 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/endpoint_config.py,sha256=QMfxqwvHhNjFSZupJ8oDCMlZK_uQkjGC145w6ETxnB8,4558
 lionagi/service/connections/header_factory.py,sha256=22sG4ian3MiNklF6SdQqkEYgtWKOZik_yDE0Lna6BiE,1754
 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/claude_code_.py,sha256=TmIxVCCbHxe2NIc2Kb3oJTYFGdJZi5IkB_23LQ1PcG0,11089
 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/oai_.py,sha256=hH5oEMvS9A0Kbvh-lSFm5dLiqPV2gfRra6zzDOq78P0,5191
 lionagi/service/connections/providers/ollama_.py,sha256=jdx6dGeChwVk5TFfFRbpnrpKzj8YQZw6D5iWJ6zYmfk,4096
 lionagi/service/connections/providers/perplexity_.py,sha256=9MH9YmMy9Jg7JDMJHQxxMYHyjJ4NP0OlN7sCuhla85I,917
 lionagi/service/third_party/README.md,sha256=qFjWnI8rmLivIyr6Tc-hRZh-rQwntROp76af4MBNJJc,2214
 lionagi/service/third_party/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lionagi/service/third_party/anthropic_models.py,sha256=wA2NiiPJzkkVF_-wFgnTJoKwvuoduqHw-yVSetp0XZI,4014
+lionagi/service/third_party/anthropic_models.py,sha256=oqSPSlcayYG-fS5BLiLeTtkrpaxgkPhEK_YgneumrOo,4004
 lionagi/service/third_party/exa_models.py,sha256=G_hnekcy-DillPLzMoDQ8ZisVAL8Mp7iMAK4xqAT_3w,5470
 lionagi/service/third_party/openai_models.py,sha256=sF-fQ726CnaDBgLY_r2NdPqc3GicPKhZjh5F8IfjBO0,501904
 lionagi/service/third_party/pplx_models.py,sha256=Nkm1ftESBa_NwP9ITBUNqLmAZ3Jh92aL732g_i6T8LQ,5947
@@ -198,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.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,,
+lionagi-0.13.0.dist-info/METADATA,sha256=calK5dDwwOP5FlidDG33qMadI8U75UD-TcPrwOyBEJ0,20200
+lionagi-0.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lionagi-0.13.0.dist-info/licenses/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.13.0.dist-info/RECORD,,