lionagi 0.12.8__tar.gz → 0.13.0__tar.gz

{lionagi-0.12.8 → lionagi-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.12.8
+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.8 → lionagi-0.13.0}/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-0.12.8 → lionagi-0.13.0}/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-0.13.0/lionagi/service/connections/providers/claude_code_.py

@@ -0,0 +1,311 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+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):
+    # -- 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
+
+    # -- 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
+    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:
+        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[str, Any]],
+        resume: str | None = 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)):
+            prompt = json.dumps(prompt)
+
+        if resume and continue_conversation is None:
+            continue_conversation = True
+
+        data: dict[str, Any] = dict(
+            prompt=prompt,
+            resume=resume,
+            continue_conversation=bool(continue_conversation),
+        )
+
+        if (messages[0]["role"] == "system") and (
+            resume or continue_conversation
+        ):
+            data["system_prompt"] = messages[0]["content"]
+
+        # Merge optional system prompts
+        if kwargs.get("system_prompt"):
+            data["append_system_prompt"] = kwargs.pop("system_prompt")
+
+        data.update(kwargs)
+        return cls.model_validate(data, strict=False)
+
+
+# --------------------------------------------------------------------------- SDK endpoint
+ENDPOINT_CONFIG = EndpointConfig(
+    name="claude_code",
+    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: EndpointConfig = ENDPOINT_CONFIG, **kwargs):
+        super().__init__(config=config, **kwargs)
+
+    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}, {}
+
+    def _stream_claude_code(self, request: ClaudeCodeRequest):
+        return sdk_query(
+            prompt=request.prompt, options=request.as_claude_options()
+        )
+
+    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:
+        """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.
+        """
+        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,
+            },
+        }
+
+        from claude_code_sdk import types
+
+        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,
+                            }
+                        )
+            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
+
+        return results
+
+    async def _call(
+        self,
+        payload: dict,
+        headers: dict,
+        **kwargs,
+    ):
+        responses = []
+        async for chunk in self._stream_claude_code(**payload):
+            responses.append(chunk)
+
+        return self._parse_claude_code_response(responses)

{lionagi-0.12.8 → lionagi-0.13.0}/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-0.12.8 → lionagi-0.13.0}/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-0.12.8 → lionagi-0.13.0}/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-0.13.0/lionagi/version.py

@@ -0,0 +1 @@
+__version__ = "0.13.0"

{lionagi-0.12.8 → lionagi-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lionagi"
-version = "0.12.8"
+version = "0.13.0"
 description = "An Intelligence Operating System."
 authors = [
     { name = "HaiyangLi", email = "quantocean.li@gmail.com" },
@@ -78,7 +78,7 @@ ollama = [
 ]
 
 claude-code = [
-    "claude-code-sdk>=0.0.10"
+    "claude-code-sdk>=0.0.14"
 ]
 
 all = [

{lionagi-0.12.8 → lionagi-0.13.0}/uv.lock

@@ -411,15 +411,15 @@ wheels = [
 
 [[package]]
 name = "claude-code-sdk"
-version = "0.0.10"
+version = "0.0.14"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/f5/6c69e0f26cc4dc0f473dcad3fa0138c17d620f6fd5e8019edc47a958579f/claude_code_sdk-0.0.10.tar.gz", hash = "sha256:9fb5d40089845b21de07b0f9dc6e48482c6b819ed5a7cc35dfdcd674b9592213", size = 11538, upload-time = "2025-06-12T07:30:48.054Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/50/489bd1cf9f448d9e06aa6af4a14db8e22ec5f7dbdb5fcc48821b1d8d1680/claude_code_sdk-0.0.14.tar.gz", hash = "sha256:a1c9384b6934c2b8351d7a35c0b7dcfd5fb657017fb456eb98bcf5e0b4f8eccd", size = 13403, upload-time = "2025-07-01T06:07:28.147Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/05/c719217354c8a783689cf94faecc222d725732a4cd3d285a9ee160c8449e/claude_code_sdk-0.0.10-py3-none-any.whl", hash = "sha256:cf4153b1723ff0d7c6a1c281540651c059d6c53b02654cc1ab9e9a85b7092a94", size = 10344, upload-time = "2025-06-12T07:30:46.643Z" },
+    { url = "https://files.pythonhosted.org/packages/db/a4/6eb606ccb0988054ca52b9453045b2c2f1bc6fd9c915e0f6cd1f73d6ce2c/claude_code_sdk-0.0.14-py3-none-any.whl", hash = "sha256:83a23a260954bb84e78cf2dc42aaaa0eee778ca392e56f1661276f31ba64992c", size = 10589, upload-time = "2025-07-01T06:07:27.029Z" },
 ]
 
 [[package]]
@@ -1179,7 +1179,7 @@ wheels = [
 
 [[package]]
 name = "lionagi"
-version = "0.12.8"
+version = "0.13.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiocache" },
@@ -1243,7 +1243,7 @@ requires-dist = [
     { name = "aiohttp", specifier = ">=3.12.0" },
     { name = "backoff", specifier = ">=2.2.1" },
     { name = "black", extras = ["jupyter"], marker = "extra == 'lint'", specifier = ">=24.10.0" },
-    { name = "claude-code-sdk", marker = "extra == 'claude-code'", specifier = ">=0.0.10" },
+    { name = "claude-code-sdk", marker = "extra == 'claude-code'", specifier = ">=0.0.14" },
     { name = "docling", marker = "extra == 'reader'", specifier = ">=2.15.1" },
     { name = "furo", marker = "extra == 'docs'", specifier = ">=2024.8.6" },
     { name = "isort", marker = "extra == 'lint'", specifier = ">=5.13.2" },