livekit-plugins-anthropic 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

livekit/plugins/anthropic/__init__.py

@@ -12,4 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .claude import ClaudePlugin, ClaudeMessage, ClaudeMessageRole
+
+from .llm import LLM, LLMStream
+from .log import logger
+from .models import ChatModels
+from .version import __version__
+
+__all__ = [
+    "LLM",
+    "LLMStream",
+    "ChatModels",
+    "logger",
+    "__version__",
+]
+
+from livekit.agents import Plugin
+
+
+class AnthropicPlugin(Plugin):
+    def __init__(self) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+
+
+Plugin.register_plugin(AnthropicPlugin())

livekit/plugins/anthropic/llm.py

@@ -0,0 +1,489 @@
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import base64
+import inspect
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Awaitable, List, Tuple, get_args, get_origin
+
+import httpx
+from livekit import rtc
+from livekit.agents import llm, utils
+
+import anthropic
+
+from .log import logger
+from .models import (
+    ChatModels,
+)
+
+
+@dataclass
+class LLMOptions:
+    model: str | ChatModels
+    user: str | None
+
+
+class LLM(llm.LLM):
+    def __init__(
+        self,
+        *,
+        model: str | ChatModels = "claude-3-opus-20240229",
+        api_key: str | None = None,
+        base_url: str | None = None,
+        user: str | None = None,
+        client: anthropic.AsyncClient | 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.
+        """
+
+        # 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(model=model, user=user)
+        self._client = client or anthropic.AsyncClient(
+            api_key=api_key,
+            base_url=base_url,
+            http_client=httpx.AsyncClient(
+                timeout=5.0,
+                follow_redirects=True,
+                limits=httpx.Limits(
+                    max_connections=1000,
+                    max_keepalive_connections=100,
+                    keepalive_expiry=120,
+                ),
+            ),
+        )
+
+    def chat(
+        self,
+        *,
+        chat_ctx: llm.ChatContext,
+        fnc_ctx: llm.FunctionContext | None = None,
+        temperature: float | None = None,
+        n: int | None = 1,
+        parallel_tool_calls: bool | None = None,
+    ) -> "LLMStream":
+        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))
+
+            opts["tools"] = fncs_desc
+
+            if fnc_ctx and parallel_tool_calls is not None:
+                opts["parallel_tool_calls"] = parallel_tool_calls
+
+        latest_system_message = _latest_system_message(chat_ctx)
+        anthropic_ctx = _build_anthropic_context(chat_ctx.messages, id(self))
+        collaped_anthropic_ctx = _merge_messages(anthropic_ctx)
+        stream = self._client.messages.create(
+            max_tokens=opts.get("max_tokens", 1000),
+            system=latest_system_message,
+            messages=collaped_anthropic_ctx,
+            model=self._opts.model,
+            temperature=temperature or anthropic.NOT_GIVEN,
+            top_k=n or anthropic.NOT_GIVEN,
+            stream=True,
+            **opts,
+        )
+
+        return LLMStream(anthropic_stream=stream, chat_ctx=chat_ctx, fnc_ctx=fnc_ctx)
+
+
+class LLMStream(llm.LLMStream):
+    def __init__(
+        self,
+        *,
+        anthropic_stream: Awaitable[
+            anthropic.AsyncStream[anthropic.types.RawMessageStreamEvent]
+        ],
+        chat_ctx: llm.ChatContext,
+        fnc_ctx: llm.FunctionContext | None,
+    ) -> None:
+        super().__init__(chat_ctx=chat_ctx, fnc_ctx=fnc_ctx)
+        self._awaitable_anthropic_stream = anthropic_stream
+        self._anthropic_stream: (
+            anthropic.AsyncStream[anthropic.types.RawMessageStreamEvent] | None
+        ) = None
+
+        # current function call that we're waiting for full completion (args are streamed)
+        self._tool_call_id: str | None = None
+        self._fnc_name: str | None = None
+        self._fnc_raw_arguments: str | None = None
+
+    async def aclose(self) -> None:
+        if self._anthropic_stream:
+            await self._anthropic_stream.close()
+
+        return await super().aclose()
+
+    async def __anext__(self):
+        if not self._anthropic_stream:
+            self._anthropic_stream = await self._awaitable_anthropic_stream
+
+        async for event in self._anthropic_stream:
+            if event.type == "message_start":
+                pass
+            elif event.type == "message_delta":
+                pass
+            elif event.type == "message_stop":
+                pass
+            elif event.type == "content_block_start":
+                if event.content_block.type == "tool_use":
+                    self._tool_call_id = event.content_block.id
+                    self._fnc_raw_arguments = ""
+                    self._fnc_name = event.content_block.name
+            elif event.type == "content_block_delta":
+                delta = event.delta
+                if delta.type == "text_delta":
+                    return llm.ChatChunk(
+                        choices=[
+                            llm.Choice(
+                                delta=llm.ChoiceDelta(
+                                    content=delta.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:
+                    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)
+                    chunk = llm.ChatChunk(
+                        choices=[
+                            llm.Choice(
+                                delta=llm.ChoiceDelta(
+                                    role="assistant", tool_calls=[fnc_info]
+                                ),
+                                index=0,
+                            )
+                        ]
+                    )
+                    self._tool_call_id = None
+                    self._fnc_raw_arguments = None
+                    self._fnc_name = None
+                    return chunk
+
+        raise StopAsyncIteration
+
+
+def _latest_system_message(chat_ctx: llm.ChatContext) -> str:
+    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)]
+            )
+    return latest_system_str
+
+
+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
+) -> List[anthropic.types.MessageParam]:
+    result: List[anthropic.types.MessageParam] = []
+    for msg in chat_ctx:
+        a_msg = _build_anthropic_message(msg, cache_key)
+        if a_msg:
+            result.append(a_msg)
+    return result
+
+
+def _build_anthropic_message(msg: llm.ChatMessage, cache_key: Any):
+    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):
+            a_msg["content"].append(
+                anthropic.types.TextBlock(
+                    text=msg.content,
+                    type="text",
+                )
+            )
+        elif isinstance(msg.content, list):
+            for cnt in msg.content:
+                if isinstance(cnt, str):
+                    content: anthropic.types.TextBlock = anthropic.types.TextBlock(
+                        text=cnt,
+                        type="text",
+                    )
+                    a_content.append(content)
+                elif isinstance(cnt, llm.ChatImage):
+                    a_content.append(_build_anthropic_image_content(cnt, cache_key))
+        return a_msg
+    elif msg.role == "tool":
+        ant_msg: anthropic.types.MessageParam = {
+            "role": "assistant",
+            "content": [],
+        }
+        assert isinstance(ant_msg["content"], list)
+        # make sure to provide when function has been called inside the context
+        # (+ raw_arguments)
+        if msg.tool_calls is not None:
+            for fnc in msg.tool_calls:
+                ant_msg["content"].append(
+                    {
+                        "id": fnc.tool_call_id,
+                        "type": "tool_use",
+                        "input": fnc.arguments,
+                        "name": fnc.function_info.name,
+                    }
+                )
+                if isinstance(msg.content, str):
+                    ant_msg["content"].append(
+                        {
+                            "tool_use_id": fnc.tool_call_id,
+                            "type": "tool_result",
+                            "content": msg.content,
+                        }
+                    )
+                else:
+                    logger.warning(
+                        "tool result content is not a string, this is not supported by anthropic"
+                    )
+        return ant_msg
+
+    return None
+
+
+def _build_anthropic_image_content(
+    image: llm.ChatImage, cache_key: Any
+) -> anthropic.types.ImageBlockParam:
+    if isinstance(image.image, str):  # image url
+        logger.warning(
+            "image url not supported by anthropic, skipping image '%s'", image.image
+        )
+    elif isinstance(image.image, rtc.VideoFrame):  # 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="center_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",
+            },
+        }
+
+    raise ValueError(f"unknown image type {type(image.image)}")
+
+
+def _create_ai_function_info(
+    fnc_ctx: llm.function_context.FunctionContext,
+    tool_call_id: str,
+    fnc_name: str,
+    raw_arguments: str,  # JSON string
+) -> llm.function_context.FunctionCallInfo:
+    if fnc_name not in fnc_ctx.ai_functions:
+        raise ValueError(f"AI function {fnc_name} not found")
+
+    parsed_arguments: dict[str, Any] = {}
+    try:
+        if raw_arguments:  # ignore empty string
+            parsed_arguments = json.loads(raw_arguments)
+    except json.JSONDecodeError:
+        raise ValueError(
+            f"AI function {fnc_name} received invalid JSON arguments - {raw_arguments}"
+        )
+
+    fnc_info = fnc_ctx.ai_functions[fnc_name]
+
+    # Ensure all necessary arguments are present and of the correct type.
+    sanitized_arguments: dict[str, Any] = {}
+    for arg_info in fnc_info.arguments.values():
+        if arg_info.name not in parsed_arguments:
+            if arg_info.default is inspect.Parameter.empty:
+                raise ValueError(
+                    f"AI function {fnc_name} missing required argument {arg_info.name}"
+                )
+            continue
+
+        arg_value = parsed_arguments[arg_info.name]
+        if get_origin(arg_info.type) is not None:
+            if not isinstance(arg_value, list):
+                raise ValueError(
+                    f"AI function {fnc_name} argument {arg_info.name} should be a list"
+                )
+
+            inner_type = get_args(arg_info.type)[0]
+            sanitized_value = [
+                _sanitize_primitive(
+                    value=v, expected_type=inner_type, choices=arg_info.choices
+                )
+                for v in arg_value
+            ]
+        else:
+            sanitized_value = _sanitize_primitive(
+                value=arg_value, expected_type=arg_info.type, choices=arg_info.choices
+            )
+
+        sanitized_arguments[arg_info.name] = sanitized_value
+
+    return llm.function_context.FunctionCallInfo(
+        tool_call_id=tool_call_id,
+        raw_arguments=raw_arguments,
+        function_info=fnc_info,
+        arguments=sanitized_arguments,
+    )
+
+
+def _build_function_description(
+    fnc_info: llm.function_context.FunctionInfo,
+) -> 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
+
+        if get_origin(arg_info.type) is list:
+            inner_type = get_args(arg_info.type)[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(arg_info.type)
+            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 {
+        "name": fnc_info.name,
+        "description": fnc_info.description,
+        "input_schema": input_schema,
+    }
+
+
+def _sanitize_primitive(
+    *, value: Any, expected_type: type, choices: Tuple[Any] | None
+) -> Any:
+    if expected_type is str:
+        if not isinstance(value, str):
+            raise ValueError(f"expected str, got {type(value)}")
+    elif expected_type in (int, float):
+        if not isinstance(value, (int, float)):
+            raise ValueError(f"expected number, got {type(value)}")
+
+        if expected_type is int:
+            if value % 1 != 0:
+                raise ValueError("expected int, got float")
+
+            value = int(value)
+        elif expected_type is float:
+            value = float(value)
+
+    elif expected_type is bool:
+        if not isinstance(value, bool):
+            raise ValueError(f"expected bool, got {type(value)}")
+
+    if choices and value not in choices:
+        raise ValueError(f"invalid value {value}, not in {choices}")
+
+    return value

livekit/plugins/anthropic/log.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("livekit.plugins.anthropic")

livekit/plugins/anthropic/models.py

@@ -0,0 +1,8 @@
+from typing import Literal
+
+ChatModels = Literal[
+    "claude-3-5-sonnet-20240620",
+    "claude-3-opus-20240229",
+    "claude-3-sonnet-20240229",
+    "claude-3-haiku-20240307",
+]

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.0.1"
+__version__ = "0.2.0"

{livekit_plugins_anthropic-0.0.1.dist-info → livekit_plugins_anthropic-0.2.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: livekit-plugins-anthropic
-Version: 0.0.1
-Summary: LiveKit Python Plugins for Anthropic Models and Services
-Home-page: https://github.com/livekit/python-agents
+Version: 0.2.0
+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/python-agents
+Project-URL: Source, https://github.com/livekit/agents
 Keywords: webrtc,realtime,audio,video,livekit
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -14,13 +14,24 @@ 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.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7.0
+Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
-Requires-Dist: anthropic >=0.7.5
+Requires-Dist: livekit-agents ~=0.8
+Requires-Dist: anthropic ~=0.34
 
-# LiveKit Pluginss for OpenAI Models and Services
+# LiveKit Plugins Anthropic
+
+Agent Framework plugin for services from Anthropic.
+
+## Installation
+
+```bash
+pip install livekit-plugins-anthropic
+```
+
+## Pre-requisites
+
+You'll need an API key from Anthropic. It can be set as an environment variable: `ANTHROPIC_API_KEY`

livekit_plugins_anthropic-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+livekit/plugins/anthropic/__init__.py,sha256=g6KUqOfZo9DIBwBD98u6QOWY7pr8ZYJJ61fk3AWpoa4,1006
+livekit/plugins/anthropic/llm.py,sha256=SJo_opc9_2rKYvcDW8-ltuOD-p7QUc0oROGDHu04htY,17162
+livekit/plugins/anthropic/log.py,sha256=fG1pYSY88AnT738gZrmzF9FO4l4BdGENj3VKHMQB3Yo,72
+livekit/plugins/anthropic/models.py,sha256=AVEhrEtKfWxsd-R03u7R74hcKjJq4oDVSTukvoPQGb0,179
+livekit/plugins/anthropic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/anthropic/version.py,sha256=cLFCdnm5S21CiJ5UJBcqfRvvFkCQ8p6M5fFUJVJkEiM,600
+livekit_plugins_anthropic-0.2.0.dist-info/METADATA,sha256=1VWzsOFCxwtoB2m-NVZgKPoPI8xwsZctTbZJO8FYxbI,1264
+livekit_plugins_anthropic-0.2.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+livekit_plugins_anthropic-0.2.0.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
+livekit_plugins_anthropic-0.2.0.dist-info/RECORD,,

{livekit_plugins_anthropic-0.0.1.dist-info → livekit_plugins_anthropic-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

livekit/plugins/anthropic/claude.py

@@ -1,126 +0,0 @@
-# Copyright 2023 LiveKit, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import logging
-import asyncio
-from dataclasses import dataclass
-from typing import AsyncIterable
-from anthropic import AsyncAnthropic, HUMAN_PROMPT, AI_PROMPT
-from enum import Enum
-
-ClaudeMessageRole = Enum(
-    'MessageRole', ["system", "human", "assistant"])
-
-
-@dataclass
-class ClaudeMessage:
-    role: ClaudeMessageRole
-    content: str
-
-    def to_api(self):
-        if ClaudeMessageRole.system == self.role:
-            return f"{self.content}"
-        elif ClaudeMessageRole.human == self.role:
-            return f"{HUMAN_PROMPT} {self.content}"
-        elif ClaudeMessageRole.assistant == self.role:
-            return f"{AI_PROMPT} {self.content}"
-        else:
-            raise ValueError("Invalid message role")
-
-
-class ClaudePlugin:
-    def __init__(self, model: str = 'claude-2', system_message: str = ''):
-        self._client = AsyncAnthropic(
-            api_key=os.environ["ANTHROPIC_API_KEY"])
-        self._model = model
-        self._system_message = system_message
-        self._messages: [ClaudeMessage] = []
-        self._producing_response = False
-        self._needs_interrupt = False
-
-    def interrupt(self):
-        if self._producing_response:
-            self._needs_interrupt = True
-
-    async def close(self):
-        pass
-
-    async def add_message(self, message: ClaudeMessage) -> AsyncIterable[str]:
-        self._messages.append(message)
-        async for text in self._generate_text_streamed():
-            yield text
-
-    async def _generate_text_streamed(self) -> AsyncIterable[str]:
-        system_message = ClaudeMessage(
-            role=ClaudeMessageRole.system, content=self._system_message)
-
-        try:
-            '''
-            Example Claude2 formatting for prompts:
-
-            Cats are wonderful animals and loved by everyone, no matter how many legs they have.
-
-            Human: I have two pet cats. One of them is missing a leg. The other one has a normal number of legs for a cat to have. In total, how many legs do my cats have?
-
-            Assistant: Can I think step-by-step?
-
-            Human: Yes, please do.
-
-            Assistant:
-            '''
-            prompt = ''.join([system_message.to_api()] + [m.to_api()
-                                                          for m in self._messages] + [ClaudeMessage(role=ClaudeMessageRole.assistant, content="").to_api()])
-            chat_stream = await asyncio.wait_for(
-                self._client.completions.create(
-                    model=self._model,
-                    max_tokens_to_sample=300,
-                    stream=True,
-                    prompt=prompt
-                ),
-                10
-            )
-        except TimeoutError:
-            yield "Sorry, I'm taking too long to respond. Please try again later."
-            return
-
-        self._producing_response = True
-        full_response = ""
-
-        while True:
-            try:
-                chunk = await asyncio.wait_for(anext(chat_stream, None), 5)
-            except TimeoutError:
-                break
-            except asyncio.CancelledError:
-                self._producing_response = False
-                self._needs_interrupt = False
-                break
-
-            if chunk is None:
-                break
-            content = chunk.completion
-
-            if self._needs_interrupt:
-                self._needs_interrupt = False
-                logging.info("Claude interrupted")
-                break
-
-            if content is not None:
-                full_response += content
-                yield content
-
-        self._messages.append(ClaudeMessage(
-            role=ClaudeMessageRole.assistant, content=full_response))
-        self._producing_response = False

livekit_plugins_anthropic-0.0.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-livekit/plugins/anthropic/__init__.py,sha256=bQ7r_vtiEz_LIY6SwFrH2W8qP1YP17-Z8aoeFvT4CFM,645
-livekit/plugins/anthropic/claude.py,sha256=ApgeJyzZOaxYIRKnW6QAjH8lBmxGcKt1Y10216VO4Iw,4276
-livekit/plugins/anthropic/version.py,sha256=6n5MU9nSMToMkOa05fR2KUwXCu_cet-aGMSmD5ouRug,600
-livekit_plugins_anthropic-0.0.1.dist-info/METADATA,sha256=Hxo7R0JWrupRHbEXq8-GKPM5vKjRtwg-pP3RveC3BHs,1129
-livekit_plugins_anthropic-0.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-livekit_plugins_anthropic-0.0.1.dist-info/top_level.txt,sha256=OoDok3xUmXbZRvOrfvvXB-Juu4DX79dlq188E19YHoo,8
-livekit_plugins_anthropic-0.0.1.dist-info/RECORD,,