vectorvein 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

vectorvein/chat_clients/__init__.py

@@ -20,7 +20,7 @@ from .deepseek_client import DeepSeekChatClient, AsyncDeepSeekChatClient
 from ..types import defaults as defs
 from ..types.enums import BackendType, ContextLengthControlType
 from .anthropic_client import AnthropicChatClient, AsyncAnthropicChatClient
-from .utils import format_messages, get_token_counts, ToolCallContentProcessor
+from .utils import format_messages, get_token_counts, get_message_token_counts, ToolCallContentProcessor
 
 
 BackendMap = {
@@ -125,5 +125,6 @@ __all__ = [
     "get_token_counts",
     "create_chat_client",
     "create_async_chat_client",
+    "get_message_token_counts",
     "ToolCallContentProcessor",
 ]

vectorvein/chat_clients/anthropic_client.py

@@ -21,7 +21,7 @@ from google.auth import _helpers
 
 from ..settings import settings
 from ..types import defaults as defs
-from .utils import cutoff_messages, get_token_counts
+from .utils import cutoff_messages, get_message_token_counts
 from .base_client import BaseChatClient, BaseAsyncChatClient
 from ..types.enums import ContextLengthControlType, BackendType
 from ..types.llm_parameters import ChatCompletionMessage, ChatCompletionDeltaMessage
@@ -112,46 +112,8 @@ class AnthropicChatClient(BaseChatClient):
             **kwargs,
         )
 
-    def create_completion(
-        self,
-        messages: list = list,
-        model: str | None = None,
-        stream: bool | None = None,
-        temperature: float | None = None,
-        max_tokens: int | None = None,
-        tools: list | NotGiven = NOT_GIVEN,
-        tool_choice: str | NotGiven = NOT_GIVEN,
-        **kwargs,
-    ):
-        if model is not None:
-            self.model = model
-        if stream is not None:
-            self.stream = stream
-        if temperature is not None:
-            self.temperature = temperature
-        if isinstance(tools, OpenAINotGiven):
-            tools = NOT_GIVEN
-        if isinstance(tool_choice, OpenAINotGiven):
-            tool_choice = NOT_GIVEN
-
-        self.model_setting = self.backend_settings.models[self.model]
-
-        if messages[0].get("role") == "system":
-            system_prompt = messages[0]["content"]
-            messages = messages[1:]
-        else:
-            system_prompt = ""
-
-        if self.context_length_control == ContextLengthControlType.Latest:
-            messages = cutoff_messages(
-                messages,
-                max_count=self.model_setting.context_length,
-                backend=self.BACKEND_NAME,
-                model=self.model_setting.id,
-            )
-
-        messages = format_messages_alternate(messages)
-
+    @property
+    def raw_client(self):
         if self.random_endpoint:
             self.random_endpoint = True
             self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
@@ -181,7 +143,7 @@ class AnthropicChatClient(BaseChatClient):
             else:
                 base_url = f"{self.endpoint.api_base}{self.endpoint.region}-aiplatform/v1"
 
-            self._client = AnthropicVertex(
+            return AnthropicVertex(
                 region=self.endpoint.region,
                 base_url=base_url,
                 project_id=self.endpoint.credentials.get("quota_project_id"),
@@ -189,25 +151,64 @@ class AnthropicChatClient(BaseChatClient):
                 http_client=self.http_client,
             )
         else:
-            self._client = Anthropic(
+            return Anthropic(
                 api_key=self.endpoint.api_key,
                 base_url=self.endpoint.api_base,
                 http_client=self.http_client,
             )
 
+    def create_completion(
+        self,
+        messages: list = list,
+        model: str | None = None,
+        stream: bool | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        tools: list | NotGiven = NOT_GIVEN,
+        tool_choice: str | NotGiven = NOT_GIVEN,
+        **kwargs,
+    ):
+        if model is not None:
+            self.model = model
+        if stream is not None:
+            self.stream = stream
+        if temperature is not None:
+            self.temperature = temperature
+        if isinstance(tools, OpenAINotGiven):
+            tools = NOT_GIVEN
+        if isinstance(tool_choice, OpenAINotGiven):
+            tool_choice = NOT_GIVEN
+
+        self.model_setting = self.backend_settings.models[self.model]
+
+        if messages[0].get("role") == "system":
+            system_prompt = messages[0]["content"]
+            messages = messages[1:]
+        else:
+            system_prompt = ""
+
+        if self.context_length_control == ContextLengthControlType.Latest:
+            messages = cutoff_messages(
+                messages,
+                max_count=self.model_setting.context_length,
+                backend=self.BACKEND_NAME,
+                model=self.model_setting.id,
+            )
+
+        messages = format_messages_alternate(messages)
+
         tools_params = refactor_tool_use_params(tools) if tools else tools
 
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
+            token_counts = get_message_token_counts(messages=messages, tools=tools_params, model=self.model_setting.id)
             if max_output_tokens is not None:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
             else:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
 
-        response = self._client.messages.create(
+        response = self.raw_client.messages.create(
             model=self.model_setting.id,
             messages=messages,
             system=system_prompt,
@@ -318,46 +319,8 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
             **kwargs,
         )
 
-    async def create_completion(
-        self,
-        messages: list = list,
-        model: str | None = None,
-        stream: bool | None = None,
-        temperature: float | None = None,
-        max_tokens: int | None = None,
-        tools: list | NotGiven = NOT_GIVEN,
-        tool_choice: str | NotGiven = NOT_GIVEN,
-        **kwargs,
-    ):
-        if model is not None:
-            self.model = model
-        if stream is not None:
-            self.stream = stream
-        if temperature is not None:
-            self.temperature = temperature
-        if isinstance(tools, OpenAINotGiven):
-            tools = NOT_GIVEN
-        if isinstance(tool_choice, OpenAINotGiven):
-            tool_choice = NOT_GIVEN
-
-        self.model_setting = self.backend_settings.models[self.model]
-
-        if messages[0].get("role") == "system":
-            system_prompt = messages[0]["content"]
-            messages = messages[1:]
-        else:
-            system_prompt = ""
-
-        if self.context_length_control == ContextLengthControlType.Latest:
-            messages = cutoff_messages(
-                messages,
-                max_count=self.model_setting.context_length,
-                backend=self.BACKEND_NAME,
-                model=self.model_setting.id,
-            )
-
-        messages = format_messages_alternate(messages)
-
+    @property
+    def raw_client(self):
         if self.random_endpoint:
             self.random_endpoint = True
             self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
@@ -387,7 +350,7 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
             else:
                 base_url = f"{self.endpoint.api_base}{self.endpoint.region}-aiplatform/v1"
 
-            self._client = AsyncAnthropicVertex(
+            return AsyncAnthropicVertex(
                 region=self.endpoint.region,
                 base_url=base_url,
                 project_id=self.endpoint.credentials.get("quota_project_id"),
@@ -395,25 +358,64 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
                 http_client=self.http_client,
             )
         else:
-            self._client = AsyncAnthropic(
+            return AsyncAnthropic(
                 api_key=self.endpoint.api_key,
                 base_url=self.endpoint.api_base,
                 http_client=self.http_client,
             )
 
+    async def create_completion(
+        self,
+        messages: list = list,
+        model: str | None = None,
+        stream: bool | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        tools: list | NotGiven = NOT_GIVEN,
+        tool_choice: str | NotGiven = NOT_GIVEN,
+        **kwargs,
+    ):
+        if model is not None:
+            self.model = model
+        if stream is not None:
+            self.stream = stream
+        if temperature is not None:
+            self.temperature = temperature
+        if isinstance(tools, OpenAINotGiven):
+            tools = NOT_GIVEN
+        if isinstance(tool_choice, OpenAINotGiven):
+            tool_choice = NOT_GIVEN
+
+        self.model_setting = self.backend_settings.models[self.model]
+
+        if messages[0].get("role") == "system":
+            system_prompt = messages[0]["content"]
+            messages = messages[1:]
+        else:
+            system_prompt = ""
+
+        if self.context_length_control == ContextLengthControlType.Latest:
+            messages = cutoff_messages(
+                messages,
+                max_count=self.model_setting.context_length,
+                backend=self.BACKEND_NAME,
+                model=self.model_setting.id,
+            )
+
+        messages = format_messages_alternate(messages)
+
         tools_params = refactor_tool_use_params(tools) if tools else tools
 
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
+            token_counts = get_message_token_counts(messages=messages, tools=tools_params, model=self.model_setting.id)
             if max_output_tokens is not None:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
             else:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
 
-        response = await self._client.messages.create(
+        response = await self.raw_client.messages.create(
             model=self.model_setting.id,
             messages=messages,
             system=system_prompt,

vectorvein/chat_clients/base_client.py

@@ -5,6 +5,8 @@ from typing import Generator, AsyncGenerator, Any
 
 import httpx
 from openai._types import NotGiven, NOT_GIVEN
+from openai import OpenAI, AsyncOpenAI, AzureOpenAI, AsyncAzureOpenAI
+from anthropic import Anthropic, AnthropicVertex, AsyncAnthropic, AsyncAnthropicVertex
 
 from ..settings import settings
 from ..types import defaults as defs
@@ -42,6 +44,11 @@ class BaseChatClient(ABC):
             self.random_endpoint = False
             self.endpoint = settings.get_endpoint(self.endpoint_id)
 
+    @property
+    @abstractmethod
+    def raw_client(self) -> OpenAI | AzureOpenAI | Anthropic | AnthropicVertex:
+        pass
+
     @abstractmethod
     def create_completion(
         self,
@@ -108,6 +115,11 @@ class BaseAsyncChatClient(ABC):
             self.random_endpoint = False
             self.endpoint = settings.get_endpoint(self.endpoint_id)
 
+    @property
+    @abstractmethod
+    def raw_client(self) -> AsyncOpenAI | AsyncAzureOpenAI | AsyncAnthropic | AsyncAnthropicVertex:
+        pass
+
     @abstractmethod
     async def create_completion(
         self,

vectorvein/chat_clients/openai_compatible_client.py

@@ -2,6 +2,7 @@
 # @Date:   2024-07-26 14:48:55
 import json
 import random
+from functools import cached_property
 
 import httpx
 from openai._types import NotGiven, NOT_GIVEN
@@ -12,7 +13,7 @@ from openai import OpenAI, AsyncOpenAI, AzureOpenAI, AsyncAzureOpenAI
 from .base_client import BaseChatClient, BaseAsyncChatClient
 from .utils import (
     cutoff_messages,
-    get_token_counts,
+    get_message_token_counts,
     ToolCallContentProcessor,
     generate_tool_use_system_prompt,
 )
@@ -48,6 +49,27 @@ class OpenAICompatibleChatClient(BaseChatClient):
             **kwargs,
         )
 
+    @cached_property
+    def raw_client(self):
+        if self.random_endpoint:
+            self.random_endpoint = True
+            self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
+            self.endpoint = settings.get_endpoint(self.endpoint_id)
+
+        if self.endpoint.is_azure:
+            return AzureOpenAI(
+                azure_endpoint=self.endpoint.api_base,
+                api_key=self.endpoint.api_key,
+                api_version="2024-08-01-preview",
+                http_client=self.http_client,
+            )
+        else:
+            return OpenAI(
+                api_key=self.endpoint.api_key,
+                base_url=self.endpoint.api_base,
+                http_client=self.http_client,
+            )
+
     def create_completion(
         self,
         messages: list = list,
@@ -68,24 +90,24 @@ class OpenAICompatibleChatClient(BaseChatClient):
 
         self.model_setting = self.backend_settings.models[self.model]
 
-        if self.random_endpoint:
-            self.random_endpoint = True
-            self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+        # if self.random_endpoint:
+        #     self.random_endpoint = True
+        #     self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
+        #     self.endpoint = settings.get_endpoint(self.endpoint_id)
 
-        if self.endpoint.is_azure:
-            self._client = AzureOpenAI(
-                azure_endpoint=self.endpoint.api_base,
-                api_key=self.endpoint.api_key,
-                api_version="2024-08-01-preview",
-                http_client=self.http_client,
-            )
-        else:
-            self._client = OpenAI(
-                api_key=self.endpoint.api_key,
-                base_url=self.endpoint.api_base,
-                http_client=self.http_client,
-            )
+        # if self.endpoint.is_azure:
+        #     self._client = AzureOpenAI(
+        #         azure_endpoint=self.endpoint.api_base,
+        #         api_key=self.endpoint.api_key,
+        #         api_version="2024-08-01-preview",
+        #         http_client=self.http_client,
+        #     )
+        # else:
+        #     self._client = OpenAI(
+        #         api_key=self.endpoint.api_key,
+        #         base_url=self.endpoint.api_base,
+        #         http_client=self.http_client,
+        #     )
 
         if self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
@@ -111,15 +133,14 @@ class OpenAICompatibleChatClient(BaseChatClient):
 
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
+            token_counts = get_message_token_counts(messages=messages, tools=tools_params, model=self.model_setting.id)
             if max_output_tokens is not None:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
             else:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
 
-        response: ChatCompletion | Stream[ChatCompletionChunk] = self._client.chat.completions.create(
+        response: ChatCompletion | Stream[ChatCompletionChunk] = self.raw_client.chat.completions.create(
             model=self.model_setting.id,
             messages=messages,
             stream=self.stream,
@@ -207,6 +228,27 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
             **kwargs,
         )
 
+    @cached_property
+    def raw_client(self):
+        if self.random_endpoint:
+            self.random_endpoint = True
+            self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
+            self.endpoint = settings.get_endpoint(self.endpoint_id)
+
+        if self.endpoint.is_azure:
+            return AsyncAzureOpenAI(
+                azure_endpoint=self.endpoint.api_base,
+                api_key=self.endpoint.api_key,
+                api_version="2024-08-01-preview",
+                http_client=self.http_client,
+            )
+        else:
+            return AsyncOpenAI(
+                api_key=self.endpoint.api_key,
+                base_url=self.endpoint.api_base,
+                http_client=self.http_client,
+            )
+
     async def create_completion(
         self,
         messages: list = list,
@@ -227,24 +269,24 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
 
         self.model_setting = self.backend_settings.models[self.model]
 
-        if self.random_endpoint:
-            self.random_endpoint = True
-            self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+        # if self.random_endpoint:
+        #     self.random_endpoint = True
+        #     self.endpoint_id = random.choice(self.backend_settings.models[self.model].endpoints)
+        #     self.endpoint = settings.get_endpoint(self.endpoint_id)
 
-        if self.endpoint.is_azure:
-            self._client = AsyncAzureOpenAI(
-                azure_endpoint=self.endpoint.api_base,
-                api_key=self.endpoint.api_key,
-                api_version="2024-08-01-preview",
-                http_client=self.http_client,
-            )
-        else:
-            self._client = AsyncOpenAI(
-                api_key=self.endpoint.api_key,
-                base_url=self.endpoint.api_base,
-                http_client=self.http_client,
-            )
+        # if self.endpoint.is_azure:
+        #     self._client = AsyncAzureOpenAI(
+        #         azure_endpoint=self.endpoint.api_base,
+        #         api_key=self.endpoint.api_key,
+        #         api_version="2024-08-01-preview",
+        #         http_client=self.http_client,
+        #     )
+        # else:
+        #     self._client = AsyncOpenAI(
+        #         api_key=self.endpoint.api_key,
+        #         base_url=self.endpoint.api_base,
+        #         http_client=self.http_client,
+        #     )
 
         if self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
@@ -270,15 +312,14 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
 
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
+            token_counts = get_message_token_counts(messages=messages, tools=tools_params, model=self.model_setting.id)
             if max_output_tokens is not None:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
             else:
-                token_counts = get_token_counts({"messages": messages, "tools_params": tools_params})
                 max_tokens = self.model_setting.context_length - token_counts
 
-        response: ChatCompletion | AsyncStream[ChatCompletionChunk] = await self._client.chat.completions.create(
+        response: ChatCompletion | AsyncStream[ChatCompletionChunk] = await self.raw_client.chat.completions.create(
             model=self.model_setting.id,
             messages=messages,
             stream=self.stream,

vectorvein/chat_clients/utils.py

@@ -2,7 +2,7 @@
 # @Date:   2024-07-26 14:48:55
 import re
 import json
-
+from math import ceil
 import httpx
 import tiktoken
 from anthropic import Anthropic
@@ -187,6 +187,46 @@ def get_token_counts(text: str | dict, model: str = "") -> int:
         return len(chatgpt_encoding.encode(text))
 
 
+def calculate_image_tokens(width: int, height: int, model: str = "gpt-4o"):
+    if width > 2048 or height > 2048:
+        aspect_ratio = width / height
+        if aspect_ratio > 1:
+            width, height = 2048, int(2048 / aspect_ratio)
+        else:
+            width, height = int(2048 * aspect_ratio), 2048
+
+    if width >= height and height > 768:
+        width, height = int((768 / height) * width), 768
+    elif height > width and width > 768:
+        width, height = 768, int((768 / width) * height)
+
+    tiles_width = ceil(width / 512)
+    tiles_height = ceil(height / 512)
+    total_tokens = 85 + 170 * (tiles_width * tiles_height)
+
+    return total_tokens
+
+
+def get_message_token_counts(messages: list, tools: dict | None = None, model: str = "gpt-4o") -> int:
+    tokens = 0
+    formatted_messages = format_messages(messages, backend=BackendType.OpenAI, native_multimodal=True)
+    for message in formatted_messages:
+        content = message["content"]
+        if isinstance(content, str):
+            tokens += get_token_counts(content, model)
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and item["type"] == "text":
+                    tokens += get_token_counts(item["text"], model)
+                elif isinstance(item, dict) and item["type"].startswith("image"):
+                    # TODO: Get real image size
+                    tokens += calculate_image_tokens(2048, 2048, model)
+    if tools is not None:
+        tokens += get_token_counts(str(tools), model)
+
+    return tokens
+
+
 def cutoff_messages(
     messages: list,
     max_count: int = 16000,

{vectorvein-0.1.15.dist-info → vectorvein-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectorvein
-Version: 0.1.15
+Version: 0.1.17
 Summary: Default template for PDM package
 Author-Email: Anderson <andersonby@163.com>
 License: MIT

{vectorvein-0.1.15.dist-info → vectorvein-0.1.17.dist-info}/RECORD

@@ -1,10 +1,10 @@
-vectorvein-0.1.15.dist-info/METADATA,sha256=3z3VVgOstft4qBbm9Nyb3GdyiiuSHbYGZnmPvD90CyM,502
-vectorvein-0.1.15.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
+vectorvein-0.1.17.dist-info/METADATA,sha256=TgZP36atynGGP_1BGQNSZhPL5HfsNaex7dAs7ahSRfs,502
+vectorvein-0.1.17.dist-info/WHEEL,sha256=rSwsxJWe3vzyR5HCwjWXQruDgschpei4h_giTm0dJVE,90
 vectorvein/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vectorvein/chat_clients/__init__.py,sha256=oaEcDx5MM89oBOqmvWWDGAkMoaHihh892cA0tJU2u4g,4599
-vectorvein/chat_clients/anthropic_client.py,sha256=sECXynbReJs1xixFEHSlfEQo9Q1zGf5uCJ-V8emdoAM,20438
+vectorvein/chat_clients/__init__.py,sha256=lOGrIEBGN-EoxJ-dF5uMsO6viNCIFIeNL8whDwE6x3g,4657
+vectorvein/chat_clients/anthropic_client.py,sha256=VJQi7cKLbbLkJtmEFN9M41JUaGjwEuJaXIuQLK-3rdw,20332
 vectorvein/chat_clients/baichuan_client.py,sha256=CVMvpgjdrZGv0BWnTOBD-f2ufZ3wq3496wqukumsAr4,526
-vectorvein/chat_clients/base_client.py,sha256=4nGY5A7s7Ubgqb7XqFGkYwM6RNYDTuWkHZrH5KTJZiE,4585
+vectorvein/chat_clients/base_client.py,sha256=AnzEmNfT4XW4lKcwf8fv2NlSk1EHK0evr4-1EH0KkwI,5018
 vectorvein/chat_clients/deepseek_client.py,sha256=3qWu01NlJAP2N-Ff62d5-CZXZitlizE1fzb20LNetig,526
 vectorvein/chat_clients/gemini_client.py,sha256=W-9Vu-GTE9wxStPznyNR0rBEgDG3LYBu2uQXd4sh1YQ,14425
 vectorvein/chat_clients/groq_client.py,sha256=Uow4pgdmFi93ZQSoOol2-0PhhqkW-S0XuSldvppz5U4,498
@@ -13,9 +13,9 @@ vectorvein/chat_clients/minimax_client.py,sha256=iNq87zWx79g8tGo784c67xUt-YQ4TyM
 vectorvein/chat_clients/mistral_client.py,sha256=1aKSylzBDaLYcFnaBIL4-sXSzWmXfBeON9Q0rq-ziWw,534
 vectorvein/chat_clients/moonshot_client.py,sha256=gbu-6nGxx8uM_U2WlI4Wus881rFRotzHtMSoYOcruGU,526
 vectorvein/chat_clients/openai_client.py,sha256=Nz6tV45pWcsOupxjnsRsGTicbQNJWIZyxuJoJ5DGMpg,527
-vectorvein/chat_clients/openai_compatible_client.py,sha256=00Kxwmnooh-yfENkNLgl1Ped2s912njwVitqes8SZpw,14181
+vectorvein/chat_clients/openai_compatible_client.py,sha256=Rq_VTEddx6bXmr9TDKeI55mGUIos4THpRUgw1h3R4w4,15710
 vectorvein/chat_clients/qwen_client.py,sha256=-ryh-m9PgsO0fc4ulcCmPTy1155J8YUy15uPoJQOHA0,513
-vectorvein/chat_clients/utils.py,sha256=mnAew2Ie3nQHdEyDLKuJvXkQ5QdcSAJ6SpYk5JPbR1Q,20888
+vectorvein/chat_clients/utils.py,sha256=EbSodMwLCR8wnzyt2J6iOsL8WvSzlwdu71xZikzNdlg,22483
 vectorvein/chat_clients/yi_client.py,sha256=RNf4CRuPJfixrwLZ3-DEc3t25QDe1mvZeb9sku2f8Bc,484
 vectorvein/chat_clients/zhipuai_client.py,sha256=Ys5DSeLCuedaDXr3PfG1EW2zKXopt-awO2IylWSwY0s,519
 vectorvein/settings/__init__.py,sha256=jVHbhHn1BuMcyfZGXrxWKiI4NdY9wzvYyGMvKYmUtqg,3378
@@ -24,4 +24,4 @@ vectorvein/types/enums.py,sha256=PNK_pTIyjJFy-yAG2PHaMIO1ey3W6fReMCkH8M8VRW4,159
 vectorvein/types/llm_parameters.py,sha256=mmJjJZz4bPRi0nHzYNUNdWsQLHa9lbf3-MNVnU78vaY,3608
 vectorvein/utilities/media_processing.py,sha256=BujciRmw1GMmc3ELRvafL8STcy6r5b2rVnh27-uA7so,2256
 vectorvein/utilities/retry.py,sha256=9ePuJdeUUGx-qMWfaFxmlOvG_lQPwCQ4UB1z3Edlo34,993
-vectorvein-0.1.15.dist-info/RECORD,,
+vectorvein-0.1.17.dist-info/RECORD,,