vectorvein 0.2.95__py3-none-any.whl → 0.2.97__py3-none-any.whl

vectorvein/chat_clients/anthropic_client.py

@@ -597,9 +597,7 @@ class AnthropicChatClient(BaseChatClient):
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
             native_multimodal = self.model_setting.native_multimodal
-            token_counts = get_message_token_counts(
-                messages=messages, tools=tools, model=self.model, native_multimodal=native_multimodal
-            )
+            token_counts = get_message_token_counts(messages=messages, tools=tools, model=self.model, native_multimodal=native_multimodal)
             if max_output_tokens is not None:
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
@@ -707,9 +705,7 @@ class AnthropicChatClient(BaseChatClient):
                                         result["raw_content"][i]["input"] = {}
                                     try:
                                         if result["tool_calls"][0]["function"]["arguments"]:
-                                            result["raw_content"][i]["input"] = json.loads(
-                                                result["tool_calls"][0]["function"]["arguments"]
-                                            )
+                                            result["raw_content"][i]["input"] = json.loads(result["tool_calls"][0]["function"]["arguments"])
                                         else:
                                             result["raw_content"][i]["input"] = {}
                                     except json.JSONDecodeError:
@@ -727,9 +723,7 @@ class AnthropicChatClient(BaseChatClient):
                         yield ChatCompletionDeltaMessage(**message)
                     elif isinstance(chunk, RawMessageDeltaEvent):
                         result["usage"]["completion_tokens"] = chunk.usage.output_tokens
-                        result["usage"]["total_tokens"] = (
-                            result["usage"]["prompt_tokens"] + result["usage"]["completion_tokens"]
-                        )
+                        result["usage"]["total_tokens"] = result["usage"]["prompt_tokens"] + result["usage"]["completion_tokens"]
                         yield ChatCompletionDeltaMessage(
                             usage=Usage(
                                 prompt_tokens=result["usage"]["prompt_tokens"],
@@ -1211,9 +1205,7 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
         if max_tokens is None:
             max_output_tokens = self.model_setting.max_output_tokens
             native_multimodal = self.model_setting.native_multimodal
-            token_counts = get_message_token_counts(
-                messages=messages, tools=tools, model=self.model, native_multimodal=native_multimodal
-            )
+            token_counts = get_message_token_counts(messages=messages, tools=tools, model=self.model, native_multimodal=native_multimodal)
             if max_output_tokens is not None:
                 max_tokens = self.model_setting.context_length - token_counts
                 max_tokens = min(max(max_tokens, 1), max_output_tokens)
@@ -1321,9 +1313,7 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
                                         result["raw_content"][i]["input"] = {}
                                     try:
                                         if result["tool_calls"][0]["function"]["arguments"]:
-                                            result["raw_content"][i]["input"] = json.loads(
-                                                result["tool_calls"][0]["function"]["arguments"]
-                                            )
+                                            result["raw_content"][i]["input"] = json.loads(result["tool_calls"][0]["function"]["arguments"])
                                         else:
                                             result["raw_content"][i]["input"] = {}
                                     except json.JSONDecodeError:
@@ -1341,9 +1331,7 @@ class AsyncAnthropicChatClient(BaseAsyncChatClient):
                         yield ChatCompletionDeltaMessage(**message)
                     elif isinstance(chunk, RawMessageDeltaEvent):
                         result["usage"]["completion_tokens"] = chunk.usage.output_tokens
-                        result["usage"]["total_tokens"] = (
-                            result["usage"]["prompt_tokens"] + result["usage"]["completion_tokens"]
-                        )
+                        result["usage"]["total_tokens"] = result["usage"]["prompt_tokens"] + result["usage"]["completion_tokens"]
                         yield ChatCompletionDeltaMessage(
                             usage=Usage(
                                 prompt_tokens=result["usage"]["prompt_tokens"],

vectorvein/chat_clients/openai_compatible_client.py

@@ -381,8 +381,8 @@ class OpenAICompatibleChatClient(BaseChatClient):
                 usage = None
                 buffer = ""
                 in_reasoning = False
-                current_reasoning = []
-                current_content = []
+                accumulated_reasoning = []
+                accumulated_content = []
 
                 for chunk in stream_response:
                     if chunk.usage and chunk.usage.total_tokens:
@@ -404,63 +404,142 @@ class OpenAICompatibleChatClient(BaseChatClient):
                             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)
+
+                        # 即使支持 function call，也要处理 <think> 标签
+                        message = chunk.choices[0].delta.model_dump()
+                        delta_content = message.get("content", "")
+                        if delta_content:
+                            buffer += delta_content
+
+                            # 处理缓冲区中的内容，提取 <think> 标签
+                            current_output_content = ""
+                            current_reasoning_content = ""
+
+                            while buffer:
+                                if not in_reasoning:
+                                    start_pos = buffer.find("<think>")
+                                    if start_pos != -1:
+                                        # 找到了 <think> 标签的开始
+                                        if start_pos > 0:
+                                            current_output_content += buffer[:start_pos]
+                                        buffer = buffer[start_pos + 7 :]  # 跳过 "<think>"
+                                        in_reasoning = True
+                                    else:
+                                        # 没有找到 <think> 标签，直接输出
+                                        current_output_content += buffer
+                                        buffer = ""
+                                else:
+                                    end_pos = buffer.find("</think>")
+                                    if end_pos != -1:
+                                        # 找到了 </think> 标签的结束
+                                        current_reasoning_content += buffer[:end_pos]
+                                        buffer = buffer[end_pos + 8 :]  # 跳过 "</think>"
+                                        in_reasoning = False
+                                    else:
+                                        # 没有找到结束标签，继续累积到推理内容中
+                                        current_reasoning_content += buffer
+                                        buffer = ""
+
+                            # 累积内容
+                            if current_output_content:
+                                accumulated_content.append(current_output_content)
+                            if current_reasoning_content:
+                                accumulated_reasoning.append(current_reasoning_content)
+
+                            # 只要有内容变化就产生 delta
+                            if current_output_content or current_reasoning_content:
+                                if current_output_content:
+                                    message["content"] = current_output_content
+                                elif current_reasoning_content:
+                                    message["reasoning_content"] = current_reasoning_content
+                                    message["content"] = ""  # 推理时不输出普通内容
+                            elif not current_output_content and not current_reasoning_content and not message.get("tool_calls"):
+                                # 如果没有任何内容且没有 tool_calls，则跳过这个消息
+                                continue
+
+                        yield ChatCompletionDeltaMessage(**message, usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()
                         delta_content = message.get("content", "")
-                        buffer += delta_content or ""
+                        if delta_content:
+                            buffer += delta_content
 
-                        while True:
+                        # 处理缓冲区中的内容，提取 <think> 标签
+                        current_output_content = ""
+                        current_reasoning_content = ""
+
+                        while buffer:
                             if not in_reasoning:
                                 start_pos = buffer.find("<think>")
                                 if start_pos != -1:
-                                    current_content.append(buffer[:start_pos])
-                                    buffer = buffer[start_pos + 7 :]
+                                    # 找到了 <think> 标签的开始
+                                    if start_pos > 0:
+                                        current_output_content += buffer[:start_pos]
+                                    buffer = buffer[start_pos + 7 :]  # 跳过 "<think>"
                                     in_reasoning = True
                                 else:
-                                    current_content.append(buffer)
+                                    # 没有找到 <think> 标签，直接输出
+                                    current_output_content += buffer
                                     buffer = ""
-                                    break
                             else:
                                 end_pos = buffer.find("</think>")
                                 if end_pos != -1:
-                                    current_reasoning.append(buffer[:end_pos])
-                                    buffer = buffer[end_pos + 8 :]
+                                    # 找到了 </think> 标签的结束
+                                    current_reasoning_content += buffer[:end_pos]
+                                    buffer = buffer[end_pos + 8 :]  # 跳过 "</think>"
                                     in_reasoning = False
                                 else:
-                                    current_reasoning.append(buffer)
+                                    # 没有找到结束标签，继续累积到推理内容中
+                                    current_reasoning_content += buffer
                                     buffer = ""
-                                    break
-
-                        message["content"] = "".join(current_content)
-                        if current_reasoning:
-                            message["reasoning_content"] = "".join(current_reasoning)
-                        current_content.clear()
-                        current_reasoning.clear()
-
-                        if tools:
-                            full_content += message["content"]
-                            tool_call_data = ToolCallContentProcessor(full_content).tool_calls
-                            if tool_call_data:
-                                message["tool_calls"] = tool_call_data["tool_calls"]
-
-                        if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
-                            message["content"] = ""
-                            result = message
-                            continue
-
-                        yield ChatCompletionDeltaMessage(**message, usage=usage)
 
+                        # 累积内容
+                        if current_output_content:
+                            accumulated_content.append(current_output_content)
+                        if current_reasoning_content:
+                            accumulated_reasoning.append(current_reasoning_content)
+
+                        # 只要有内容变化就产生 delta
+                        if current_output_content or current_reasoning_content:
+                            if current_output_content:
+                                message["content"] = current_output_content
+                            elif current_reasoning_content:
+                                message["reasoning_content"] = current_reasoning_content
+                                message["content"] = ""  # 推理时不输出普通内容
+
+                            if tools:
+                                full_content += current_output_content
+                                tool_call_data = ToolCallContentProcessor(full_content).tool_calls
+                                if tool_call_data:
+                                    message["tool_calls"] = tool_call_data["tool_calls"]
+
+                            if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
+                                message["content"] = ""
+                                result = message
+                                continue
+
+                            yield ChatCompletionDeltaMessage(**message, usage=usage)
+
+                # 处理最后剩余的缓冲区内容
                 if buffer:
                     if in_reasoning:
-                        current_reasoning.append(buffer)
+                        accumulated_reasoning.append(buffer)
                     else:
-                        current_content.append(buffer)
-                    final_message = {
-                        "content": "".join(current_content),
-                        "reasoning_content": "".join(current_reasoning) if current_reasoning else None,
-                    }
-                    yield ChatCompletionDeltaMessage(**final_message, usage=usage)
+                        accumulated_content.append(buffer)
+
+                    final_message = {}
+                    if accumulated_content:
+                        final_content = "".join(accumulated_content)
+                        if final_content.strip():  # 只有当内容非空时才输出
+                            final_message["content"] = final_content
+
+                    if accumulated_reasoning:
+                        final_reasoning = "".join(accumulated_reasoning)
+                        if final_reasoning.strip():  # 只有当推理内容非空时才输出
+                            final_message["reasoning_content"] = final_reasoning
+
+                    if final_message:
+                        yield ChatCompletionDeltaMessage(**final_message, usage=usage)
 
                 if result:
                     yield ChatCompletionDeltaMessage(**result, usage=usage)
@@ -517,8 +596,9 @@ class OpenAICompatibleChatClient(BaseChatClient):
                     result["content"] = result["content"].replace(think_match.group(0), "", 1)
 
             if tools:
-                if self.model_setting.function_call_available and response.choices[0].message.tool_calls:
-                    result["tool_calls"] = [{**tool_call.model_dump(), "type": "function"} for tool_call in response.choices[0].message.tool_calls]
+                if self.model_setting.function_call_available:
+                    if response.choices[0].message.tool_calls:
+                        result["tool_calls"] = [{**tool_call.model_dump(), "type": "function"} for tool_call in response.choices[0].message.tool_calls]
                 else:
                     tool_call_content_processor = ToolCallContentProcessor(result["content"])
                     tool_call_data = tool_call_content_processor.tool_calls
@@ -819,7 +899,7 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                 messages=messages,
                 stream=self.stream,
                 temperature=self.temperature,
-                max_tokens=max_tokens,  # Azure 的 OpenAI 怎么 stream 模式不支持 max_completion_tokens
+                max_tokens=max_tokens,
                 top_p=top_p,
                 audio=audio,
                 frequency_penalty=frequency_penalty,
@@ -854,8 +934,8 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                 usage = None
                 buffer = ""
                 in_reasoning = False
-                current_reasoning = []
-                current_content = []
+                accumulated_reasoning = []
+                accumulated_content = []
 
                 async for chunk in stream_response:
                     if chunk.usage and chunk.usage.total_tokens:
@@ -877,63 +957,142 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                             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)
+
+                        # 即使支持 function call，也要处理 <think> 标签
+                        message = chunk.choices[0].delta.model_dump()
+                        delta_content = message.get("content", "")
+                        if delta_content:
+                            buffer += delta_content
+
+                            # 处理缓冲区中的内容，提取 <think> 标签
+                            current_output_content = ""
+                            current_reasoning_content = ""
+
+                            while buffer:
+                                if not in_reasoning:
+                                    start_pos = buffer.find("<think>")
+                                    if start_pos != -1:
+                                        # 找到了 <think> 标签的开始
+                                        if start_pos > 0:
+                                            current_output_content += buffer[:start_pos]
+                                        buffer = buffer[start_pos + 7 :]  # 跳过 "<think>"
+                                        in_reasoning = True
+                                    else:
+                                        # 没有找到 <think> 标签，直接输出
+                                        current_output_content += buffer
+                                        buffer = ""
+                                else:
+                                    end_pos = buffer.find("</think>")
+                                    if end_pos != -1:
+                                        # 找到了 </think> 标签的结束
+                                        current_reasoning_content += buffer[:end_pos]
+                                        buffer = buffer[end_pos + 8 :]  # 跳过 "</think>"
+                                        in_reasoning = False
+                                    else:
+                                        # 没有找到结束标签，继续累积到推理内容中
+                                        current_reasoning_content += buffer
+                                        buffer = ""
+
+                            # 累积内容
+                            if current_output_content:
+                                accumulated_content.append(current_output_content)
+                            if current_reasoning_content:
+                                accumulated_reasoning.append(current_reasoning_content)
+
+                            # 只要有内容变化就产生 delta
+                            if current_output_content or current_reasoning_content:
+                                if current_output_content:
+                                    message["content"] = current_output_content
+                                elif current_reasoning_content:
+                                    message["reasoning_content"] = current_reasoning_content
+                                    message["content"] = ""  # 推理时不输出普通内容
+                            elif not current_output_content and not current_reasoning_content and not message.get("tool_calls"):
+                                # 如果没有任何内容且没有 tool_calls，则跳过这个消息
+                                continue
+
+                        yield ChatCompletionDeltaMessage(**message, usage=usage)
                     else:
                         message = chunk.choices[0].delta.model_dump()
                         delta_content = message.get("content", "")
-                        buffer += delta_content or ""
+                        if delta_content:
+                            buffer += delta_content
 
-                        while True:
+                        # 处理缓冲区中的内容，提取 <think> 标签
+                        current_output_content = ""
+                        current_reasoning_content = ""
+
+                        while buffer:
                             if not in_reasoning:
                                 start_pos = buffer.find("<think>")
                                 if start_pos != -1:
-                                    current_content.append(buffer[:start_pos])
-                                    buffer = buffer[start_pos + 7 :]
+                                    # 找到了 <think> 标签的开始
+                                    if start_pos > 0:
+                                        current_output_content += buffer[:start_pos]
+                                    buffer = buffer[start_pos + 7 :]  # 跳过 "<think>"
                                     in_reasoning = True
                                 else:
-                                    current_content.append(buffer)
+                                    # 没有找到 <think> 标签，直接输出
+                                    current_output_content += buffer
                                     buffer = ""
-                                    break
                             else:
                                 end_pos = buffer.find("</think>")
                                 if end_pos != -1:
-                                    current_reasoning.append(buffer[:end_pos])
-                                    buffer = buffer[end_pos + 8 :]
+                                    # 找到了 </think> 标签的结束
+                                    current_reasoning_content += buffer[:end_pos]
+                                    buffer = buffer[end_pos + 8 :]  # 跳过 "</think>"
                                     in_reasoning = False
                                 else:
-                                    current_reasoning.append(buffer)
+                                    # 没有找到结束标签，继续累积到推理内容中
+                                    current_reasoning_content += buffer
                                     buffer = ""
-                                    break
-
-                        message["content"] = "".join(current_content)
-                        if current_reasoning:
-                            message["reasoning_content"] = "".join(current_reasoning)
-                        current_content.clear()
-                        current_reasoning.clear()
-
-                        if tools:
-                            full_content += message["content"]
-                            tool_call_data = ToolCallContentProcessor(full_content).tool_calls
-                            if tool_call_data:
-                                message["tool_calls"] = tool_call_data["tool_calls"]
-
-                        if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
-                            message["content"] = ""
-                            result = message
-                            continue
-
-                        yield ChatCompletionDeltaMessage(**message, usage=usage)
 
+                        # 累积内容
+                        if current_output_content:
+                            accumulated_content.append(current_output_content)
+                        if current_reasoning_content:
+                            accumulated_reasoning.append(current_reasoning_content)
+
+                        # 只要有内容变化就产生 delta
+                        if current_output_content or current_reasoning_content:
+                            if current_output_content:
+                                message["content"] = current_output_content
+                            elif current_reasoning_content:
+                                message["reasoning_content"] = current_reasoning_content
+                                message["content"] = ""  # 推理时不输出普通内容
+
+                            if tools:
+                                full_content += current_output_content
+                                tool_call_data = ToolCallContentProcessor(full_content).tool_calls
+                                if tool_call_data:
+                                    message["tool_calls"] = tool_call_data["tool_calls"]
+
+                            if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
+                                message["content"] = ""
+                                result = message
+                                continue
+
+                            yield ChatCompletionDeltaMessage(**message, usage=usage)
+
+                # 处理最后剩余的缓冲区内容
                 if buffer:
                     if in_reasoning:
-                        current_reasoning.append(buffer)
+                        accumulated_reasoning.append(buffer)
                     else:
-                        current_content.append(buffer)
-                    final_message = {
-                        "content": "".join(current_content),
-                        "reasoning_content": "".join(current_reasoning) if current_reasoning else None,
-                    }
-                    yield ChatCompletionDeltaMessage(**final_message, usage=usage)
+                        accumulated_content.append(buffer)
+
+                    final_message = {}
+                    if accumulated_content:
+                        final_content = "".join(accumulated_content)
+                        if final_content.strip():  # 只有当内容非空时才输出
+                            final_message["content"] = final_content
+
+                    if accumulated_reasoning:
+                        final_reasoning = "".join(accumulated_reasoning)
+                        if final_reasoning.strip():  # 只有当推理内容非空时才输出
+                            final_message["reasoning_content"] = final_reasoning
+
+                    if final_message:
+                        yield ChatCompletionDeltaMessage(**final_message, usage=usage)
 
                 if result:
                     yield ChatCompletionDeltaMessage(**result, usage=usage)
@@ -990,8 +1149,9 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                     result["content"] = result["content"].replace(think_match.group(0), "", 1)
 
             if tools:
-                if self.model_setting.function_call_available and response.choices[0].message.tool_calls:
-                    result["tool_calls"] = [{**tool_call.model_dump(), "type": "function"} for tool_call in response.choices[0].message.tool_calls]
+                if self.model_setting.function_call_available:
+                    if response.choices[0].message.tool_calls:
+                        result["tool_calls"] = [{**tool_call.model_dump(), "type": "function"} for tool_call in response.choices[0].message.tool_calls]
                 else:
                     tool_call_content_processor = ToolCallContentProcessor(result["content"])
                     tool_call_data = tool_call_content_processor.tool_calls

{vectorvein-0.2.95.dist-info → vectorvein-0.2.97.dist-info}/METADATA

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

{vectorvein-0.2.95.dist-info → vectorvein-0.2.97.dist-info}/RECORD

@@ -1,13 +1,13 @@
-vectorvein-0.2.95.dist-info/METADATA,sha256=cIWk4Y8IB4PZX5xGduN9gxhtaNkmJzCvkWI4MPUG8M8,4567
-vectorvein-0.2.95.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-vectorvein-0.2.95.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+vectorvein-0.2.97.dist-info/METADATA,sha256=F8G_9pNYMNCXCIo0SSfoV-D-DqPa_exIH6QQRW9h91c,4567
+vectorvein-0.2.97.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+vectorvein-0.2.97.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
 vectorvein/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectorvein/api/__init__.py,sha256=lfY-XA46fgD2iIZTU0VYP8i07AwA03Egj4Qua0vUKrQ,738
 vectorvein/api/client.py,sha256=xF-leKDQzVyyy9FnIRaz0k4eElYW1XbbzeRLcpnyk90,33047
 vectorvein/api/exceptions.py,sha256=uS_PAdx0ksC0r3dgfSGWdbLMZm4qdLeWSSqCv1g3_Gc,772
 vectorvein/api/models.py,sha256=xtPWMsB0yIJI7i-gY4B6MtvXv0ZIXnoeKspmeInH6fU,1449
 vectorvein/chat_clients/__init__.py,sha256=UIytpIgwo8qkZpIyrHVxLYTyliUOTp4J7C4iHRjbtWE,23850
-vectorvein/chat_clients/anthropic_client.py,sha256=xAB2JDCqm865mmCXK9jfN636-lNrICTDUcBypuoWu_0,69234
+vectorvein/chat_clients/anthropic_client.py,sha256=OYqPjRzFcwhZjHSxmj0NlfZSwsVAo_PPD5sCqnMMBHA,68874
 vectorvein/chat_clients/baichuan_client.py,sha256=CVMvpgjdrZGv0BWnTOBD-f2ufZ3wq3496wqukumsAr4,526
 vectorvein/chat_clients/base_client.py,sha256=p7s-G4Wh9MSpDKEfG8wuFAeWy5DGvj5Go31hqrpQPhM,38817
 vectorvein/chat_clients/deepseek_client.py,sha256=3qWu01NlJAP2N-Ff62d5-CZXZitlizE1fzb20LNetig,526
@@ -19,7 +19,7 @@ vectorvein/chat_clients/minimax_client.py,sha256=YOILWcsHsN5tihLTMbKJIyJr9TJREMI
 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=0nj5DwnY8llctoxbW-UXsqVjTRiuezAgkISnV_ygnA4,48869
+vectorvein/chat_clients/openai_compatible_client.py,sha256=p9jWjuNnrOg3-OwW_Q_1FjgtPHKsKL4_L3oD_7M7U2Y,58729
 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
@@ -65,4 +65,4 @@ vectorvein/workflow/utils/analyse.py,sha256=msmvyz35UTYTwqQR5sg9H0sm1vxmGDSmep9X
 vectorvein/workflow/utils/check.py,sha256=B_NdwqIqnc7Ko2HHqFpfOmWVaAu21tPITe0szKfiZKc,11414
 vectorvein/workflow/utils/json_to_code.py,sha256=P8dhhSNgKhTnW17qXNjLO2aLdb0rA8qMAWxhObol2TU,7295
 vectorvein/workflow/utils/layout.py,sha256=j0bRD3uaXu40xCS6U6BGahBI8FrHa5MiF55GbTrZ1LM,4565
-vectorvein-0.2.95.dist-info/RECORD,,
+vectorvein-0.2.97.dist-info/RECORD,,