livekit-plugins-anthropic 0.2.13__py3-none-any.whl → 1.0.0.dev5__py3-none-any.whl

livekit/plugins/anthropic/llm.py

@@ -14,56 +14,40 @@
 
 from __future__ import annotations
 
-import base64
-import inspect
-import json
 import os
+from collections.abc import Awaitable
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Awaitable,
-    List,
-    Literal,
-    Union,
-    cast,
-    get_args,
-    get_origin,
-)
+from typing import Any, Literal
 
 import httpx
-from livekit import rtc
-from livekit.agents import (
-    APIConnectionError,
-    APIStatusError,
-    APITimeoutError,
-    llm,
-    utils,
-)
-from livekit.agents.llm import LLMCapabilities, ToolChoice
-from livekit.agents.llm.function_context import (
-    _create_ai_function_info,
-    _is_optional_type,
-)
-from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, APIConnectOptions
 
 import anthropic
-
-from .log import logger
-from .models import (
-    ChatModels,
+from livekit.agents import APIConnectionError, APIStatusError, APITimeoutError, llm
+from livekit.agents.llm import ToolChoice
+from livekit.agents.llm.chat_context import ChatContext
+from livekit.agents.llm.tool_context import FunctionTool
+from livekit.agents.types import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    NOT_GIVEN,
+    APIConnectOptions,
+    NotGivenOr,
 )
+from livekit.agents.utils import is_given
 
-CACHE_CONTROL_EPHEMERAL = anthropic.types.CacheControlEphemeralParam(type="ephemeral")
+from .models import ChatModels
+from .utils import to_chat_ctx, to_fnc_ctx
 
 
 @dataclass
-class LLMOptions:
+class _LLMOptions:
     model: str | ChatModels
-    user: str | None
-    temperature: float | None
-    parallel_tool_calls: bool | None
-    tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] | None
-    caching: Literal["ephemeral"] | None = None
+    user: NotGivenOr[str]
+    temperature: NotGivenOr[float]
+    parallel_tool_calls: NotGivenOr[bool]
+    tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]]
+    caching: NotGivenOr[Literal["ephemeral"]]
+    top_k: NotGivenOr[int]
+    max_tokens: NotGivenOr[int]
     """If set to "ephemeral", the system prompt, tools, and chat history will be cached."""
 
 
@@ -72,14 +56,16 @@ class LLM(llm.LLM):
         self,
         *,
         model: str | ChatModels = "claude-3-5-sonnet-20241022",
-        api_key: str | None = None,
-        base_url: str | None = None,
-        user: str | None = None,
+        api_key: NotGivenOr[str] = NOT_GIVEN,
+        base_url: NotGivenOr[str] = NOT_GIVEN,
+        user: NotGivenOr[str] = NOT_GIVEN,
         client: anthropic.AsyncClient | None = None,
-        temperature: float | None = None,
-        parallel_tool_calls: bool | None = None,
-        tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]] = "auto",
-        caching: Literal["ephemeral"] | None = None,
+        top_k: NotGivenOr[int] = NOT_GIVEN,
+        max_tokens: NotGivenOr[int] = NOT_GIVEN,
+        temperature: NotGivenOr[float] = NOT_GIVEN,
+        parallel_tool_calls: NotGivenOr[bool] = NOT_GIVEN,
+        tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]] = NOT_GIVEN,
+        caching: NotGivenOr[Literal["ephemeral"]] = NOT_GIVEN,
     ) -> None:
         """
         Create a new instance of Anthropic LLM.
@@ -98,29 +84,25 @@ class LLM(llm.LLM):
         caching (Literal["ephemeral"] | None): If set to "ephemeral", caching will be enabled for the system prompt, tools, and chat history.
         """
 
-        super().__init__(
-            capabilities=LLMCapabilities(
-                requires_persistent_functions=True,
-                supports_choices_on_int=True,
-            )
-        )
+        super().__init__()
 
-        # throw an error on our end
-        api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        if api_key is None:
-            raise ValueError("Anthropic API key is required")
-
-        self._opts = LLMOptions(
+        self._opts = _LLMOptions(
             model=model,
             user=user,
             temperature=temperature,
             parallel_tool_calls=parallel_tool_calls,
             tool_choice=tool_choice,
             caching=caching,
+            top_k=top_k,
+            max_tokens=max_tokens,
         )
-        self._client = client or anthropic.AsyncClient(
-            api_key=api_key,
-            base_url=base_url,
+        api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if not is_given(api_key):
+            raise ValueError("Anthropic API key is required")
+
+        self._client = anthropic.AsyncClient(
+            api_key=api_key or None,
+            base_url=base_url or None,
             http_client=httpx.AsyncClient(
                 timeout=5.0,
                 follow_redirects=True,
@@ -135,42 +117,33 @@ class LLM(llm.LLM):
     def chat(
         self,
         *,
-        chat_ctx: llm.ChatContext,
+        chat_ctx: ChatContext,
+        tools: list[FunctionTool] | None = None,
         conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-        fnc_ctx: llm.FunctionContext | None = None,
-        temperature: float | None = None,
-        n: int | None = 1,
-        parallel_tool_calls: bool | None = None,
-        tool_choice: Union[ToolChoice, Literal["auto", "required", "none"]]
-        | None = None,
-    ) -> "LLMStream":
-        if temperature is None:
-            temperature = self._opts.temperature
-        if parallel_tool_calls is None:
-            parallel_tool_calls = self._opts.parallel_tool_calls
-        if tool_choice is None:
-            tool_choice = self._opts.tool_choice
-
-        opts: dict[str, Any] = dict()
-        if fnc_ctx and len(fnc_ctx.ai_functions) > 0:
-            fncs_desc: list[anthropic.types.ToolParam] = []
-            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,
-                    )
-                )
+        parallel_tool_calls: NotGivenOr[bool] = NOT_GIVEN,
+        tool_choice: NotGivenOr[ToolChoice | Literal["auto", "required", "none"]] = NOT_GIVEN,
+        extra_kwargs: NotGivenOr[dict[str, Any]] = NOT_GIVEN,
+    ) -> LLMStream:
+        extra = {}
+
+        if is_given(extra_kwargs):
+            extra.update(extra_kwargs)
+
+        if is_given(self._opts.user):
+            extra["user"] = self._opts.user
+
+        if is_given(self._opts.temperature):
+            extra["temperature"] = self._opts.temperature
+
+        if is_given(self._opts.top_k):
+            extra["top_k"] = self._opts.top_k
 
-            opts["tools"] = fncs_desc
-            if tool_choice is not None:
+        extra["max_tokens"] = self._opts.max_tokens if is_given(self._opts.max_tokens) else 1024
+
+        if tools:
+            extra["tools"] = to_fnc_ctx(tools, self._opts.caching)
+            tool_choice = tool_choice if is_given(tool_choice) else self._opts.tool_choice
+            if is_given(tool_choice):
                 anthropic_tool_choice: dict[str, Any] | None = {"type": "auto"}
                 if isinstance(tool_choice, ToolChoice):
                     if tool_choice.type == "function":
@@ -182,41 +155,35 @@ class LLM(llm.LLM):
                     if tool_choice == "required":
                         anthropic_tool_choice = {"type": "any"}
                     elif tool_choice == "none":
-                        opts["tools"] = []
+                        extra["tools"] = []
                         anthropic_tool_choice = None
-            if anthropic_tool_choice is not None:
-                if parallel_tool_calls is False:
-                    anthropic_tool_choice["disable_parallel_tool_use"] = True
-                opts["tool_choice"] = anthropic_tool_choice
+                if anthropic_tool_choice is not None:
+                    parallel_tool_calls = (
+                        parallel_tool_calls
+                        if is_given(parallel_tool_calls)
+                        else self._opts.parallel_tool_calls
+                    )
+                    if is_given(parallel_tool_calls):
+                        anthropic_tool_choice["disable_parallel_tool_use"] = not parallel_tool_calls
+                    extra["tool_choice"] = anthropic_tool_choice
 
-        latest_system_message: anthropic.types.TextBlockParam | None = (
-            _latest_system_message(chat_ctx, caching=self._opts.caching)
-        )
-        if latest_system_message:
-            opts["system"] = [latest_system_message]
+        anthropic_ctx, system_message = to_chat_ctx(chat_ctx, id(self), 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)
+        if system_message:
+            extra["system"] = [system_message]
 
         stream = self._client.messages.create(
-            max_tokens=opts.get("max_tokens", 1024),
-            messages=collaped_anthropic_ctx,
+            messages=anthropic_ctx,
             model=self._opts.model,
-            temperature=temperature or anthropic.NOT_GIVEN,
-            top_k=n or anthropic.NOT_GIVEN,
             stream=True,
-            **opts,
+            **extra,
         )
 
         return LLMStream(
             self,
             anthropic_stream=stream,
             chat_ctx=chat_ctx,
-            fnc_ctx=fnc_ctx,
+            tools=tools,
             conn_options=conn_options,
         )
 
@@ -226,16 +193,12 @@ class LLMStream(llm.LLMStream):
         self,
         llm: LLM,
         *,
-        anthropic_stream: Awaitable[
-            anthropic.AsyncStream[anthropic.types.RawMessageStreamEvent]
-        ],
+        anthropic_stream: Awaitable[anthropic.AsyncStream[anthropic.types.RawMessageStreamEvent]],
         chat_ctx: llm.ChatContext,
-        fnc_ctx: llm.FunctionContext | None,
+        tools: list[FunctionTool] | None,
         conn_options: APIConnectOptions,
     ) -> None:
-        super().__init__(
-            llm, chat_ctx=chat_ctx, fnc_ctx=fnc_ctx, conn_options=conn_options
-        )
+        super().__init__(llm, chat_ctx=chat_ctx, tools=tools, conn_options=conn_options)
         self._awaitable_anthropic_stream = anthropic_stream
         self._anthropic_stream: (
             anthropic.AsyncStream[anthropic.types.RawMessageStreamEvent] | None
@@ -268,7 +231,7 @@ class LLMStream(llm.LLMStream):
 
                 self._event_ch.send_nowait(
                     llm.ChatChunk(
-                        request_id=self._request_id,
+                        id=self._request_id,
                         usage=llm.CompletionUsage(
                             completion_tokens=self._output_tokens,
                             prompt_tokens=self._input_tokens,
@@ -281,29 +244,25 @@ class LLMStream(llm.LLMStream):
                         ),
                     )
                 )
-        except anthropic.APITimeoutError:
-            raise APITimeoutError(retryable=retryable)
+        except anthropic.APITimeoutError as e:
+            raise APITimeoutError(retryable=retryable) from e
         except anthropic.APIStatusError as e:
             raise APIStatusError(
                 e.message,
                 status_code=e.status_code,
                 request_id=e.request_id,
                 body=e.body,
-            )
+            ) from e
         except Exception as e:
             raise APIConnectionError(retryable=retryable) from e
 
-    def _parse_event(
-        self, event: anthropic.types.RawMessageStreamEvent
-    ) -> llm.ChatChunk | None:
+    def _parse_event(self, event: anthropic.types.RawMessageStreamEvent) -> llm.ChatChunk | None:
         if event.type == "message_start":
             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
-                )
+                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":
@@ -318,7 +277,7 @@ class LLMStream(llm.LLMStream):
             if delta.type == "text_delta":
                 text = delta.text
 
-                if self._fnc_ctx is not None:
+                if self._tools is not None:
                     # anthropic may inject COC when using functions
                     if text.startswith("<thinking>"):
                         self._ignoring_cot = True
@@ -330,306 +289,32 @@ class LLMStream(llm.LLMStream):
                     return None
 
                 return llm.ChatChunk(
-                    request_id=self._request_id,
-                    choices=[
-                        llm.Choice(
-                            delta=llm.ChoiceDelta(content=text, role="assistant")
-                        )
-                    ],
+                    id=self._request_id,
+                    delta=llm.ChoiceDelta(content=text, role="assistant"),
                 )
             elif delta.type == "input_json_delta":
                 assert self._fnc_raw_arguments is not None
                 self._fnc_raw_arguments += delta.partial_json
 
         elif event.type == "content_block_stop":
-            if self._tool_call_id is not None and self._fnc_ctx:
+            if self._tool_call_id is not None:
                 assert self._fnc_name is not None
                 assert self._fnc_raw_arguments is not None
 
-                fnc_info = _create_ai_function_info(
-                    self._fnc_ctx,
-                    self._tool_call_id,
-                    self._fnc_name,
-                    self._fnc_raw_arguments,
-                )
-                self._function_calls_info.append(fnc_info)
-
                 chat_chunk = llm.ChatChunk(
-                    request_id=self._request_id,
-                    choices=[
-                        llm.Choice(
-                            delta=llm.ChoiceDelta(
-                                role="assistant", tool_calls=[fnc_info]
-                            ),
-                        )
-                    ],
+                    id=self._request_id,
+                    delta=llm.ChoiceDelta(
+                        role="assistant",
+                        tool_calls=[
+                            llm.FunctionToolCall(
+                                arguments=self._fnc_raw_arguments or "",
+                                name=self._fnc_name or "",
+                                call_id=self._tool_call_id or "",
+                            )
+                        ],
+                    ),
                 )
                 self._tool_call_id = self._fnc_raw_arguments = self._fnc_name = None
                 return chat_chunk
 
         return None
-
-
-def _latest_system_message(
-    chat_ctx: llm.ChatContext, caching: Literal["ephemeral"] | None = None
-) -> anthropic.types.TextBlockParam | None:
-    latest_system_message: llm.ChatMessage | None = None
-    for m in chat_ctx.messages:
-        if m.role == "system":
-            latest_system_message = m
-            continue
-
-    latest_system_str = ""
-    if latest_system_message:
-        if isinstance(latest_system_message.content, str):
-            latest_system_str = latest_system_message.content
-        elif isinstance(latest_system_message.content, list):
-            latest_system_str = " ".join(
-                [c for c in latest_system_message.content if isinstance(c, str)]
-            )
-    if 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
-    return None
-
-
-def _merge_messages(
-    messages: List[anthropic.types.MessageParam],
-) -> List[anthropic.types.MessageParam]:
-    # Anthropic enforces alternating messages
-    combined_messages: list[anthropic.types.MessageParam] = []
-    for m in messages:
-        if len(combined_messages) == 0 or m["role"] != combined_messages[-1]["role"]:
-            combined_messages.append(m)
-            continue
-        last_message = combined_messages[-1]
-        if not isinstance(last_message["content"], list) or not isinstance(
-            m["content"], list
-        ):
-            logger.error("message content is not a list")
-            continue
-
-        last_message["content"].extend(m["content"])
-
-    if len(combined_messages) == 0 or combined_messages[0]["role"] != "user":
-        combined_messages.insert(
-            0, {"role": "user", "content": [{"type": "text", "text": "(empty)"}]}
-        )
-
-    return combined_messages
-
-
-def _build_anthropic_context(
-    chat_ctx: List[llm.ChatMessage],
-    cache_key: Any,
-    caching: Literal["ephemeral"] | None,
-) -> List[anthropic.types.MessageParam]:
-    result: List[anthropic.types.MessageParam] = []
-    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,
-    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None,
-) -> anthropic.types.MessageParam | None:
-    if msg.role == "user" or msg.role == "assistant":
-        a_msg: anthropic.types.MessageParam = {
-            "role": msg.role,
-            "content": [],
-        }
-        assert isinstance(a_msg["content"], list)
-        a_content = a_msg["content"]
-
-        # add content if provided
-        if isinstance(msg.content, str) and msg.content:
-            a_msg["content"].append(
-                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.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, cache_ctrl)
-                    )
-        if msg.tool_calls is not None:
-            for fnc in msg.tool_calls:
-                tool_use = anthropic.types.ToolUseBlockParam(
-                    id=fnc.tool_call_id,
-                    type="tool_use",
-                    name=fnc.function_info.name,
-                    input=fnc.arguments,
-                    cache_control=cache_ctrl,
-                )
-                a_content.append(tool_use)
-
-        return a_msg
-    elif msg.role == "tool":
-        if isinstance(msg.content, dict):
-            msg.content = json.dumps(msg.content)
-        if not isinstance(msg.content, str):
-            logger.warning("tool message content is not a string or dict")
-            return None
-        if not msg.tool_call_id:
-            return None
-
-        u_content = anthropic.types.ToolResultBlockParam(
-            tool_use_id=msg.tool_call_id,
-            type="tool_result",
-            content=msg.content,
-            is_error=msg.tool_exception is not None,
-            cache_control=cache_ctrl,
-        )
-        return {
-            "role": "user",
-            "content": [u_content],
-        }
-
-    return None
-
-
-def _build_anthropic_image_content(
-    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:"):
-            raise ValueError("LiveKit Anthropic Plugin: Image URLs must be data URLs")
-
-        try:
-            header, b64_data = image.image.split(",", 1)
-            media_type = header.split(";")[0].split(":")[1]
-
-            supported_types = {"image/jpeg", "image/png", "image/webp", "image/gif"}
-            if media_type not in supported_types:
-                raise ValueError(
-                    f"LiveKit Anthropic Plugin: Unsupported media type {media_type}. Must be jpeg, png, webp, or gif"
-                )
-
-            return {
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "data": b64_data,
-                    "media_type": cast(
-                        Literal["image/jpeg", "image/png", "image/gif", "image/webp"],
-                        media_type,
-                    ),
-                },
-                "cache_control": cache_ctrl,
-            }
-        except (ValueError, IndexError) as e:
-            raise ValueError(
-                f"LiveKit Anthropic Plugin: Invalid image data URL {str(e)}"
-            )
-    elif isinstance(image.image, rtc.VideoFrame):  # image is a VideoFrame
-        if cache_key not in image._cache:
-            # inside our internal implementation, we allow to put extra metadata to
-            # each ChatImage (avoid to reencode each time we do a chatcompletion request)
-            opts = utils.images.EncodeOptions()
-            if image.inference_width and image.inference_height:
-                opts.resize_options = utils.images.ResizeOptions(
-                    width=image.inference_width,
-                    height=image.inference_height,
-                    strategy="scale_aspect_fit",
-                )
-
-            encoded_data = utils.images.encode(image.image, opts)
-            image._cache[cache_key] = base64.b64encode(encoded_data).decode("utf-8")
-
-        return {
-            "type": "image",
-            "source": {
-                "type": "base64",
-                "data": image._cache[cache_key],
-                "media_type": "image/jpeg",
-            },
-            "cache_control": cache_ctrl,
-        }
-
-    raise ValueError(
-        "LiveKit Anthropic Plugin: ChatImage must be an rtc.VideoFrame or a data URL"
-    )
-
-
-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:
-            if t is str:
-                return "string"
-            elif t in (int, float):
-                return "number"
-            elif t is bool:
-                return "boolean"
-
-            raise ValueError(f"unsupported type {t} for ai_property")
-
-        p: dict[str, Any] = {}
-        if arg_info.default is inspect.Parameter.empty:
-            p["required"] = True
-        else:
-            p["required"] = False
-
-        if arg_info.description:
-            p["description"] = arg_info.description
-
-        _, inner_th = _is_optional_type(arg_info.type)
-
-        if get_origin(inner_th) is list:
-            inner_type = get_args(inner_th)[0]
-            p["type"] = "array"
-            p["items"] = {}
-            p["items"]["type"] = type2str(inner_type)
-
-            if arg_info.choices:
-                p["items"]["enum"] = arg_info.choices
-        else:
-            p["type"] = type2str(inner_th)
-            if arg_info.choices:
-                p["enum"] = arg_info.choices
-
-        return p
-
-    input_schema: dict[str, object] = {"type": "object"}
-
-    for arg_info in fnc_info.arguments.values():
-        input_schema[arg_info.name] = build_schema_field(arg_info)
-
-    return anthropic.types.ToolParam(
-        name=fnc_info.name,
-        description=fnc_info.description,
-        input_schema=input_schema,
-        cache_control=cache_ctrl,
-    )

livekit/plugins/anthropic/utils.py

@@ -0,0 +1,140 @@
+import base64
+import json
+from typing import Any, Literal
+
+import anthropic
+from livekit.agents import llm
+from livekit.agents.llm import FunctionTool
+
+CACHE_CONTROL_EPHEMERAL = anthropic.types.CacheControlEphemeralParam(type="ephemeral")
+
+__all__ = ["to_fnc_ctx", "to_chat_ctx"]
+
+
+def to_fnc_ctx(
+    fncs: list[FunctionTool], caching: Literal["ephemeral"] | None
+) -> list[anthropic.types.ToolParam]:
+    tools: list[anthropic.types.ToolParam] = []
+    for i, fnc in enumerate(fncs):
+        cache_ctrl = (
+            CACHE_CONTROL_EPHEMERAL if (i == len(fncs) - 1) and caching == "ephemeral" else None
+        )
+        tools.append(_build_anthropic_schema(fnc, cache_ctrl=cache_ctrl))
+
+    return tools
+
+
+def to_chat_ctx(
+    chat_ctx: llm.ChatContext,
+    cache_key: Any,
+    caching: Literal["ephemeral"] | None,
+) -> list[anthropic.types.MessageParam]:
+    messages: list[anthropic.types.MessageParam] = []
+    system_message: anthropic.types.TextBlockParam | None = None
+    current_role: str | None = None
+    content: list[anthropic.types.TextBlockParam] = []
+    for i, msg in enumerate(chat_ctx.items):
+        if msg.type == "message" and msg.role == "system":
+            for content in msg.content:
+                if isinstance(content, str):
+                    system_message = anthropic.types.TextBlockParam(
+                        text=content,
+                        type="text",
+                        cache_control=CACHE_CONTROL_EPHEMERAL if caching == "ephemeral" else None,
+                    )
+            continue
+
+        cache_ctrl = (
+            CACHE_CONTROL_EPHEMERAL
+            if (i == len(chat_ctx.items) - 1) and caching == "ephemeral"
+            else None
+        )
+        if msg.type == "message":
+            role = "assistant" if msg.role == "assistant" else "user"
+        elif msg.type == "function_call":
+            role = "assistant"
+        elif msg.type == "function_call_output":
+            role = "user"
+
+        if role != current_role:
+            if current_role is not None and content:
+                messages.append(anthropic.types.MessageParam(role=current_role, content=content))
+            content = []
+            current_role = role
+
+        if msg.type == "message":
+            for c in msg.content:
+                if isinstance(c, str):
+                    content.append(
+                        anthropic.types.TextBlockParam(
+                            text=c, type="text", cache_control=cache_ctrl
+                        )
+                    )
+                elif isinstance(c, llm.ImageContent):
+                    content.append(_to_image_content(c, cache_key, cache_ctrl=cache_ctrl))
+        elif msg.type == "function_call":
+            content.append(
+                anthropic.types.ToolUseBlockParam(
+                    id=msg.call_id,
+                    type="tool_use",
+                    name=msg.name,
+                    input=json.loads(msg.arguments or "{}"),
+                    cache_control=cache_ctrl,
+                )
+            )
+        elif msg.type == "function_call_output":
+            content.append(
+                anthropic.types.ToolResultBlockParam(
+                    tool_use_id=msg.call_id,
+                    type="tool_result",
+                    content=msg.output,
+                    cache_control=cache_ctrl,
+                )
+            )
+
+    if current_role is not None and content:
+        messages.append(anthropic.types.MessageParam(role=current_role, content=content))
+
+    # ensure the messages starts with a "user" message
+    if not messages or messages[0]["role"] != "user":
+        messages.insert(
+            0,
+            anthropic.types.MessageParam(
+                role="user", content=[anthropic.types.TextBlockParam(text="(empty)", type="text")]
+            ),
+        )
+
+    return messages, system_message
+
+
+def _to_image_content(
+    image: llm.ImageContent,
+    cache_key: Any,
+    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None,
+) -> anthropic.types.ImageBlockParam:
+    img = llm.utils.serialize_image(image)
+    if cache_key not in image._cache:
+        image._cache[cache_key] = img.data_bytes
+    b64_data = base64.b64encode(image._cache[cache_key]).decode("utf-8")
+    return {
+        "type": "image",
+        "source": {
+            "type": "base64",
+            "data": f"data:{img.media_type};base64,{b64_data}",
+            "media_type": img.media_type,
+        },
+        "cache_control": cache_ctrl,
+    }
+
+
+def _build_anthropic_schema(
+    function_tool: FunctionTool,
+    cache_ctrl: anthropic.types.CacheControlEphemeralParam | None = None,
+) -> anthropic.types.ToolParam:
+    fnc = llm.utils.build_legacy_openai_schema(function_tool, internally_tagged=True)
+    return anthropic.types.ToolParam(
+        name=fnc["name"],
+        description=fnc["description"] or "",
+        input_schema=fnc["parameters"],
+        cache_control=cache_ctrl,
+    )

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.13"
+__version__ = "1.0.0.dev5"

{livekit_plugins_anthropic-0.2.13.dist-info → livekit_plugins_anthropic-1.0.0.dev5.dist-info}/METADATA

@@ -1,36 +1,26 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: livekit-plugins-anthropic
-Version: 0.2.13
+Version: 1.0.0.dev5
 Summary: Agent Framework plugin for services from Anthropic
-Home-page: https://github.com/livekit/agents
-License: Apache-2.0
 Project-URL: Documentation, https://docs.livekit.io
 Project-URL: Website, https://livekit.io/
 Project-URL: Source, https://github.com/livekit/agents
-Keywords: webrtc,realtime,audio,video,livekit
+Author-email: LiveKit <support@livekit.io>
+License-Expression: Apache-2.0
+Keywords: audio,livekit,realtime,video,webrtc
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Topic :: Multimedia :: Sound/Audio
-Classifier: Topic :: Multimedia :: Video
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9.0
-Description-Content-Type: text/markdown
-Requires-Dist: livekit-agents<1.0.0,>=0.12.16
 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
+Requires-Dist: livekit-agents>=1.0.0.dev5
+Description-Content-Type: text/markdown
 
 # LiveKit Plugins Anthropic
 

livekit_plugins_anthropic-1.0.0.dev5.dist-info/RECORD

@@ -0,0 +1,10 @@
+livekit/plugins/anthropic/__init__.py,sha256=1WCyNEaR6qBsX54qJQM0SeY-QHIucww16PLXcSnMqRo,1175
+livekit/plugins/anthropic/llm.py,sha256=T22doOXWfmw-xSbY2Ts6jCQxENOA9pQTcbPQn-_3Eao,12969
+livekit/plugins/anthropic/log.py,sha256=fG1pYSY88AnT738gZrmzF9FO4l4BdGENj3VKHMQB3Yo,72
+livekit/plugins/anthropic/models.py,sha256=wyTr2nl6SL4ylN6s4mHJcqtmgV2mjJysZo89FknWdhI,213
+livekit/plugins/anthropic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/anthropic/utils.py,sha256=tr7lQwIWP5hzNQl1XE6L91htsd7x8fPzfXfh9eVoWH0,4939
+livekit/plugins/anthropic/version.py,sha256=pXgCpV03nQI-5Kk-74NFyAdw1htj2cx6unwQHipEcfE,605
+livekit_plugins_anthropic-1.0.0.dev5.dist-info/METADATA,sha256=N8A6WjOyZxgFXr3LQeBhfA6LEkZEtwOIWKeqV0XoA6s,1283
+livekit_plugins_anthropic-1.0.0.dev5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+livekit_plugins_anthropic-1.0.0.dev5.dist-info/RECORD,,

{livekit_plugins_anthropic-0.2.13.dist-info → livekit_plugins_anthropic-1.0.0.dev5.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

livekit_plugins_anthropic-0.2.13.dist-info/RECORD

@@ -1,10 +0,0 @@
-livekit/plugins/anthropic/__init__.py,sha256=1WCyNEaR6qBsX54qJQM0SeY-QHIucww16PLXcSnMqRo,1175
-livekit/plugins/anthropic/llm.py,sha256=dtIA1qWxMPWFxG4QbAeQ-xztmJZxRxBzYxqLFty59dA,23374
-livekit/plugins/anthropic/log.py,sha256=fG1pYSY88AnT738gZrmzF9FO4l4BdGENj3VKHMQB3Yo,72
-livekit/plugins/anthropic/models.py,sha256=wyTr2nl6SL4ylN6s4mHJcqtmgV2mjJysZo89FknWdhI,213
-livekit/plugins/anthropic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-livekit/plugins/anthropic/version.py,sha256=DC7zV-PQt-EaJK0DNm_kMuF_1mO7oPlaMVvGD0eDMwA,601
-livekit_plugins_anthropic-0.2.13.dist-info/METADATA,sha256=M4I1liRz8JcHrEGBAIKqKGzm49s9_6BNLHCzVTFxzsk,1489
-livekit_plugins_anthropic-0.2.13.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-livekit_plugins_anthropic-0.2.13.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
-livekit_plugins_anthropic-0.2.13.dist-info/RECORD,,

livekit_plugins_anthropic-0.2.13.dist-info/top_level.txt

@@ -1 +0,0 @@
-livekit