livekit-plugins-anthropic 0.2.9__tar.gz → 0.2.11__tar.gz

{livekit_plugins_anthropic-0.2.9 → livekit_plugins_anthropic-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: livekit-plugins-anthropic
-Version: 0.2.9
+Version: 0.2.11
 Summary: Agent Framework plugin for services from Anthropic
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -21,6 +21,16 @@ Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: livekit-agents>=0.12.3
 Requires-Dist: anthropic>=0.34
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # LiveKit Plugins Anthropic
 

{livekit_plugins_anthropic-0.2.9 → livekit_plugins_anthropic-0.2.11}/livekit/plugins/anthropic/llm.py

@@ -39,7 +39,7 @@ from livekit.agents import (
     llm,
     utils,
 )
-from livekit.agents.llm import ToolChoice
+from livekit.agents.llm import LLMCapabilities, ToolChoice
 from livekit.agents.llm.function_context import (
     _create_ai_function_info,
     _is_optional_type,
@@ -53,6 +53,8 @@ from .models import (
     ChatModels,
 )
 
+CACHE_CONTROL_EPHEMERAL = anthropic.types.CacheControlEphemeralParam(type="ephemeral")
+
 
 @dataclass
 class LLMOptions:
@@ -61,6 +63,8 @@ class LLMOptions:
     temperature: float | None
     parallel_tool_calls: bool | None
     tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] | None
+    caching: Literal["ephemeral"] | None = None
+    """If set to "ephemeral", the system prompt, tools, and chat history will be cached."""
 
 
 class LLM(llm.LLM):
@@ -75,14 +79,31 @@ class LLM(llm.LLM):
         temperature: float | None = None,
         parallel_tool_calls: bool | None = None,
         tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] = "auto",
+        caching: Literal["ephemeral"] | None = None,
     ) -> None:
         """
         Create a new instance of Anthropic LLM.
 
         ``api_key`` must be set to your Anthropic API key, either using the argument or by setting
         the ``ANTHROPIC_API_KEY`` environmental variable.
+
+        model (str | ChatModels): The model to use. Defaults to "claude-3-5-sonnet-20241022".
+        api_key (str | None): The Anthropic API key. Defaults to the ANTHROPIC_API_KEY environment variable.
+        base_url (str | None): The base URL for the Anthropic API. Defaults to None.
+        user (str | None): The user for the Anthropic API. Defaults to None.
+        client (anthropic.AsyncClient | None): The Anthropic client to use. Defaults to None.
+        temperature (float | None): The temperature for the Anthropic API. Defaults to None.
+        parallel_tool_calls (bool | None): Whether to parallelize tool calls. Defaults to None.
+        tool_choice (Union[ToolChoice, Literal["auto", "required", "none"]] | None): The tool choice for the Anthropic API. Defaults to "auto".
+        caching (Literal["ephemeral"] | None): If set to "ephemeral", caching will be enabled for the system prompt, tools, and chat history.
         """
-        super().__init__()
+
+        super().__init__(
+            capabilities=LLMCapabilities(
+                requires_persistent_functions=True,
+                supports_choices_on_int=True,
+            )
+        )
 
         # throw an error on our end
         api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
@@ -95,6 +116,7 @@ class LLM(llm.LLM):
             temperature=temperature,
             parallel_tool_calls=parallel_tool_calls,
             tool_choice=tool_choice,
+            caching=caching,
         )
         self._client = client or anthropic.AsyncClient(
             api_key=api_key,
@@ -132,8 +154,20 @@ class LLM(llm.LLM):
         opts: dict[str, Any] = dict()
         if fnc_ctx and len(fnc_ctx.ai_functions) > 0:
             fncs_desc: list[anthropic.types.ToolParam] = []
-            for fnc in fnc_ctx.ai_functions.values():
-                fncs_desc.append(_build_function_description(fnc))
+            for i, fnc in enumerate(fnc_ctx.ai_functions.values()):
+                # caching last tool will cache all the tools if caching is enabled
+                cache_ctrl = (
+                    CACHE_CONTROL_EPHEMERAL
+                    if (i == len(fnc_ctx.ai_functions) - 1)
+                    and self._opts.caching == "ephemeral"
+                    else None
+                )
+                fncs_desc.append(
+                    _build_function_description(
+                        fnc,
+                        cache_ctrl=cache_ctrl,
+                    )
+                )
 
             opts["tools"] = fncs_desc
             if tool_choice is not None:
@@ -151,13 +185,19 @@ class LLM(llm.LLM):
                 anthropic_tool_choice["disable_parallel_tool_use"] = True
             opts["tool_choice"] = anthropic_tool_choice
 
-        latest_system_message = _latest_system_message(chat_ctx)
-        anthropic_ctx = _build_anthropic_context(chat_ctx.messages, id(self))
+        latest_system_message: anthropic.types.TextBlockParam = _latest_system_message(
+            chat_ctx, caching=self._opts.caching
+        )
+        anthropic_ctx = _build_anthropic_context(
+            chat_ctx.messages,
+            id(self),
+            caching=self._opts.caching,
+        )
         collaped_anthropic_ctx = _merge_messages(anthropic_ctx)
 
         stream = self._client.messages.create(
             max_tokens=opts.get("max_tokens", 1024),
-            system=latest_system_message,
+            system=[latest_system_message],
             messages=collaped_anthropic_ctx,
             model=self._opts.model,
             temperature=temperature or anthropic.NOT_GIVEN,
@@ -203,6 +243,8 @@ class LLMStream(llm.LLMStream):
         self._request_id: str = ""
         self._ignoring_cot = False  # ignore chain of thought
         self._input_tokens = 0
+        self._cache_creation_tokens = 0
+        self._cache_read_tokens = 0
         self._output_tokens = 0
 
     async def _run(self) -> None:
@@ -224,7 +266,12 @@ class LLMStream(llm.LLMStream):
                         usage=llm.CompletionUsage(
                             completion_tokens=self._output_tokens,
                             prompt_tokens=self._input_tokens,
-                            total_tokens=self._input_tokens + self._output_tokens,
+                            total_tokens=self._input_tokens
+                            + self._output_tokens
+                            + self._cache_creation_tokens
+                            + self._cache_read_tokens,
+                            cache_creation_input_tokens=self._cache_creation_tokens,
+                            cache_read_input_tokens=self._cache_read_tokens,
                         ),
                     )
                 )
@@ -247,6 +294,12 @@ class LLMStream(llm.LLMStream):
             self._request_id = event.message.id
             self._input_tokens = event.message.usage.input_tokens
             self._output_tokens = event.message.usage.output_tokens
+            if event.message.usage.cache_creation_input_tokens:
+                self._cache_creation_tokens = (
+                    event.message.usage.cache_creation_input_tokens
+                )
+            if event.message.usage.cache_read_input_tokens:
+                self._cache_read_tokens = event.message.usage.cache_read_input_tokens
         elif event.type == "message_delta":
             self._output_tokens += event.usage.output_tokens
         elif event.type == "content_block_start":
@@ -311,7 +364,9 @@ class LLMStream(llm.LLMStream):
         return None
 
 
-def _latest_system_message(chat_ctx: llm.ChatContext) -> str:
+def _latest_system_message(
+    chat_ctx: llm.ChatContext, caching: Literal["ephemeral"] | None = None
+) -> anthropic.types.TextBlockParam:
     latest_system_message: llm.ChatMessage | None = None
     for m in chat_ctx.messages:
         if m.role == "system":
@@ -326,7 +381,12 @@ def _latest_system_message(chat_ctx: llm.ChatContext) -> str:
             latest_system_str = " ".join(
                 [c for c in latest_system_message.content if isinstance(c, str)]
             )
-    return latest_system_str
+    system_text_block = anthropic.types.TextBlockParam(
+        text=latest_system_str,
+        type="text",
+        cache_control=CACHE_CONTROL_EPHEMERAL if caching == "ephemeral" else None,
+    )
+    return system_text_block
 
 
 def _merge_messages(
@@ -356,18 +416,29 @@ def _merge_messages(
 
 
 def _build_anthropic_context(
-    chat_ctx: List[llm.ChatMessage], cache_key: Any
+    chat_ctx: List[llm.ChatMessage],
+    cache_key: Any,
+    caching: Literal["ephemeral"] | None,
 ) -> List[anthropic.types.MessageParam]:
     result: List[anthropic.types.MessageParam] = []
-    for msg in chat_ctx:
-        a_msg = _build_anthropic_message(msg, cache_key, chat_ctx)
+    for i, msg in enumerate(chat_ctx):
+        # caching last message will cache whole chat history if caching is enabled
+        cache_ctrl = (
+            CACHE_CONTROL_EPHEMERAL
+            if ((i == len(chat_ctx) - 1) and caching == "ephemeral")
+            else None
+        )
+        a_msg = _build_anthropic_message(msg, cache_key, cache_ctrl=cache_ctrl)
+
         if a_msg:
             result.append(a_msg)
     return result
 
 
 def _build_anthropic_message(
-    msg: llm.ChatMessage, cache_key: Any, chat_ctx: List[llm.ChatMessage]
+    msg: llm.ChatMessage,
+    cache_key: Any,
+    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None,
 ) -> anthropic.types.MessageParam | None:
     if msg.role == "user" or msg.role == "assistant":
         a_msg: anthropic.types.MessageParam = {
@@ -380,22 +451,27 @@ def _build_anthropic_message(
         # add content if provided
         if isinstance(msg.content, str) and msg.content:
             a_msg["content"].append(
-                anthropic.types.TextBlock(
+                anthropic.types.TextBlockParam(
                     text=msg.content,
                     type="text",
+                    cache_control=cache_ctrl,
                 )
             )
         elif isinstance(msg.content, list):
             for cnt in msg.content:
                 if isinstance(cnt, str) and cnt:
-                    content: anthropic.types.TextBlock = anthropic.types.TextBlock(
-                        text=cnt,
-                        type="text",
+                    content: anthropic.types.TextBlockParam = (
+                        anthropic.types.TextBlockParam(
+                            text=cnt,
+                            type="text",
+                            cache_control=cache_ctrl,
+                        )
                     )
                     a_content.append(content)
                 elif isinstance(cnt, llm.ChatImage):
-                    a_content.append(_build_anthropic_image_content(cnt, cache_key))
-
+                    a_content.append(
+                        _build_anthropic_image_content(cnt, cache_key, cache_ctrl)
+                    )
         if msg.tool_calls is not None:
             for fnc in msg.tool_calls:
                 tool_use = anthropic.types.ToolUseBlockParam(
@@ -403,6 +479,7 @@ def _build_anthropic_message(
                     type="tool_use",
                     name=fnc.function_info.name,
                     input=fnc.arguments,
+                    cache_control=cache_ctrl,
                 )
                 a_content.append(tool_use)
 
@@ -421,6 +498,7 @@ def _build_anthropic_message(
             type="tool_result",
             content=msg.content,
             is_error=msg.tool_exception is not None,
+            cache_control=cache_ctrl,
         )
         return {
             "role": "user",
@@ -431,7 +509,9 @@ def _build_anthropic_message(
 
 
 def _build_anthropic_image_content(
-    image: llm.ChatImage, cache_key: Any
+    image: llm.ChatImage,
+    cache_key: Any,
+    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None,
 ) -> anthropic.types.ImageBlockParam:
     if isinstance(image.image, str):  # image is a URL
         if not image.image.startswith("data:"):
@@ -457,6 +537,7 @@ def _build_anthropic_image_content(
                         media_type,
                     ),
                 },
+                "cache_control": cache_ctrl,
             }
         except (ValueError, IndexError) as e:
             raise ValueError(
@@ -484,6 +565,7 @@ def _build_anthropic_image_content(
                 "data": image._cache[cache_key],
                 "media_type": "image/jpeg",
             },
+            "cache_control": cache_ctrl,
         }
 
     raise ValueError(
@@ -493,6 +575,7 @@ def _build_anthropic_image_content(
 
 def _build_function_description(
     fnc_info: llm.function_context.FunctionInfo,
+    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None,
 ) -> anthropic.types.ToolParam:
     def build_schema_field(arg_info: llm.function_context.FunctionArgInfo):
         def type2str(t: type) -> str:
@@ -514,7 +597,7 @@ def _build_function_description(
         if arg_info.description:
             p["description"] = arg_info.description
 
-        is_optional, inner_th = _is_optional_type(arg_info.type)
+        _, inner_th = _is_optional_type(arg_info.type)
 
         if get_origin(inner_th) is list:
             inner_type = get_args(inner_th)[0]
@@ -536,8 +619,9 @@ def _build_function_description(
     for arg_info in fnc_info.arguments.values():
         input_schema[arg_info.name] = build_schema_field(arg_info)
 
-    return {
-        "name": fnc_info.name,
-        "description": fnc_info.description,
-        "input_schema": input_schema,
-    }
+    return anthropic.types.ToolParam(
+        name=fnc_info.name,
+        description=fnc_info.description,
+        input_schema=input_schema,
+        cache_control=cache_ctrl,
+    )

{livekit_plugins_anthropic-0.2.9 → livekit_plugins_anthropic-0.2.11}/livekit/plugins/anthropic/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.2.9"
+__version__ = "0.2.11"

{livekit_plugins_anthropic-0.2.9 → livekit_plugins_anthropic-0.2.11}/livekit_plugins_anthropic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: livekit-plugins-anthropic
-Version: 0.2.9
+Version: 0.2.11
 Summary: Agent Framework plugin for services from Anthropic
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -21,6 +21,16 @@ Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: livekit-agents>=0.12.3
 Requires-Dist: anthropic>=0.34
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # LiveKit Plugins Anthropic