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

lionagi/integrations/anthropic_/anthropic_price_data.yaml

@@ -0,0 +1,14 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+model:
+  claude-3-opus-20240229:
+    input_tokens: 0.000015
+    output_tokens: 0.000075
+  claude-3-sonnet-20240229:
+    input_tokens: 0.000003
+    output_tokens: 0.000015
+  claude-3-haiku-20240307:
+    input_tokens: 0.0000005
+    output_tokens: 0.0000025

lionagi/integrations/anthropic_/api_endpoints/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/integrations/anthropic_/api_endpoints/api_request.py

@@ -0,0 +1,277 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from collections.abc import AsyncGenerator
+from os import getenv
+from typing import Any
+
+import aiohttp
+from pydantic import BaseModel, Field, field_validator
+
+from .data_models import (
+    AnthropicEndpointPathParam,
+    AnthropicEndpointQueryParam,
+    AnthropicEndpointRequestBody,
+)
+from .match_response import match_response
+
+
+class AnthropicRequest(BaseModel):
+    api_key: str = Field(
+        description="API key for authentication", exclude=True
+    )
+
+    endpoint: str = Field(description="Endpoint for request")
+
+    method: str = Field(description="HTTP method")
+
+    content_type: str | None = Field(
+        default=None, description="HTTP Content-Type"
+    )
+
+    api_version: str = Field(
+        default="2023-06-01", description="Anthropic API version"
+    )
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "extra": "allow",  # Allow extra attributes for mocking
+    }
+
+    @field_validator("api_key")
+    @classmethod
+    def get_id(cls, value: str) -> str:
+        try:
+            if api_key := getenv(value):
+                return api_key
+            else:
+                return value
+        except Exception:
+            return value
+
+    def get_endpoint(self, path_param: AnthropicEndpointPathParam = None):
+        if path_param is None:
+            return self.endpoint
+        else:
+            return self.endpoint.format(**path_param.model_dump())
+
+    @property
+    def base_url(self):
+        return "https://api.anthropic.com/v1/"
+
+    async def invoke(
+        self,
+        json_data: AnthropicEndpointRequestBody = None,
+        params: AnthropicEndpointQueryParam = None,
+        path_param: AnthropicEndpointPathParam = None,
+        output_file: str = None,
+        with_response_header: bool = False,
+        parse_response: bool = True,
+    ) -> Any:
+        def get_headers():
+            headers = {
+                "x-api-key": self.api_key,
+                "anthropic-version": self.api_version,
+            }
+            if self.content_type:
+                headers["Content-Type"] = self.content_type
+            return headers
+
+        url = self.base_url + self.get_endpoint(path_param)
+        headers = get_headers()
+        json_data = (
+            json_data.model_dump(exclude_unset=True) if json_data else None
+        )
+        params = params.model_dump(exclude_unset=True) if params else None
+
+        async with aiohttp.ClientSession() as client:
+            async with client.request(
+                method=self.method,
+                url=url,
+                headers=headers,
+                json=json_data,
+                params=params,
+            ) as response:
+                if response.status != 200:
+                    try:
+                        error_text = await response.json()
+                    except Exception:
+                        error_text = await response.text()
+                    raise aiohttp.ClientResponseError(
+                        request_info=response.request_info,
+                        history=response.history,
+                        status=response.status,
+                        message=f"{error_text}",
+                        headers=response.headers,
+                    )
+
+                # handle stream in messages
+                if json_data and json_data.get("stream"):
+                    response_body = []
+                    file_handle = None
+                    if output_file:
+                        try:
+                            file_handle = open(output_file, "w")
+                        except Exception as e:
+                            raise ValueError(
+                                f"Invalid to output the response "
+                                f"to {output_file}. Error:{e}"
+                            )
+
+                    try:
+                        async for chunk in response.content:
+                            chunk_str = chunk.decode("utf-8")
+                            if chunk_str.startswith("data: "):
+                                chunk_str = chunk_str[
+                                    6:
+                                ]  # Remove "data: " prefix
+                            if chunk_str.strip() == "[DONE]":
+                                continue
+                            try:
+                                chunk_data = json.loads(chunk_str)
+                                if file_handle:
+                                    file_handle.write(
+                                        json.dumps(chunk_data) + "\n"
+                                    )
+                                response_body.append(chunk_data)
+                            except json.JSONDecodeError:
+                                continue
+                    except Exception as e:
+                        raise e
+                    finally:
+                        if file_handle:
+                            file_handle.close()
+
+                    if parse_response:
+                        response_body = match_response(self, response_body)
+                    if with_response_header:
+                        return response_body, response.headers
+                    else:
+                        return response_body
+
+                if output_file:
+                    try:
+                        with open(output_file, "wb") as f:
+                            f.write(await response.read())
+                    except Exception as e:
+                        raise ValueError(
+                            f"Invalid to output the response "
+                            f"to {output_file}. Error:{e}"
+                        )
+
+                response_body = await response.json()
+
+                if parse_response:
+                    response_body = match_response(self, response_body)
+                if with_response_header:
+                    return response_body, response.headers
+                else:
+                    return response_body
+
+    async def stream(
+        self,
+        json_data: AnthropicEndpointRequestBody,
+        verbose: bool = True,
+        output_file: str = None,
+        with_response_header: bool = False,
+    ) -> AsyncGenerator[Any, None]:
+        if not getattr(json_data, "stream"):
+            raise ValueError(
+                "Request does not support stream. "
+                "Only messages requests with stream=True are supported"
+            )
+
+        def get_headers():
+            headers = {
+                "x-api-key": self.api_key,
+                "anthropic-version": self.api_version,
+            }
+            if self.content_type:
+                headers["Content-Type"] = self.content_type
+            return headers
+
+        url = self.base_url + self.get_endpoint()
+        headers = get_headers()
+        json_data = (
+            json_data.model_dump(exclude_unset=True) if json_data else None
+        )
+
+        try:
+            async with aiohttp.ClientSession() as client:
+                async with client.request(
+                    method=self.method,
+                    url=url,
+                    headers=headers,
+                    json=json_data,
+                ) as response:
+                    if response.status != 200:
+                        try:
+                            error_text = await response.json()
+                        except Exception:
+                            error_text = await response.text()
+                        raise aiohttp.ClientResponseError(
+                            request_info=response.request_info,
+                            history=response.history,
+                            status=response.status,
+                            message=f"{error_text}",
+                            headers=response.headers,
+                        )
+
+                    file_handle = None
+                    if output_file:
+                        try:
+                            file_handle = open(output_file, "w")
+                        except Exception as e:
+                            raise ValueError(
+                                f"Invalid to output the response "
+                                f"to {output_file}. Error:{e}"
+                            )
+
+                    try:
+                        async for chunk in response.content:
+                            chunk_str = chunk.decode("utf-8")
+                            if chunk_str.startswith("data: "):
+                                chunk_str = chunk_str[
+                                    6:
+                                ]  # Remove "data: " prefix
+                            if chunk_str.strip() == "[DONE]":
+                                continue
+                            try:
+                                chunk_data = json.loads(chunk_str)
+                                if file_handle:
+                                    file_handle.write(
+                                        json.dumps(chunk_data) + "\n"
+                                    )
+
+                                # Print content when verbose is True
+                                if verbose:
+                                    if (
+                                        chunk_data.get("type")
+                                        == "content_block_delta"
+                                    ):
+                                        if text := chunk_data.get(
+                                            "delta", {}
+                                        ).get("text"):
+                                            print(text, end="", flush=True)
+
+                                yield chunk_data
+                            except json.JSONDecodeError:
+                                continue
+
+                        if with_response_header:
+                            yield response.headers
+                    except Exception as e:
+                        raise e
+                    finally:
+                        if file_handle:
+                            file_handle.close()
+        except Exception as e:
+            raise e
+
+    def __repr__(self):
+        return (
+            f"AnthropicRequest(endpoint={self.endpoint}, method={self.method}, "
+            f"content_type={self.content_type}, api_version={self.api_version})"
+        )

lionagi/integrations/anthropic_/api_endpoints/data_models.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import BaseModel, ConfigDict
+
+
+class AnthropicEndpointRequestBody(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+        use_enum_values=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+
+class AnthropicEndpointResponseBody(BaseModel):
+    model_config = ConfigDict(
+        use_enum_values=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+
+class AnthropicEndpointQueryParam(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+        use_enum_values=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+
+class AnthropicEndpointPathParam(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+        use_enum_values=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )

lionagi/integrations/anthropic_/api_endpoints/match_response.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+imported_models = {}
+
+
+def match_response(request_model, response: dict | list):
+    global imported_models
+
+    endpoint = request_model.endpoint
+    method = request_model.method
+
+    # Messages endpoint
+    if endpoint == "messages":
+        if isinstance(response, dict):
+            # Single message response
+            if "AnthropicMessageResponseBody" not in imported_models:
+                from .messages.response.response_body import (
+                    AnthropicMessageResponseBody,
+                )
+
+                imported_models["AnthropicMessageResponseBody"] = (
+                    AnthropicMessageResponseBody
+                )
+
+            # Convert to OpenAI-like format for AssistantResponse
+            if response.get("content") and len(response["content"]) > 0:
+                text_content = " ".join(
+                    block["text"]
+                    for block in response["content"]
+                    if block["type"] == "text"
+                )
+                return {
+                    "choices": [
+                        {
+                            "message": {
+                                "content": text_content,
+                                "role": "assistant",
+                            }
+                        }
+                    ],
+                    "model": response.get("model"),
+                    "usage": response.get("usage", {}),
+                }
+            return response
+        else:
+            # Stream response list
+            if "AnthropicMessageResponseBody" not in imported_models:
+                from .messages.response.response_body import (
+                    AnthropicMessageResponseBody,
+                )
+
+                imported_models["AnthropicMessageResponseBody"] = (
+                    AnthropicMessageResponseBody
+                )
+
+            # For streaming, we need to convert each chunk to OpenAI format
+            result = []
+            for item in response:
+                if "type" not in item:
+                    continue
+
+                if item.get("type") == "content_block_delta":
+                    if text := item.get("delta", {}).get(
+                        "type"
+                    ) == "text_delta" and item.get("delta", {}).get(
+                        "text", {}
+                    ):
+                        result.append(
+                            {
+                                "choices": [
+                                    {
+                                        "delta": {
+                                            "content": item["delta"]["text"],
+                                            "role": "assistant",
+                                        }
+                                    }
+                                ]
+                            }
+                        )
+                elif item.get("type") == "message_delta":
+                    # Include usage updates
+                    if "usage" in item:
+                        result.append(
+                            {
+                                "choices": [
+                                    {
+                                        "delta": {
+                                            "content": "",
+                                            "role": "assistant",
+                                        }
+                                    }
+                                ],
+                                "usage": item["usage"],
+                            }
+                        )
+                elif item.get("type") == "message_stop":
+                    # Final message with stop reason
+                    result.append(
+                        {
+                            "choices": [
+                                {
+                                    "delta": {
+                                        "content": "",
+                                        "role": "assistant",
+                                    },
+                                    "finish_reason": "stop",
+                                }
+                            ],
+                            "usage": item.get("usage", {}),
+                        }
+                    )
+
+            return result
+
+    raise ValueError(
+        "There is no standard response model for the provided request and response"
+    )

lionagi/integrations/anthropic_/api_endpoints/messages/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/integrations/anthropic_/api_endpoints/messages/request/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0

lionagi/integrations/anthropic_/api_endpoints/messages/request/message_models.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class Message(BaseModel):
+    role: Literal["user", "assistant"] = Field(
+        description="The role of the message sender"
+    )
+    content: str = Field(description="The content of the message")

lionagi/integrations/anthropic_/api_endpoints/messages/request/request_body.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from pydantic import Field, model_validator
+
+from ...data_models import AnthropicEndpointRequestBody
+from .message_models import Message
+
+
+class AnthropicMessageRequestBody(AnthropicEndpointRequestBody):
+    model: str = Field(
+        description="The model to use for generating the response"
+    )
+
+    messages: list[Message] = Field(
+        description="The messages to send to the model"
+    )
+
+    max_tokens: int = Field(
+        default=8000,  # Default to Anthropic's max model response tokens
+        description="The maximum number of tokens to generate before stopping",
+    )
+
+    metadata: dict | None = Field(
+        None, description="An object describing metadata about the request"
+    )
+
+    stop_sequences: list[str] | None = Field(
+        None,
+        description="Custom text sequences that will cause the model to stop generating",
+    )
+
+    stream: bool | None = Field(
+        False, description="Whether to stream the response back token by token"
+    )
+
+    system: str | None = Field(
+        None,
+        description="System prompt that helps define the behavior of the assistant",
+    )
+
+    temperature: float | None = Field(
+        None,
+        ge=0,
+        le=1,
+        description="Amount of randomness injected into the response",
+    )
+
+    top_k: int | None = Field(
+        None,
+        description="Number of most likely tokens to consider at each step",
+    )
+
+    top_p: float | None = Field(
+        None,
+        ge=0,
+        le=1,
+        description="Total probability mass of tokens to consider at each step",
+    )
+
+    @model_validator(mode="after")
+    def validate_messages(self):
+        if not self.messages:
+            raise ValueError("Messages list cannot be empty")
+
+        # Check for alternating user/assistant messages
+        for i in range(1, len(self.messages)):
+            if self.messages[i].role == self.messages[i - 1].role:
+                raise ValueError(
+                    "Messages must alternate between user and assistant roles"
+                )
+
+        return self

lionagi/integrations/anthropic_/api_endpoints/messages/response/content_models.py

@@ -0,0 +1,32 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class TextContent(BaseModel):
+    type: Literal["text"] = Field(description="Type of content block")
+    text: str = Field(description="The text content")
+
+
+class ToolUseContent(BaseModel):
+    type: Literal["tool_use"] = Field(description="Type of content block")
+    id: str = Field(description="Unique identifier for this tool use")
+    name: str = Field(description="Name of the tool being called")
+    input: dict = Field(description="Input parameters for the tool call")
+
+
+class ToolResultContent(BaseModel):
+    type: Literal["tool_result"] = Field(description="Type of content block")
+    tool_use_id: str = Field(
+        description="ID of the tool use this is a result for"
+    )
+    content: str = Field(
+        description="The result content from running the tool"
+    )
+
+
+ContentBlock = TextContent | ToolUseContent | ToolResultContent

lionagi/integrations/anthropic_/api_endpoints/messages/response/response_body.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field, model_validator
+
+from ...data_models import AnthropicEndpointResponseBody
+from .content_models import ContentBlock
+from .usage_models import Usage
+
+
+class AnthropicMessageResponseBody(AnthropicEndpointResponseBody):
+    id: str = Field(description="Unique object identifier")
+
+    type: Literal[
+        "message",
+        "message_start",
+        "content_block_start",
+        "content_block_delta",
+        "content_block_stop",
+        "message_delta",
+        "message_stop",
+    ] = Field(description="Type of the response")
+
+    role: Literal["assistant"] | None = Field(
+        default=None,
+        description="Conversational role of the generated message. Always 'assistant' for non-stream responses",
+    )
+
+    content: list[ContentBlock] | None = Field(
+        default=None,
+        description="Content generated by the model",
+    )
+
+    model: str | None = Field(
+        default=None,
+        description="The model that handled the request",
+    )
+
+    stop_reason: (
+        Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
+    ) = Field(
+        default=None,
+        description="""The reason that we stopped. May be:
+        "end_turn": the model reached a natural stopping point
+        "max_tokens": exceeded the requested max_tokens or model's maximum
+        "stop_sequence": one of the provided custom stop_sequences was generated
+        "tool_use": the model invoked one or more tools""",
+    )
+
+    stop_sequence: str | None = Field(
+        default=None,
+        description="Which custom stop sequence was generated, if any",
+    )
+
+    usage: Usage | None = Field(
+        default=None,
+        description="""Billing and rate-limit usage. Anthropic's API bills and
+        rate-limits by token counts, as tokens represent the underlying cost to our systems.""",
+    )
+
+    # Stream-specific fields
+    message: "AnthropicMessageResponseBody | None" = Field(
+        default=None,
+        description="Initial message object in stream response",
+    )
+
+    content_block: dict | None = Field(
+        default=None,
+        description="Content block information in stream response",
+    )
+
+    delta: dict | None = Field(
+        default=None,
+        description="Delta update in stream response",
+    )
+
+    message_id: str | None = Field(
+        default=None,
+        description="Message ID reference in stream response",
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @model_validator(mode="after")
+    def validate_stream_fields(self):
+        # For stream responses, some fields are optional
+        if self.type != "message":
+            return self
+
+        # For regular message responses, validate required fields
+        if not self.role:
+            raise ValueError("role is required for message responses")
+        if self.content is None:
+            raise ValueError("content is required for message responses")
+        if not self.model:
+            raise ValueError("model is required for message responses")
+
+        return self