lionagi 0.14.5__py3-none-any.whl → 0.14.7__py3-none-any.whl

lionagi/service/connections/providers/claude_code_cli.py

@@ -1,352 +1,23 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
 from __future__ import annotations
 
-import asyncio
-import codecs
-import contextlib
-import dataclasses
-import json
-import logging
-import shutil
-from collections.abc import AsyncIterator, Callable
-from datetime import datetime
-from functools import partial
-from textwrap import shorten
-from typing import Any
+from collections.abc import AsyncIterator
 
-from json_repair import repair_json
 from pydantic import BaseModel
 
-from lionagi.libs.schema.as_readable import as_readable
 from lionagi.service.connections.endpoint import Endpoint, EndpointConfig
 from lionagi.utils import to_dict
 
-from .claude_code_ import ClaudeCodeRequest
-
-CLAUDE = shutil.which("claude") or "claude"
-if not shutil.which(CLAUDE):
-    raise RuntimeError(
-        "Claude CLI binary not found (npm i -g @anthropic-ai/claude-code)"
-    )
-logging.basicConfig(level=logging.INFO)
-log = logging.getLogger("claude-cli")
-
-
-@dataclasses.dataclass
-class ClaudeChunk:
-    """Low-level wrapper around every NDJSON object coming from the CLI."""
-
-    raw: dict[str, Any]
-    type: str
-    # convenience views
-    thinking: str | None = None
-    text: str | None = None
-    tool_use: dict[str, Any] | None = None
-    tool_result: dict[str, Any] | None = None
-
-
-@dataclasses.dataclass
-class ClaudeSession:
-    """Aggregated view of a whole CLI conversation."""
-
-    session_id: str | None = None
-    model: str | None = None
-
-    # chronological log
-    chunks: list[ClaudeChunk] = dataclasses.field(default_factory=list)
-
-    # materialised views
-    thinking_log: list[str] = dataclasses.field(default_factory=list)
-    messages: list[dict[str, Any]] = dataclasses.field(default_factory=list)
-    tool_uses: list[dict[str, Any]] = dataclasses.field(default_factory=list)
-    tool_results: list[dict[str, Any]] = dataclasses.field(
-        default_factory=list
-    )
-
-    # final summary
-    result: str = ""
-    usage: dict[str, Any] = dataclasses.field(default_factory=dict)
-    total_cost_usd: float | None = None
-    num_turns: int | None = None
-    duration_ms: int | None = None
-    duration_api_ms: int | None = None
-    is_error: bool = False
-
-
-# --------------------------------------------------------------------------- helpers
-
-
-async def ndjson_from_cli(request: ClaudeCodeRequest):
-    """
-    Yields each JSON object emitted by the *claude-code* CLI.
-
-    • Robust against UTF‑8 splits across chunks (incremental decoder).
-    • Robust against braces inside strings (uses json.JSONDecoder.raw_decode)
-    • Falls back to `json_repair.repair_json` when necessary.
-    """
-    workspace = request.cwd()
-    workspace.mkdir(parents=True, exist_ok=True)
-
-    proc = await asyncio.create_subprocess_exec(
-        CLAUDE,
-        *request.as_cmd_args(),
-        cwd=str(workspace),
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
-
-    decoder = codecs.getincrementaldecoder("utf-8")()
-    json_decoder = json.JSONDecoder()
-    buffer: str = ""  # text buffer that may hold >1 JSON objects
-
-    try:
-        while True:
-            chunk = await proc.stdout.read(4096)
-            if not chunk:
-                break
-
-            # 1) decode *incrementally* so we never split multibyte chars
-            buffer += decoder.decode(chunk)
-
-            # 2) try to peel off as many complete JSON objs as possible
-            while buffer:
-                buffer = buffer.lstrip()  # remove leading spaces/newlines
-                if not buffer:
-                    break
-                try:
-                    obj, idx = json_decoder.raw_decode(buffer)
-                    yield obj
-                    buffer = buffer[idx:]  # keep remainder for next round
-                except json.JSONDecodeError:
-                    # incomplete → need more bytes
-                    break
-
-        # 3) flush any tail bytes in the incremental decoder
-        buffer += decoder.decode(b"", final=True)
-        buffer = buffer.strip()
-        if buffer:
-            try:
-                obj, idx = json_decoder.raw_decode(buffer)
-                yield obj
-            except json.JSONDecodeError:
-                try:
-                    fixed = repair_json(buffer)
-                    yield json.loads(fixed)
-                    log.warning(
-                        "Repaired malformed JSON fragment at stream end"
-                    )
-                except Exception:
-                    log.error(
-                        "Skipped unrecoverable JSON tail: %.120s…", buffer
-                    )
-
-        # 4) propagate non‑zero exit code
-        if await proc.wait() != 0:
-            err = (await proc.stderr.read()).decode().strip()
-            raise RuntimeError(err or "CLI exited non‑zero")
-
-    finally:
-        with contextlib.suppress(ProcessLookupError):
-            proc.terminate()
-        await proc.wait()
-
-
-# --------------------------------------------------------------------------- SSE route
-async def stream_events(request: ClaudeCodeRequest):
-    async for obj in ndjson_from_cli(request):
-        yield obj
-    yield {"type": "done"}
-
-
-print_readable = partial(as_readable, md=True, display_str=True)
-
-
-def _pp_system(sys_obj: dict[str, Any], theme) -> None:
-    txt = (
-        f"◼️  **Claude Code Session**  \n"
-        f"- id: `{sys_obj.get('session_id', '?')}`  \n"
-        f"- model: `{sys_obj.get('model', '?')}`  \n"
-        f"- tools: {', '.join(sys_obj.get('tools', [])[:8])}"
-        + ("…" if len(sys_obj.get("tools", [])) > 8 else "")
-    )
-    print_readable(txt, border=False, theme=theme)
-
-
-def _pp_thinking(thought: str, theme) -> None:
-    text = f"""
-    🧠 Thinking:
-    {thought}
-    """
-    print_readable(text, border=True, theme=theme)
-
-
-def _pp_assistant_text(text: str, theme) -> None:
-    txt = f"""
-    > 🗣️ Claude:
-    {text}
-    """
-    print_readable(txt, theme=theme)
-
-
-def _pp_tool_use(tu: dict[str, Any], theme) -> None:
-    preview = shorten(str(tu["input"]).replace("\n", " "), 130)
-    body = f"- 🔧 Tool Use — {tu['name']}({tu['id']}) - input: {preview}"
-    print_readable(body, border=False, panel=False, theme=theme)
-
-
-def _pp_tool_result(tr: dict[str, Any], theme) -> None:
-    body_preview = shorten(str(tr["content"]).replace("\n", " "), 130)
-    status = "ERR" if tr.get("is_error") else "OK"
-    body = f"- 📄 Tool Result({tr['tool_use_id']}) - {status}\n\n\tcontent: {body_preview}"
-    print_readable(body, border=False, panel=False, theme=theme)
-
-
-def _pp_final(sess: ClaudeSession, theme) -> None:
-    usage = sess.usage or {}
-    txt = (
-        f"### ✅ Session complete - {datetime.utcnow().isoformat(timespec='seconds')} UTC\n"
-        f"**Result:**\n\n{sess.result or ''}\n\n"
-        f"- cost: **${sess.total_cost_usd:.4f}**  \n"
-        f"- turns: **{sess.num_turns}**  \n"
-        f"- duration: **{sess.duration_ms} ms** (API {sess.duration_api_ms} ms)  \n"
-        f"- tokens in/out: {usage.get('input_tokens', 0)}/{usage.get('output_tokens', 0)}"
-    )
-    print_readable(txt, theme=theme)
-
-
-# --------------------------------------------------------------------------- internal utils
-
-
-async def _maybe_await(func, *args, **kw):
-    """Call func which may be sync or async."""
-    res = func(*args, **kw) if func else None
-    if asyncio.iscoroutine(res):
-        await res
-
-
-# --------------------------------------------------------------------------- main parser
-
-
-async def stream_claude_code_cli(  # noqa: C901  (complexity from branching is fine here)
-    request: ClaudeCodeRequest,
-    session: ClaudeSession = ClaudeSession(),
-    *,
-    on_system: Callable[[dict[str, Any]], None] | None = None,
-    on_thinking: Callable[[str], None] | None = None,
-    on_text: Callable[[str], None] | None = None,
-    on_tool_use: Callable[[dict[str, Any]], None] | None = None,
-    on_tool_result: Callable[[dict[str, Any]], None] | None = None,
-    on_final: Callable[[ClaudeSession], None] | None = None,
-) -> AsyncIterator[ClaudeChunk | dict | ClaudeSession]:
-    """
-    Consume the ND‑JSON stream produced by ndjson_from_cli()
-    and return a fully‑populated ClaudeSession.
-
-    If callbacks are omitted a default pretty‑print is emitted.
-    """
-    stream = ndjson_from_cli(request)
-    theme = request.cli_display_theme or "light"
-
-    async for obj in stream:
-        typ = obj.get("type", "unknown")
-        chunk = ClaudeChunk(raw=obj, type=typ)
-        session.chunks.append(chunk)
-
-        # ------------------------ SYSTEM -----------------------------------
-        if typ == "system":
-            data = obj
-            session.session_id = data.get("session_id", session.session_id)
-            session.model = data.get("model", session.model)
-            await _maybe_await(on_system, data)
-            if request.verbose_output and on_system is None:
-                _pp_system(data, theme)
-            yield data
-
-        # ------------------------ ASSISTANT --------------------------------
-        elif typ == "assistant":
-            msg = obj["message"]
-            session.messages.append(msg)
-
-            for blk in msg.get("content", []):
-                btype = blk.get("type")
-                if btype == "thinking":
-                    thought = blk.get("thinking", "").strip()
-                    chunk.thinking = thought
-                    session.thinking_log.append(thought)
-                    await _maybe_await(on_thinking, thought)
-                    if request.verbose_output and on_thinking is None:
-                        _pp_thinking(thought, theme)
-
-                elif btype == "text":
-                    text = blk.get("text", "")
-                    chunk.text = text
-                    await _maybe_await(on_text, text)
-                    if request.verbose_output and on_text is None:
-                        _pp_assistant_text(text, theme)
-
-                elif btype == "tool_use":
-                    tu = {
-                        "id": blk["id"],
-                        "name": blk["name"],
-                        "input": blk["input"],
-                    }
-                    chunk.tool_use = tu
-                    session.tool_uses.append(tu)
-                    await _maybe_await(on_tool_use, tu)
-                    if request.verbose_output and on_tool_use is None:
-                        _pp_tool_use(tu, theme)
-
-                elif btype == "tool_result":
-                    tr = {
-                        "tool_use_id": blk["tool_use_id"],
-                        "content": blk["content"],
-                        "is_error": blk.get("is_error", False),
-                    }
-                    chunk.tool_result = tr
-                    session.tool_results.append(tr)
-                    await _maybe_await(on_tool_result, tr)
-                    if request.verbose_output and on_tool_result is None:
-                        _pp_tool_result(tr, theme)
-            yield chunk
-
-        # ------------------------ USER (tool_result containers) ------------
-        elif typ == "user":
-            msg = obj["message"]
-            session.messages.append(msg)
-            for blk in msg.get("content", []):
-                if blk.get("type") == "tool_result":
-                    tr = {
-                        "tool_use_id": blk["tool_use_id"],
-                        "content": blk["content"],
-                        "is_error": blk.get("is_error", False),
-                    }
-                    chunk.tool_result = tr
-                    session.tool_results.append(tr)
-                    await _maybe_await(on_tool_result, tr)
-                    if request.verbose_output and on_tool_result is None:
-                        _pp_tool_result(tr, theme)
-            yield chunk
-
-        # ------------------------ RESULT -----------------------------------
-        elif typ == "result":
-            session.result = obj.get("result", "").strip()
-            session.usage = obj.get("usage", {})
-            session.total_cost_usd = obj.get("total_cost_usd")
-            session.num_turns = obj.get("num_turns")
-            session.duration_ms = obj.get("duration_ms")
-            session.duration_api_ms = obj.get("duration_api_ms")
-            session.is_error = obj.get("is_error", False)
-
-        # ------------------------ DONE -------------------------------------
-        elif typ == "done":
-            break
-
-    # final pretty print
-    await _maybe_await(on_final, session)
-    if request.verbose_output and on_final is None:
-        _pp_final(session, theme)
-
-    yield session
-
+from ._claude_code.models import ClaudeCodeRequest
+from ._claude_code.stream_cli import (
+    ClaudeChunk,
+    ClaudeSession,
+    log,
+    stream_claude_code_cli,
+)
 
 ENDPOINT_CONFIG = EndpointConfig(
     name="claude_code_cli",
@@ -363,13 +34,27 @@ class ClaudeCodeCLIEndpoint(Endpoint):
     def __init__(self, config: EndpointConfig = ENDPOINT_CONFIG, **kwargs):
         super().__init__(config=config, **kwargs)
 
+    @property
+    def claude_handlers(self):
+        handlers = {
+            "on_thinking": None,
+            "on_text": None,
+            "on_tool_use": None,
+            "on_tool_result": None,
+            "on_system": None,
+            "on_final": None,
+        }
+        return self.config.kwargs.get("claude_handlers", handlers)
+
     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}, {}
 
-    async def stream(self, request: dict | BaseModel, **kwargs):
+    async def stream(
+        self, request: dict | BaseModel, **kwargs
+    ) -> AsyncIterator[ClaudeChunk | dict | ClaudeSession]:
         payload, _ = self.create_payload(request, **kwargs)["request"]
         async for chunk in stream_claude_code_cli(payload):
             yield chunk
@@ -386,7 +71,9 @@ class ClaudeCodeCLIEndpoint(Endpoint):
         system: dict = None
 
         # 1. stream the Claude Code response
-        async for chunk in stream_claude_code_cli(request, session, **kwargs):
+        async for chunk in stream_claude_code_cli(
+            request, session, **self.claude_handlers, **kwargs
+        ):
             if isinstance(chunk, dict):
                 system = chunk
             responses.append(chunk)
@@ -395,6 +82,7 @@ class ClaudeCodeCLIEndpoint(Endpoint):
             responses[-1], ClaudeSession
         ):
             req2 = request.model_copy(deep=True)
+            req2.prompt = "Please provide a the final result message only"
             req2.max_turns = 1
             req2.continue_conversation = True
             if system:
@@ -407,4 +95,11 @@ class ClaudeCodeCLIEndpoint(Endpoint):
         log.info(
             f"Session {session.session_id} finished with {len(responses)} chunks"
         )
+        texts = []
+        for i in session.chunks:
+            if i.text is not None:
+                texts.append(i.text)
+
+        texts.append(session.result)
+        session.result = "\n".join(texts)
         return to_dict(session, recursive=True)

lionagi/service/types.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .connections.api_calling import APICalling
-from .connections.endpoint import Endpoint
+from .connections.endpoint import Endpoint, EndpointConfig
 from .imodel import iModel
 from .manager import iModelManager
 from .rate_limited_processor import RateLimitedAPIExecutor
@@ -12,6 +12,7 @@ from .token_calculator import TokenCalculator
 __all__ = (
     "APICalling",
     "Endpoint",
+    "EndpointConfig",
     "RateLimitedAPIExecutor",
     "TokenCalculator",
     "iModel",

lionagi/session/branch.py

@@ -917,9 +917,7 @@ class Branch(Element, Communicatable, Relational):
         actions: bool = False,
         reason: bool = False,
         action_kwargs: dict = None,
-        action_strategy: Literal[
-            "sequential", "concurrent", "batch"
-        ] = "concurrent",
+        action_strategy: Literal["sequential", "concurrent"] = "concurrent",
         verbose_action: bool = False,
         field_models: list[FieldModel] = None,
         exclude_fields: list | dict | None = None,
@@ -987,7 +985,7 @@ class Branch(Element, Communicatable, Relational):
                 If `True`, signals that the LLM should provide chain-of-thought or reasoning (where applicable).
             action_kwargs (dict | None, optional):
                 Additional parameters for the `branch.act()` call if tools are invoked.
-            action_strategy (Literal["sequential","concurrent","batch"], optional):
+            action_strategy (Literal["sequential","concurrent"], optional):
                 The strategy for invoking tools (default: "concurrent").
             verbose_action (bool, optional):
                 If `True`, logs detailed information about tool invocation.
@@ -1174,9 +1172,8 @@ class Branch(Element, Communicatable, Relational):
         self,
         action_request: list | ActionRequest | BaseModel | dict,
         *,
-        strategy: Literal["concurrent", "sequential", "batch"] = "concurrent",
+        strategy: Literal["concurrent", "sequential"] = "concurrent",
         verbose_action: bool = False,
-        batch_size: int = None,
         suppress_errors: bool = True,
         sanitize_input: bool = False,
         unique_input: bool = False,
@@ -1223,7 +1220,7 @@ class Branch(Element, Communicatable, Relational):
             retry_timeout (float|None):
                 Overall timeout for all attempts (None = no limit).
             max_concurrent (int|None):
-                Maximum concurrent tasks (if batching).
+                Maximum concurrent tasks.
             throttle_period (float|None):
                 Minimum spacing (in seconds) between requests.
             flatten (bool):
@@ -1239,11 +1236,6 @@ class Branch(Element, Communicatable, Relational):
             Any:
                 The result or results from the invoked tool(s).
         """
-        if batch_size and not strategy == "batch":
-            raise ValueError(
-                "Batch size is only applicable for 'batch' strategy."
-            )
-
         match strategy:
             case "concurrent":
                 return await self._concurrent_act(
@@ -1271,27 +1263,8 @@ class Branch(Element, Communicatable, Relational):
                     verbose_action=verbose_action,
                     suppress_errors=suppress_errors,
                 )
-            case "batch":
-                return await self._batch_act(
-                    action_request,
-                    verbose_action=verbose_action,
-                    batch_size=batch_size or 1,
-                    max_concurrent=max_concurrent,
-                    suppress_errors=suppress_errors,
-                    sanitize_input=sanitize_input,
-                    unique_input=unique_input,
-                    num_retries=num_retries,
-                    initial_delay=initial_delay,
-                    retry_delay=retry_delay,
-                    backoff_factor=backoff_factor,
-                    retry_default=retry_default,
-                    retry_timeout=retry_timeout,
-                    throttle_period=throttle_period,
-                    flatten=flatten,
-                    dropna=dropna,
-                    unique_output=unique_output,
-                    flatten_tuple_set=flatten_tuple_set,
-                )
+            case _:
+                raise
 
     async def _concurrent_act(
         self,
@@ -1322,19 +1295,6 @@ class Branch(Element, Communicatable, Relational):
             )
         return results
 
-    async def _batch_act(
-        self,
-        action_request: list[ActionRequest | BaseModel | dict],
-        batch_size: int = None,
-        **kwargs,
-    ) -> list:
-        result = []
-        async for i in bcall(
-            action_request, self._act, batch_size=batch_size, **kwargs
-        ):
-            result.extend(i)
-        return result
-
     async def translate(
         self,
         text: str,

lionagi/session/session.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import contextlib
 from collections.abc import Callable
 from typing import Any
 
@@ -46,7 +47,7 @@ class Session(Node, Communicatable, Relational):
         mail_manager (MailManager | None): Manages mail operations.
     """
 
-    branches: Pile[Any] = Field(
+    branches: Pile[Branch] = Field(
         default_factory=lambda: Pile(item_type={Branch}, strict_type=False)
     )
     default_branch: Any = Field(default=None, exclude=True)
@@ -57,21 +58,38 @@ class Session(Node, Communicatable, Relational):
     name: str = Field(default="Session")
 
     @model_validator(mode="after")
-    def _initialize_default_branch(self) -> Self:
+    def _add_mail_sources(self) -> Self:
         if self.default_branch is None:
-            from .branch import Branch
-
             self.default_branch = Branch()
-        return self
-
-    @model_validator(mode="after")
-    def _add_mail_sources(self) -> Self:
         if self.default_branch not in self.branches:
             self.branches.include(self.default_branch)
         if self.branches:
             self.mail_manager.add_sources(self.branches)
         return self
 
+    def _lookup_branch_by_name(self, name: str) -> Branch | None:
+        for branch in self.branches:
+            if branch.name == name:
+                return branch
+        return None
+
+    def get_branch(
+        self, branch: ID.Ref | str, default: Any = ..., /
+    ) -> Branch:
+        """Get a branch by its ID or name."""
+
+        with contextlib.suppress(ItemNotFoundError, ValueError):
+            id = ID.get_id(branch)
+            return self.branches[id]
+
+        if isinstance(branch, str):
+            if b := self._lookup_branch_by_name(branch):
+                return b
+
+        if default is ...:
+            raise ItemNotFoundError(f"Branch '{branch}' not found.")
+        return default
+
     def new_branch(
         self,
         system: System | JsonValue = None,

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.14.5"
+__version__ = "0.14.7"

{lionagi-0.14.5.dist-info → lionagi-0.14.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.14.5
+Version: 0.14.7
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>, Liangbingyan Luo <llby_luo@outlook.com>
 License:            Apache License
@@ -234,9 +234,9 @@ Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: toml>=0.9.0
 Provides-Extra: all
 Requires-Dist: aiosqlite>=0.21.0; extra == 'all'
-Requires-Dist: claude-code-sdk>=0.0.14; extra == 'all'
+Requires-Dist: claude-code-sdk>=0.0.15; extra == 'all'
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'all'
-Requires-Dist: docling>=2.15.1; extra == 'all'
+Requires-Dist: docling>=2.15.0; extra == 'all'
 Requires-Dist: fastmcp>=2.10.5; extra == 'all'
 Requires-Dist: matplotlib>=3.7.0; extra == 'all'
 Requires-Dist: networkx>=3.0.0; extra == 'all'
@@ -244,36 +244,26 @@ Requires-Dist: ollama>=0.4.0; extra == 'all'
 Requires-Dist: pydapter[postgres]; extra == 'all'
 Requires-Dist: rich>=13.0.0; extra == 'all'
 Provides-Extra: claude-code
-Requires-Dist: claude-code-sdk>=0.0.14; extra == 'claude-code'
-Provides-Extra: docs
-Requires-Dist: furo>=2024.8.6; extra == 'docs'
-Requires-Dist: sphinx-autobuild>=2024.10.3; extra == 'docs'
-Requires-Dist: sphinx>=8.1.3; extra == 'docs'
+Requires-Dist: claude-code-sdk>=0.0.15; extra == 'claude-code'
 Provides-Extra: graph
 Requires-Dist: matplotlib>=3.7.0; extra == 'graph'
 Requires-Dist: networkx>=3.0.0; extra == 'graph'
-Provides-Extra: lint
-Requires-Dist: black[jupyter]>=24.10.0; extra == 'lint'
-Requires-Dist: isort>=5.13.2; extra == 'lint'
-Requires-Dist: pre-commit>=4.0.1; extra == 'lint'
 Provides-Extra: mcp
 Requires-Dist: fastmcp>=2.10.5; extra == 'mcp'
 Provides-Extra: ollama
 Requires-Dist: ollama>=0.4.0; extra == 'ollama'
 Provides-Extra: postgres
-Requires-Dist: aiosqlite>=0.21.0; extra == 'postgres'
 Requires-Dist: pydapter[postgres]; extra == 'postgres'
 Provides-Extra: reader
-Requires-Dist: docling>=2.15.1; extra == 'reader'
+Requires-Dist: docling>=2.15.0; extra == 'reader'
 Provides-Extra: rich
 Requires-Dist: rich>=13.0.0; extra == 'rich'
 Provides-Extra: schema
 Requires-Dist: datamodel-code-generator>=0.31.2; extra == 'schema'
-Provides-Extra: test
-Requires-Dist: pytest-asyncio>=1.0.0; extra == 'test'
-Requires-Dist: pytest>=8.3.4; extra == 'test'
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.21.0; extra == 'sqlite'
 Provides-Extra: tools
-Requires-Dist: docling>=2.15.1; extra == 'tools'
+Requires-Dist: docling>=2.15.0; extra == 'tools'
 Description-Content-Type: text/markdown
 
 ![PyPI - Version](https://img.shields.io/pypi/v/lionagi?labelColor=233476aa&color=231fc935)
@@ -416,7 +406,7 @@ 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:
+LionAGI now supports Anthropic's [Claude Code Python SDK](https://github.com/anthropics/claude-code-sdk-python), enabling autonomous coding capabilities with persistent session management:
 
 ```python
 from lionagi import iModel, Branch