lionagi 0.12.2__py3-none-any.whl → 0.12.4__py3-none-any.whl

lionagi/service/third_party/pplx_models.py

@@ -0,0 +1,156 @@
+from enum import Enum
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class PerplexityModels(str, Enum):
+    """
+    Models available in Perplexity's API.
+
+    sonar: Lightweight, cost-effective search model designed for quick, grounded
+        answers
+    sonar-pro: Advanced search model optimized for complex queries and deeper content
+        understanding.
+    sonar-reasoning: Quick problem-solving and reasoning model, ideal for evaluating
+        complex queries.
+    sonar-deep-research: Best suited for exhaustive research, generating detailed
+        reports and in-depth insights.
+    """
+
+    SONAR = "sonar"
+    SONAR_PRO = "sonar-pro"
+    SONAR_REASONING = "sonar-reasoning"
+    SONAR_DEEP_RESEARCH = "sonar-deep-research"
+
+
+class PerplexityMessage(BaseModel):
+    """A single message in the conversation."""
+
+    role: Literal["system", "user", "assistant"] = Field(
+        ...,
+        description="The role of the speaker. Must be system, user, or assistant.",
+    )
+    content: str = Field(
+        ...,
+        description="The contents of the message in this turn of conversation",
+    )
+
+
+class WebSearchOptions(BaseModel):
+    search_context_size: Literal["low", "medium", "high"] = Field(
+        default="low",
+        description="Determines how much search context is retrieved for the model. "
+        "Options are: low (minimizes context for cost savings but less comprehensive "
+        "answers), medium (balanced approach suitable for most queries), and high "
+        "(maximizes context for comprehensive answers but at higher cost).",
+    )
+
+
+class PerplexityChatRequest(BaseModel):
+    """
+    Represents the request body for Perplexity's Chat Completions endpoint.
+    Endpoint: POST https://api.perplexity.ai/chat/completions
+    """
+
+    model: PerplexityModels = Field(
+        PerplexityModels.SONAR,
+        description="The model name, e.g. 'sonar', (the only model available at the "
+        "time when this request model was updated, check doc for latest info).",
+    )
+    messages: list[PerplexityMessage] = Field(
+        ..., description="A list of messages forming the conversation so far."
+    )
+
+    # Optional parameters
+    frequency_penalty: float | None = Field(
+        default=1,
+        ge=0,
+        le=2.0,
+        description=(
+            "Decreases likelihood of repetition based on prior frequency. Applies a "
+            "penalty to tokens based on how frequently they've appeared in the text "
+            "so far. Values typically range from 0 (no penalty) to 2.0 (strong "
+            "penalty). Higher values (e.g., 1.5) reduce repetition of the same words"
+            " and phrases. Useful for preventing the model from getting stuck in loops"
+        ),
+    )
+    presence_penalty: float | None = Field(
+        default=None,
+        ge=0,
+        le=2.0,
+        description=(
+            "Positive values increase the likelihood of discussing new topics. Applies "
+            "a penalty to tokens that have already appeared in the text, encouraging "
+            "the model to talk about new concepts. Values typically range from 0 (no"
+            " penalty) to 2.0 (strong penalty). Higher values reduce repetition but "
+            "may lead to more off-topic text."
+        ),
+    )
+    max_tokens: int | None = Field(
+        default=None,
+        description=(
+            "The maximum number of completion tokens returned by the API. Controls the "
+            "length of the model's response. If the response would exceed this limit, "
+            "it will be truncated. "
+        ),
+    )
+    return_related_questions: bool | None = Field(
+        default=False,
+        description="Determines whether related questions should be returned.",
+    )
+    search_domain_filter: list[Any] | None = Field(
+        default=None,
+        description="A list of domains to limit search results to. Currently limited "
+        "to 10 domains for Allowlisting and Denylisting. For Denylisting, add a - at "
+        "the beginning of the domain string. for more info, "
+        "see: https://docs.perplexity.ai/guides/search-domain-filters",
+        examples=[
+            "nasa.gov",
+            "wikipedia.org",
+            "-example.com",
+            "-facebook.com",
+        ],
+    )
+    search_recency_filter: str | None = Field(
+        default=None,
+        description=(
+            "Returns search results within a specified time interval: 'month', 'week', "
+            "'day', or 'hour'."
+        ),
+    )
+    temperature: float | None = Field(
+        default=None,
+        ge=0.0,
+        lt=2.0,
+        description=(
+            "The amount of randomness in the response, valued between 0 and 2. Lower "
+            "values (e.g., 0.1) make the output more focused, deterministic, and less "
+            "creative. Higher values (e.g., 1.5) make the output more random and "
+            "creative. Use lower values for factual/information retrieval tasks and "
+            "higher values for creative applications."
+        ),
+    )
+    top_k: int | None = Field(
+        default=None,
+        ge=0,
+        le=2048,
+        description=(
+            "Top-K filtering. 0 disables top-k filtering. If set, only the top K "
+            "tokens are considered. We recommend altering either top_k or top_p, "
+            "but not both."
+        ),
+    )
+    top_p: float | None = Field(
+        default=None,
+        ge=0.0,
+        le=1.0,
+        description=(
+            "The nucleus sampling threshold, valued between 0 and 1. Controls the "
+            "diversity of generated text by considering only the tokens whose "
+            "cumulative probability exceeds the top_p value. Lower values (e.g., 0.5) "
+            "make the output more focused and deterministic, while higher values "
+            "(e.g., 0.95) allow for more diverse outputs. Often used as an alternative"
+            " to temperature."
+        ),
+    )

lionagi/service/types.py

@@ -2,15 +2,16 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from .endpoints.base import APICalling, EndPoint
-from .endpoints.rate_limited_processor import RateLimitedAPIExecutor
-from .endpoints.token_calculator import TokenCalculator
+from .connections.api_calling import APICalling
+from .connections.endpoint import Endpoint
 from .imodel import iModel
 from .manager import iModelManager
+from .rate_limited_processor import RateLimitedAPIExecutor
+from .token_calculator import TokenCalculator
 
 __all__ = (
     "APICalling",
-    "EndPoint",
+    "Endpoint",
     "RateLimitedAPIExecutor",
     "TokenCalculator",
     "iModel",

lionagi/session/branch.py

@@ -10,6 +10,7 @@ import pandas as pd
 from jinja2 import Template
 from pydantic import BaseModel, Field, JsonValue, PrivateAttr
 
+from lionagi.config import settings
 from lionagi.fields import Instruct
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.models.field_model import FieldModel
@@ -42,7 +43,7 @@ from lionagi.protocols.types import (
     SenderRecipient,
     System,
 )
-from lionagi.service.endpoints.base import EndPoint
+from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.types import iModel, iModelManager
 from lionagi.settings import Settings
 from lionagi.tools.base import LionTool
@@ -200,9 +201,15 @@ class Branch(Element, Communicatable, Relational):
 
         chat_model = chat_model or imodel
         if not chat_model:
-            chat_model = iModel(**Settings.iModel.CHAT)
+            chat_model = iModel(
+                provider=settings.LIONAGI_CHAT_PROVIDER,
+                model=settings.LIONAGI_CHAT_MODEL,
+            )
         if not parse_model:
-            parse_model = iModel(**Settings.iModel.PARSE)
+            parse_model = iModel(
+                provider=settings.LIONAGI_CHAT_PROVIDER,
+                model="gpt-4o-mini",  # Default parse model
+            )
 
         if isinstance(chat_model, dict):
             chat_model = iModel.from_dict(chat_model)
@@ -571,7 +578,7 @@ class Branch(Element, Communicatable, Relational):
         self,
         provider: str = None,
         base_url: str = None,
-        endpoint: str | EndPoint = "chat",
+        endpoint: str | Endpoint = "chat",
         endpoint_params: list[str] | None = None,
         api_key: str = None,
         queue_capacity: int = 100,
@@ -799,9 +806,7 @@ class Branch(Element, Communicatable, Relational):
             request_fields=request_fields,
             response_format=response_format,
             progression=progression,
-            chat_model=kwargs.pop("chat_model", None)
-            or imodel
-            or self.chat_model,
+            imodel=imodel or kwargs.pop("chat_model", None) or self.chat_model,
             tool_schemas=tool_schemas,
             images=images,
             image_detail=image_detail,

lionagi/tools/file/reader.py

@@ -8,7 +8,7 @@ from enum import Enum
 from pydantic import BaseModel, Field, model_validator
 
 from lionagi.protocols.action.tool import Tool
-from lionagi.service.endpoints.token_calculator import TokenCalculator
+from lionagi.service.token_calculator import TokenCalculator
 from lionagi.utils import to_num
 
 from ..base import LionTool