vectorvein 0.1.75__tar.gz → 0.1.77__tar.gz

{vectorvein-0.1.75 → vectorvein-0.1.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectorvein
-Version: 0.1.75
+Version: 0.1.77
 Summary: VectorVein python SDK
 Author-Email: Anderson <andersonby@163.com>
 License: MIT

{vectorvein-0.1.75 → vectorvein-0.1.77}/pyproject.toml

@@ -17,7 +17,7 @@ description = "VectorVein python SDK"
 name = "vectorvein"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.1.75"
+version = "0.1.77"
 
 [project.license]
 text = "MIT"

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/chat_clients/anthropic_client.py

@@ -1,7 +1,6 @@
 # @Author: Bi Ying
 # @Date:   2024-07-26 14:48:55
 import json
-import random
 from typing import overload, Generator, AsyncGenerator, Any, Literal, Iterable
 
 import httpx
@@ -29,7 +28,6 @@ from google.oauth2.credentials import Credentials
 from google.auth.transport.requests import Request
 from google.auth import _helpers
 
-from ..settings import settings
 from ..types import defaults as defs
 from .utils import cutoff_messages, get_message_token_counts
 from .base_client import BaseChatClient, BaseAsyncChatClient
@@ -40,7 +38,6 @@ from ..types.llm_parameters import (
     NotGiven,
     ToolParam,
     ToolChoice,
-    EndpointSetting,
     AnthropicToolParam,
     AnthropicToolChoice,
     ChatCompletionMessage,
@@ -153,7 +150,7 @@ def refactor_into_openai_messages(messages: Iterable[MessageParam]):
 
 
 class AnthropicChatClient(BaseChatClient):
-    DEFAULT_MODEL: str | None = defs.ANTHROPIC_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.ANTHROPIC_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.Anthropic
 
     def __init__(
@@ -180,44 +177,13 @@ class AnthropicChatClient(BaseChatClient):
         self.model_id = None
         self.endpoint = None
 
-    def set_model_id_by_endpoint_id(self, endpoint_id: str):
-        for endpoint_option in self.backend_settings.models[self.model].endpoints:
-            if isinstance(endpoint_option, dict):
-                if endpoint_id == endpoint_option["endpoint_id"]:
-                    self.model_id = endpoint_option["model_id"]
-                    break
-            else:
-                if endpoint_id == endpoint_option:
-                    self.model_id = endpoint_option
-                    break
-        return self.model_id
-
-    def _set_endpoint(self):
-        if self.endpoint is None:
-            if self.random_endpoint:
-                self.random_endpoint = True
-                endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
-                if isinstance(endpoint, dict):
-                    self.endpoint_id = endpoint["endpoint_id"]
-                    self.model_id = endpoint["model_id"]
-                else:
-                    self.endpoint_id = endpoint
-                self.endpoint = settings.get_endpoint(self.endpoint_id)
-            else:
-                self.endpoint = settings.get_endpoint(self.endpoint_id)
-                self.set_model_id_by_endpoint_id(self.endpoint_id)
-        elif isinstance(self.endpoint, EndpointSetting):
-            self.endpoint_id = self.endpoint.id
-            self.set_model_id_by_endpoint_id(self.endpoint_id)
-        else:
-            raise ValueError("Invalid endpoint")
-
-        return self.endpoint, self.model_id
-
     @property
     def raw_client(self):  # type: ignore
         self.endpoint, self.model_id = self._set_endpoint()
 
+        if self.endpoint.proxy is not None and self.http_client is None:
+            self.http_client = httpx.Client(proxy=self.endpoint.proxy)
+
         if self.endpoint.is_vertex:
             if self.endpoint.credentials is None:
                 raise ValueError("Anthropic Vertex endpoint requires credentials")
@@ -565,7 +531,7 @@ class AnthropicChatClient(BaseChatClient):
 
 
 class AsyncAnthropicChatClient(BaseAsyncChatClient):
-    DEFAULT_MODEL: str | None = defs.ANTHROPIC_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.ANTHROPIC_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.Anthropic
 
     def __init__(
@@ -592,44 +558,13 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
         self.model_id = None
         self.endpoint = None
 
-    def set_model_id_by_endpoint_id(self, endpoint_id: str):
-        for endpoint_option in self.backend_settings.models[self.model].endpoints:
-            if isinstance(endpoint_option, dict):
-                if endpoint_id == endpoint_option["endpoint_id"]:
-                    self.model_id = endpoint_option["model_id"]
-                    break
-            else:
-                if endpoint_id == endpoint_option:
-                    self.model_id = endpoint_option
-                    break
-        return self.model_id
-
-    def _set_endpoint(self):
-        if self.endpoint is None:
-            if self.random_endpoint:
-                self.random_endpoint = True
-                endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
-                if isinstance(endpoint, dict):
-                    self.endpoint_id = endpoint["endpoint_id"]
-                    self.model_id = endpoint["model_id"]
-                else:
-                    self.endpoint_id = endpoint
-                self.endpoint = settings.get_endpoint(self.endpoint_id)
-            else:
-                self.endpoint = settings.get_endpoint(self.endpoint_id)
-                self.set_model_id_by_endpoint_id(self.endpoint_id)
-        elif isinstance(self.endpoint, EndpointSetting):
-            self.endpoint_id = self.endpoint.id
-            self.set_model_id_by_endpoint_id(self.endpoint_id)
-        else:
-            raise ValueError("Invalid endpoint")
-
-        return self.endpoint, self.model_id
-
     @property
     def raw_client(self):  # type: ignore
         self.endpoint, self.model_id = self._set_endpoint()
 
+        if self.endpoint.proxy is not None and self.http_client is None:
+            self.http_client = httpx.AsyncClient(proxy=self.endpoint.proxy)
+
         if self.endpoint.is_vertex:
             if self.endpoint.credentials is None:
                 raise ValueError("Anthropic Vertex endpoint requires credentials")

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/chat_clients/base_client.py

@@ -1,5 +1,6 @@
 # @Author: Bi Ying
 # @Date:   2024-07-26 14:48:55
+import random
 from abc import ABC, abstractmethod
 from functools import cached_property
 from typing import Generator, AsyncGenerator, Any, overload, Literal, Iterable
@@ -23,6 +24,7 @@ from ..types.llm_parameters import (
     NOT_GIVEN,
     ToolParam,
     ToolChoice,
+    EndpointSetting,
     ChatCompletionMessage,
     ChatCompletionDeltaMessage,
     ChatCompletionStreamOptionsParam,
@@ -30,7 +32,7 @@ from ..types.llm_parameters import (
 
 
 class BaseChatClient(ABC):
-    DEFAULT_MODEL: str | None = None
+    DEFAULT_MODEL: str
     BACKEND_NAME: BackendType
 
     def __init__(
@@ -62,6 +64,35 @@ class BaseChatClient(ABC):
             self.random_endpoint = False
             self.endpoint = settings.get_endpoint(self.endpoint_id)
 
+    def set_model_id_by_endpoint_id(self, endpoint_id: str):
+        for endpoint_option in self.backend_settings.models[self.model].endpoints:
+            if isinstance(endpoint_option, dict) and endpoint_id == endpoint_option["endpoint_id"]:
+                self.model_id = endpoint_option["model_id"]
+                break
+        return self.model_id
+
+    def _set_endpoint(self):
+        if self.endpoint is None:
+            if self.random_endpoint:
+                self.random_endpoint = True
+                endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
+                if isinstance(endpoint, dict):
+                    self.endpoint_id = endpoint["endpoint_id"]
+                    self.model_id = endpoint["model_id"]
+                else:
+                    self.endpoint_id = endpoint
+                self.endpoint = settings.get_endpoint(self.endpoint_id)
+            else:
+                self.endpoint = settings.get_endpoint(self.endpoint_id)
+                self.set_model_id_by_endpoint_id(self.endpoint_id)
+        elif isinstance(self.endpoint, EndpointSetting):
+            self.endpoint_id = self.endpoint.id
+            self.set_model_id_by_endpoint_id(self.endpoint_id)
+        else:
+            raise ValueError("Invalid endpoint")
+
+        return self.endpoint, self.model_id
+
     @cached_property
     @abstractmethod
     def raw_client(
@@ -178,7 +209,7 @@ class BaseChatClient(ABC):
 
 
 class BaseAsyncChatClient(ABC):
-    DEFAULT_MODEL: str | None = None
+    DEFAULT_MODEL: str
     BACKEND_NAME: BackendType
 
     def __init__(
@@ -210,6 +241,35 @@ class BaseAsyncChatClient(ABC):
             self.random_endpoint = False
             self.endpoint = settings.get_endpoint(self.endpoint_id)
 
+    def set_model_id_by_endpoint_id(self, endpoint_id: str):
+        for endpoint_option in self.backend_settings.models[self.model].endpoints:
+            if isinstance(endpoint_option, dict) and endpoint_id == endpoint_option["endpoint_id"]:
+                self.model_id = endpoint_option["model_id"]
+                break
+        return self.model_id
+
+    def _set_endpoint(self):
+        if self.endpoint is None:
+            if self.random_endpoint:
+                self.random_endpoint = True
+                endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
+                if isinstance(endpoint, dict):
+                    self.endpoint_id = endpoint["endpoint_id"]
+                    self.model_id = endpoint["model_id"]
+                else:
+                    self.endpoint_id = endpoint
+                self.endpoint = settings.get_endpoint(self.endpoint_id)
+            else:
+                self.endpoint = settings.get_endpoint(self.endpoint_id)
+                self.set_model_id_by_endpoint_id(self.endpoint_id)
+        elif isinstance(self.endpoint, EndpointSetting):
+            self.endpoint_id = self.endpoint.id
+            self.set_model_id_by_endpoint_id(self.endpoint_id)
+        else:
+            raise ValueError("Invalid endpoint")
+
+        return self.endpoint, self.model_id
+
     @cached_property
     @abstractmethod
     def raw_client(

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/chat_clients/gemini_client.py

@@ -1,13 +1,11 @@
 # @Author: Bi Ying
 # @Date:   2024-06-17 23:47:49
 import json
-import random
 from functools import cached_property
 from typing import Iterable, Literal, Generator, AsyncGenerator, overload, Any
 
 import httpx
 
-from ..settings import settings
 from .utils import cutoff_messages
 from ..types import defaults as defs
 from .base_client import BaseChatClient, BaseAsyncChatClient
@@ -24,7 +22,7 @@ from ..types.llm_parameters import (
 
 
 class GeminiChatClient(BaseChatClient):
-    DEFAULT_MODEL: str | None = defs.GEMINI_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.GEMINI_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.Gemini
 
     def __init__(
@@ -48,9 +46,14 @@ class GeminiChatClient(BaseChatClient):
             http_client,
             backend_name,
         )
+        self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self):
+        self.endpoint, self.model_id = self._set_endpoint()
+        if not self.http_client:
+            self.http_client = httpx.Client(timeout=300, proxy=self.endpoint.proxy)
         return self.http_client
 
     @overload
@@ -134,6 +137,10 @@ class GeminiChatClient(BaseChatClient):
             self.temperature = temperature
 
         self.model_setting = self.backend_settings.models[self.model]
+        if self.model_id is None:
+            self.model_id = self.model_setting.id
+
+        self.endpoint, self.model_id = self._set_endpoint()
 
         if messages[0].get("role") == "system":
             system_prompt = messages[0]["content"]
@@ -162,16 +169,6 @@ class GeminiChatClient(BaseChatClient):
         if top_p:
             top_p_params = {"top_p": top_p}
 
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint_choice = random.choice(self.backend_settings.models[self.model].endpoints)
-            if isinstance(endpoint_choice, dict):
-                self.endpoint_id = endpoint_choice["endpoint_id"]
-                self.model_id = endpoint_choice["model_id"]
-            else:
-                self.endpoint_id = endpoint_choice
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
-
         request_body = {
             "contents": messages,
             "safetySettings": [
@@ -202,10 +199,7 @@ class GeminiChatClient(BaseChatClient):
 
             def generator():
                 result = {"content": "", "tool_calls": [], "usage": {}}
-                if self.http_client:
-                    client = self.http_client
-                else:
-                    client = httpx.Client(timeout=300)
+                client = self.raw_client
                 with client.stream("POST", url, headers=headers, params=params, json=request_body) as response:
                     for chunk in response.iter_lines():
                         message = {"content": "", "tool_calls": []}
@@ -241,10 +235,7 @@ class GeminiChatClient(BaseChatClient):
             return generator()
         else:
             url = f"{self.endpoint.api_base}/models/{self.model_setting.id}:generateContent"
-            if self.http_client:
-                client = self.http_client
-            else:
-                client = httpx.Client(timeout=300)
+            client = self.raw_client
             response = client.post(url, json=request_body, headers=headers, params=params, timeout=None).json()
             if "error" in response:
                 raise Exception(response["error"])
@@ -279,7 +270,7 @@ class GeminiChatClient(BaseChatClient):
 
 
 class AsyncGeminiChatClient(BaseAsyncChatClient):
-    DEFAULT_MODEL: str | None = defs.GEMINI_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.GEMINI_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.Gemini
 
     def __init__(
@@ -303,9 +294,14 @@ class AsyncGeminiChatClient(BaseAsyncChatClient):
             http_client,
             backend_name,
         )
+        self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self):
+        self.endpoint, self.model_id = self._set_endpoint()
+        if not self.http_client:
+            self.http_client = httpx.AsyncClient(timeout=300, proxy=self.endpoint.proxy)
         return self.http_client
 
     @overload
@@ -389,6 +385,10 @@ class AsyncGeminiChatClient(BaseAsyncChatClient):
             self.temperature = temperature
 
         self.model_setting = self.backend_settings.models[self.model]
+        if self.model_id is None:
+            self.model_id = self.model_setting.id
+
+        self.endpoint, self.model_id = self._set_endpoint()
 
         if messages[0].get("role") == "system":
             system_prompt = messages[0]["content"]
@@ -417,16 +417,6 @@ class AsyncGeminiChatClient(BaseAsyncChatClient):
         if top_p:
             top_p_params = {"top_p": top_p}
 
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint_choice = random.choice(self.backend_settings.models[self.model].endpoints)
-            if isinstance(endpoint_choice, dict):
-                self.endpoint_id = endpoint_choice["endpoint_id"]
-                self.model_id = endpoint_choice["model_id"]
-            else:
-                self.endpoint_id = endpoint_choice
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
-
         request_body = {
             "contents": messages,
             "safetySettings": [
@@ -457,10 +447,7 @@ class AsyncGeminiChatClient(BaseAsyncChatClient):
 
             async def generator():
                 result = {"content": "", "tool_calls": [], "usage": {}}
-                if self.http_client:
-                    client = self.http_client
-                else:
-                    client = httpx.AsyncClient(timeout=300)
+                client = self.raw_client
                 async with client.stream("POST", url, headers=headers, params=params, json=request_body) as response:
                     async for chunk in response.aiter_lines():
                         message = {"content": "", "tool_calls": []}
@@ -496,10 +483,7 @@ class AsyncGeminiChatClient(BaseAsyncChatClient):
             return generator()
         else:
             url = f"{self.endpoint.api_base}/models/{self.model_setting.id}:generateContent"
-            if self.http_client:
-                client = self.http_client
-            else:
-                client = httpx.AsyncClient(timeout=300)
+            client = self.raw_client
             async with client:
                 response = await client.post(url, json=request_body, headers=headers, params=params, timeout=None)
                 response = response.json()

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/chat_clients/minimax_client.py

@@ -1,12 +1,11 @@
 # @Author: Bi Ying
 # @Date:   2024-07-26 14:48:55
 import json
-import random
 from functools import cached_property
 from typing import Iterable, Literal, Generator, AsyncGenerator, overload, Any
+
 import httpx
 
-from ..settings import settings
 from ..types import defaults as defs
 from .utils import cutoff_messages, get_token_counts
 from .base_client import BaseChatClient, BaseAsyncChatClient
@@ -45,7 +44,7 @@ def extract_tool_calls(response):
 
 
 class MiniMaxChatClient(BaseChatClient):
-    DEFAULT_MODEL: str | None = defs.MINIMAX_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.MINIMAX_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.MiniMax
 
     def __init__(
@@ -69,19 +68,20 @@ class MiniMaxChatClient(BaseChatClient):
             http_client,
             backend_name,
         )
-        if http_client:
-            self.http_client = http_client
-        else:
-            self.http_client = httpx.Client()
         self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self):
+        self.endpoint, self.model_id = self._set_endpoint()
+        if not self.http_client:
+            self.http_client = httpx.Client(timeout=300, proxy=self.endpoint.proxy)
         return self.http_client
 
     @overload
     def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
         stream: Literal[False] = False,
@@ -100,9 +100,10 @@ class MiniMaxChatClient(BaseChatClient):
     @overload
     def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
-        stream: Literal[True] = True,
+        stream: Literal[True],
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -118,9 +119,10 @@ class MiniMaxChatClient(BaseChatClient):
     @overload
     def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
-        stream: bool | None = None,
+        stream: bool,
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -137,7 +139,7 @@ class MiniMaxChatClient(BaseChatClient):
         self,
         messages: list,
         model: str | None = None,
-        stream: bool | None = None,
+        stream: Literal[False] | Literal[True] = False,
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -160,15 +162,8 @@ class MiniMaxChatClient(BaseChatClient):
         self.model_setting = self.backend_settings.models[self.model]
         if self.model_id is None:
             self.model_id = self.model_setting.id
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint_choice = random.choice(self.backend_settings.models[self.model].endpoints)
-            if isinstance(endpoint_choice, dict):
-                self.endpoint_id = endpoint_choice["endpoint_id"]
-                self.model_id = endpoint_choice["model_id"]
-            else:
-                self.endpoint_id = endpoint_choice
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+
+        self.endpoint, self.model_id = self._set_endpoint()
 
         if not skip_cutoff and self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
@@ -221,7 +216,7 @@ class MiniMaxChatClient(BaseChatClient):
                 )
                 max_tokens = self.model_setting.context_length - token_counts
 
-        self.url = self.endpoint.api_base
+        self.url = self.endpoint.api_base or "https://api.minimax.chat/v1/text/chatcompletion_v2"
         self.headers = {"Authorization": f"Bearer {self.endpoint.api_key}", "Content-Type": "application/json"}
 
         request_body = {
@@ -236,10 +231,12 @@ class MiniMaxChatClient(BaseChatClient):
             **kwargs,
         }
 
+        raw_client = self.raw_client
+
         if self.stream:
 
             def generator():
-                with self.http_client.stream(
+                with raw_client.stream(
                     "POST",
                     url=self.url,
                     headers=self.headers,
@@ -271,7 +268,7 @@ class MiniMaxChatClient(BaseChatClient):
 
             return generator()
         else:
-            response = httpx.post(
+            response = raw_client.post(
                 url=self.url,
                 headers=self.headers,
                 json=request_body,
@@ -294,7 +291,7 @@ class MiniMaxChatClient(BaseChatClient):
 
 
 class AsyncMiniMaxChatClient(BaseAsyncChatClient):
-    DEFAULT_MODEL: str | None = defs.MINIMAX_DEFAULT_MODEL
+    DEFAULT_MODEL: str = defs.MINIMAX_DEFAULT_MODEL
     BACKEND_NAME: BackendType = BackendType.MiniMax
 
     def __init__(
@@ -318,19 +315,20 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
             http_client,
             backend_name,
         )
-        if http_client:
-            self.http_client = http_client
-        else:
-            self.http_client = httpx.AsyncClient()
         self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self):
+        self.endpoint, self.model_id = self._set_endpoint()
+        if not self.http_client:
+            self.http_client = httpx.AsyncClient(timeout=300, proxy=self.endpoint.proxy)
         return self.http_client
 
     @overload
     async def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
         stream: Literal[False] = False,
@@ -349,9 +347,10 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
     @overload
     async def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
-        stream: Literal[True] = True,
+        stream: Literal[True],
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -367,9 +366,10 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
     @overload
     async def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
-        stream: bool | None = None,
+        stream: bool,
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -384,9 +384,10 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
 
     async def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
-        stream: bool | None = None,
+        stream: Literal[False] | Literal[True] = False,
         temperature: float | None = None,
         max_tokens: int | None = None,
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
@@ -409,15 +410,8 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
         self.model_setting = self.backend_settings.models[self.model]
         if self.model_id is None:
             self.model_id = self.model_setting.id
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint_choice = random.choice(self.backend_settings.models[self.model].endpoints)
-            if isinstance(endpoint_choice, dict):
-                self.endpoint_id = endpoint_choice["endpoint_id"]
-                self.model_id = endpoint_choice["model_id"]
-            else:
-                self.endpoint_id = endpoint_choice
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+
+        self.endpoint, self.model_id = self._set_endpoint()
 
         if not skip_cutoff and self.context_length_control == ContextLengthControlType.Latest:
             messages = cutoff_messages(
@@ -468,7 +462,7 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
                 )
                 max_tokens = self.model_setting.context_length - token_counts
 
-        self.url = self.endpoint.api_base
+        self.url = self.endpoint.api_base or "https://api.minimax.chat/v1/text/chatcompletion_v2"
         self.headers = {"Authorization": f"Bearer {self.endpoint.api_key}", "Content-Type": "application/json"}
 
         request_body = {
@@ -483,10 +477,12 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
             **kwargs,
         }
 
+        raw_client = self.raw_client
+
         if self.stream:
 
             async def generator():
-                async with self.http_client.stream(
+                async with raw_client.stream(
                     "POST",
                     url=self.url,
                     headers=self.headers,
@@ -519,7 +515,7 @@ class AsyncMiniMaxChatClient(BaseAsyncChatClient):
 
             return generator()
         else:
-            response = await self.http_client.post(
+            response = await raw_client.post(
                 url=self.url,
                 headers=self.headers,
                 json=request_body,

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/chat_clients/openai_compatible_client.py

@@ -1,7 +1,6 @@
 # @Author: Bi Ying
 # @Date:   2024-07-26 14:48:55
 import json
-import random
 from functools import cached_property
 from typing import overload, Generator, AsyncGenerator, Any, Literal, Iterable
 
@@ -15,7 +14,6 @@ from .utils import (
     ToolCallContentProcessor,
     generate_tool_use_system_prompt,
 )
-from ..settings import settings
 from ..types import defaults as defs
 from ..types.enums import ContextLengthControlType, BackendType
 from ..types.llm_parameters import (
@@ -33,7 +31,7 @@ from ..types.llm_parameters import (
 
 
 class OpenAICompatibleChatClient(BaseChatClient):
-    DEFAULT_MODEL: str | None = ""
+    DEFAULT_MODEL: str = ""
     BACKEND_NAME: BackendType
 
     def __init__(
@@ -58,19 +56,14 @@ class OpenAICompatibleChatClient(BaseChatClient):
             backend_name,
         )
         self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self) -> OpenAI | AzureOpenAI:
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
-            self.model_id = None
-            if isinstance(endpoint, dict):
-                self.endpoint_id = endpoint["endpoint_id"]
-                self.model_id = endpoint["model_id"]
-            else:
-                self.endpoint_id = endpoint
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+        self.endpoint, self.model_id = self._set_endpoint()
+
+        if self.endpoint.proxy is not None and self.http_client is None:
+            self.http_client = httpx.Client(proxy=self.endpoint.proxy)
 
         if self.endpoint.is_azure:
             if self.endpoint.api_base is None:
@@ -78,7 +71,7 @@ class OpenAICompatibleChatClient(BaseChatClient):
             return AzureOpenAI(
                 azure_endpoint=self.endpoint.api_base,
                 api_key=self.endpoint.api_key,
-                api_version="2024-10-01-preview",
+                api_version="2024-12-01-preview",
                 http_client=self.http_client,
             )
         else:
@@ -305,7 +298,7 @@ class OpenAICompatibleChatClient(BaseChatClient):
 
 
 class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
-    DEFAULT_MODEL: str | None = ""
+    DEFAULT_MODEL: str = ""
     BACKEND_NAME: BackendType
 
     def __init__(
@@ -330,19 +323,14 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
             backend_name,
         )
         self.model_id = None
+        self.endpoint = None
 
     @cached_property
     def raw_client(self):
-        if self.random_endpoint:
-            self.random_endpoint = True
-            endpoint = random.choice(self.backend_settings.models[self.model].endpoints)
-            self.model_id = None
-            if isinstance(endpoint, dict):
-                self.endpoint_id = endpoint["endpoint_id"]
-                self.model_id = endpoint["model_id"]
-            else:
-                self.endpoint_id = endpoint
-            self.endpoint = settings.get_endpoint(self.endpoint_id)
+        self.endpoint, self.model_id = self._set_endpoint()
+
+        if self.endpoint.proxy is not None and self.http_client is None:
+            self.http_client = httpx.AsyncClient(proxy=self.endpoint.proxy)
 
         if self.endpoint.is_azure:
             if self.endpoint.api_base is None:
@@ -350,7 +338,7 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
             return AsyncAzureOpenAI(
                 azure_endpoint=self.endpoint.api_base,
                 api_key=self.endpoint.api_key,
-                api_version="2024-10-01-preview",
+                api_version="2024-12-01-preview",
                 http_client=self.http_client,
             )
         else:
@@ -419,6 +407,7 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
 
     async def create_completion(
         self,
+        *,
         messages: list,
         model: str | None = None,
         stream: Literal[False] | Literal[True] = False,

{vectorvein-0.1.75 → vectorvein-0.1.77}/src/vectorvein/types/llm_parameters.py

@@ -44,6 +44,7 @@ class EndpointSetting(BaseModel):
         description="Whether to use concurrent requests for the LLM service.",
         default=defs.ENDPOINT_CONCURRENT_REQUESTS,
     )
+    proxy: Optional[str] = Field(None, description="The proxy URL for the endpoint.")
 
 
 class ModelSetting(BaseModel):