vectorvein 0.1.93__py3-none-any.whl → 0.1.95__py3-none-any.whl

vectorvein/chat_clients/minimax_client.py

@@ -1,548 +1,13 @@
-# @Author: Bi Ying
-# @Date:   2024-07-26 14:48:55
-import json
-from functools import cached_property
-from typing import Iterable, Literal, Generator, AsyncGenerator, overload, Any
+from ..types.enums import BackendType
+from ..types.defaults import MINIMAX_DEFAULT_MODEL
+from .openai_compatible_client import OpenAICompatibleChatClient, AsyncOpenAICompatibleChatClient
 
-import httpx
 
-from ..types import defaults as defs
-from .utils import cutoff_messages, get_token_counts
-from .base_client import BaseChatClient, BaseAsyncChatClient
-from ..types.enums import ContextLengthControlType, BackendType
-from ..types.llm_parameters import (
-    NotGiven,
-    NOT_GIVEN,
-    ToolParam,
-    ToolChoice,
-    ChatCompletionMessage,
-    ChatCompletionDeltaMessage,
-    ChatCompletionStreamOptionsParam,
-)
+class MiniMaxChatClient(OpenAICompatibleChatClient):
+    DEFAULT_MODEL = MINIMAX_DEFAULT_MODEL
+    BACKEND_NAME = BackendType.MiniMax
 
 
-def extract_tool_calls(response):
-    try:
-        message = response["choices"][0].get("delta") or response["choices"][0].get("message", {})
-        tool_calls = message.get("tool_calls")
-        if tool_calls:
-            return {
-                "tool_calls": [
-                    {
-                        "index": index,
-                        "id": tool_call["id"],
-                        "function": tool_call["function"],
-                        "type": "function",
-                    }
-                    for index, tool_call in enumerate(tool_calls)
-                ]
-            }
-        else:
-            return {}
-    except Exception:
-        return {}
-
-
-class MiniMaxChatClient(BaseChatClient):
-    DEFAULT_MODEL: str = defs.MINIMAX_DEFAULT_MODEL
-    BACKEND_NAME: BackendType = BackendType.MiniMax
-
-    def __init__(
-        self,
-        model: str = defs.MINIMAX_DEFAULT_MODEL,
-        stream: bool = True,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        context_length_control: ContextLengthControlType = defs.CONTEXT_LENGTH_CONTROL,
-        random_endpoint: bool = True,
-        endpoint_id: str = "",
-        http_client: httpx.Client | None = None,
-        backend_name: str | None = None,
-    ):
-        super().__init__(
-            model,
-            stream,
-            temperature,
-            context_length_control,
-            random_endpoint,
-            endpoint_id,
-            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
-    def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[False] = False,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> ChatCompletionMessage:
-        pass
-
-    @overload
-    def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[True],
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> Generator[ChatCompletionDeltaMessage, None, None]:
-        pass
-
-    @overload
-    def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: bool,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> ChatCompletionMessage | Generator[ChatCompletionDeltaMessage, Any, None]:
-        pass
-
-    def create_completion(
-        self,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[False] | Literal[True] = False,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **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(tool_choice, NotGiven):
-            tool_choice = "auto"
-
-        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 not skip_cutoff and 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,
-            )
-
-        if tools:
-            tools_params = {
-                "tools": [
-                    {
-                        "type": "function",
-                        "function": {
-                            "name": tool["function"]["name"],
-                            "description": tool["function"].get("description", ""),
-                            "parameters": json.dumps(
-                                tool["function"].get("parameters", {})
-                            ),  # 非要搞不同，parameters 是个字符串
-                        },
-                    }
-                    for tool in tools
-                ],
-                "tool_choice": tool_choice,
-            }
-        else:
-            tools_params = {}
-
-        if top_p:
-            top_p_params = {"top_p": top_p}
-        else:
-            top_p_params = {}
-
-        temperature_params = {}
-        if temperature:
-            temperature_params = {"temperature": temperature}
-
-        if max_tokens is None:
-            max_output_tokens = self.model_setting.max_output_tokens
-            if max_output_tokens is not None:
-                token_counts = get_token_counts(
-                    text={"messages": messages, "tools_params": tools_params},
-                    model=self.model,
-                    use_token_server_first=True,
-                )
-                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(
-                    text={"messages": messages, "tools_params": tools_params},
-                    model=self.model,
-                    use_token_server_first=True,
-                )
-                max_tokens = self.model_setting.context_length - token_counts
-
-        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 = {
-            "model": self.model_id,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "stream": self.stream,
-            "mask_sensitive_info": False,
-            **temperature_params,
-            **top_p_params,
-            **tools_params,
-            **kwargs,
-        }
-
-        raw_client = self.raw_client
-
-        if self.stream:
-
-            def generator():
-                with raw_client.stream(
-                    "POST",
-                    url=self.url,
-                    headers=self.headers,
-                    json=request_body,
-                    timeout=300,
-                ) as response:
-                    for chunk in response.iter_lines():
-                        if chunk:
-                            chunk_data = json.loads(chunk[6:])
-                            if chunk_data["object"] != "chat.completion.chunk":
-                                continue
-                            tool_calls_params = extract_tool_calls(chunk_data)
-                            has_tool_calls = True if tool_calls_params else False
-                            if has_tool_calls:
-                                yield ChatCompletionDeltaMessage(
-                                    **{
-                                        "content": chunk_data["choices"][0]["delta"].get("content"),
-                                        "role": "assistant",
-                                        **tool_calls_params,
-                                    }
-                                )
-                            else:
-                                yield ChatCompletionDeltaMessage(
-                                    **{
-                                        "content": chunk_data["choices"][0]["delta"]["content"],
-                                        "role": "assistant",
-                                    }
-                                )
-
-            return generator()
-        else:
-            response = raw_client.post(
-                url=self.url,
-                headers=self.headers,
-                json=request_body,
-                timeout=300,
-            )
-            result = response.json()
-            tool_calls_params = extract_tool_calls(result)
-            return ChatCompletionMessage(
-                **{
-                    "content": result["choices"][0]["message"].get("content"),
-                    "usage": {
-                        "prompt_tokens": 0,
-                        "completion_tokens": result["usage"]["total_tokens"],
-                        "total_tokens": result["usage"]["total_tokens"],
-                    },
-                    "role": "assistant",
-                    **tool_calls_params,
-                }
-            )
-
-
-class AsyncMiniMaxChatClient(BaseAsyncChatClient):
-    DEFAULT_MODEL: str = defs.MINIMAX_DEFAULT_MODEL
-    BACKEND_NAME: BackendType = BackendType.MiniMax
-
-    def __init__(
-        self,
-        model: str = defs.MINIMAX_DEFAULT_MODEL,
-        stream: bool = True,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        context_length_control: ContextLengthControlType = defs.CONTEXT_LENGTH_CONTROL,
-        random_endpoint: bool = True,
-        endpoint_id: str = "",
-        http_client: httpx.AsyncClient | None = None,
-        backend_name: str | None = None,
-    ):
-        super().__init__(
-            model,
-            stream,
-            temperature,
-            context_length_control,
-            random_endpoint,
-            endpoint_id,
-            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
-    async def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[False] = False,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> ChatCompletionMessage:
-        pass
-
-    @overload
-    async def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[True],
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> AsyncGenerator[ChatCompletionDeltaMessage, Any]:
-        pass
-
-    @overload
-    async def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: bool,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **kwargs,
-    ) -> ChatCompletionMessage | AsyncGenerator[ChatCompletionDeltaMessage, Any]:
-        pass
-
-    async def create_completion(
-        self,
-        *,
-        messages: list,
-        model: str | None = None,
-        stream: Literal[False] | Literal[True] = False,
-        temperature: float | None | NotGiven = NOT_GIVEN,
-        max_tokens: int | None = None,
-        tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN,
-        tool_choice: ToolChoice | NotGiven = NOT_GIVEN,
-        response_format: dict | None = None,
-        stream_options: ChatCompletionStreamOptionsParam | None = None,
-        top_p: float | NotGiven | None = NOT_GIVEN,
-        skip_cutoff: bool = False,
-        **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(tool_choice, NotGiven):
-            tool_choice = "auto"
-
-        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 not skip_cutoff and 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,
-            )
-
-        if tools:
-            tools_params = {
-                "tools": [
-                    {
-                        "type": "function",
-                        "function": {
-                            "name": tool["function"]["name"],
-                            "description": tool["function"].get("description", ""),
-                            "parameters": json.dumps(tool["function"].get("parameters", {})),
-                        },
-                    }
-                    for tool in tools
-                ],
-                "tool_choice": tool_choice,
-            }
-        else:
-            tools_params = {}
-
-        if top_p:
-            top_p_params = {"top_p": top_p}
-        else:
-            top_p_params = {}
-
-        temperature_params = {}
-        if temperature:
-            temperature_params = {"temperature": temperature}
-
-        if max_tokens is None:
-            max_output_tokens = self.model_setting.max_output_tokens
-            if max_output_tokens is not None:
-                token_counts = get_token_counts(
-                    text={"messages": messages, "tools_params": tools_params},
-                    model=self.model,
-                    use_token_server_first=True,
-                )
-                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(
-                    text={"messages": messages, "tools_params": tools_params},
-                    model=self.model,
-                    use_token_server_first=True,
-                )
-                max_tokens = self.model_setting.context_length - token_counts
-
-        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 = {
-            "model": self.model_id,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "stream": self.stream,
-            "mask_sensitive_info": False,
-            **temperature_params,
-            **top_p_params,
-            **tools_params,
-            **kwargs,
-        }
-
-        raw_client = self.raw_client
-
-        if self.stream:
-
-            async def generator():
-                async with raw_client.stream(
-                    "POST",
-                    url=self.url,
-                    headers=self.headers,
-                    json=request_body,
-                    timeout=300,
-                ) as response:
-                    has_tool_calls = False
-                    async for chunk in response.aiter_lines():
-                        if chunk:
-                            chunk_data = json.loads(chunk[6:])
-                            if chunk_data["object"] != "chat.completion.chunk":
-                                continue
-                            tool_calls_params = extract_tool_calls(chunk_data)
-                            has_tool_calls = True if tool_calls_params else False
-                            if has_tool_calls:
-                                yield ChatCompletionDeltaMessage(
-                                    **{
-                                        "content": chunk_data["choices"][0]["delta"].get("content"),
-                                        "role": "assistant",
-                                        **tool_calls_params,
-                                    }
-                                )
-                            else:
-                                yield ChatCompletionDeltaMessage(
-                                    **{
-                                        "content": chunk_data["choices"][0]["delta"]["content"],
-                                        "role": "assistant",
-                                    }
-                                )
-
-            return generator()
-        else:
-            response = await raw_client.post(
-                url=self.url,
-                headers=self.headers,
-                json=request_body,
-                timeout=300,
-            )
-            result = response.json()
-            tool_calls_params = extract_tool_calls(result)
-            return ChatCompletionMessage(
-                **{
-                    "content": result["choices"][0]["message"].get("content"),
-                    "usage": {
-                        "prompt_tokens": 0,
-                        "completion_tokens": result["usage"]["total_tokens"],
-                        "total_tokens": result["usage"]["total_tokens"],
-                    },
-                    "role": "assistant",
-                    **tool_calls_params,
-                }
-            )
-
-    async def __aexit__(self, exc_type, exc, tb):
-        await self.http_client.aclose()
+class AsyncMiniMaxChatClient(AsyncOpenAICompatibleChatClient):
+    DEFAULT_MODEL = MINIMAX_DEFAULT_MODEL
+    BACKEND_NAME = BackendType.MiniMax

vectorvein/chat_clients/openai_compatible_client.py

@@ -181,7 +181,21 @@ class OpenAICompatibleChatClient(BaseChatClient):
 
         if tools:
             if self.model_setting.function_call_available:
-                tools_params = dict(tools=tools, tool_choice=tool_choice)
+                _tools = tools
+                if self.BACKEND_NAME.value == BackendType.MiniMax.value:  # MiniMax 就非要搞特殊
+                    _tools = []
+                    for tool in tools:
+                        _tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool["function"]["name"],
+                                    "description": tool["function"].get("description", ""),
+                                    "parameters": json.dumps(tool["function"].get("parameters", {})),
+                                },
+                            }
+                        )
+                tools_params = dict(tools=_tools, tool_choice=tool_choice)
             else:
                 tools_str = json.dumps(tools, ensure_ascii=False, indent=None)
                 additional_system_prompt = generate_tool_use_system_prompt(tools=tools_str)
@@ -256,6 +270,7 @@ class OpenAICompatibleChatClient(BaseChatClient):
                         if chunk.choices[0].delta.tool_calls:
                             for index, tool_call in enumerate(chunk.choices[0].delta.tool_calls):
                                 tool_call.index = index
+                                tool_call.type = "function"  # 也是 MiniMax 的不规范导致的问题
                         yield ChatCompletionDeltaMessage(**chunk.choices[0].delta.model_dump(), usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()
@@ -509,7 +524,21 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
 
         if tools:
             if self.model_setting.function_call_available:
-                tools_params = dict(tools=tools, tool_choice=tool_choice)
+                _tools = tools
+                if self.BACKEND_NAME.value == BackendType.MiniMax.value:
+                    _tools = []
+                    for tool in tools:
+                        _tools.append(
+                            {
+                                "type": "function",
+                                "function": {
+                                    "name": tool["function"]["name"],
+                                    "description": tool["function"].get("description", ""),
+                                    "parameters": json.dumps(tool["function"].get("parameters", {})),
+                                },
+                            }
+                        )
+                tools_params = dict(tools=_tools, tool_choice=tool_choice)
             else:
                 tools_str = json.dumps(tools, ensure_ascii=False, indent=None)
                 additional_system_prompt = generate_tool_use_system_prompt(tools=tools_str)
@@ -584,6 +613,7 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                         if chunk.choices[0].delta.tool_calls:
                             for index, tool_call in enumerate(chunk.choices[0].delta.tool_calls):
                                 tool_call.index = index
+                                tool_call.type = "function"
                         yield ChatCompletionDeltaMessage(**chunk.choices[0].delta.model_dump(), usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()

vectorvein/chat_clients/utils.py

@@ -311,10 +311,13 @@ def get_token_counts(text: str | dict, model: str = "", use_token_server_first:
         result = response.json()
         return result["usage"]["prompt_tokens"]
     else:
-        return len(get_gpt_35_encoding().encode(text))
+        return len(get_gpt_4o_encoding().encode(text))
 
 
 def calculate_image_tokens(width: int, height: int, model: str = "gpt-4o"):
+    if model.startswith("moonshot"):
+        return 1024
+
     if width > 2048 or height > 2048:
         aspect_ratio = width / height
         if aspect_ratio > 1:
@@ -559,7 +562,10 @@ def transform_from_openai_message(message: ChatCompletionMessageParam, backend:
                 if isinstance(item, str):
                     formatted_content.append({"type": "text", "text": item})
                 elif isinstance(item, dict) and "type" in item:
-                    formatted_content.append(item)
+                    if item["type"] == "image_url":
+                        formatted_content.append(format_image_message(item["image_url"]["url"], backend))
+                    else:
+                        formatted_content.append(item)
             return {"role": role, "content": formatted_content}
         else:
             return {"role": role, "content": content}

vectorvein/types/defaults.py

@@ -33,6 +33,28 @@ MOONSHOT_MODELS: Final[Dict[str, Dict[str, Any]]] = {
         "function_call_available": True,
         "response_format_available": True,
     },
+    "moonshot-v1-8k-vision-preview": {
+        "id": "moonshot-v1-8k-vision-preview",
+        "context_length": 8192,
+        "max_output_tokens": 4096,
+        "function_call_available": True,
+        "response_format_available": True,
+        "native_multimodal": True,
+    },
+    "moonshot-v1-32k-vision-preview": {
+        "id": "moonshot-v1-32k-vision-preview",
+        "context_length": 32768,
+        "function_call_available": True,
+        "response_format_available": True,
+        "native_multimodal": True,
+    },
+    "moonshot-v1-128k-vision-preview": {
+        "id": "moonshot-v1-128k-vision-preview",
+        "context_length": 131072,
+        "function_call_available": True,
+        "response_format_available": True,
+        "native_multimodal": True,
+    },
 }
 
 # Deepseek models
@@ -293,13 +315,6 @@ QWEN_MODELS: Final[Dict[str, Dict[str, Any]]] = {
 # Yi models
 YI_DEFAULT_MODEL: Final[str] = "yi-lightning"
 YI_MODELS: Final[Dict[str, Dict[str, Any]]] = {
-    "yi-large": {
-        "id": "yi-large",
-        "context_length": 32000,
-        "max_output_tokens": 4096,
-        "function_call_available": False,
-        "response_format_available": False,
-    },
     "yi-lightning": {
         "id": "yi-lightning",
         "context_length": 16000,
@@ -307,44 +322,9 @@ YI_MODELS: Final[Dict[str, Dict[str, Any]]] = {
         "function_call_available": False,
         "response_format_available": False,
     },
-    "yi-large-turbo": {
-        "id": "yi-large-turbo",
+    "yi-vision-v2": {
+        "id": "yi-vision-v2",
         "context_length": 16000,
-        "max_output_tokens": 4096,
-        "function_call_available": False,
-        "response_format_available": False,
-    },
-    "yi-large-fc": {
-        "id": "yi-large-fc",
-        "context_length": 32000,
-        "max_output_tokens": 4096,
-        "function_call_available": True,
-        "response_format_available": False,
-    },
-    "yi-medium": {
-        "id": "yi-medium",
-        "context_length": 16000,
-        "max_output_tokens": 4096,
-        "function_call_available": False,
-        "response_format_available": False,
-    },
-    "yi-medium-200k": {
-        "id": "yi-medium-200k",
-        "context_length": 200000,
-        "max_output_tokens": 4096,
-        "function_call_available": False,
-        "response_format_available": False,
-    },
-    "yi-spark": {
-        "id": "yi-spark",
-        "context_length": 16000,
-        "max_output_tokens": 4096,
-        "function_call_available": False,
-        "response_format_available": False,
-    },
-    "yi-vision": {
-        "id": "yi-vision",
-        "context_length": 4000,
         "max_output_tokens": 2000,
         "function_call_available": False,
         "response_format_available": False,

vectorvein/utilities/media_processing.py

@@ -32,11 +32,18 @@ class ImageProcessor:
         self._cached_base64_image = None
 
     def _load_image(self):
-        if not self.is_local and isinstance(self.image_source, str):
-            image_url = self.image_source
-            response = httpx.get(image_url)
-            return Image.open(BytesIO(response.content))
-        elif isinstance(self.image_source, (Path, str)):
+        if isinstance(self.image_source, str):
+            if self.image_source.startswith(("data:image/", "data:application/octet-stream;base64,")):
+                base64_data = self.image_source.split(",")[1]
+                image_data = base64.b64decode(base64_data)
+                return Image.open(BytesIO(image_data))
+            elif not self.is_local:
+                image_url = self.image_source
+                response = httpx.get(image_url)
+                return Image.open(BytesIO(response.content))
+            else:
+                return Image.open(self.image_source)
+        elif isinstance(self.image_source, Path):
             return Image.open(self.image_source)
         elif isinstance(self.image_source, Image.Image):
             return self.image_source

{vectorvein-0.1.93.dist-info → vectorvein-0.1.95.dist-info}/METADATA

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

{vectorvein-0.1.93.dist-info → vectorvein-0.1.95.dist-info}/RECORD

@@ -1,6 +1,6 @@
-vectorvein-0.1.93.dist-info/METADATA,sha256=rT9Ne1VJGZNokWrrapauOMreRrvt1KNbEeLBAAOzkiQ,775
-vectorvein-0.1.93.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-vectorvein-0.1.93.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+vectorvein-0.1.95.dist-info/METADATA,sha256=9jaFqXZu5L1clFveApXDGA8IQEsC72Q7pyGibiFBAfU,775
+vectorvein-0.1.95.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+vectorvein-0.1.95.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 vectorvein/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/chat_clients/__init__.py,sha256=omQuG4PRRPNflSAgtdU--rwsWG6vMpwMEyIGZyFVHVQ,18596
 vectorvein/chat_clients/anthropic_client.py,sha256=Zk6X1feIvv7Az5dgyipJXbm9TkgWgpFghSTxLiXKKA8,38405
@@ -10,15 +10,15 @@ vectorvein/chat_clients/deepseek_client.py,sha256=3qWu01NlJAP2N-Ff62d5-CZXZitliz
 vectorvein/chat_clients/gemini_client.py,sha256=ufovIZrmAE3RLEe8h5WXombf7bARAZxnkj6ydNK2FQM,475
 vectorvein/chat_clients/groq_client.py,sha256=Uow4pgdmFi93ZQSoOol2-0PhhqkW-S0XuSldvppz5U4,498
 vectorvein/chat_clients/local_client.py,sha256=55nOsxzqUf79q3Y14MKROA71zxhsT7p7FsDZ89rts2M,422
-vectorvein/chat_clients/minimax_client.py,sha256=ooJU92UCACC4TVWKJ-uo8vqQ8qF3K14ziAuSFm8Wj3M,20025
+vectorvein/chat_clients/minimax_client.py,sha256=YOILWcsHsN5tihLTMbKJIyJr9TJREMIXWolSl93tLxs,469
 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=F_kHsoCtrqJ7jLsgyIZ2mJSNQ_YnDp9SRNW4ydFDtic,28950
+vectorvein/chat_clients/openai_compatible_client.py,sha256=H20SXdvXalf7_jaashff_aLCa8lO-n4-biBEY-6Nqfo,30572
 vectorvein/chat_clients/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/chat_clients/qwen_client.py,sha256=-ryh-m9PgsO0fc4ulcCmPTy1155J8YUy15uPoJQOHA0,513
 vectorvein/chat_clients/stepfun_client.py,sha256=zsD2W5ahmR4DD9cqQTXmJr3txrGuvxbRWhFlRdwNijI,519
-vectorvein/chat_clients/utils.py,sha256=nXldWLhLCxY4t60Fn3Tp3krFgbgSZSOD5huFnH6tzhw,24795
+vectorvein/chat_clients/utils.py,sha256=r8tlt-suUjISSRjc_tCCcBYmQT3zng1YFVnQgeAG1Co,25041
 vectorvein/chat_clients/xai_client.py,sha256=eLFJJrNRJ-ni3DpshODcr3S1EJQLbhVwxyO1E54LaqM,491
 vectorvein/chat_clients/yi_client.py,sha256=RNf4CRuPJfixrwLZ3-DEc3t25QDe1mvZeb9sku2f8Bc,484
 vectorvein/chat_clients/zhipuai_client.py,sha256=Ys5DSeLCuedaDXr3PfG1EW2zKXopt-awO2IylWSwY0s,519
@@ -26,12 +26,12 @@ vectorvein/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/server/token_server.py,sha256=36F9PKSNOX8ZtYBXY_l-76GQTpUSmQ2Y8EMy1H7wtdQ,1353
 vectorvein/settings/__init__.py,sha256=ecGyrE_6YfX9z6Igb1rDCu1Q-qMTcVozWF3WEl_hiKA,4871
 vectorvein/settings/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vectorvein/types/defaults.py,sha256=MAoxFhtvzPWBl1Zroz6hhKl7AshyHcO90hcE3pXzePQ,27384
+vectorvein/types/defaults.py,sha256=GI4uBq_1VWCqKEr81hOW90ErvwNR5r9J3c4JDwxdCUw,26885
 vectorvein/types/enums.py,sha256=7KTJSVtQueImmbr1fSwv3rQVtc0RyMWXJmoE2tDOaso,1667
 vectorvein/types/exception.py,sha256=gnW4GnJ76jND6UGnodk9xmqkcbeS7Cz2rvncA2HpD5E,69
 vectorvein/types/llm_parameters.py,sha256=9KJ8z_7xVa0JsV0YPxRKz5n8Eb8PfvB9Y89e6ahjmjw,5989
 vectorvein/types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vectorvein/utilities/media_processing.py,sha256=CTRq-lGlFkFgP_FSRhNwF_qUgmOrXPf2_1Ok9HY42_g,5887
+vectorvein/utilities/media_processing.py,sha256=7KtbLFzOYIn1e9QTN9G6C76NH8CBlV9kfAgiRKEIeXY,6263
 vectorvein/utilities/rate_limiter.py,sha256=dwolIUVw2wP83Odqpx0AAaE77de1GzxkYDGH4tM_u_4,10300
 vectorvein/utilities/retry.py,sha256=6KFS9R2HdhqM3_9jkjD4F36ZSpEx2YNFGOVlpOsUetM,2208
 vectorvein/workflow/graph/edge.py,sha256=xLZEJmBjAfVB53cd7CuRcKhgE6QqXv9nz32wJn8cmyk,1064
@@ -55,4 +55,4 @@ vectorvein/workflow/nodes/vector_db.py,sha256=t6I17q6iR3yQreiDHpRrksMdWDPIvgqJs0
 vectorvein/workflow/nodes/video_generation.py,sha256=qmdg-t_idpxq1veukd-jv_ChICMOoInKxprV9Z4Vi2w,4118
 vectorvein/workflow/nodes/web_crawlers.py,sha256=LsqomfXfqrXfHJDO1cl0Ox48f4St7X_SL12DSbAMSOw,5415
 vectorvein/workflow/utils/json_to_code.py,sha256=F7dhDy8kGc8ndOeihGLRLGFGlquoxVlb02ENtxnQ0C8,5914
-vectorvein-0.1.93.dist-info/RECORD,,
+vectorvein-0.1.95.dist-info/RECORD,,