lionagi 0.14.8__py3-none-any.whl → 0.14.9__py3-none-any.whl

lionagi/service/connections/providers/claude_code_cli.py

@@ -4,48 +4,78 @@
 
 from __future__ import annotations
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 
 from pydantic import BaseModel
 
 from lionagi.service.connections.endpoint import Endpoint, EndpointConfig
 from lionagi.utils import to_dict
 
-from ._claude_code.models import ClaudeCodeRequest
-from ._claude_code.stream_cli import (
+from ...third_party.claude_code import (
     ClaudeChunk,
+    ClaudeCodeRequest,
     ClaudeSession,
-    log,
+)
+from ...third_party.claude_code import log as cc_log
+from ...third_party.claude_code import (
     stream_claude_code_cli,
 )
 
-ENDPOINT_CONFIG = EndpointConfig(
+_get_config = lambda: EndpointConfig(
     name="claude_code_cli",
     provider="claude_code",
     base_url="internal",
     endpoint="query_cli",
-    api_key="dummy",
+    api_key="dummy-key",
     request_options=ClaudeCodeRequest,
     timeout=18000,  # 30 mins
 )
 
+ENDPOINT_CONFIG = _get_config()  # backward compatibility
+
+
+_CLAUDE_HANDLER_PARAMS = (
+    "on_thinking",
+    "on_text",
+    "on_tool_use",
+    "on_tool_result",
+    "on_system",
+    "on_final",
+)
+
+
+def _validate_handlers(handlers: dict[str, Callable | None], /) -> None:
+    if not isinstance(handlers, dict):
+        raise ValueError("Handlers must be a dictionary")
+    for k, v in handlers.items():
+        if k not in _CLAUDE_HANDLER_PARAMS:
+            raise ValueError(f"Invalid handler key: {k}")
+        if not (v is None or callable(v)):
+            raise ValueError(
+                f"Handler value must be callable or None, got {type(v)}"
+            )
+
 
 class ClaudeCodeCLIEndpoint(Endpoint):
-    def __init__(self, config: EndpointConfig = ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config: EndpointConfig = None, **kwargs):
+        config = config or _get_config()
         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,
-        }
+        handlers = {k: None for k in _CLAUDE_HANDLER_PARAMS}
         return self.config.kwargs.get("claude_handlers", handlers)
 
+    @claude_handlers.setter
+    def claude_handlers(self, value: dict):
+        _validate_handlers(value)
+        self.config.kwargs["claude_handlers"] = value
+
+    def update_handlers(self, **kwargs):
+        _validate_handlers(kwargs)
+        handlers = {**self.claude_handlers, **kwargs}
+        self.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")
@@ -75,6 +105,8 @@ class ClaudeCodeCLIEndpoint(Endpoint):
             request, session, **self.claude_handlers, **kwargs
         ):
             if isinstance(chunk, dict):
+                if chunk.get("type") == "done":
+                    break
                 system = chunk
             responses.append(chunk)
 
@@ -92,7 +124,7 @@ class ClaudeCodeCLIEndpoint(Endpoint):
                 responses.append(chunk)
                 if isinstance(chunk, ClaudeSession):
                     break
-        log.info(
+        cc_log.info(
             f"Session {session.session_id} finished with {len(responses)} chunks"
         )
         texts = []
@@ -102,4 +134,7 @@ class ClaudeCodeCLIEndpoint(Endpoint):
 
         texts.append(session.result)
         session.result = "\n".join(texts)
+        if request.cli_include_summary:
+            session.populate_summary()
+
         return to_dict(session, recursive=True)

lionagi/service/connections/providers/exa_.py

@@ -11,8 +11,7 @@ from lionagi.service.third_party.exa_models import ExaSearchRequest
 
 __all__ = ("ExaSearchEndpoint",)
 
-
-ENDPOINT_CONFIG = EndpointConfig(
+_get_config = lambda: EndpointConfig(
     name="exa_search",
     provider="exa",
     base_url="https://api.exa.ai",
@@ -27,7 +26,10 @@ ENDPOINT_CONFIG = EndpointConfig(
     content_type="application/json",
 )
 
+ENDPOINT_CONFIG = _get_config()  # backward compatibility
+
 
 class ExaSearchEndpoint(Endpoint):
-    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config: EndpointConfig = None, **kwargs):
+        config = config or _get_config()
         super().__init__(config=config, **kwargs)

lionagi/service/connections/providers/oai_.py

@@ -2,107 +2,126 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""
+OpenAI and OpenAI-compatible endpoint configurations.
+
+This module provides endpoint configurations for:
+- OpenAI (chat, response, embedding)
+- OpenRouter (OpenAI-compatible)
+- Groq (OpenAI-compatible)
+
+Each provider has a helper function (_get_*_config) that creates
+configurations with sensible defaults that can be overridden.
+"""
+
 from pydantic import BaseModel
 
 from lionagi.config import settings
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.service.third_party.openai_models import (
-    CreateChatCompletionRequest,
-    CreateResponse,
+from lionagi.service.third_party.openai_model_names import (
+    REASONING_MODELS,
+    is_reasoning_model,
 )
 
 __all__ = (
     "OpenaiChatEndpoint",
     "OpenaiResponseEndpoint",
+    "OpenaiEmbedEndpoint",
     "OpenrouterChatEndpoint",
+    "GroqChatEndpoint",
+    "OPENAI_CHAT_ENDPOINT_CONFIG",
+    "OPENAI_RESPONSE_ENDPOINT_CONFIG",
+    "OPENAI_EMBEDDING_ENDPOINT_CONFIG",
+    "OPENROUTER_CHAT_ENDPOINT_CONFIG",
     "OPENROUTER_GEMINI_ENDPOINT_CONFIG",
+    "GROQ_CHAT_ENDPOINT_CONFIG",
+    "REASONING_MODELS",
+    "REASONING_NOT_SUPPORT_PARAMS",
 )
 
 
-OPENAI_CHAT_ENDPOINT_CONFIG = EndpointConfig(
-    name="openai_chat",
-    provider="openai",
-    base_url="https://api.openai.com/v1",
-    endpoint="chat/completions",
-    kwargs={"model": "gpt-4.1-nano"},
-    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
-    requires_tokens=True,
-    request_options=CreateChatCompletionRequest,
-)
-
-OPENAI_RESPONSE_ENDPOINT_CONFIG = EndpointConfig(
+def _get_openai_config(**kwargs):
+    """Create OpenAI endpoint configuration with defaults."""
+    config = dict(
+        name="openai_chat",
+        provider="openai",
+        base_url="https://api.openai.com/v1",
+        endpoint="chat/completions",
+        kwargs={"model": settings.OPENAI_DEFAULT_MODEL},
+        api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
+        auth_type="bearer",
+        content_type="application/json",
+        method="POST",
+        requires_tokens=True,
+        # NOTE: OpenAI models have incorrect role literals, only use for param validation
+        # request_options=CreateChatCompletionRequest,
+    )
+    config.update(kwargs)
+    return EndpointConfig(**config)
+
+
+def _get_openrouter_config(**kwargs):
+    """Create OpenRouter endpoint configuration with defaults."""
+    config = dict(
+        name="openrouter_chat",
+        provider="openrouter",
+        base_url="https://openrouter.ai/api/v1",
+        endpoint="chat/completions",
+        kwargs={"model": "google/gemini-2.5-flash"},
+        api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
+        auth_type="bearer",
+        content_type="application/json",
+        method="POST",
+        # NOTE: OpenRouter uses OpenAI-compatible format
+        # request_options=CreateChatCompletionRequest,
+    )
+    config.update(kwargs)
+    return EndpointConfig(**config)
+
+
+def _get_groq_config(**kwargs):
+    """Create Groq endpoint configuration with defaults."""
+    config = dict(
+        name="groq_chat",
+        provider="groq",
+        base_url="https://api.groq.com/openai/v1",
+        endpoint="chat/completions",
+        kwargs={"model": "llama-3.3-70b-versatile"},
+        api_key=settings.GROQ_API_KEY or "dummy-key-for-testing",
+        auth_type="bearer",
+        content_type="application/json",
+        method="POST",
+    )
+    config.update(kwargs)
+    return EndpointConfig(**config)
+
+
+# OpenAI endpoints
+OPENAI_CHAT_ENDPOINT_CONFIG = _get_openai_config()
+
+OPENAI_RESPONSE_ENDPOINT_CONFIG = _get_openai_config(
     name="openai_response",
-    provider="openai",
-    base_url="https://api.openai.com/v1",
-    endpoint="chat/completions",  # OpenAI responses API uses same endpoint
-    kwargs={"model": "gpt-4o"},
-    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
-    requires_tokens=True,
-    request_options=CreateResponse,
-)
-
-OPENROUTER_CHAT_ENDPOINT_CONFIG = EndpointConfig(
-    name="openrouter_chat",
-    provider="openrouter",
-    base_url="https://openrouter.ai/api/v1",
-    endpoint="chat/completions",
-    kwargs={"model": "google/gemini-2.5-flash"},
-    api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
-    request_options=CreateChatCompletionRequest,
+    endpoint="responses",
 )
 
-OPENAI_EMBEDDING_ENDPOINT_CONFIG = EndpointConfig(
+OPENAI_EMBEDDING_ENDPOINT_CONFIG = _get_openai_config(
     name="openai_embed",
-    provider="openai",
-    base_url="https://api.openai.com/v1",
     endpoint="embeddings",
     kwargs={"model": "text-embedding-3-small"},
-    api_key=settings.OPENAI_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
-)
-
-GROQ_CHAT_ENDPOINT_CONFIG = EndpointConfig(
-    name="groq_chat",
-    provider="groq",
-    base_url="https://api.groq.com/openai/v1",
-    endpoint="chat/completions",
-    api_key=settings.GROQ_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
 )
 
+# OpenRouter endpoints
+OPENROUTER_CHAT_ENDPOINT_CONFIG = _get_openrouter_config()
 
-REASONING_MODELS = (
-    "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",
+OPENROUTER_GEMINI_ENDPOINT_CONFIG = _get_openrouter_config(
+    name="openrouter_gemini",
+    kwargs={"model": "google/gemini-2.5-flash"},
 )
 
+# Groq endpoints
+GROQ_CHAT_ENDPOINT_CONFIG = _get_groq_config()
+
 REASONING_NOT_SUPPORT_PARAMS = (
     "temperature",
     "top_p",
@@ -113,7 +132,8 @@ REASONING_NOT_SUPPORT_PARAMS = (
 
 
 class OpenaiChatEndpoint(Endpoint):
-    def __init__(self, config=OPENAI_CHAT_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_openai_config()
         super().__init__(config, **kwargs)
 
     def create_payload(
@@ -129,7 +149,11 @@ class OpenaiChatEndpoint(Endpoint):
 
         # Handle reasoning models
         model = payload.get("model")
-        if model in REASONING_MODELS:
+        if (
+            model
+            and is_reasoning_model(model)
+            and not model.startswith("gpt-5")
+        ):
             # Remove unsupported parameters for reasoning models
             for param in REASONING_NOT_SUPPORT_PARAMS:
                 payload.pop(param, None)
@@ -146,20 +170,31 @@ class OpenaiChatEndpoint(Endpoint):
 
 
 class OpenaiResponseEndpoint(Endpoint):
-    def __init__(self, config=OPENAI_RESPONSE_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_openai_config(
+            name="openai_response",
+            endpoint="responses",
+        )
         super().__init__(config, **kwargs)
 
 
 class OpenrouterChatEndpoint(Endpoint):
-    def __init__(self, config=OPENROUTER_CHAT_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_openrouter_config()
         super().__init__(config, **kwargs)
 
 
 class GroqChatEndpoint(Endpoint):
-    def __init__(self, config=GROQ_CHAT_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_groq_config()
         super().__init__(config, **kwargs)
 
 
 class OpenaiEmbedEndpoint(Endpoint):
-    def __init__(self, config=OPENAI_EMBEDDING_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_openai_config(
+            name="openai_embed",
+            endpoint="embeddings",
+            kwargs={"model": "text-embedding-3-small"},
+        )
         super().__init__(config, **kwargs)

lionagi/service/connections/providers/ollama_.py

@@ -2,31 +2,50 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""
+Ollama endpoint configuration.
+
+Ollama provides local model hosting with both native and OpenAI-compatible APIs.
+This module configures the OpenAI-compatible endpoint for consistency.
+"""
+
 from pydantic import BaseModel
 
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.service.third_party.openai_models import (
-    CreateChatCompletionRequest,
-)
 from lionagi.utils import is_import_installed
 
+__all__ = (
+    "OllamaChatEndpoint",
+    "OLLAMA_CHAT_ENDPOINT_CONFIG",
+)
+
 _HAS_OLLAMA = is_import_installed("ollama")
 
-OLLAMA_CHAT_ENDPOINT_CONFIG = EndpointConfig(
-    name="ollama_chat",
-    provider="ollama",
-    base_url="http://localhost:11434/v1",  # Ollama desktop client default
-    endpoint="chat/completions",  # Use full OpenAI-compatible endpoint
-    kwargs={},  # Empty kwargs, model will be provided at runtime
-    openai_compatible=False,  # Use HTTP transport
-    api_key=None,  # No API key needed
-    method="POST",
-    content_type="application/json",
-    auth_type="none",  # No authentication
-    default_headers={},  # No auth headers needed
-    request_options=CreateChatCompletionRequest,  # Use Pydantic model for validation
-)
+
+def _get_ollama_config(**kwargs):
+    """Create Ollama endpoint configuration with defaults."""
+    config = dict(
+        name="ollama_chat",
+        provider="ollama",
+        base_url="http://localhost:11434/v1",  # OpenAI-compatible endpoint
+        endpoint="chat/completions",
+        kwargs={},  # Model will be provided at runtime
+        openai_compatible=False,  # Use HTTP transport
+        api_key=None,  # No API key needed
+        method="POST",
+        content_type="application/json",
+        auth_type="none",  # No authentication
+        default_headers={},  # No auth headers needed
+        # NOTE: Not using request_options due to OpenAI model role literal issues
+        # request_options=CreateChatCompletionRequest,
+    )
+    config.update(kwargs)
+    return EndpointConfig(**config)
+
+
+# Default OpenAI-compatible configuration
+OLLAMA_CHAT_ENDPOINT_CONFIG = _get_ollama_config()
 
 
 class OllamaChatEndpoint(Endpoint):
@@ -34,7 +53,7 @@ class OllamaChatEndpoint(Endpoint):
     Documentation: https://platform.openai.com/docs/api-reference/chat/create
     """
 
-    def __init__(self, config=OLLAMA_CHAT_ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
         if not _HAS_OLLAMA:
             raise ModuleNotFoundError(
                 "ollama is not installed, please install it with `pip install lionagi[ollama]`"
@@ -44,6 +63,7 @@ class OllamaChatEndpoint(Endpoint):
         if "api_key" in kwargs:
             kwargs.pop("api_key")
 
+        config = config or _get_ollama_config()
         super().__init__(config, **kwargs)
 
         from ollama import list as ollama_list  # type: ignore[import]

lionagi/service/connections/providers/perplexity_.py

@@ -2,28 +2,50 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+"""
+Perplexity AI endpoint configuration.
+
+Perplexity provides real-time web search and Q&A capabilities through their Sonar API.
+This module configures endpoints for different Sonar model tiers.
+"""
+
 from lionagi.config import settings
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
 from lionagi.service.third_party.pplx_models import PerplexityChatRequest
 
-__all__ = ("PerplexityChatEndpoint",)
+__all__ = (
+    "PerplexityChatEndpoint",
+    "PERPLEXITY_CHAT_ENDPOINT_CONFIG",
+)
 
 
-ENDPOINT_CONFIG = EndpointConfig(
-    name="perplexity_chat",
-    provider="perplexity",
-    base_url="https://api.perplexity.ai",
-    endpoint="chat/completions",
-    method="POST",
-    kwargs={"model": "sonar"},
-    api_key=settings.PERPLEXITY_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    request_options=PerplexityChatRequest,
-)
+def _get_perplexity_config(**kwargs):
+    """Create Perplexity endpoint configuration with defaults."""
+    config = dict(
+        name="perplexity_chat",
+        provider="perplexity",
+        base_url="https://api.perplexity.ai",
+        endpoint="chat/completions",
+        method="POST",
+        kwargs={"model": "sonar"},  # Default to base sonar model
+        api_key=settings.PERPLEXITY_API_KEY or "dummy-key-for-testing",
+        auth_type="bearer",
+        content_type="application/json",
+        request_options=PerplexityChatRequest,
+    )
+    config.update(kwargs)
+    return EndpointConfig(**config)
+
+
+# Default configuration (users can specify model at runtime)
+PERPLEXITY_CHAT_ENDPOINT_CONFIG = _get_perplexity_config()
+
+# Legacy naming for backward compatibility
+ENDPOINT_CONFIG = PERPLEXITY_CHAT_ENDPOINT_CONFIG
 
 
 class PerplexityChatEndpoint(Endpoint):
-    def __init__(self, config=ENDPOINT_CONFIG, **kwargs):
+    def __init__(self, config=None, **kwargs):
+        config = config or _get_perplexity_config()
         super().__init__(config, **kwargs)

lionagi/service/connections/providers/types.py

@@ -0,0 +1,30 @@
+from .anthropic_ import AnthropicMessagesEndpoint
+from .claude_code_ import ClaudeCodeEndpoint, ClaudeCodeRequest
+from .claude_code_cli import ClaudeCodeCLIEndpoint
+from .exa_ import ExaSearchEndpoint, ExaSearchRequest
+from .oai_ import (
+    GroqChatEndpoint,
+    OpenaiChatEndpoint,
+    OpenaiEmbedEndpoint,
+    OpenaiResponseEndpoint,
+    OpenrouterChatEndpoint,
+)
+from .ollama_ import OllamaChatEndpoint
+from .perplexity_ import PerplexityChatEndpoint, PerplexityChatRequest
+
+__all__ = (
+    "AnthropicMessagesEndpoint",
+    "ClaudeCodeEndpoint",
+    "ClaudeCodeRequest",
+    "ClaudeCodeCLIEndpoint",
+    "ExaSearchEndpoint",
+    "ExaSearchRequest",
+    "OpenaiChatEndpoint",
+    "OpenaiEmbedEndpoint",
+    "OpenaiResponseEndpoint",
+    "OpenrouterChatEndpoint",
+    "GroqChatEndpoint",
+    "OllamaChatEndpoint",
+    "PerplexityChatEndpoint",
+    "PerplexityChatRequest",
+)

lionagi/service/hooks/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.protocols.types import DataLogger
+
+from ._types import AssosiatedEventInfo, HookDict, HookEventTypes
+from .hook_event import HookEvent
+from .hook_registry import HookRegistry
+
+global_hook_logger = DataLogger(
+    persist_dir="./data/logs",
+    subfolder="hooks",
+    file_prefix="hook",
+    capacity=1000,
+)
+
+
+__all__ = (
+    "HookEventTypes",
+    "HookDict",
+    "AssosiatedEventInfo",
+    "HookEvent",
+    "HookRegistry",
+    "global_hook_logger",
+)

lionagi/service/hooks/_types.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2025, HaiyangLi <quantocean.li at gmail dot com>
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+from typing_extensions import TypedDict
+
+from lionagi.utils import StringEnum
+
+SC = TypeVar("SC")  # streaming chunk type
+
+__all__ = (
+    "HookEventTypes",
+    "ALLOWED_HOOKS_TYPES",
+    "HookDict",
+    "StreamHandlers",
+    "AssosiatedEventInfo",
+)
+
+
+class HookEventTypes(StringEnum):
+    PreEventCreate = "pre_event_create"
+    PreInvokation = "pre_invokation"
+    PostInvokation = "post_invokation"
+
+
+ALLOWED_HOOKS_TYPES = HookEventTypes.allowed()
+
+
+class HookDict(TypedDict):
+    pre_event_create: Callable | None
+    pre_invokation: Callable | None
+    post_invokation: Callable | None
+
+
+StreamHandlers = dict[str, Callable[[SC], Awaitable[None]]]
+
+
+class AssosiatedEventInfo(TypedDict, total=False):
+    """Information about the event associated with the hook."""
+
+    lion_class: str
+    """Full qualified name of the event class."""
+
+    event_id: str
+    """ID of the event."""
+
+    event_created_at: float
+    """Creation timestamp of the event."""