lionagi 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/integrations/openai_/api_endpoints/chat_completions/request/message_models.py

@@ -0,0 +1,121 @@
+from typing import List, Literal, Optional, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from .types import Detail
+
+
+class TextContentPart(BaseModel):
+    type: Literal["text"] = Field(description="The type of the content part.")
+    text: str = Field(description="The text content.")
+
+
+class ImageURL(BaseModel):
+    url: str = Field(description="The URL of the image.")
+    detail: Detail = Field(
+        "auto", description="The detail level of the image."
+    )
+    model_config = ConfigDict(use_enum_values=True)
+
+
+class ImageContentPart(BaseModel):
+    type: Literal["image_url"] = Field(
+        description="The type of the content part."
+    )
+    image_url: ImageURL = Field(description="The image URL and detail level.")
+
+
+ContentPart: TypeAlias = TextContentPart | ImageContentPart
+
+
+class Function(BaseModel):
+    name: str = Field(description="The name of the function to call.")
+    arguments: str = Field(
+        description="The arguments to call the function with, as JSON."
+    )
+
+
+class ToolCall(BaseModel):
+    id: str = Field(description="The ID of the tool call.")
+    type: Literal["function"] = Field(
+        description="The type of the tool. Only 'function' is supported."
+    )
+    function: Function = Field(
+        description="The function that the model called."
+    )
+
+
+class SystemMessage(BaseModel):
+    role: Literal["system"]
+    content: str = Field(description="The content of the system message.")
+
+    name: str | None = Field(
+        None,
+        description="An optional name for the participant."
+        " Provides the model information "
+        "to differentiate between participants of the same role.",
+    )
+
+
+class UserMessage(BaseModel):
+    role: Literal["user"]
+    content: str | list[ContentPart] = Field(
+        description="The content of the user message"
+    )
+
+    name: str | None = Field(
+        None,
+        description="An optional name for the participant."
+        " Provides the model information "
+        "to differentiate between participants of the same role.",
+    )
+
+
+class AssistantMessage(BaseModel):
+    role: Literal["assistant"]
+    content: str | None = Field(
+        None,
+        description="The contents of the assistant message."
+        " Required unless tool_calls is specified.",
+    )
+
+    refusal: str | None = Field(
+        None, description="The refusal message by the assistant."
+    )
+
+    name: str | None = Field(
+        None,
+        description="An optional name for the participant."
+        " Provides the model information "
+        "to differentiate between participants of the same role.",
+    )
+
+    tool_calls: list[ToolCall] | None = Field(
+        None,
+        description="The tool calls generated by the model,"
+        " such as function calls.",
+    )
+
+    @model_validator(mode="after")
+    def validate_content(self):
+        if not self.content and not self.tool_calls:
+            raise ValueError(
+                "Assistant messages require content or tool_calls"
+            )
+        return self
+
+
+class ToolMessage(BaseModel):
+    role: Literal["tool"]
+    content: str | list = Field(
+        description="The contents of the tool message."
+    )
+
+    tool_calls_id: str = Field(
+        description="Tool call that this message is responding to."
+    )
+
+
+Message: TypeAlias = (
+    SystemMessage | UserMessage | AssistantMessage | ToolMessage
+)

lionagi/integrations/openai_/api_endpoints/chat_completions/request/request_body.py

@@ -0,0 +1,221 @@
+from typing import Dict, List, Optional
+
+from pydantic import Field, SerializeAsAny, model_validator
+
+from ...data_models import OpenAIEndpointRequestBody
+from .message_models import Message
+from .response_format import ResponseFormat
+from .stream_options import StreamOptions
+from .tool_choice_models import ToolChoice as ToolChoiceObj
+from .tool_models import Tool
+from .types import ServiceTier
+from .types import ToolChoice as ToolChoiceStr
+
+
+class OpenAIChatCompletionRequestBody(OpenAIEndpointRequestBody):
+    messages: SerializeAsAny[list[Message]] = Field(
+        description="A list of messages comprising the conversation so far."
+    )
+
+    model: str = Field(description="ID of the model to use.")
+
+    frequency_penalty: float | None = Field(
+        0,
+        ge=-2.0,
+        le=2.0,
+        description=(
+            "Number between -2.0 and 2.0. Positive values penalize new tokens "
+            "based on their existing frequency in the text so far, decreasing "
+            "the model's likelihood to repeat the same line verbatim."
+        ),
+    )
+
+    logit_bias: dict[str, float] | None = Field(
+        None,
+        description=(
+            "Modify the likelihood of specified tokens appearing in the "
+            "completion. Accepts a JSON object that maps tokens (specified by "
+            "their token ID in the tokenizer) to an associated "
+            "bias value from -100 to 100."
+        ),
+    )
+
+    logprobs: bool | None = Field(
+        False,
+        description=(
+            "Whether to return log probabilities of the output tokens or not. "
+            "If true, returns the log probabilities of each output token "
+            "returned in the content of message."
+        ),
+    )
+
+    top_logprobs: int | None = Field(
+        None,
+        ge=0,
+        le=20,
+        description=(
+            "An integer between 0 and 20 specifying the number of most likely "
+            "tokens to return at each token position, each with an associated "
+            "log probability. logprobs must be true if this parameter "
+            "is used."
+        ),
+    )
+
+    max_completion_tokens: int | None = Field(
+        None,
+        description=(
+            "The maximum number of tokens that can be generated in the chat "
+            "completion. The total length of input tokens and generated "
+            "tokens is limited by the model's context length."
+        ),
+    )
+
+    n: int | None = Field(
+        1,
+        ge=1,
+        description=(
+            "How many chat completion choices to generate for each input "
+            "message. Note that you will be charged based on the number of "
+            "generated tokens across all of the choices. Keep n as 1 to "
+            "minimize costs."
+        ),
+    )
+
+    presence_penalty: float | None = Field(
+        0,
+        ge=-2.0,
+        le=2.0,
+        description=(
+            "Number between -2.0 and 2.0. Positive values penalize new tokens "
+            "based on whether they appear in the text so far, increasing the "
+            "model's likelihood to talk about new topics."
+        ),
+    )
+
+    response_format: ResponseFormat | None = Field(
+        None,
+        description=(
+            "An object specifying the format that the model must output. "
+            "Compatible with GPT-4o, GPT-4o mini, GPT-4 Turbo and all GPT-3.5 "
+            "Turbo models newer than gpt-3.5-turbo-1106. Setting to "
+            "{ 'type': 'json_schema', 'json_schema': {...} } enables "
+            "Structured Outputs. Setting to { 'type': 'json_object' } enables "
+            "JSON mode. Important: when using JSON mode, you must also "
+            "instruct the model to produce JSON via a system or user message."
+        ),
+    )
+
+    seed: int | None = Field(
+        None,
+        description=(
+            "This feature is in Beta. If specified, our system will make a "
+            "best effort to sample deterministically, such that repeated "
+            "requests with the same seed and parameters should return the "
+            "same result."
+        ),
+    )
+
+    service_tier: ServiceTier | None = Field(
+        None,
+        description=(
+            "Specifies the latency tier to use for processing the request. "
+            "This parameter is relevant for customers subscribed to the scale "
+            "tier service."
+        ),
+    )
+
+    stop: str | list[str] | None = Field(
+        None,
+        max_items=4,
+        description=(
+            "Up to 4 sequences where the API will stop generating further "
+            "tokens."
+        ),
+    )
+
+    stream: bool | None = Field(
+        False,
+        description=(
+            "If set, partial message deltas will be sent, like in ChatGPT. "
+            "Tokens will be sent as data-only server-sent events as they "
+            "become available, with the stream terminated by a data: [DONE] "
+            "message."
+        ),
+    )
+
+    stream_options: StreamOptions | None = Field(
+        None,
+        description=(
+            "Options for streaming response. Only set this when you set "
+            "stream: true."
+        ),
+    )
+
+    temperature: float | None = Field(
+        1.0,
+        ge=0,
+        le=2,
+        description=(
+            "What sampling temperature to use, between 0 and 2. Higher values "
+            "like 0.8 will make the output more random, while lower values "
+            "like 0.2 will make it more focused and deterministic."
+        ),
+    )
+
+    top_p: float | None = Field(
+        1.0,
+        ge=0,
+        le=1,
+        description=(
+            "An alternative to sampling with temperature, called nucleus "
+            "sampling, where the model considers the results of the tokens "
+            "with top_p probability mass. So 0.1 means only the tokens "
+            "comprising the top 10% probability mass are considered."
+        ),
+    )
+
+    tools: list[Tool] | None = Field(
+        None,
+        max_items=128,
+        description=(
+            "A list of tools the model may call. Currently, only functions "
+            "are supported as a tool. Use this to provide a list of functions "
+            "the model may generate JSON inputs for."
+        ),
+    )
+
+    tool_choice: ToolChoiceStr | ToolChoiceObj | None = Field(
+        None,
+        description=(
+            "Controls which (if any) tool is called by the model. 'none' "
+            "means the model will not call a tool and instead generates a "
+            "message. 'auto' means the model can pick between generating a "
+            "message or calling a tool. 'required' means the model must call "
+            "a tool."
+        ),
+    )
+
+    parallel_tool_calls: bool | None = Field(
+        True,
+        decription="Whether to enable parallel "
+        "function calling during tool use.",
+    )
+
+    user: str | None = Field(
+        None,
+        description=(
+            "A unique identifier representing your end-user, which can help "
+            "OpenAI to monitor and detect abuse."
+        ),
+    )
+
+    @model_validator(mode="after")
+    def validate_request(self) -> "OpenAIChatCompletionRequestBody":
+        if self.tools:
+            self.model_fields["tool_choice"].default = "auto"
+        else:
+            self.model_fields["tool_choice"].default = "none"
+
+        if self.top_logprobs is not None and not self.logprobs:
+            raise ValueError("logprobs must be true when top_logprobs is set")
+        return self

lionagi/integrations/openai_/api_endpoints/chat_completions/request/response_format.py

@@ -0,0 +1,71 @@
+import warnings
+from typing import Any, Dict, Literal, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+# Suppress the specific warning about field name shadowing
+warnings.filterwarnings(
+    "ignore",
+    message='Field name "schema" in "JSONSchema" '
+    'shadows an attribute in parent "BaseModel"',
+)
+
+
+class JSONSchema(BaseModel):
+    description: str | None = Field(
+        None,
+        description=(
+            "A description of what the response format is for, used by the "
+            "model to determine how to respond in the format."
+        ),
+    )
+
+    name: str = Field(
+        max_length=64,
+        pattern="^[a-zA-Z0-9_-]+$",
+        description=(
+            "The name of the response format. Must be a-z, A-Z, 0-9, or "
+            "contain underscores and dashes, with a maximum length of 64."
+        ),
+    )
+
+    schema: dict[str, Any] | None = Field(
+        None,
+        description="The schema for the response "
+        "format, described as a JSON Schema object.",
+    )
+
+    strict: bool | None = Field(
+        False,
+        description=(
+            "Whether to enable strict schema adherence when generating the "
+            "output. If set to true, the model will always follow the exact "
+            "schema defined in the `schema` field. Only a subset of JSON "
+            "Schema is supported when `strict` is `true`."
+        ),
+    )
+
+
+class ResponseFormat(BaseModel):
+    type: Literal["text", "json_object", "json_schema"] = Field(
+        description="The type of response format being defined."
+    )
+    json_schema: JSONSchema | None = Field(
+        None,
+        description=(
+            "The JSON schema to use when type is 'json_schema'. Required "
+            "when type is 'json_schema'."
+        ),
+    )
+
+    @model_validator(mode="after")
+    def validate_response_format(self) -> "ResponseFormat":
+        if self.type == "json_schema" and not self.json_schema:
+            raise ValueError(
+                "json_schema is required when type is 'json_schema'"
+            )
+        if self.type != "json_schema" and self.json_schema:
+            raise ValueError(
+                "json_schema should only be set when type is 'json_schema'"
+            )
+        return self

lionagi/integrations/openai_/api_endpoints/chat_completions/request/stream_options.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, Field
+
+
+class StreamOptions(BaseModel):
+    include_usage: bool | None = Field(
+        None,
+        description=(
+            "If set, an additional chunk will be streamed before the "
+            "`data: [DONE]` message. The `usage` field on this chunk shows "
+            "the token usage statistics for the entire request, and the "
+            "`choices` field will always be an empty array. All other chunks "
+            "will also include a `usage` field, but with a null value."
+        ),
+    )

lionagi/integrations/openai_/api_endpoints/chat_completions/request/tool_choice_models.py

@@ -0,0 +1,17 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class Function(BaseModel):
+    name: str = Field(description="The name of the function to call.")
+
+
+class ToolChoice(BaseModel):
+    type: Literal["function"] = Field(
+        description="The type of the tool. Currently,"
+        " only function is supported."
+    )
+    function: Function = Field(
+        description="Specifies the function to be called."
+    )

lionagi/integrations/openai_/api_endpoints/chat_completions/request/tool_models.py

@@ -0,0 +1,54 @@
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class FunctionParameters(BaseModel):
+    type: Literal["object"] = "object"
+    properties: dict[str, dict[str, Any]]
+    required: list[str] | None = None
+
+
+class Function(BaseModel):
+    description: str | None = Field(
+        None,
+        description=(
+            "A description of what the function does, used by the model to "
+            "choose when and how to call the function."
+        ),
+    )
+
+    name: str = Field(
+        max_length=64,
+        pattern="^[a-zA-Z0-9_-]+$",
+        description=(
+            "The name of the function to be called. Must be a-z, A-Z, 0-9, "
+            "or contain underscores and dashes, with a maximum length of 64."
+        ),
+    )
+
+    parameters: FunctionParameters | None = Field(
+        None,
+        description=(
+            "The parameters the functions accepts, described as a JSON Schema "
+            "object. See the guide for examples, and the JSON Schema "
+            "reference for documentation about the format."
+        ),
+    )
+
+    strict: bool | None = Field(
+        False,
+        description="Whether to enable strict schema"
+        " adherence when generating the function call. "
+        "If set to true, the model will follow the exact"
+        " schema defined in the parameters field. "
+        "Only a subset of JSON Schema is supported when strict is true.",
+    )
+
+
+class Tool(BaseModel):
+    type: Literal["function"] = Field(
+        description="The type of the tool. Currently,"
+        " only function is supported."
+    )
+    function: Function = Field(description="The function definition.")

lionagi/integrations/openai_/api_endpoints/chat_completions/request/types.py

@@ -0,0 +1,18 @@
+from enum import Enum
+
+
+class Detail(str, Enum):
+    AUTO = "auto"
+    LOW = "low"
+    HIGH = "high"
+
+
+class ServiceTier(str, Enum):
+    AUTO = "auto"
+    DEFAULT = "default"
+
+
+class ToolChoice(str, Enum):
+    NONE = "none"
+    AUTO = "auto"
+    REQUIRED = "required"

lionagi/integrations/openai_/api_endpoints/chat_completions/response/choice_models.py

@@ -0,0 +1,62 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+from .log_prob_models import LogProbs
+from .message_models import Message
+from .types import FinishReason
+
+
+class Choice(BaseModel):
+    finish_reason: FinishReason = Field(
+        description=(
+            "The reason the model stopped generating tokens. This will be "
+            "stop if the model hit a natural stop point or a provided stop "
+            "sequence, length if the maximum number of tokens specified in "
+            "the request was reached, content_filter if content was omitted "
+            "due to a flag from our content filters, tool_calls if the model "
+            "called a tool, or function_call (deprecated) if the model "
+            "called a function."
+        )
+    )
+
+    index: int = Field(
+        description="The index of the choice in the list of choices."
+    )
+
+    message: Message = Field(
+        description="A chat completion message generated by the model."
+    )
+
+    logprobs: LogProbs | None = Field(
+        None, description="Log probability information for the choice."
+    )
+
+    model_config = ConfigDict(use_enum_values=True)
+
+
+class ChunkChoice(BaseModel):
+    delta: Message = Field(
+        description="A chat completion delta generated"
+        " by streamed model responses."
+    )
+
+    logprobs: LogProbs | None = Field(
+        description="Log probability information for the choice."
+    )
+
+    finish_reason: FinishReason | None = Field(
+        description=(
+            "The reason the model stopped generating tokens. This will be "
+            "stop if the model hit a natural stop point or a provided stop "
+            "sequence, length if the maximum number of tokens specified in "
+            "the request was reached, content_filter if content was omitted "
+            "due to a flag from our content filters, tool_calls if the model "
+            "called a tool, or function_call (deprecated) if the model "
+            "called a function."
+        )
+    )
+
+    index: int = Field(
+        description="The index of the choice in the list of choices."
+    )
+
+    model_config = ConfigDict(use_enum_values=True)

lionagi/integrations/openai_/api_endpoints/chat_completions/response/function_models.py

@@ -0,0 +1,16 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class Function(BaseModel):
+    name: str = Field(description="The name of the function to call.")
+    arguments: str = Field(
+        description="The arguments to pass to the function."
+    )
+
+
+class ToolCall(BaseModel):
+    id: str = Field(description="The ID of the tool call.")
+    type: Literal["function"] = Field(description="The type of the tool call.")
+    function: Function = Field(description="The function call details.")

lionagi/integrations/openai_/api_endpoints/chat_completions/response/log_prob_models.py

@@ -0,0 +1,47 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class TokenLogProb(BaseModel):
+    token: str = Field(description="The token.")
+    logprob: float = Field(
+        description=(
+            "The log probability of this token, if it is within the top 20 "
+            "most likely tokens. Otherwise, the value -9999.0 is used to "
+            "signify that the token is very unlikely."
+        )
+    )
+    bytes: list[int] | None = Field(
+        None,
+        description=(
+            "A list of integers representing the UTF-8 bytes representation "
+            "of the token. Useful in instances where characters are "
+            "represented by multiple tokens and their byte representations "
+            "must be combined to generate the correct text representation. "
+            "Can be null if there is no bytes representation for the token."
+        ),
+    )
+
+
+class LogProbContent(TokenLogProb):
+    top_logprobs: list[TokenLogProb] = Field(
+        description=(
+            "List of the most likely tokens and their log probability, at "
+            "this token position. In rare cases, there may be fewer than the "
+            "number of requested top_logprobs returned."
+        )
+    )
+
+
+class LogProbs(BaseModel):
+    content: list[LogProbContent] | None = Field(
+        None,
+        description="A list of message content "
+        "tokens with log probability information.",
+    )
+    refusal: list[LogProbContent] | None = Field(
+        None,
+        description="A list of message refusal "
+        "tokens with log probability information.",
+    )

lionagi/integrations/openai_/api_endpoints/chat_completions/response/message_models.py

@@ -0,0 +1,25 @@
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from .function_models import ToolCall
+
+
+class Message(BaseModel):
+    content: str | None = Field(
+        None, description="The contents of the message."
+    )
+
+    refusal: str | None = Field(
+        None, description="The refusal message generated by the model."
+    )
+
+    tool_calls: list[ToolCall] | None = Field(
+        None,
+        description="The tool calls generated by the model, "
+        "such as function calls.",
+    )
+
+    role: str | None = Field(
+        None, description="The role of the author of this message."
+    )